Model save

README.md

@@ -1,255 +1,89 @@
 ---
-license: apache-2.0
-language:
-- en
-base_model:
-- bobbysam/resnet18-image-detector
 library_name: transformers
-pipeline_tag: image-classification
 tags:
-- computer-vision
-- image-classification
-- ai-detection
-- pytorch
-- resnet
-datasets:
-- custom
+- generated_from_trainer
 metrics:
 - accuracy
+- f1
 - precision
 - recall
-- f1
 model-index:
 - name: resnet18-image-detector
-  results:
-  - task:
-      type: image-classification
-      name: AI vs Real Image Detection
-    dataset:
-      name: Custom AI Detection Dataset
-      type: custom
-    metrics:
-    - type: accuracy
-      value: 0.95
-      name: Accuracy
-    - type: f1
-      value: 0.94
-      name: F1 Score
-    - type: precision
-      value: 0.93
-      name: Precision
-    - type: recall
-      value: 0.96
-      name: Recall
----
-# ResNet18 AI Image Detector
-
-**Repository:** [bobbysam/resnet18-image-detector](https://huggingface.co/bobbysam/resnet18-image-detector)
-
-[![Train](https://huggingface.co/datasets/huggingface/badges/raw/main/train-on-spaces-sm.svg)](https://huggingface.co/spaces/autotrain-projects/train-resnet18-detector)
-[![Deploy](https://huggingface.co/datasets/huggingface/badges/raw/main/deploy-on-spaces-sm.svg)](https://huggingface.co/spaces/autotrain-projects/deploy-resnet18-detector)
-
----
-
-## 🧠 What does this model do?
-
-This is a **ResNet18-based deep neural network** trained to **detect whether an input image is a real photograph or AI-generated** (binary classification: `real` vs. `ai_generated`).  
-It is part of the [ProofGuard](https://github.com/Proofguard/proofguard-backend) project and can be used to build trustworthy AI image detection pipelines.
-
-**Key Features:**
-- 🔬 Binary classification: Real vs AI-generated images
-- 🚀 Fast inference with ResNet18 architecture
-- 🤗 Compatible with Hugging Face Transformers
-- 📊 Comprehensive evaluation metrics
-- 🎯 Easy-to-use inference API
-
----
-
-## 🚀 Quick Start
-
-### **Option 1: Using Hugging Face Transformers (Recommended)**
-
-```python
-from transformers import AutoModelForImageClassification, AutoImageProcessor
-from PIL import Image
-import torch
-
-# Load model and processor
-model = AutoModelForImageClassification.from_pretrained("bobbysam/resnet18-image-detector")
-processor = AutoImageProcessor.from_pretrained("bobbysam/resnet18-image-detector")
-
-# Load and process image
-image = Image.open("your_image.jpg")
-inputs = processor(image, return_tensors="pt")
-
-# Make prediction
-with torch.no_grad():
-    outputs = model(**inputs)
-    probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    prediction = torch.argmax(probabilities, dim=-1).item()
-
-labels = ["Real", "AI-generated"]
-confidence = probabilities[0, prediction].item()
-print(f"Prediction: {labels[prediction]} (Confidence: {confidence:.2%})")
-```
-
-### **Option 2: Using the Inference Script**
-
-```bash
-# Clone the repository
-git clone https://huggingface.co/bobbysam/resnet18-image-detector
-cd resnet18-image-detector
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Run inference
-python inference.py --image path/to/your/image.jpg --model ./
-```
-
-### **Option 3: Using the Custom Wrapper**
-
-```python
-from inference import AIImageDetector
-
-# Initialize detector
-detector = AIImageDetector()
-
-# Make prediction
-result = detector.predict("your_image.jpg")
-print(f"Prediction: {result['prediction']}")
-print(f"Confidence: {result['confidence']:.2%}")
-``` ---
-
-## 🏋️ Training Your Own Model
-
-### **Quick Training with Hugging Face Trainer**
-
-```bash
-# 1. Setup the environment
-python setup.py
-
-# 2. Download/prepare your dataset
-python download_dataset.py --dataset_type custom --source_dir /path/to/your/data
-
-# 3. Train the model
-python trainer.py \
-    --data_dir ./data \
-    --output_dir ./results \
-    --num_epochs 10 \
-    --batch_size 16 \
-    --push_to_hub \
-    --hub_model_id your-username/resnet18-detector
-```
-
-### **Training Arguments**
-
-| Argument | Description | Default |
-|----------|-------------|---------|
-| `--data_dir` | Path to dataset directory | Required |
-| `--output_dir` | Output directory for model | `./results` |
-| `--num_epochs` | Number of training epochs | 10 |
-| `--batch_size` | Training batch size | 16 |
-| `--learning_rate` | Learning rate | 2e-5 |
-| `--dropout_rate` | Dropout rate for regularization | 0.5 |
-| `--freeze_backbone` | Freeze ResNet backbone | False |
-| `--push_to_hub` | Push model to HF Hub | False |
-| `--hub_model_id` | Hugging Face model ID | None |
-
-### **Dataset Structure**
-
-Your dataset should be organized as follows:
-```
-data/
-├── real/
-│   ├── image1.jpg
-│   ├── image2.jpg
-│   └── ...
-└── ai_generated/
-    ├── image1.jpg
-    ├── image2.jpg
-    └── ...
-```
-
----
-
-## 🚀 Deployment Options
-
-This model supports multiple deployment options through Hugging Face:
-
-### **1. Hugging Face Inference Endpoints**
-- Production-ready inference API
-- Auto-scaling and load balancing
-- Pay-per-request pricing
-
-### **2. Amazon SageMaker**
-- Deploy directly to AWS SageMaker
-- Enterprise-grade infrastructure
-- Custom scaling policies
-
-### **3. Azure ML**
-- Deploy to Azure Machine Learning
-- Integration with Azure services
-- Enterprise security features
-
-### **4. Local Deployment**
-```python
-# Load model locally
-from transformers import pipeline
-
-classifier = pipeline(
-    "image-classification",
-    model="bobbysam/resnet18-image-detector",
-    device=0 if torch.cuda.is_available() else -1
-)
-
-result = classifier("path/to/image.jpg")
-```
-
----
-
-## 📥 Input format and requirements
-
-- **Input:** RGB image (PIL Image or file path), resized to 224x224, normalized as in ImageNet.
-- **Output:**  
-  - `0` = Real photograph  
-  - `1` = AI-generated image
-
----
-
-## 📦 Model details
-
-- **Architecture:** ResNet18 (PyTorch, torchvision)
-- **Training data:** Real & AI-generated images (see [ProofGuard project](https://github.com/Proofguard/proofguard-backend))
-- **Framework:** PyTorch
-- **Size:** ~60MB
-
----
-
-## ⚖️ License and usage
-
-- **License:** [MIT](https://opensource.org/license/mit/) (or specify your own)
-- **Usage restrictions:** For research, education, and non-commercial projects.  
-  _For commercial use, contact the author or check the ProofGuard project license._
-
----
-
-## 🙏 Citation
-
-If you use this model, please cite:
-```text
-ProofGuard: AI Image Authenticity Detection
-https://github.com/Proofguard/proofguard-backend
-Model by @bobbysam (Hugging Face)
-```
-
----
-
-## 🛠️ Maintainer
-
-- [@bobbysam](https://huggingface.co/bobbysam)
-- [ProofGuard GitHub](https://github.com/Proofguard/proofguard-backend)
-
+  results: []
 ---
 
-*Feel free to open issues or PRs on the [ProofGuard repo](https://github.com/Proofguard/proofguard-backend) for improvements or questions!*
+<!-- This model card has been generated automatically according to the information the Trainer had access to. You
+should probably proofread and complete it, then remove this comment. -->
+
+# resnet18-image-detector
+
+This model is a fine-tuned version of [](https://huggingface.co/) on the None dataset.
+It achieves the following results on the evaluation set:
+- Loss: 0.2461
+- Accuracy: 0.9738
+- F1: 0.9737
+- Precision: 0.9739
+- Recall: 0.9738
+
+## Model description
+
+More information needed
+
+## Intended uses & limitations
+
+More information needed
+
+## Training and evaluation data
+
+More information needed
+
+## Training procedure
+
+### Training hyperparameters
+
+The following hyperparameters were used during training:
+- learning_rate: 0.0001
+- train_batch_size: 16
+- eval_batch_size: 16
+- seed: 42
+- gradient_accumulation_steps: 2
+- total_train_batch_size: 32
+- optimizer: Use adamw_torch with betas=(0.9,0.999) and epsilon=1e-08 and optimizer_args=No additional optimizer arguments
+- lr_scheduler_type: cosine_with_restarts
+- lr_scheduler_warmup_ratio: 0.1
+- num_epochs: 3
+
+### Training results
+
+| Training Loss | Epoch  | Step | Validation Loss | Accuracy | F1     | Precision | Recall |
+|:-------------:|:------:|:----:|:---------------:|:--------:|:------:|:---------:|:------:|
+| 1.3887        | 0.0533 | 50   | 0.6371          | 0.7338   | 0.7336 | 0.7345    | 0.7338 |
+| 1.1433        | 0.1067 | 100  | 0.4604          | 0.8571   | 0.8569 | 0.8591    | 0.8571 |
+| 0.8563        | 0.16   | 150  | 0.3538          | 0.9081   | 0.9080 | 0.9094    | 0.9081 |
+| 0.7671        | 0.2133 | 200  | 0.3244          | 0.9277   | 0.9277 | 0.9282    | 0.9277 |
+| 0.7213        | 0.2667 | 250  | 0.3244          | 0.9301   | 0.9300 | 0.9307    | 0.9301 |
+| 0.6996        | 0.32   | 300  | 0.3187          | 0.9324   | 0.9323 | 0.9339    | 0.9324 |
+| 0.6975        | 0.3733 | 350  | 0.3429          | 0.9193   | 0.9189 | 0.9268    | 0.9193 |
+| 0.7327        | 0.4267 | 400  | 0.2890          | 0.9520   | 0.9520 | 0.9523    | 0.9520 |
+| 0.7072        | 0.48   | 450  | 0.2939          | 0.9460   | 0.9460 | 0.9475    | 0.9460 |
+| 0.666         | 0.5333 | 500  | 0.2886          | 0.9506   | 0.9505 | 0.9509    | 0.9506 |
+| 0.6596        | 0.5867 | 550  | 0.2800          | 0.9543   | 0.9543 | 0.9550    | 0.9543 |
+| 0.6394        | 0.64   | 600  | 0.2800          | 0.9523   | 0.9522 | 0.9524    | 0.9523 |
+| 0.6734        | 0.6933 | 650  | 0.2740          | 0.9579   | 0.9579 | 0.9586    | 0.9579 |
+| 0.6467        | 0.7467 | 700  | 0.2727          | 0.9582   | 0.9582 | 0.9595    | 0.9582 |
+| 0.6662        | 0.8    | 750  | 0.2711          | 0.9585   | 0.9585 | 0.9586    | 0.9585 |
+| 0.5994        | 0.8533 | 800  | 0.2625          | 0.9656   | 0.9656 | 0.9656    | 0.9656 |
+| 0.6189        | 0.9067 | 850  | 0.2843          | 0.95     | 0.9500 | 0.9511    | 0.95   |
+| 0.6317        | 0.96   | 900  | 0.2600          | 0.9651   | 0.9651 | 0.9658    | 0.9651 |
+| 0.5973        | 1.0128 | 950  | 0.2497          | 0.9733   | 0.9733 | 0.9733    | 0.9733 |
+| 0.5592        | 1.0661 | 1000 | 0.2461          | 0.9738   | 0.9737 | 0.9739    | 0.9738 |
+| 0.6093        | 1.1195 | 1050 | 0.2705          | 0.9567   | 0.9567 | 0.9590    | 0.9567 |
+| 0.5505        | 1.1728 | 1100 | 0.2465          | 0.9716   | 0.9716 | 0.9718    | 0.9716 |
+
+
+### Framework versions
+
+- Transformers 4.54.1
+- Pytorch 2.7.1+cu126
+- Datasets 4.0.0
+- Tokenizers 0.21.4

hf_config.py

@@ -0,0 +1,64 @@
+"""
+Hugging Face compatible configuration for existing Space
+This extends your existing config without breaking it
+"""
+
+try:
+    from transformers import PretrainedConfig
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    # Fallback configuration
+    class PretrainedConfig:
+        def __init__(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+
+class HFResNet18DetectorConfig(PretrainedConfig):
+    """
+    Hugging Face compatible configuration for your existing model
+    Works alongside your existing training config
+    """
+    
+    model_type = "resnet18-detector"
+    
+    def __init__(
+        self,
+        num_classes: int = 2,
+        image_size: int = 224,
+        architecture: str = "resnet18",
+        dropout_rate: float = 0.5,
+        freeze_backbone: bool = False,
+        pretrained_weights: str = "IMAGENET1K_V1",
+        label_smoothing: float = 0.1,  # Anti-overfitting: Label smoothing
+        weight_decay: float = 0.1,      # Anti-overfitting: L2 regularization
+        max_grad_norm: float = 1.0,     # Anti-overfitting: Gradient clipping
+        **kwargs
+    ):
+        """
+        Initialize HF compatible config with anti-overfitting parameters
+        """
+        self.num_classes = num_classes
+        self.image_size = image_size
+        self.architecture = architecture
+        self.dropout_rate = dropout_rate
+        self.freeze_backbone = freeze_backbone
+        self.pretrained_weights = pretrained_weights
+        self.label_smoothing = label_smoothing
+        self.weight_decay = weight_decay
+        self.max_grad_norm = max_grad_norm
+        
+        if TRANSFORMERS_AVAILABLE:
+            super().__init__(**kwargs)
+        else:
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+
+# Register for auto-loading if transformers is available
+if TRANSFORMERS_AVAILABLE:
+    try:
+        HFResNet18DetectorConfig.register_for_auto_class()
+    except:
+        pass

hf_model.py

@@ -0,0 +1,179 @@
+"""
+Hugging Face compatible model wrapper for your existing Space
+This works alongside your existing model loading without breaking it
+"""
+
+import torch
+import torch.nn as nn
+from typing import Optional
+import sys
+import os
+
+# Import transformers components if available
+try:
+    from transformers import PreTrainedModel
+    from transformers.modeling_outputs import ImageClassifierOutput
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    # Fallback classes
+    class PreTrainedModel(nn.Module):
+        def __init__(self, config):
+            super().__init__()
+            self.config = config
+    
+    class ImageClassifierOutput:
+        def __init__(self, loss=None, logits=None):
+            self.loss = loss
+            self.logits = logits
+
+# Import your existing components
+sys.path.append(os.path.join(os.path.dirname(__file__), "training"))
+
+try:
+    from hf_config import HFResNet18DetectorConfig
+except ImportError:
+    # Fallback config
+    class HFResNet18DetectorConfig:
+        def __init__(self, num_classes=2, **kwargs):
+            self.num_classes = num_classes
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+
+class HFResNet18Detector(PreTrainedModel):
+    """
+    Hugging Face compatible wrapper for your existing model
+    This allows your model to work with HF Trainer and ecosystem
+    """
+    
+    config_class = HFResNet18DetectorConfig
+    
+    def __init__(self, config: HFResNet18DetectorConfig):
+        super().__init__(config)
+        
+        self.num_labels = getattr(config, 'num_classes', 2)
+        self.config = config
+        
+        # Try to use your existing model creation logic first
+        try:
+            from training.detection_models import create_model
+            from training.config import get_model_config
+            
+            model_config = get_model_config("resnet18")
+            self.backbone = create_model("resnet18", model_config)
+            print("[HF Model] Using existing model creation logic")
+            
+        except Exception as e:
+            print(f"[HF Model] Fallback to basic ResNet18: {e}")
+            # Fallback to basic ResNet18
+            from torchvision.models import resnet18, ResNet18_Weights
+            
+            weights = ResNet18_Weights.IMAGENET1K_V1
+            self.backbone = resnet18(weights=weights)
+            
+            # Replace final layer with enhanced regularization
+            in_features = self.backbone.fc.in_features
+            dropout_rate = getattr(config, 'dropout_rate', 0.5)
+            num_classes = getattr(config, 'num_classes', 2)
+            
+            # Multi-layer classification head with stronger regularization
+            self.backbone.fc = nn.Sequential(
+                nn.Dropout(dropout_rate),
+                nn.Linear(in_features, 512),
+                nn.ReLU(),
+                nn.BatchNorm1d(512),
+                nn.Dropout(0.6),  # Higher dropout for intermediate layer
+                nn.Linear(512, 256),
+                nn.ReLU(),
+                nn.BatchNorm1d(256),
+                nn.Dropout(0.7),  # Even higher dropout near output
+                nn.Linear(256, num_classes)
+            )
+    
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs
+    ):
+        """
+        Forward pass compatible with both HF and your existing code
+        """
+        # Handle both HF format and your existing format
+        if pixel_values is None:
+            raise ValueError("pixel_values must be provided")
+        
+        # Forward pass through your existing model
+        logits = self.backbone(pixel_values)
+        
+        loss = None
+        if labels is not None:
+            # Ensure labels are properly formatted
+            if isinstance(labels, torch.Tensor):
+                labels = labels.long()
+            else:
+                labels = torch.tensor(labels, dtype=torch.long)
+            
+            # Ensure labels are 1D
+            if labels.dim() > 1:
+                labels = labels.squeeze()
+            
+            # Use label smoothing to combat overfitting with proper error handling
+            try:
+                label_smoothing = getattr(self.config, 'label_smoothing', 0.1)
+                loss_fct = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
+                loss = loss_fct(logits, labels)
+            except Exception as e:
+                print(f"[HF Model] Label smoothing failed ({e}), falling back to standard CrossEntropyLoss")
+                # Fallback to standard cross entropy if label smoothing fails
+                loss_fct = nn.CrossEntropyLoss()
+                loss = loss_fct(logits, labels)
+        
+        if TRANSFORMERS_AVAILABLE and return_dict:
+            return ImageClassifierOutput(
+                loss=loss,
+                logits=logits,
+            )
+        else:
+            # Fallback for non-HF usage
+            if loss is not None:
+                return loss, logits
+            return logits
+    
+    def predict_compatibility(self, x):
+        """
+        Compatibility method for your existing inference code
+        """
+        return self.backbone(x)
+
+
+# Register for auto-loading if transformers is available
+if TRANSFORMERS_AVAILABLE:
+    try:
+        HFResNet18Detector.register_for_auto_class("AutoModelForImageClassification")
+    except:
+        pass
+
+
+def create_hf_compatible_model(existing_model_path=None):
+    """
+    Helper function to create HF compatible model from existing weights
+    """
+    config = HFResNet18DetectorConfig()
+    model = HFResNet18Detector(config)
+    
+    if existing_model_path and os.path.exists(existing_model_path):
+        try:
+            # Load your existing model weights
+            checkpoint = torch.load(existing_model_path, map_location="cpu", weights_only=False)
+            if 'model_state_dict' in checkpoint:
+                model.backbone.load_state_dict(checkpoint['model_state_dict'])
+            else:
+                model.backbone.load_state_dict(checkpoint)
+            print(f"[HF Model] Loaded weights from {existing_model_path}")
+        except Exception as e:
+            print(f"[HF Model] Failed to load weights: {e}")
+    
+    return model

model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:03c332a43edc3107efc8fc01433ec598a08a0dab97d04e8c25f48b6a637c2efa
+oid sha256:d66bdfeedccc35f11a7b63a1c1864eae577135e56fa9cb8e00a828e6ce274d4d
 size 45284592