Upload folder using huggingface_hub

README.md

@@ -1,351 +1,81 @@
 ---
 license: apache-2.0
+base_model: google/vit-base-patch16-224-in21k
 tags:
-- computer-vision
 - image-classification
-- vision
-base_model: google/vit-base-patch16-224-in21k
+- computer-vision
+- skincare
+- vision-transformer
 datasets:
 - custom
 metrics:
 - accuracy
 - f1
-model-index:
-- name: skincare-detection
-  results: []
-inference: true
-widget:
-  - src: >-
-      https://huggingface.co/0xnu/skincare-detection/resolve/main/joe.jpeg
-    example_title: "Sample Skin Image"
+pipeline_tag: image-classification
 ---
 
-## skincare-detection
+# skincare-detection
 
-A custom model for skincare image classification.
+## Model Description
 
-### Data Classes (Training)
+This model is a fine-tuned version of [google/vit-base-patch16-224-in21k](https://huggingface.co/google/vit-base-patch16-224-in21k) for skincare image classification.
 
-+ acne
-+ athlete-foot
-+ cellulitis
-+ chickenpox
-+ cutaneous-larva-migrans
-+ eczema
-+ impetigo
-+ nail-fungus
-+ normal
-+ ringworm
-+ rosacea
-+ shingles
+## Model Performance
 
-### Model Performance (Evaluation Results)
+- **Accuracy**: N/A
+- **F1 Score**: N/A
+- **Precision**: N/A
+- **Recall**: N/A
 
-```sh
-  eval_loss: 0.2097
-  eval_accuracy: 0.9779
-  eval_f1: 0.9778
-  eval_precision: 0.9794
-  eval_recall: 0.9779
-  eval_runtime: 14.2159
-  eval_samples_per_second: 19.1340
-  eval_steps_per_second: 0.6330
-  epoch: 12.0000
-```
+## Training Details
 
-### Confusion Matrix
+### Training Data
+Custom dataset with 1009 training samples
 
-![Confusion Matrix](confusion_matrix.png "Confusion Matrix")
+### Training Hyperparameters
 
-### Usage
+- Learning rate: 2e-4
+- Batch size: 32
+- Number of epochs: 12
+- Optimizer: Adam
+- Scheduler: Linear with warmup
 
-```python
-#!/usr/bin/env python3
+### Classes
+Classes: acne, athlete-foot, cellulitis, chickenpox, cutaneous-larva-migrans, eczema, impetigo, nail-fungus, normal, ringworm, rosacea, shingles
 
-import torch
+## Usage
+
+```python
 from transformers import ViTImageProcessor, ViTForImageClassification
 from PIL import Image
-import numpy as np
-from pathlib import Path
-import json
-from typing import List, Dict, Union
-import argparse
+import torch
+
+# Load model and processor
+processor = ViTImageProcessor.from_pretrained('0xnu/skincare-detection')
+model = ViTForImageClassification.from_pretrained('0xnu/skincare-detection')
 
-class SkincareClassifier:
-    """Skincare classifier with detailed outputs."""
-    
-    def __init__(self, model_name: str = '0xnu/skincare-detection'):
-        """Initialize the classifier with model loading."""
-        print(f"🔄 Loading model: {model_name}")
-        
-        try:
-            self.processor = ViTImageProcessor.from_pretrained(model_name)
-            self.model = ViTForImageClassification.from_pretrained(model_name)
-            self.model.eval()
-            
-            # Get class information
-            self.id2label = self.model.config.id2label
-            self.label2id = self.model.config.label2id
-            self.num_classes = len(self.id2label)
-            
-            print(f"✅ Model loaded successfully!")
-            print(f"📊 Classes ({self.num_classes}): {list(self.id2label.values())}")
-            
-        except Exception as e:
-            print(f"❌ Error loading model: {e}")
-            raise e
-    
-    def classify_single_image(self, image_path: Union[str, Path], 
-                            show_all_scores: bool = True,
-                            min_confidence: float = 0.01) -> Dict:
-        """
-        Classify a single image and return detailed results.
-        
-        Args:
-            image_path: Path to the image file
-            show_all_scores: Whether to show all class scores
-            min_confidence: Minimum confidence to display (0.0 to 1.0)
-            
-        Returns:
-            Dictionary with classification results
-        """
-        
-        try:
-            # Load and process image
-            image = Image.open(image_path).convert('RGB')
-            inputs = self.processor(images=image, return_tensors="pt")
-            
-            # Make prediction
-            with torch.no_grad():
-                outputs = self.model(**inputs)
-                logits = outputs.logits
-                probabilities = torch.softmax(logits, dim=-1)[0]
-            
-            # Get top prediction
-            predicted_class_id = logits.argmax().item()
-            predicted_label = self.id2label[predicted_class_id]
-            predicted_confidence = float(probabilities[predicted_class_id])
-            
-            # Prepare all scores
-            all_scores = {}
-            for class_id, class_name in self.id2label.items():
-                confidence = float(probabilities[class_id])
-                if confidence >= min_confidence:
-                    all_scores[class_name] = confidence
-            
-            # Sort by confidence
-            sorted_scores = dict(sorted(all_scores.items(), 
-                                     key=lambda x: x[1], reverse=True))
-            
-            result = {
-                'image_path': str(image_path),
-                'image_name': Path(image_path).name,
-                'predicted_class': predicted_label,
-                'predicted_confidence': predicted_confidence,
-                'all_scores': sorted_scores if show_all_scores else None,
-                'image_size': image.size,
-                'num_classes': self.num_classes
-            }
-            
-            return result
-            
-        except Exception as e:
-            return {
-                'image_path': str(image_path),
-                'error': str(e)
-            }
-    
-    def classify_multiple_images(self, image_paths: List[Union[str, Path]], 
-                               **kwargs) -> List[Dict]:
-        """Classify multiple images and return results."""
-        
-        results = []
-        total_images = len(image_paths)
-        
-        print(f"🔄 Processing {total_images} images...")
-        
-        for i, image_path in enumerate(image_paths, 1):
-            print(f"  Processing {i}/{total_images}: {Path(image_path).name}")
-            result = self.classify_single_image(image_path, **kwargs)
-            results.append(result)
-        
-        return results
-    
-    def classify_directory(self, directory_path: Union[str, Path], 
-                         **kwargs) -> List[Dict]:
-        """Classify all images in a directory."""
-        
-        directory_path = Path(directory_path)
-        
-        # Find all image files
-        image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'}
-        image_paths = [
-            p for p in directory_path.rglob('*') 
-            if p.suffix.lower() in image_extensions
-        ]
-        
-        if not image_paths:
-            print(f"❌ No images found in {directory_path}")
-            return []
-        
-        print(f"📁 Found {len(image_paths)} images in {directory_path}")
-        return self.classify_multiple_images(image_paths, **kwargs)
-    
-    def print_results(self, results: Union[Dict, List[Dict]], 
-                     detailed: bool = True):
-        """Print classification results in a nice format."""
-        
-        if isinstance(results, dict):
-            results = [results]
-        
-        print(f"\n🔍 CLASSIFICATION RESULTS")
-        print("=" * 60)
-        
-        successful_results = [r for r in results if 'error' not in r]
-        failed_results = [r for r in results if 'error' in r]
-        
-        # Print successful classifications
-        for i, result in enumerate(successful_results, 1):
-            print(f"\n📸 Image {i}: {result['image_name']}")
-            print(f"   Size: {result['image_size'][0]}x{result['image_size'][1]} pixels")
-            
-            # Top prediction
-            pred_class = result['predicted_class']
-            pred_conf = result['predicted_confidence']
-            print(f"\n🎯 TOP PREDICTION:")
-            print(f"   {pred_class.upper()}: {pred_conf:.1%}")
-            
-            # All scores if detailed
-            if detailed and result.get('all_scores'):
-                print(f"\n📊 ALL SCORES:")
-                for class_name, confidence in result['all_scores'].items():
-                    # Create progress bar
-                    bar_length = int(confidence * 40)  # Scale to 40 chars
-                    bar = "█" * bar_length + "░" * (40 - bar_length)
-                    
-                    print(f"   {class_name:>8}: {confidence:.1%} {bar}")
-            
-            print(f"   {'-' * 50}")
-        
-        # Print failed classifications
-        if failed_results:
-            print(f"\n❌ FAILED CLASSIFICATIONS ({len(failed_results)}):")
-            for result in failed_results:
-                print(f"   {result['image_path']}: {result['error']}")
-        
-        # Summary
-        if len(successful_results) > 1:
-            print(f"\n📈 SUMMARY:")
-            print(f"   Successfully processed: {len(successful_results)} images")
-            print(f"   Failed: {len(failed_results)} images")
-            
-            # Class distribution
-            class_counts = {}
-            for result in successful_results:
-                pred_class = result['predicted_class']
-                class_counts[pred_class] = class_counts.get(pred_class, 0) + 1
-            
-            print(f"\n📊 CLASS DISTRIBUTION:")
-            for class_name, count in sorted(class_counts.items()):
-                percentage = (count / len(successful_results)) * 100
-                print(f"   {class_name:>8}: {count:>3} images ({percentage:.1f}%)")
-    
-    def save_results(self, results: List[Dict], output_file: str):
-        """Save results to JSON file."""
-        
-        try:
-            with open(output_file, 'w') as f:
-                json.dump(results, f, indent=2, default=str)
-            print(f"💾 Results saved to: {output_file}")
-        except Exception as e:
-            print(f"❌ Error saving results: {e}")
+# Process image
+image = Image.open('path_to_your_image.jpg')
+inputs = processor(images=image, return_tensors="pt")
 
-def main():
-    """Main function with command line interface."""
-    
-    parser = argparse.ArgumentParser(description="Skincare Image Classification")
-    parser.add_argument('input', help='Image file or directory path')
-    parser.add_argument('--model', default='0xnu/skincare-detection',
-                       help='HuggingFace model name')
-    parser.add_argument('--output', help='Output JSON file for results')
-    parser.add_argument('--min-confidence', type=float, default=0.01,
-                       help='Minimum confidence to display (0.0-1.0)')
-    parser.add_argument('--brief', action='store_true',
-                       help='Show only top prediction')
-    parser.add_argument('--batch-size', type=int, default=1,
-                       help='Batch size for processing (not implemented yet)')
-    
-    args = parser.parse_args()
-    
-    try:
-        # Initialize classifier
-        classifier = SkincareClassifier(args.model)
-        
-        input_path = Path(args.input)
-        
-        if input_path.is_file():
-            # Single image
-            result = classifier.classify_single_image(
-                input_path,
-                show_all_scores=not args.brief,
-                min_confidence=args.min_confidence
-            )
-            classifier.print_results(result, detailed=not args.brief)
-            
-            if args.output:
-                classifier.save_results([result], args.output)
-        
-        elif input_path.is_dir():
-            # Directory of images
-            results = classifier.classify_directory(
-                input_path,
-                show_all_scores=not args.brief,
-                min_confidence=args.min_confidence
-            )
-            classifier.print_results(results, detailed=not args.brief)
-            
-            if args.output:
-                classifier.save_results(results, args.output)
-        
-        else:
-            print(f"❌ Error: {input_path} is not a valid file or directory")
-    
-    except Exception as e:
-        print(f"❌ Error: {e}")
+# Make prediction
+with torch.no_grad():
+    outputs = model(**inputs)
+    logits = outputs.logits
+    predicted_class_id = logits.argmax().item()
+    predicted_label = model.config.id2label[predicted_class_id]
 
-if __name__ == "__main__":
-    # If run directly, you can also use it programmatically
-    import sys
-    
-    if len(sys.argv) == 1:
-        print("🔬 Skincare Classification")
-        print("=" * 40)
-        
-        # Initialize classifier
-        classifier = SkincareClassifier('0xnu/skincare-detection')
-        
-        # Example with your image
-        image_path = 'joe.jpeg'  # Your image
-        
-        if Path(image_path).exists():
-            result = classifier.classify_single_image(image_path)
-            classifier.print_results(result)
-        else:
-            print(f"❌ Image not found: {image_path}")
-            print("\n💡 Usage examples:")
-            print("python skincare.py joe.jpeg")
-            print("python skincare.py image_directory/")
-            print("python skincare.py joe.jpeg --output results.json")
-    else:
-        main()
+print(f"Predicted class: {predicted_label}")
 ```
 
-### Limitations and Bias
+## Limitations and Bias
 
 - The model performance depends on the quality and diversity of training data
 - May not generalise well to skincare images significantly different from training distribution
 - Evaluate model performance on your specific use case before deployment
 
-### Copyright
+## Training Environment
 
-(c) Copyright 2025 Finbarrs Oketunji. All Rights Reserved.
+- Framework: Transformers 4.38.2
+- PyTorch: 2.1.2
+- Hardware: GPU/CPU

checkpoint-96/config.json

@@ -0,0 +1,53 @@
+{
+  "architectures": [
+    "ViTForImageClassification"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "encoder_stride": 16,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "acne",
+    "1": "athlete-foot",
+    "2": "cellulitis",
+    "3": "chickenpox",
+    "4": "cutaneous-larva-migrans",
+    "5": "eczema",
+    "6": "impetigo",
+    "7": "nail-fungus",
+    "8": "normal",
+    "9": "ringworm",
+    "10": "rosacea",
+    "11": "shingles"
+  },
+  "image_size": 224,
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "acne": 0,
+    "athlete-foot": 1,
+    "cellulitis": 2,
+    "chickenpox": 3,
+    "cutaneous-larva-migrans": 4,
+    "eczema": 5,
+    "impetigo": 6,
+    "nail-fungus": 7,
+    "normal": 8,
+    "ringworm": 9,
+    "rosacea": 10,
+    "shingles": 11
+  },
+  "layer_norm_eps": 1e-12,
+  "model_type": "vit",
+  "num_attention_heads": 12,
+  "num_channels": 3,
+  "num_hidden_layers": 12,
+  "patch_size": 16,
+  "pooler_act": "tanh",
+  "pooler_output_size": 768,
+  "problem_type": "single_label_classification",
+  "qkv_bias": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.55.0"
+}

checkpoint-96/model.safetensors

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

checkpoint-96/optimizer.pt

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

checkpoint-96/rng_state.pth

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

checkpoint-96/scheduler.pt

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

checkpoint-96/trainer_state.json

@@ -0,0 +1,118 @@
+{
+  "best_global_step": 50,
+  "best_metric": 0.9785714285714285,
+  "best_model_checkpoint": null,
+  "epoch": 12.0,
+  "eval_steps": 50,
+  "global_step": 96,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 1.25,
+      "grad_norm": 1.411300778388977,
+      "learning_rate": 0.00018,
+      "loss": 2.2387,
+      "step": 10
+    },
+    {
+      "epoch": 2.5,
+      "grad_norm": 1.0807230472564697,
+      "learning_rate": 0.00017906976744186048,
+      "loss": 1.2121,
+      "step": 20
+    },
+    {
+      "epoch": 3.75,
+      "grad_norm": 0.6904317736625671,
+      "learning_rate": 0.0001558139534883721,
+      "loss": 0.5672,
+      "step": 30
+    },
+    {
+      "epoch": 5.0,
+      "grad_norm": 0.5183396935462952,
+      "learning_rate": 0.00013255813953488372,
+      "loss": 0.3326,
+      "step": 40
+    },
+    {
+      "epoch": 6.25,
+      "grad_norm": 0.4176619052886963,
+      "learning_rate": 0.00010930232558139534,
+      "loss": 0.2472,
+      "step": 50
+    },
+    {
+      "epoch": 6.25,
+      "eval_accuracy": 0.9785714285714285,
+      "eval_f1": 0.9781596849266023,
+      "eval_loss": 0.27442124485969543,
+      "eval_precision": 0.9790764790764791,
+      "eval_recall": 0.9785714285714285,
+      "eval_runtime": 8.6568,
+      "eval_samples_per_second": 16.172,
+      "eval_steps_per_second": 0.578,
+      "step": 50
+    },
+    {
+      "epoch": 7.5,
+      "grad_norm": 0.3670105040073395,
+      "learning_rate": 8.604651162790697e-05,
+      "loss": 0.2062,
+      "step": 60
+    },
+    {
+      "epoch": 8.75,
+      "grad_norm": 0.34629565477371216,
+      "learning_rate": 6.27906976744186e-05,
+      "loss": 0.1832,
+      "step": 70
+    },
+    {
+      "epoch": 10.0,
+      "grad_norm": 0.3259499967098236,
+      "learning_rate": 3.953488372093023e-05,
+      "loss": 0.1699,
+      "step": 80
+    },
+    {
+      "epoch": 11.25,
+      "grad_norm": 0.3109147548675537,
+      "learning_rate": 1.6279069767441862e-05,
+      "loss": 0.1625,
+      "step": 90
+    }
+  ],
+  "logging_steps": 10,
+  "max_steps": 96,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 12,
+  "save_steps": 100,
+  "stateful_callbacks": {
+    "EarlyStoppingCallback": {
+      "args": {
+        "early_stopping_patience": 3,
+        "early_stopping_threshold": 0.0
+      },
+      "attributes": {
+        "early_stopping_patience_counter": 0
+      }
+    },
+    "TrainerControl": {
+      "args": {
+        "should_epoch_stop": false,
+        "should_evaluate": false,
+        "should_log": false,
+        "should_save": true,
+        "should_training_stop": true
+      },
+      "attributes": {}
+    }
+  },
+  "total_flos": 9.383571046956073e+17,
+  "train_batch_size": 32,
+  "trial_name": null,
+  "trial_params": null
+}

checkpoint-96/training_args.bin

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

config.json

@@ -9,18 +9,34 @@
   "hidden_size": 768,
   "id2label": {
     "0": "acne",
-    "1": "eczema",
-    "2": "normal",
-    "3": "rosacea"
+    "1": "athlete-foot",
+    "2": "cellulitis",
+    "3": "chickenpox",
+    "4": "cutaneous-larva-migrans",
+    "5": "eczema",
+    "6": "impetigo",
+    "7": "nail-fungus",
+    "8": "normal",
+    "9": "ringworm",
+    "10": "rosacea",
+    "11": "shingles"
   },
   "image_size": 224,
   "initializer_range": 0.02,
   "intermediate_size": 3072,
   "label2id": {
     "acne": 0,
-    "eczema": 1,
-    "normal": 2,
-    "rosacea": 3
+    "athlete-foot": 1,
+    "cellulitis": 2,
+    "chickenpox": 3,
+    "cutaneous-larva-migrans": 4,
+    "eczema": 5,
+    "impetigo": 6,
+    "nail-fungus": 7,
+    "normal": 8,
+    "ringworm": 9,
+    "rosacea": 10,
+    "shingles": 11
   },
   "layer_norm_eps": 1e-12,
   "model_type": "vit",

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5823126bb2dcf845e0d5b5a9ef85febfef7bd6461e0fcda29ed0adfee64c79ef
-size 343230128
+oid sha256:e51135ac7635a9a36723c23064bb400884097037a64fef2c237d15f684f8ac5c
+size 343254736

training_args.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4aed3420e473a8800e471f723bc84c39200216f80b1882c067e8e9691f167105
+oid sha256:5c1fad4ba54b504a5110180cd6b64009b07e6b350131fe6cf05a4712d39c1b9f
 size 5713

training_results.json

@@ -1,8 +1,8 @@
 {
-  "train_runtime": 211.1149,
-  "train_samples_per_second": 11.368,
-  "train_steps_per_second": 0.114,
-  "total_flos": 1.859841088487424e+17,
-  "train_loss": 0.4300013507405917,
+  "train_runtime": 1232.5529,
+  "train_samples_per_second": 9.824,
+  "train_steps_per_second": 0.078,
+  "total_flos": 9.383571046956073e+17,
+  "train_loss": 0.5641234858582417,
   "epoch": 12.0
 }