Initial model upload

README.md

@@ -0,0 +1,165 @@
+---
+license: mit
+tags:
+- image-classification
+- pytorch
+- skin-analysis
+- dermatology
+- computer-vision
+datasets:
+- custom
+metrics:
+- accuracy
+- f1
+pipeline_tag: image-classification
+widget:
+- src: https://example.com/dry-skin-sample.jpg
+  example_title: Dry Skin
+- src: https://example.com/oily-skin-sample.jpg
+  example_title: Oily Skin
+---
+
+# 🔬 Skin Type Classification Model
+
+A deep learning model for classifying skin types into **dry** and **oily** categories using computer vision.
+
+## Model Description
+
+This model is based on ResNet50 architecture and has been fine-tuned specifically for skin type classification. It can analyze facial skin images and determine whether the skin type is dry or oily with high accuracy.
+
+### Key Features
+- **Architecture**: ResNet50-based classification model
+- **Classes**: 2 (dry, oily)
+- **Input**: RGB images (224x224 pixels)
+- **Framework**: PyTorch + Transformers
+- **Performance**: High accuracy on skin type classification
+
+## Intended Use
+
+### Primary Use Cases
+- Dermatological analysis and skin assessment
+- Cosmetic product recommendation systems
+- Skincare routine personalization
+- Medical research and skin health monitoring
+
+### Limitations
+- Designed specifically for facial skin analysis
+- Requires good lighting and clear skin visibility
+- Not suitable for medical diagnosis (for research/cosmetic use only)
+- Performance may vary across different skin tones and ethnicities
+
+## How to Use
+
+### Quick Start with Transformers
+
+```python
+from transformers import AutoModelForImageClassification, AutoImageProcessor
+from PIL import Image
+import torch
+
+# Load model and processor
+model = AutoModelForImageClassification.from_pretrained("your-username/skin-type-classifier")
+processor = AutoImageProcessor.from_pretrained("your-username/skin-type-classifier")
+
+# Load and process image
+image = Image.open("path/to/skin/image.jpg")
+inputs = processor(images=image, return_tensors="pt")
+
+# Make prediction
+with torch.no_grad():
+    outputs = model(**inputs)
+    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    predicted_class = predictions.argmax().item()
+
+# Get result
+labels = ["dry", "oily"]
+confidence = predictions[0][predicted_class].item()
+print(f"Predicted skin type: {labels[predicted_class]} (confidence: {confidence:.2%})")
+```
+
+### Using the Pipeline API
+
+```python
+from transformers import pipeline
+
+# Create classification pipeline
+classifier = pipeline("image-classification", model="your-username/skin-type-classifier")
+
+# Classify image
+result = classifier("path/to/skin/image.jpg")
+print(result)
+```
+
+## Model Details
+
+### Architecture
+- **Base Model**: ResNet50
+- **Modification**: Custom classification head with 2 output classes
+- **Input Size**: 224 × 224 × 3 (RGB)
+- **Parameters**: ~25M parameters
+
+### Training Details
+- **Dataset**: Custom skin type classification dataset
+- **Preprocessing**: 
+  - Resize to 224×224 pixels
+  - Normalization: ImageNet statistics
+  - Data augmentation applied during training
+- **Training Framework**: PyTorch
+- **Optimization**: Adam optimizer with learning rate scheduling
+
+### Performance Metrics
+- **Training Accuracy**: High performance on validation set
+- **Inference Speed**: Fast inference suitable for real-time applications
+- **Model Size**: ~94MB
+
+## Technical Specifications
+
+### Input Format
+- **Type**: RGB Images
+- **Size**: 224 × 224 pixels
+- **Format**: PIL Image, numpy array, or torch tensor
+- **Normalization**: ImageNet mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+
+### Output Format
+- **Type**: Classification logits
+- **Classes**: 
+  - 0: "dry" - Dry skin type
+  - 1: "oily" - Oily skin type
+- **Output**: Softmax probabilities for each class
+
+## Ethical Considerations
+
+### Bias and Fairness
+- Model trained on diverse skin types but may have limitations
+- Users should be aware of potential biases in skin tone representation
+- Continuous evaluation needed for fair performance across demographics
+
+### Privacy
+- Model processes images locally - no data transmission required
+- Users responsible for ensuring proper consent when analyzing others' images
+- Recommend anonymization of facial features when possible
+
+## License
+
+This model is released under the MIT License. See LICENSE file for details.
+
+## Citation
+
+If you use this model in your research, please cite:
+
+```bibtex
+@misc{skin-type-classifier-2025,
+  title={Skin Type Classification Model},
+  author={Your Name},
+  year={2025},
+  howpublished={\\url{https://huggingface.co/your-username/skin-type-classifier}},
+}
+```
+
+## Contact
+
+For questions, issues, or collaboration opportunities, please reach out through the Hugging Face model page or GitHub repository.
+
+---
+
+**Disclaimer**: This model is for research and cosmetic purposes only. It should not be used for medical diagnosis or treatment decisions. Always consult healthcare professionals for medical concerns.

config.json

@@ -0,0 +1,19 @@
+{
+  "architectures": [
+    "ResNet50ForImageClassification"
+  ],
+  "model_type": "resnet",
+  "task": "image-classification",
+  "id2label": {
+    "0": "dry",
+    "1": "oily"
+  },
+  "label2id": {
+    "dry": 0,
+    "oily": 1
+  },
+  "num_labels": 2,
+  "image_size": 224,
+  "num_channels": 3,
+  "problem_type": "single_label_classification"
+}

example_usage.py

@@ -0,0 +1,91 @@
+"""
+Example usage script for the Skin Type Classification model on Hugging Face.
+"""
+
+from transformers import AutoModelForImageClassification, AutoImageProcessor
+from PIL import Image
+import torch
+import requests
+from io import BytesIO
+
+def load_model(model_name="your-username/skin-type-classifier"):
+    """Load the model and processor from Hugging Face."""
+    model = AutoModelForImageClassification.from_pretrained(model_name)
+    processor = AutoImageProcessor.from_pretrained(model_name)
+    return model, processor
+
+def predict_skin_type(image_path_or_url, model, processor):
+    """
+    Predict skin type from an image.
+    
+    Args:
+        image_path_or_url: Path to local image or URL
+        model: The loaded model
+        processor: The loaded processor
+    
+    Returns:
+        dict: Prediction results with class and confidence
+    """
+    # Load image
+    if image_path_or_url.startswith(('http://', 'https://')):
+        response = requests.get(image_path_or_url)
+        image = Image.open(BytesIO(response.content))
+    else:
+        image = Image.open(image_path_or_url)
+    
+    # Convert to RGB if needed
+    if image.mode != 'RGB':
+        image = image.convert('RGB')
+    
+    # Process image
+    inputs = processor(images=image, return_tensors="pt")
+    
+    # Make prediction
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        predicted_class_idx = predictions.argmax().item()
+        confidence = predictions[0][predicted_class_idx].item()
+    
+    # Map to class names
+    class_names = {0: "dry", 1: "oily"}
+    predicted_class = class_names[predicted_class_idx]
+    
+    return {
+        "predicted_class": predicted_class,
+        "confidence": confidence,
+        "all_scores": {
+            "dry": predictions[0][0].item(),
+            "oily": predictions[0][1].item()
+        }
+    }
+
+def main():
+    """Example usage of the skin type classification model."""
+    print("🔬 Loading Skin Type Classification Model...")
+    
+    # Load model and processor
+    model, processor = load_model()
+    
+    print("✅ Model loaded successfully!")
+    
+    # Example with local image (replace with your image path)
+    try:
+        image_path = "example_skin_image.jpg"  # Replace with actual image path
+        result = predict_skin_type(image_path, model, processor)
+        
+        print(f"\n📊 Prediction Results:")
+        print(f"Predicted Skin Type: {result['predicted_class']}")
+        print(f"Confidence: {result['confidence']:.2%}")
+        print(f"All Scores: {result['all_scores']}")
+        
+    except FileNotFoundError:
+        print("ℹ️  Please provide a valid image path to test the model")
+    
+    # Example usage patterns
+    print("\n💡 Usage Examples:")
+    print("1. Local image: predict_skin_type('path/to/image.jpg', model, processor)")
+    print("2. URL image: predict_skin_type('https://example.com/image.jpg', model, processor)")
+
+if __name__ == "__main__":
+    main()

modeling_skin_classifier.py

@@ -0,0 +1,78 @@
+import torch
+import torch.nn as nn
+from torchvision.models import resnet50, ResNet50_Weights
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers.modeling_outputs import ImageClassifierOutput
+from typing import Optional
+
+
+class SkinClassifierConfig(PretrainedConfig):
+    """Configuration class for SkinClassifier model."""
+    
+    model_type = "skin-classifier"
+    
+    def __init__(
+        self,
+        num_labels: int = 2,
+        image_size: int = 224,
+        num_channels: int = 3,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.num_labels = num_labels
+        self.image_size = image_size
+        self.num_channels = num_channels
+
+
+class SkinClassifierModel(PreTrainedModel):
+    """
+    Skin Type Classification Model based on ResNet50.
+    
+    This model classifies skin images into two categories:
+    - dry (label 0)
+    - oily (label 1)
+    """
+    
+    config_class = SkinClassifierConfig
+    
+    def __init__(self, config):
+        super().__init__(config)
+        self.config = config
+        
+        # Initialize ResNet50 backbone
+        self.resnet = resnet50(weights=None)
+        
+        # Replace the final classification layer
+        self.resnet.fc = nn.Linear(self.resnet.fc.in_features, config.num_labels)
+        
+        # Initialize weights
+        self.post_init()
+    
+    def forward(
+        self,
+        pixel_values: torch.FloatTensor,
+        labels: Optional[torch.LongTensor] = None,
+        **kwargs
+    ) -> ImageClassifierOutput:
+        """
+        Forward pass of the model.
+        
+        Args:
+            pixel_values: Tensor of shape (batch_size, num_channels, height, width)
+            labels: Optional tensor of shape (batch_size,) for training
+            
+        Returns:
+            ImageClassifierOutput with logits and optional loss
+        """
+        # Forward pass through ResNet
+        logits = self.resnet(pixel_values)
+        
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(logits, labels)
+        
+        return ImageClassifierOutput(
+            loss=loss,
+            logits=logits,
+        )

preprocessor_config.json

@@ -0,0 +1,12 @@
+{
+  "do_normalize": true,
+  "do_resize": true,
+  "feature_extractor_type": "ImageFeatureExtractor",
+  "image_mean": [0.485, 0.456, 0.406],
+  "image_std": [0.229, 0.224, 0.225],
+  "resample": 2,
+  "size": {
+    "height": 224,
+    "width": 224
+  }
+}

pytorch_model.bin

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

requirements.txt

@@ -0,0 +1,5 @@
+torch>=1.9.0
+torchvision>=0.10.0
+transformers>=4.21.0
+Pillow>=8.0.0
+numpy>=1.21.0