Create README.md

README.md

@@ -0,0 +1,122 @@
+
+# Model Card: Fine-Tuned MobileNetV2 for Skin Lesion Classification
+# Model Details
+**Model Name:** Fine-Tuned MobileNetV2 for Skin Lesion Classification
+**Base Model:** google/mobilenet_v2_1.0_224 (pretrained on ImageNet)
+**Dataset:** marmal88/skin_cancer
+**Quantization:** Available as an optional FP16 version for optimized inference
+**Training Device:** CUDA (GPU, 12 GB)
+
+# Dataset Information
+```
+Dataset Structure
+
+DatasetDict({
+    train: Dataset({
+        features: ['image', 'image_id', 'lesion_id', 'dx', 'dx_type', 'age', 'sex', 'localization'],
+        num_rows: 9577
+    })
+    validation: Dataset({
+        features: ['image', 'image_id', 'lesion_id', 'dx', 'dx_type', 'age', 'sex', 'localization'],
+        num_rows: 2492
+    })
+    test: Dataset({
+        features: ['image', 'image_id', 'lesion_id', 'dx', 'dx_type', 'age', 'sex', 'localization'],
+        num_rows: 1285
+    })
+})
+Available Splits
+Train: 9,577 examples
+Validation: 2,492 examples
+Test: 1,285 examples
+```
+# Feature Representation
+- image: RGB image (originally 600x450, resized to 224x224 during preprocessing)
+- image_id: Unique identifier (e.g., ISIC_0024329)
+- lesion_id: Lesion identifier (e.g., HAM_0002954)
+- dx: Diagnosis label (e.g., melanoma, actinic_keratoses)
+- dx_type: Diagnosis method (e.g., histo for histopathology)
+- age: Patient age (float, e.g., 75.0)
+- sex: Patient gender (e.g., female)
+- localization: Body location (e.g., lower extremity)
+# Note: Only image and dx (converted to integer labels) were used for training; other features were dropped during preprocessing.
+
+# Training Details
+- Number of Classes: 7
+- Class Names: actinic_keratoses, basal_cell_carcinoma, benign_keratosis-like_lesions, dermatofibroma, melanocytic_Nevi, melanoma, vascular_lesions
+- Training Process: Fine-tuned for 5 epochs (initially planned for 10, reduced to 5)
+- Learning Rate: 0.001 (Adam optimizer, fine-tuning all layers)
+- Batch Size: 32 (suitable for a 12 GB GPU)
+- Preprocessing: Images resized to 224x224, normalized with mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] (ImageNet stats)
+- Performance Metrics
+- Epochs: 5
+- Training Loss: [To be filled after training output]
+- Validation Loss: [To be filled after training output]
+- Accuracy: [To be filled after training output]
+- F1 Score: Not computed (can be added with additional evaluation)
+# Note: Performance metrics depend on your training output. Please provide the training log (loss/accuracy per epoch) to complete this section.
+
+Inference Example
+```python
+import torch
+from torchvision import transforms
+from PIL import Image
+import torch.nn.functional as F
+import json
+
+# Preprocessing (matches training)
+preprocess = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+# Load model and labels
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model_path = "skin_cancer_model_fp16/mobilenetv2_skin_cancer_fp16.pt"
+model = torch.load(model_path, map_location=device)
+model = model.to(device)
+model.eval()
+
+with open("skin_cancer_model_fp16/labels.json", 'r') as f:
+    label_mapping = json.load(f)
+class_names = list(label_mapping.keys())
+
+# Inference function
+def predict_image(image_path, model, preprocess, device, class_names):
+    image = Image.open(image_path).convert('RGB')
+    image_tensor = preprocess(image).unsqueeze(0).half()  # FP16
+    image_tensor = image_tensor.to(device)
+    
+    with torch.no_grad():
+        outputs = model(image_tensor)
+        probabilities = F.softmax(outputs, dim=1)
+        confidence, predicted = torch.max(probabilities, 1)
+        predicted_class = class_names[predicted.item()]
+        confidence_score = confidence.item() * 100
+    
+    return predicted_class, confidence_score
+
+# Example usage
+if __name__ == "__main__":
+    image_path = "C:/path/to/your/image.jpg"  # Replace with your image path
+    predicted_class, confidence = predict_image(image_path, model, preprocess, device, class_names)
+    print(f"Predicted Class: {predicted_class}")
+    print(f"Confidence: {confidence:.2f}%")
+
+```
+# Quantization & Optimization
+**Quantization:** Optional FP16 version created using PyTorch’s .half() for faster inference and reduced memory footprint (~50% size reduction).
+**Optimized:** Suitable for deployment on GPU-enabled devices (e.g., CUDA with 12 GB VRAM).
+
+# Usage
+- Input: RGB images (any size, resized to 224x224 during preprocessing)
+- Output: Predicted skin lesion class (one of 7) with confidence probability
+# Limitations
+- Generalization: Trained on the marmal88/skin_cancer dataset, which may not fully represent all real-world skin lesions (e.g., varying lighting, angles, or skin types).
+- Dataset Bias: Performance may vary depending on dataset diversity (e.g., age, sex, localization not used in training).
+- Accuracy: Limited to 5 epochs; further training or larger datasets might improve results.
+# Future Improvements
+- Data Augmentation: Add rotation, flipping, or color jittering to enhance robustness.
+- Larger Dataset: Incorporate additional skin cancer datasets (e.g., ISIC Archive) for better coverage.
+- Model Tuning: Experiment with freezing feature layers or adjusting learning rate for better convergence.