Create skin_analyzer.py

models/skin_analyzer.py

@@ -0,0 +1,184 @@
+import numpy as np
+import cv2
+from typing import List, Dict, Tuple
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from PIL import Image
+
+class SkinConditionClassifier(nn.Module):
+    """
+    Neural network for skin condition classification
+    """
+    def __init__(self, num_classes=23):
+        super(SkinConditionClassifier, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            
+            nn.Conv2d(64, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            
+            nn.Conv2d(128, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        )
+        
+        self.classifier = nn.Sequential(
+            nn.AdaptiveAvgPool2d((6, 6)),
+            nn.Flatten(),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, num_classes),
+        )
+    
+    def forward(self, x):
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+class SkinAnalyzer:
+    def __init__(self, model_path: str = None):
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.model = SkinConditionClassifier(num_classes=23)
+        
+        if model_path and torch.cuda.is_available():
+            self.model.load_state_dict(torch.load(model_path))
+        elif model_path:
+            self.model.load_state_dict(torch.load(model_path, map_location='cpu'))
+        
+        self.model = self.model.to(self.device)
+        self.model.eval()
+        
+        self.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])
+        ])
+        
+        self.condition_names = [
+            'blackheads', 'whiteheads', 'papules', 'pustules', 'cystic_acne',
+            'nodules', 'acne_scars', 'hyperpigmentation', 'hypopigmentation',
+            'oily_skin', 'dry_skin', 'combination_skin', 'sensitive_skin',
+            'rosacea', 'eczema', 'seborrheic_dermatitis', 'milia',
+            'keratosis_pilaris', 'folliculitis', 'sunburn_uv_damage',
+            'fine_lines', 'uneven_texture', 'enlarged_pores'
+        ]
+    
+    def analyze(self, image: np.ndarray) -> List[Dict]:
+        """
+        Analyze skin conditions in image
+        """
+        # Preprocess image
+        pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        input_tensor = self.transform(pil_image).unsqueeze(0).to(self.device)
+        
+        # Run inference
+        with torch.no_grad():
+            outputs = self.model(input_tensor)
+            probabilities = torch.softmax(outputs, dim=1)[0]
+        
+        # Get top predictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        results = []
+        for prob, idx in zip(top_probs, top_indices):
+            if prob > 0.1:  # Only include if confidence > 10%
+                condition = self.condition_names[idx]
+                
+                # Determine severity based on probability
+                if prob > 0.8:
+                    severity = 'severe'
+                elif prob > 0.5:
+                    severity = 'moderate'
+                else:
+                    severity = 'mild'
+                
+                results.append({
+                    'condition': condition,
+                    'confidence': float(prob) * 100,
+                    'severity': severity
+                })
+        
+        return results
+    
+    def analyze_regions(self, image: np.ndarray, regions: Dict) -> Dict:
+        """
+        Analyze specific face regions
+        """
+        results = {}
+        h, w, _ = image.shape
+        
+        for region_name, (x, y, width, height) in regions.items():
+            # Extract region
+            region_img = image[y:y+height, x:x+width]
+            if region_img.size == 0:
+                continue
+            
+            # Analyze region
+            region_results = self.analyze(region_img)
+            results[region_name] = region_results
+        
+        return results
+    
+    def get_severity_score(self, condition: str, confidence: float) -> str:
+        """
+        Get severity level based on condition and confidence
+        """
+        # Define severity thresholds per condition
+        severe_conditions = ['cystic_acne', 'nodules', 'rosacea', 'eczema']
+        moderate_conditions = ['papules', 'pustules', 'hyperpigmentation']
+        
+        if condition in severe_conditions:
+            return 'severe'
+        elif condition in moderate_conditions:
+            return 'moderate' if confidence > 50 else 'mild'
+        else:
+            if confidence > 80:
+                return 'moderate'
+            elif confidence > 50:
+                return 'mild'
+            else:
+                return 'mild'
+    
+    def get_condition_info(self, condition: str) -> Dict:
+        """
+        Get detailed information about a condition
+        """
+        condition_info = {
+            'blackheads': {
+                'name': 'Blackheads',
+                'description': 'Open comedones with oxidized sebum',
+                'treatments': ['Salicylic acid', 'Retinoids', 'Clay masks'],
+                'avoid': ['Comedogenic products', 'Heavy oils']
+            },
+            'whiteheads': {
+                'name': 'Whiteheads',
+                'description': 'Closed comedones under skin surface',
+                'treatments': ['Benzoyl peroxide', 'Retinoids', 'Chemical exfoliation'],
+                'avoid': ['Pore-clogging makeup', 'Petroleum-based products']
+            },
+            # Add all 23 conditions...
+        }
+        
+        return condition_info.get(condition, {
+            'name': condition.replace('_', ' ').title(),
+            'description': 'Skin condition detected by AI analysis',
+            'treatments': ['Consult a dermatologist for proper treatment'],
+            'avoid': ['Self-diagnosis', 'Aggressive treatment']
+        })