Add skin type classifier app with trained model

README.md

@@ -1,13 +1,28 @@
 ---
 title: Skin Type Classifier
-emoji: 🏆
+emoji: 🔬
 colorFrom: blue
-colorTo: red
+colorTo: green
 sdk: gradio
-sdk_version: 5.35.0
+sdk_version: 4.44.1
 app_file: app.py
 pinned: false
-short_description: Image Classifier
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔬 Skin Type Classifier
+
+A deep learning model for classifying skin types into dry and oily categories using computer vision.
+
+## Features
+- Upload facial skin images
+- Real-time classification (dry vs oily)
+- Confidence scores and recommendations
+- Built with ResNet50 architecture
+
+## How to Use
+1. Upload a clear facial skin image
+2. Get instant skin type classification
+3. View confidence scores and skincare recommendations
+
+⚠️ **Disclaimer**: This model is for educational and research purposes only. Consult a dermatologist for professional skin analysis.

app.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Space for Skin Type Classification
+"""
+
+import gradio as gr
+import torch
+import torch.nn as nn
+import pickle
+from PIL import Image
+import torchvision.transforms as transforms
+from torchvision.models import resnet50
+import os
+
+# Model configuration
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Global model variable
+model = None
+transform = None
+label_mappings = None
+
+def load_model():
+    """Load the model from local files"""
+    global model, transform, label_mappings
+    
+    try:
+        # Load label mappings
+        if os.path.exists('label_maps.pkl'):
+            with open('label_maps.pkl', 'rb') as f:
+                label_mappings = pickle.load(f)
+            print("✅ Label mappings loaded successfully!")
+        else:
+            # Fallback label mappings
+            label_mappings = {'index_label': {0: 'dry', 1: 'oily'}}
+            print("⚠️ Using fallback label mappings")
+        
+        # Initialize model architecture
+        model = resnet50(weights=None)
+        model.fc = nn.Linear(model.fc.in_features, 2)  # 2 classes (dry, oily)
+        
+        # Load trained weights
+        if os.path.exists('best_skin_model.pth'):
+            model.load_state_dict(torch.load('best_skin_model.pth', map_location=DEVICE))
+            print("✅ Model weights loaded successfully!")
+        else:
+            print("⚠️ Model weights not found, using randomly initialized model")
+        
+        model.to(DEVICE)
+        model.eval()
+        
+        # Define transforms
+        transform = transforms.Compose([
+            transforms.Resize((224, 224)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+        
+        return True
+        
+    except Exception as e:
+        print(f"Error initializing model: {e}")
+        return False
+
+def predict_skin_type(image):
+    """Predict skin type from uploaded image"""
+    if image is None:
+        return "Please upload an image first.", {}
+    
+    try:
+        # Ensure image is RGB
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Preprocess image
+        input_tensor = transform(image).unsqueeze(0).to(DEVICE)
+        
+        # Make prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = torch.softmax(outputs, dim=1)
+            predicted_class = torch.argmax(probabilities, dim=1).item()
+            confidence = probabilities[0][predicted_class].item()
+        
+        # Get predictions
+        dry_prob = float(probabilities[0][0])
+        oily_prob = float(probabilities[0][1])
+        
+        # Determine skin type using label mappings
+        predicted_label = label_mappings['index_label'][predicted_class]
+        skin_type = predicted_label.title()  # 'dry' -> 'Dry', 'oily' -> 'Oily'
+        
+        # Create results
+        confidence_dict = {
+            "Dry Skin": dry_prob,
+            "Oily Skin": oily_prob
+        }
+        
+        # Create detailed results text
+        result_text = f"""
+## 🔬 Analysis Results
+
+**Predicted Skin Type: {skin_type.upper()}**
+**Confidence: {confidence:.1%}**
+
+### 📊 Probabilities:
+- Dry Skin: {dry_prob:.1%}
+- Oily Skin: {oily_prob:.1%}
+
+### 💡 Skincare Recommendations:
+"""
+        
+        if skin_type == "Dry":
+            result_text += """
+- Use hydrating moisturizers with hyaluronic acid
+- Avoid harsh cleansers that strip natural oils  
+- Try gentle, cream-based cleansers
+- Apply moisturizer on damp skin
+- Consider facial oils for extra hydration
+"""
+        else:
+            result_text += """
+- Use oil-free, non-comedogenic products
+- Try salicylic acid or niacinamide treatments
+- Use gentle foaming cleansers
+- Don't over-cleanse (can increase oil production)
+- Consider clay masks 1-2 times per week
+"""
+        
+        result_text += """
+### ⚠️ Important Note:
+This is an AI prediction for educational purposes. For professional skin analysis and personalized skincare advice, consult a dermatologist.
+"""
+        
+        return result_text, confidence_dict
+        
+    except Exception as e:
+        error_msg = f"Error during prediction: {str(e)}"
+        return error_msg, {"Error": 1.0}
+
+# Load model at startup
+print("🚀 Initializing Skin Type Classifier...")
+model_loaded = load_model()
+
+if not model_loaded:
+    print("❌ Failed to load model")
+
+# Create Gradio interface
+with gr.Blocks(
+    title="🔬 Skin Type Classifier",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {
+        max-width: 900px;
+        margin: auto;
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🔬 AI Skin Type Classifier
+    
+    Upload a facial skin image to determine if it's **dry** or **oily** skin type.
+    
+    ### 📸 Tips for Best Results:
+    - Use clear, well-lit photos of facial skin
+    - Avoid heavily filtered or edited images
+    - Ensure the skin area is clearly visible
+    - Natural lighting works best
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Image input
+            image_input = gr.Image(
+                type="pil",
+                label="📷 Upload Skin Image",
+                height=400
+            )
+            
+            # Predict button
+            predict_btn = gr.Button(
+                "🔍 Analyze Skin Type",
+                variant="primary",
+                size="lg"
+            )
+            
+        with gr.Column(scale=1):
+            # Results
+            result_text = gr.Markdown(
+                value="Upload an image to see analysis results...",
+                label="📋 Analysis Results"
+            )
+            
+            confidence_output = gr.Label(
+                label="📊 Confidence Scores",
+                num_top_classes=2
+            )
+    
+    # Event handlers
+    predict_btn.click(
+        fn=predict_skin_type,
+        inputs=[image_input],
+        outputs=[result_text, confidence_output]
+    )
+    
+    # Auto-predict when image is uploaded
+    image_input.change(
+        fn=predict_skin_type,
+        inputs=[image_input],
+        outputs=[result_text, confidence_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    
+    ### 🤖 About This Model
+    
+    - **Architecture**: ResNet50-based neural network
+    - **Classes**: Dry skin vs Oily skin
+    - **Training**: Custom dataset with skin type annotations
+    - **Purpose**: Educational and research use only
+    
+    ### 📚 How It Works
+    
+    1. **Image Processing**: Resizes and normalizes your uploaded image
+    2. **Feature Extraction**: Uses ResNet50 to extract skin features  
+    3. **Classification**: Predicts skin type with confidence scores
+    4. **Recommendations**: Provides tailored skincare suggestions
+    
+    ### ⚠️ Important Disclaimers
+    
+    - This tool is for **educational purposes only**
+    - **Not for medical diagnosis** - consult a dermatologist for professional advice
+    - Results may vary based on lighting, image quality, and individual skin characteristics
+    - The model may have limitations across different skin tones and ethnicities
+    
+    ---
+    
+    **Created with ❤️ using Gradio and PyTorch**
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

best_skin_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:311dc1b2cac8025b2e1da09127daa9a21b372c0a06455db5ffeb402c18205b0d
+size 94364655

label_maps.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f60fc6fd236a8bf42973f119adf839e7cfb8ab073b3e3a20eb4f56e568820470
+size 77

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.44.1
+torch==1.13.1
+torchvision==0.14.1
+Pillow==10.4.0
+requests==2.32.4