Upload Deep SVDD anomaly detection model

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,154 @@
+---
+license: apache-2.0
+tags:
+- anomaly-detection
+- deep-svdd
+- computer-vision
+- pytorch
+datasets:
+- cifar10
+- cifar100
+metrics:
+- accuracy
+- precision
+- recall
+- f1
+library_name: pytorch
+---
+
+# Deep SVDD Anomaly Detection Model
+
+A Deep Support Vector Data Description (Deep SVDD) model trained for anomaly detection on natural images.
+
+## Model Description
+
+This model uses a ResNet-based encoder to learn a hypersphere representation of normal data. Images are classified as anomalies based on their distance from the center of this hypersphere.
+
+**Training Data:**
+- CIFAR-10 (50,000 images)
+- CIFAR-100 (50,000 images)  
+- STL-10 (100,000 images)
+
+**Architecture:**
+- ResNet-based encoder with residual blocks
+- Latent dimension: 512
+- Input size: 128x128x3
+
+## Performance
+
+Evaluated on CIFAR-10 (normal) vs MNIST (anomaly):
+
+| Metric | Value |
+|--------|-------|
+| Accuracy | 87.00% |
+| Precision | 80.33% |
+| Recall | 98.00% |
+| F1 Score | 88.29% |
+
+**Anomaly Score Separation:** 6.15x (anomalies score ~6x higher than normal images)
+
+## Usage
+
+### Quick Start
+
+```python
+from model import DeepSVDDAnomalyDetector
+
+# Load model
+detector = DeepSVDDAnomalyDetector.from_pretrained('.')
+
+# Predict on image
+score, is_anomaly = detector.predict('test.jpg')
+print(f"Anomaly Score: {score:.6f}")
+print(f"Is Anomaly: {is_anomaly}")
+```
+
+### Download from Hugging Face
+
+```python
+from huggingface_hub import snapshot_download
+
+# Download model
+model_path = snapshot_download(repo_id="ash12321/deep-svdd-anomaly-detection")
+
+# Load
+detector = DeepSVDDAnomalyDetector.from_pretrained(model_path)
+```
+
+### Threshold Options
+
+The model supports three threshold presets:
+
+```python
+# Optimal F1 (default, recommended)
+detector.set_threshold('optimal')  # threshold = 0.001618
+
+# 95th percentile (balanced)
+detector.set_threshold('95th')     # threshold = 0.008501
+
+# 99th percentile (conservative, fewer false positives)
+detector.set_threshold('99th')     # threshold = 0.015922
+```
+
+**Threshold Comparison:**
+
+| Threshold | Accuracy | Precision | Recall | Use Case |
+|-----------|----------|-----------|--------|----------|
+| Optimal (0.0016) | 87% | 80% | 98% | **Recommended** - Best F1 |
+| 95th (0.0085) | 75% | 95% | 53% | Few false alarms |
+| 99th (0.0159) | 68% | 100% | 35% | Zero false alarms |
+
+## Training Details
+
+- **Framework:** PyTorch 2.9.1+cu128
+- **Precision:** bfloat16 mixed precision
+- **Optimizer:** Fused AdamW
+- **Hardware:** NVIDIA H200
+- **Epochs:** 50
+- **Batch Size:** 1536
+
+## Model Files
+
+- `deepsvdd_model.pth` - Model weights and hypersphere parameters
+- `thresholds.pkl` - All threshold configurations
+- `thresholds.json` - Thresholds in JSON format
+- `config.json` - Model configuration
+- `model.py` - Inference code
+- `requirements.txt` - Python dependencies
+
+## Citation
+
+```bibtex
+@misc{deep-svdd-anomaly-detection,
+  title={Deep SVDD Anomaly Detection Model},
+  author={ash12321},
+  year={2024},
+  publisher={Hugging Face},
+  url={https://huggingface.co/ash12321/deep-svdd-anomaly-detection}
+}
+```
+
+## License
+
+Apache 2.0
+
+## Limitations
+
+- Trained on natural images (CIFAR-10/100, STL-10)
+- Best suited for detecting distribution shift in natural images
+- May not generalize well to very different domains
+- Requires RGB images, resized to 128x128
+
+## Intended Use
+
+**Primary Use:** Anomaly detection in natural image datasets
+
+**Good for:**
+- Quality control in image datasets
+- Detecting out-of-distribution samples
+- Filtering unusual/corrupted images
+- Content moderation
+
+**Not recommended for:**
+- Critical safety systems without human review
+- Domains very different from natural images

config.json

@@ -0,0 +1,41 @@
+{
+  "model_type": "deep-svdd",
+  "task": "anomaly-detection",
+  "architecture": "resnet-encoder",
+  "latent_dim": 512,
+  "image_size": 128,
+  "input_channels": 3,
+  "training_datasets": [
+    "cifar10",
+    "cifar100",
+    "stl10"
+  ],
+  "normalization": {
+    "mean": [
+      0.485,
+      0.456,
+      0.406
+    ],
+    "std": [
+      0.229,
+      0.224,
+      0.225
+    ]
+  },
+  "thresholds": {
+    "optimal_f1": 0.001618,
+    "95th_percentile": 0.008500736206769943,
+    "99th_percentile": 0.015921616926789284,
+    "recommended": 0.001618
+  },
+  "performance": {
+    "threshold": 0.001618,
+    "accuracy": 0.87,
+    "precision": 0.8033,
+    "recall": 0.98,
+    "f1": 0.8829
+  },
+  "framework": "pytorch",
+  "pytorch_version": "2.9.1+cu128",
+  "license": "apache-2.0"
+}

deepsvdd_model.pth

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

example.py

@@ -0,0 +1,25 @@
+"""
+Example usage of Deep SVDD Anomaly Detection Model
+"""
+
+from model import DeepSVDDAnomalyDetector
+from huggingface_hub import snapshot_download
+
+# Download model from HuggingFace
+print("Downloading model...")
+model_path = snapshot_download(repo_id="ash12321/deep-svdd-anomaly-detection")
+
+# Load model
+print("Loading model...")
+detector = DeepSVDDAnomalyDetector.from_pretrained(model_path)
+
+# Example: Predict on image
+score, is_anomaly = detector.predict('test.jpg')
+print(f"Score: {score:.6f}")
+print(f"Anomaly: {is_anomaly}")
+
+# Try different thresholds
+for threshold in ['optimal', '95th', '99th']:
+    detector.set_threshold(threshold)
+    score, is_anomaly = detector.predict('test.jpg')
+    print(f"{threshold}: Score={score:.6f}, Anomaly={is_anomaly}")

model.py

@@ -0,0 +1,142 @@
+"""
+Deep SVDD Anomaly Detection Model
+Trained on CIFAR-10, CIFAR-100, and STL-10
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import transforms
+from PIL import Image
+import pickle
+import json
+from pathlib import Path
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_ch: int, out_ch: int, stride: int = 1):
+        super().__init__()
+        self.conv1 = nn.Conv2d(in_ch, out_ch, 3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_ch)
+        self.conv2 = nn.Conv2d(out_ch, out_ch, 3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(out_ch)
+        
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_ch != out_ch:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_ch, out_ch, 1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_ch)
+            )
+    
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        return F.relu(out)
+
+
+class DeepSVDDEncoder(nn.Module):
+    def __init__(self, latent_dim: int = 512):
+        super().__init__()
+        self.conv1 = nn.Conv2d(3, 64, 7, stride=2, padding=3, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(64, 128, stride=2)
+        self.layer2 = self._make_layer(128, 256, stride=2)
+        self.layer3 = self._make_layer(256, 512, stride=2)
+        self.layer4 = self._make_layer(512, 512, stride=2)
+        self.fc = nn.Linear(512 * 4 * 4, latent_dim, bias=False)
+    
+    def _make_layer(self, in_ch: int, out_ch: int, stride: int = 1):
+        return nn.Sequential(
+            ResidualBlock(in_ch, out_ch, stride),
+            ResidualBlock(out_ch, out_ch, 1)
+        )
+    
+    def forward(self, x):
+        x = F.relu(self.bn1(self.conv1(x)))
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = x.view(x.size(0), -1)
+        return self.fc(x)
+
+
+class DeepSVDDAnomalyDetector:
+    """
+    Deep SVDD Anomaly Detection Model
+    
+    Usage:
+        from model import DeepSVDDAnomalyDetector
+        
+        detector = DeepSVDDAnomalyDetector.from_pretrained('.')
+        score, is_anomaly = detector.predict('image.jpg')
+    """
+    
+    def __init__(self, model_path, thresholds_path, config_path, device='cuda'):
+        self.device = torch.device(device if torch.cuda.is_available() else 'cpu')
+        
+        # Load config
+        with open(config_path, 'r') as f:
+            self.config = json.load(f)
+        
+        # Load model
+        checkpoint = torch.load(model_path, map_location=self.device)
+        self.latent_dim = checkpoint['latent_dim']
+        self.center = checkpoint['center'].to(self.device)
+        self.radius = checkpoint['radius'].item()
+        
+        self.encoder = DeepSVDDEncoder(self.latent_dim).to(self.device)
+        self.encoder.load_state_dict(checkpoint['encoder_state_dict'])
+        self.encoder.eval()
+        
+        # Load thresholds
+        with open(thresholds_path, 'rb') as f:
+            thresholds = pickle.load(f)
+        
+        self.threshold_95 = thresholds['95th_percentile']
+        self.threshold_99 = thresholds['99th_percentile']
+        self.threshold_optimal = thresholds['optimal_f1']
+        self.threshold = self.threshold_optimal
+        
+        # Image preprocessing
+        self.transform = transforms.Compose([
+            transforms.Resize((128, 128)),
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+        ])
+    
+    @classmethod
+    def from_pretrained(cls, model_path='.', device='cuda'):
+        """Load pretrained model from directory or HuggingFace Hub"""
+        model_path = Path(model_path)
+        return cls(
+            model_path=model_path / 'deepsvdd_model.pth',
+            thresholds_path=model_path / 'thresholds.pkl',
+            config_path=model_path / 'config.json',
+            device=device
+        )
+    
+    def set_threshold(self, threshold_type='optimal'):
+        """Set threshold: 'optimal', '95th', or '99th'"""
+        if threshold_type == 'optimal':
+            self.threshold = self.threshold_optimal
+        elif threshold_type == '95th':
+            self.threshold = self.threshold_95
+        elif threshold_type == '99th':
+            self.threshold = self.threshold_99
+    
+    @torch.no_grad()
+    def predict(self, image_path):
+        """Predict if image is anomaly"""
+        if isinstance(image_path, (str, Path)):
+            image = Image.open(image_path).convert('RGB')
+        else:
+            image = image_path
+        
+        image_tensor = self.transform(image).unsqueeze(0).to(self.device)
+        embeddings = self.encoder(image_tensor)
+        score = torch.sum((embeddings - self.center) ** 2, dim=1).item()
+        is_anomaly = score > self.threshold
+        
+        return score, is_anomaly

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+numpy>=1.21.0

thresholds.json

@@ -0,0 +1,24 @@
+{
+  "95th_percentile": 0.008500736206769943,
+  "99th_percentile": 0.015921616926789284,
+  "optimal_f1": 0.001618,
+  "conservative": 0.015,
+  "balanced": 0.006,
+  "sensitive": 0.001618,
+  "radius": 0.01232091523706913,
+  "latent_dim": 512,
+  "optimal_metrics": {
+    "threshold": 0.001618,
+    "accuracy": 0.87,
+    "precision": 0.8033,
+    "recall": 0.98,
+    "f1": 0.8829
+  },
+  "recommendations": {
+    "default": "optimal_f1",
+    "production": "optimal_f1",
+    "zero_false_positives": "99th_percentile",
+    "balanced": "balanced",
+    "maximum_detection": "sensitive"
+  }
+}

thresholds.pkl

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

thresholds_report.txt

@@ -0,0 +1,99 @@
+
+================================================================================
+DEEP SVDD ANOMALY DETECTION - THRESHOLD CONFIGURATION
+================================================================================
+
+MODEL INFORMATION
+-----------------
+Latent Dimension: 512
+Hypersphere Radius: 0.012321
+Center Location: torch.Size([512])
+
+================================================================================
+AVAILABLE THRESHOLDS
+================================================================================
+
+1. OPTIMAL F1 (RECOMMENDED FOR PRODUCTION)
+   Threshold: 0.001618
+   Accuracy:  87.00%
+   Precision: 80.33%
+   Recall:    98.00%
+   F1 Score:  88.29%
+   
+   Use Case: Best overall performance, maximizes F1 score
+   Command:  detector.set_custom_threshold(0.001618)
+
+2. 95TH PERCENTILE (BALANCED)
+   Threshold: 0.008501
+   
+   Use Case: Few false positives, moderate recall
+   Command:  detector.set_threshold('95th')
+
+3. 99TH PERCENTILE (CONSERVATIVE)
+   Threshold: 0.015922
+   
+   Use Case: Zero or near-zero false positives
+   Command:  detector.set_threshold('99th')
+
+4. BALANCED (MIDDLE GROUND)
+   Threshold: 0.006000
+   
+   Use Case: Good balance between precision and recall
+   Command:  detector.set_custom_threshold(0.006000)
+
+5. SENSITIVE (MAXIMUM DETECTION)
+   Threshold: 0.001618
+   
+   Use Case: Catch as many anomalies as possible
+   Command:  detector.set_custom_threshold(0.001618)
+
+6. CONSERVATIVE (ZERO FALSE POSITIVES)
+   Threshold: 0.015000
+   
+   Use Case: Critical systems where false alarms are unacceptable
+   Command:  detector.set_custom_threshold(0.015000)
+
+================================================================================
+USAGE RECOMMENDATIONS
+================================================================================
+
+SCENARIO 1: General Production Use
+→ Use: OPTIMAL F1 (threshold = 0.001618)
+  Best overall performance with 87.0% accuracy
+
+SCENARIO 2: False Alarms Are Costly
+→ Use: 99TH PERCENTILE (threshold = 0.015922)
+  Minimizes false positives at cost of lower recall
+
+SCENARIO 3: Must Catch All Anomalies
+→ Use: SENSITIVE (threshold = 0.001618)
+  Maximum recall, accepts higher false positive rate
+
+SCENARIO 4: Balanced Approach
+→ Use: BALANCED (threshold = 0.006000)
+  Good middle ground for most applications
+
+================================================================================
+QUICK START CODE
+================================================================================
+
+# Load model with optimal threshold (recommended)
+from inference import DeepSVDDAnomalyDetector
+
+detector = DeepSVDDAnomalyDetector(
+    model_dir='./saved_model',
+    custom_threshold=0.001618  # Optimal F1
+)
+
+# Or switch thresholds dynamically
+detector.set_threshold('95th')              # Use 95th percentile
+detector.set_threshold('99th')              # Use 99th percentile
+detector.set_custom_threshold(0.001618)  # Use optimal
+
+# Predict
+score, is_anomaly = detector.predict_image('test.jpg')
+print(f"Score: {score:.6f}, Anomaly: {is_anomaly}")
+
+================================================================================
+Generated: 2025-12-14 13:03:54
+================================================================================