--- license: apache-2.0 tags: - keras - tensorflow - computer-vision - medical - dermatology - image-classification - skin-disease - efficientnet - healthcare library_name: keras pipeline_tag: image-classification --- # DermaAI - Skin Disease Classification Model A deep learning model for classifying skin diseases using computer vision. This model can identify 5 different skin conditions with confidence scores and medical recommendations. ## 🏥 Supported Skin Conditions The model can classify the following skin diseases: 1. **Atopic Dermatitis** - A chronic inflammatory skin condition 2. **Eczema** - Inflammatory skin condition causing red, itchy patches 3. **Psoriasis** - Autoimmune condition causing scaly skin patches 4. **Seborrheic Keratoses** - Common benign skin growths 5. **Tinea Ringworm Candidiasis** - Fungal skin infections ## 🔧 Model Details - **Model Type**: Keras/TensorFlow model based on EfficientNetV2 - **Task**: Image Classification (Multi-class) - **Domain**: Medical/Dermatology - **Framework**: TensorFlow/Keras - **Input Size**: 224x224x3 (RGB images) - **Output**: 5-class probability distribution - **Preprocessing**: EfficientNetV2 preprocessing ## 🚀 Quick Start ### Basic Usage ```python import tensorflow as tf from huggingface_hub import hf_hub_download import numpy as np from PIL import Image from tensorflow.keras.applications.efficientnet_v2 import preprocess_input # Download and load the model model_path = hf_hub_download(repo_id="Siraja704/DermaAI", filename="DermaAI.keras") model = tf.keras.models.load_model(model_path) # Class names class_names = [ 'Atopic Dermatitis', 'Eczema', 'Psoriasis', 'Seborrheic Keratoses', 'Tinea Ringworm Candidiasis' ] # Prediction function def predict_skin_condition(image_path): # Load and preprocess image image = Image.open(image_path).convert('RGB') image = image.resize((224, 224)) image_array = np.array(image) image_array = preprocess_input(image_array) image_array = np.expand_dims(image_array, axis=0) # Make prediction predictions = model.predict(image_array) predicted_class_index = np.argmax(predictions[0]) predicted_class = class_names[predicted_class_index] confidence = predictions[0][predicted_class_index] * 100 return predicted_class, confidence # Example usage prediction, confidence = predict_skin_condition("path/to/your/image.jpg") print(f"Prediction: {prediction} ({confidence:.2f}% confidence)") ``` ## 🌐 Flask API Usage Create a complete web API for skin disease classification: ### 1. Install Dependencies ```bash pip install flask numpy tensorflow pillow flask-cors huggingface-hub ``` ### 2. Create Flask Application (`app.py`) ```python from flask import Flask, request, jsonify import numpy as np import tensorflow as tf import base64 import io from PIL import Image from flask_cors import CORS from tensorflow.keras.applications.efficientnet_v2 import preprocess_input from huggingface_hub import hf_hub_download app = Flask(__name__) CORS(app) # Download and load the model from Hugging Face print("Downloading model from Hugging Face...") model_path = hf_hub_download(repo_id="Siraja704/DermaAI", filename="DermaAI.keras") model = tf.keras.models.load_model(model_path) print("✅ Model loaded successfully!") # Class names class_names = [ 'Atopic Dermatitis', 'Eczema', 'Psoriasis', 'Seborrheic Keratoses', 'Tinea Ringworm Candidiasis' ] @app.route('/predict', methods=['POST']) def predict(): try: data = request.json if not data or 'image' not in data: return jsonify({'error': 'No image data provided'}), 400 # Process base64 image image_data = data['image'] if 'base64,' in image_data: image_data = image_data.split('base64,')[1] # Decode and preprocess image decoded_image = base64.b64decode(image_data) image = Image.open(io.BytesIO(decoded_image)).convert('RGB') image = image.resize((224, 224)) image_array = np.array(image) image_array = preprocess_input(image_array) image_array = np.expand_dims(image_array, axis=0) # Make prediction predictions = model.predict(image_array) predicted_class_index = int(np.argmax(predictions[0])) predicted_class = class_names[predicted_class_index] confidence = float(predictions[0][predicted_class_index] * 100) # Get top alternatives top_indices = np.argsort(predictions[0])[-3:][::-1] top_predictions = [ { 'class': class_names[i], 'confidence': float(predictions[0][i] * 100) } for i in top_indices if i != predicted_class_index ] # Generate medical recommendation if confidence < 10: recommendation = "Very low confidence. Please retake image with better lighting and focus." elif confidence < 30: recommendation = "Low confidence. Preliminary result only. Consult a dermatologist." elif confidence < 60: recommendation = "Moderate confidence. Consider alternatives and consult healthcare professional." else: recommendation = "High confidence prediction. Always consult healthcare professional for confirmation." return jsonify({ 'prediction': predicted_class, 'confidence': round(confidence, 2), 'all_confidences': { class_names[i]: float(pred * 100) for i, pred in enumerate(predictions[0]) }, 'top_alternatives': top_predictions, 'recommendation': recommendation }) except Exception as e: return jsonify({'error': str(e)}), 500 @app.route('/health', methods=['GET']) def health(): return jsonify({'status': 'healthy', 'model_loaded': True}) if __name__ == '__main__': app.run(host='0.0.0.0', port=5001, debug=True) ``` ### 3. Run the API ```bash python app.py ``` The API will be available at `http://localhost:5001` ### 4. API Usage Examples **Python Client:** ```python import requests import base64 def predict_image(image_path, api_url="http://localhost:5001/predict"): with open(image_path, "rb") as image_file: encoded_string = base64.b64encode(image_file.read()).decode('utf-8') data = {"image": f"data:image/jpeg;base64,{encoded_string}"} response = requests.post(api_url, json=data) return response.json() # Usage result = predict_image("skin_image.jpg") print(f"Prediction: {result['prediction']} ({result['confidence']}%)") ``` **JavaScript Client:** ```javascript async function predictSkinCondition(imageFile) { const base64 = await new Promise((resolve) => { const reader = new FileReader(); reader.onload = () => resolve(reader.result); reader.readAsDataURL(imageFile); }); const response = await fetch('http://localhost:5001/predict', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({image: base64}) }); return await response.json(); } ``` **cURL:** ```bash curl -X POST http://localhost:5001/predict \ -H "Content-Type: application/json" \ -d '{"image": "data:image/jpeg;base64,YOUR_BASE64_IMAGE_HERE"}' ``` ## 📋 API Response Format ```json { "prediction": "Eczema", "confidence": 85.23, "all_confidences": { "Atopic Dermatitis": 12.45, "Eczema": 85.23, "Psoriasis": 1.32, "Seborrheic Keratoses": 0.67, "Tinea Ringworm Candidiasis": 0.33 }, "top_alternatives": [ { "class": "Atopic Dermatitis", "confidence": 12.45 } ], "recommendation": "High confidence prediction. Always consult healthcare professional for confirmation." } ``` ## 🖼️ Image Requirements - **Formats**: JPG, PNG, WebP, and other common formats - **Size**: Automatically resized to 224x224 pixels - **Quality**: High-resolution images with good lighting work best - **Focus**: Ensure affected skin area is clearly visible ## 🐳 Docker Deployment **Dockerfile:** ```dockerfile FROM python:3.9-slim WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY app.py . EXPOSE 5001 CMD ["python", "app.py"] ``` **Requirements.txt:** ```txt flask>=2.0.0 numpy>=1.21.0 tensorflow>=2.13.0 pillow>=9.0.0 flask-cors>=3.0.0 huggingface-hub>=0.20.0 ``` **Build and Run:** ```bash docker build -t dermaai-api . docker run -p 5001:5001 dermaai-api ``` ## ⚕️ Important Medical Disclaimer **This model is for educational and research purposes only. It should NOT be used as a substitute for professional medical diagnosis or treatment. Always consult qualified healthcare professionals for proper medical evaluation and treatment of skin conditions.** ## 📊 Performance Notes - **Input**: 224x224 RGB images - **Preprocessing**: EfficientNetV2 normalization - **Architecture**: Based on EfficientNetV2 - **Classes**: 5 skin disease categories - **Confidence Levels**: - Low: < 30% (requires professional consultation) - Moderate: 30-60% (consider alternatives) - High: > 60% (still requires medical confirmation) ## 🤝 Citation If you use this model in your research or applications, please cite appropriately: ```bibtex @misc{dermaai2024, title={DermaAI: Deep Learning Model for Skin Disease Classification}, author={Siraja704}, year={2024}, publisher={Hugging Face}, url={https://huggingface.co/Siraja704/DermaAI} } ``` ## 📝 License Licensed under the Apache 2.0 License. See the LICENSE file for details. ## 🔗 Links - **Model Repository**: [Siraja704/DermaAI](https://huggingface.co/Siraja704/DermaAI) - **Framework**: [TensorFlow](https://tensorflow.org) - **Base Architecture**: [EfficientNetV2](https://arxiv.org/abs/2104.00298)