Create models/skin_analysis_model.py

models/skin_analysis_model.py

@@ -0,0 +1,183 @@
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import mediapipe as mp
+import numpy as np
+import json
+import os
+
+class SkinAnalysisModel:
+    def __init__(self):
+        self.mp_face_detection = mp.solutions.face_detection
+        self.mp_face_mesh = mp.solutions.face_mesh
+        self.model = self._load_model()
+        self.transform = self._get_transforms()
+        self.conditions_map = self._load_conditions_map()
+        
+    def _load_model(self):
+        """Load pre-trained model for skin analysis"""
+        # In production, load your trained model
+        # For now, using a placeholder
+        return torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
+    
+    def _get_transforms(self):
+        """Get image transforms"""
+        return transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                               std=[0.229, 0.224, 0.225]),
+        ])
+    
+    def _load_conditions_map(self):
+        """Load skin conditions mapping"""
+        return {
+            0: {'id': 'blackheads', 'name': 'Blackheads', 'severity': 'mild'},
+            1: {'id': 'whiteheads', 'name': 'Whiteheads', 'severity': 'mild'},
+            2: {'id': 'papules', 'name': 'Papules', 'severity': 'moderate'},
+            3: {'id': 'pustules', 'name': 'Pustules', 'severity': 'moderate'},
+            4: {'id': 'cystic_acne', 'name': 'Cystic Acne', 'severity': 'severe'},
+            5: {'id': 'nodules', 'name': 'Nodules', 'severity': 'severe'},
+            6: {'id': 'acne_scars', 'name': 'Acne Scars', 'severity': 'mild'},
+            7: {'id': 'hyperpigmentation', 'name': 'Hyperpigmentation', 'severity': 'moderate'},
+            8: {'id': 'hypopigmentation', 'name': 'Hypopigmentation', 'severity': 'moderate'},
+            9: {'id': 'oily_skin', 'name': 'Oily Skin', 'severity': 'mild'},
+            10: {'id': 'dry_skin', 'name': 'Dry Skin', 'severity': 'mild'},
+            11: {'id': 'combination_skin', 'name': 'Combination Skin', 'severity': 'mild'},
+            12: {'id': 'sensitive_skin', 'name': 'Sensitive Skin', 'severity': 'moderate'},
+            13: {'id': 'rosacea', 'name': 'Rosacea', 'severity': 'severe'},
+            14: {'id': 'eczema', 'name': 'Eczema', 'severity': 'severe'},
+            15: {'id': 'seborrheic_dermatitis', 'name': 'Seborrheic Dermatitis', 'severity': 'moderate'},
+            16: {'id': 'milia', 'name': 'Milia', 'severity': 'mild'},
+            17: {'id': 'keratosis_pilaris', 'name': 'Keratosis Pilaris', 'severity': 'mild'},
+            18: {'id': 'folliculitis', 'name': 'Folliculitis', 'severity': 'moderate'},
+            19: {'id': 'sunburn_uv_damage', 'name': 'Sunburn/UV Damage', 'severity': 'moderate'},
+            20: {'id': 'fine_lines', 'name': 'Fine Lines', 'severity': 'mild'},
+            21: {'id': 'uneven_texture', 'name': 'Uneven Texture', 'severity': 'mild'},
+            22: {'id': 'enlarged_pores', 'name': 'Enlarged Pores', 'severity': 'mild'},
+        }
+    
+    def analyze_skin(self, image_bytes: bytes) -> dict:
+        """
+        Analyze skin from image
+        Returns detected conditions with positions and severity
+        """
+        try:
+            # Load image
+            image = Image.open(image_bytes)
+            image_np = np.array(image)
+            
+            # Detect face and get landmarks
+            with self.mp_face_detection.FaceDetection(
+                model_selection=1, 
+                min_detection_confidence=0.5
+            ) as face_detection:
+                
+                results = face_detection.process(image_np)
+                
+                if not results.detections:
+                    return {"error": "No face detected", "conditions": []}
+                
+                # Get face bounding box
+                detection = results.detections[0]
+                bbox = detection.location_data.relative_bounding_box
+                
+                # Extract face region
+                h, w, _ = image_np.shape
+                x = int(bbox.xmin * w)
+                y = int(bbox.ymin * h)
+                width = int(bbox.width * w)
+                height = int(bbox.height * h)
+                
+                face_region = image_np[y:y+height, x:x+width]
+                
+                # Run AI analysis on face region
+                conditions = self._detect_conditions(face_region)
+                
+                # Generate pin positions based on detected conditions
+                pins = self._generate_pin_positions(conditions, bbox)
+                
+                return {
+                    "conditions": conditions,
+                    "pins": pins,
+                    "face_bbox": {
+                        "x": float(bbox.xmin),
+                        "y": float(bbox.ymin),
+                        "width": float(bbox.width),
+                        "height": float(bbox.height)
+                    },
+                    "dermatologist_warning": any(
+                        c['severity'] in ['severe', 'moderate'] 
+                        for c in conditions
+                    )
+                }
+                
+        except Exception as e:
+            return {"error": str(e), "conditions": []}
+    
+    def _detect_conditions(self, face_region):
+        """Detect skin conditions from face region"""
+        # Convert to tensor
+        face_pil = Image.fromarray(face_region)
+        input_tensor = self.transform(face_pil).unsqueeze(0)
+        
+        # Run inference (placeholder - in production, use actual model)
+        with torch.no_grad():
+            outputs = self.model(input_tensor)
+            probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
+        
+        # Get top conditions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        conditions = []
+        for idx, prob in zip(top_indices, top_probs):
+            condition_info = self.conditions_map.get(idx.item(), {
+                'id': 'unknown',
+                'name': 'Unknown',
+                'severity': 'mild'
+            })
+            
+            # Adjust severity based on confidence
+            severity = condition_info['severity']
+            if prob.item() > 0.8:
+                severity = 'severe'
+            elif prob.item() > 0.5:
+                severity = 'moderate'
+            
+            conditions.append({
+                'condition': condition_info['id'],
+                'name': condition_info['name'],
+                'severity': severity,
+                'confidence': round(prob.item() * 100, 2)
+            })
+        
+        return conditions
+    
+    def _generate_pin_positions(self, conditions, face_bbox):
+        """Generate pin positions for detected conditions"""
+        # In production, use actual detection coordinates
+        # For now, distribute pins around face zones
+        zones = [
+            {'name': 'forehead', 'x': 0.5, 'y': 0.2},
+            {'name': 'left_cheek', 'x': 0.3, 'y': 0.5},
+            {'name': 'right_cheek', 'x': 0.7, 'y': 0.5},
+            {'name': 'chin', 'x': 0.5, 'y': 0.8},
+            {'name': 'nose', 'x': 0.5, 'y': 0.4},
+        ]
+        
+        pins = []
+        for i, condition in enumerate(conditions):
+            zone = zones[i % len(zones)]
+            pins.append({
+                'condition': condition['condition'],
+                'position': {
+                    'x': zone['x'],
+                    'y': zone['y']
+                },
+                'severity': condition['severity'],
+                'confidence': condition['confidence'],
+                'is_ai_detected': True
+            })
+        
+        return pins