Upload folder using huggingface_hub

README.md

@@ -1,3 +1,315 @@
----
-license: mit
----
+# Deepfake Detector V8 - Foundation Model
+
+**Baseline accuracy: 100.00%** | **F1-Score: 1.0000**
+
+This is a foundation model designed for continuous improvement. It provides a solid starting point with room for enhancement.
+
+## 📊 Performance
+
+- **Accuracy**: 100.00%
+- **F1-Score**: 1.0000
+- **Precision**: 1.0000
+- **Recall**: 1.0000
+- **Training Samples**: 4,800
+- **Validation Samples**: 1,200
+
+## 🏗️ Architecture
+
+- **Backbone**: EfficientNetV2-S (pretrained on ImageNet)
+- **Classifier**: 3-layer MLP with BatchNorm and Dropout
+- **Input Size**: 224x224 RGB images
+- **Output**: Binary classification (Real vs Fake)
+
+## 📁 Files in This Folder
+
+```
+./deepfake_v8_model/
+├── model.safetensors       ✓ Model weights (HuggingFace format)
+├── pytorch_model.bin       ✓ Fallback weights (if safetensors unavailable)
+├── optimizer.pt            ✓ Optimizer state for continuing training
+├── scheduler.pt            ✓ Learning rate scheduler state
+├── config.json             ✓ Model architecture configuration
+├── training_args.json      ✓ All hyperparameters used
+├── rng_state.pth          ✓ Random states for reproducibility
+├── metrics.json           ✓ Performance metrics
+├── tokenizer.json         ✓ HuggingFace compatibility
+├── tokenizer_config.json  ✓ HuggingFace compatibility
+└── README.md              ✓ This file
+```
+
+## 🚀 How to Use This Model
+
+### Option 1: Inference (Predict on New Images)
+
+```python
+import torch
+import torch.nn as nn
+import timm
+from PIL import Image
+from torchvision import transforms
+
+# Define model architecture
+class DeepfakeDetector(nn.Module):
+    def __init__(self, dropout=0.5):
+        super().__init__()
+        self.backbone = timm.create_model('tf_efficientnetv2_s', pretrained=False, num_classes=0)
+        self.classifier = nn.Sequential(
+            nn.Linear(1280, 512), nn.BatchNorm1d(512), nn.SiLU(), nn.Dropout(dropout),
+            nn.Linear(512, 256), nn.BatchNorm1d(256), nn.SiLU(), nn.Dropout(dropout * 0.8),
+            nn.Linear(256, 1)
+        )
+    
+    def forward(self, x):
+        return self.classifier(self.backbone(x)).squeeze(-1)
+
+# Load model
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = DeepfakeDetector(0.5)
+
+try:
+    from safetensors.torch import load_file
+    state_dict = load_file('./deepfake_v8_model/model.safetensors')
+except:
+    state_dict = torch.load('./deepfake_v8_model/pytorch_model.bin', map_location=device)
+
+model.load_state_dict(state_dict)
+model = model.to(device)
+model.eval()
+
+# Predict on image
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+
+img = Image.open('test_image.jpg').convert('RGB')
+img_tensor = transform(img).unsqueeze(0).to(device)
+
+with torch.no_grad():
+    logit = model(img_tensor)
+    prob = torch.sigmoid(logit).item()
+
+if prob > 0.7:
+    print(f"🔴 LIKELY FAKE ({prob:.1%} confidence)")
+elif prob > 0.5:
+    print(f"⚠️ POSSIBLY FAKE ({prob:.1%} confidence)")
+elif prob > 0.3:
+    print(f"⚠️ POSSIBLY REAL ({(1-prob):.1%} confidence)")
+else:
+    print(f"🟢 LIKELY REAL ({(1-prob):.1%} confidence)")
+```
+
+### Option 2: Continue Training (Improve the Model)
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import timm
+import json
+import random
+import numpy as np
+
+# Load training configuration
+with open('./deepfake_v8_model/training_args.json', 'r') as f:
+    config = json.load(f)
+
+# Define model (same architecture as above)
+class DeepfakeDetector(nn.Module):
+    def __init__(self, dropout=0.5):
+        super().__init__()
+        self.backbone = timm.create_model('tf_efficientnetv2_s', pretrained=False, num_classes=0)
+        self.classifier = nn.Sequential(
+            nn.Linear(1280, 512), nn.BatchNorm1d(512), nn.SiLU(), nn.Dropout(dropout),
+            nn.Linear(512, 256), nn.BatchNorm1d(256), nn.SiLU(), nn.Dropout(dropout * 0.8),
+            nn.Linear(256, 1)
+        )
+    
+    def forward(self, x):
+        return self.classifier(self.backbone(x)).squeeze(-1)
+
+# Load model
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = DeepfakeDetector(config['dropout'])
+
+try:
+    from safetensors.torch import load_file
+    state_dict = load_file('./deepfake_v8_model/model.safetensors')
+except:
+    state_dict = torch.load('./deepfake_v8_model/pytorch_model.bin', map_location=device)
+
+model.load_state_dict(state_dict)
+model = model.to(device)
+
+# Load optimizer
+optimizer = optim.AdamW(
+    filter(lambda p: p.requires_grad, model.parameters()),
+    lr=config['learning_rate'] * 0.1  # Lower LR for fine-tuning
+)
+optimizer.load_state_dict(torch.load('./deepfake_v8_model/optimizer.pt'))
+
+# Load scheduler
+scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=config['epochs'])
+scheduler.load_state_dict(torch.load('./deepfake_v8_model/scheduler.pt'))
+
+# Load RNG state for reproducibility
+rng_state = torch.load('./deepfake_v8_model/rng_state.pth')
+random.setstate(rng_state['python'])
+np.random.set_state(rng_state['numpy'])
+torch.set_rng_state(rng_state['torch'])
+if torch.cuda.is_available() and rng_state['torch_cuda']:
+    torch.cuda.set_rng_state_all(rng_state['torch_cuda'])
+
+print("✓ Model loaded and ready for continued training!")
+
+# Now continue training with:
+# - More epochs
+# - More/better data
+# - Different augmentations
+# - Fine-tuning strategies
+```
+
+## 📤 How to Upload to HuggingFace
+
+### Step 1: Install HuggingFace CLI
+
+```bash
+pip install -U huggingface_hub
+```
+
+### Step 2: Login to HuggingFace
+
+```python
+from huggingface_hub import notebook_login
+notebook_login()
+```
+
+Or via CLI:
+```bash
+huggingface-cli login
+```
+
+### Step 3: Upload Your Model
+
+```python
+from huggingface_hub import HfApi
+
+api = HfApi()
+api.upload_folder(
+    folder_path="./deepfake_v8_model",
+    repo_id="YOUR_USERNAME/deepfake-detector-v8",
+    repo_type="model"
+)
+
+print("✓ Model uploaded to HuggingFace!")
+print("Visit: https://huggingface.co/YOUR_USERNAME/deepfake-detector-v8")
+```
+
+### Step 4: Load from HuggingFace in New Notebook
+
+```python
+from huggingface_hub import hf_hub_download
+import torch
+
+# Download files
+model_path = hf_hub_download(
+    repo_id="YOUR_USERNAME/deepfake-detector-v8",
+    filename="model.safetensors"
+)
+
+optimizer_path = hf_hub_download(
+    repo_id="YOUR_USERNAME/deepfake-detector-v8",
+    filename="optimizer.pt"
+)
+
+# Load and continue training...
+```
+
+## 💡 How to Improve This Model
+
+### 1. Add More Real Data
+```python
+# In new notebook, load more datasets
+from datasets import load_dataset
+
+# Add real AI-generated images
+stable_diffusion_images = load_dataset("your_sd_dataset")
+dalle_images = load_dataset("your_dalle_dataset")
+
+# Combine with existing model and retrain
+```
+
+### 2. Train Longer
+```python
+# Load model (as shown above)
+# Then train for 5-10 more epochs
+CONFIG['epochs'] = 10  # or more
+# Continue training loop...
+```
+
+### 3. Unfreeze More Layers
+```python
+# Unfreeze all backbone layers for fine-tuning
+for param in model.backbone.parameters():
+    param.requires_grad = True
+
+# Use lower learning rate
+optimizer = optim.AdamW(model.parameters(), lr=1e-5)
+```
+
+### 4. Use Real Deepfakes
+```python
+# Load actual deepfake datasets
+# - FaceForensics++
+# - Celeb-DF
+# - DFDC
+# And retrain on real deepfakes
+```
+
+### 5. Ensemble Multiple Models
+```python
+# Train multiple versions
+# Average predictions for better accuracy
+```
+
+## 🎯 Improvement Roadmap
+
+**Current**: 100.0% (Foundation)
+
+**Next Steps**:
+1. **Add 10K more samples** → Target: 93-95%
+2. **Train 5 more epochs** → Target: 94-96%
+3. **Add real AI images** → Target: 95-97%
+4. **Fine-tune all layers** → Target: 96-98%
+5. **Ensemble 3 models** → Target: 97-99%
+
+## ⚠️ Important Notes
+
+- This model was trained on **synthetic fakes**
+- For production use, train on **real AI-generated images**
+- Use **confidence thresholds** (>0.7 for high confidence)
+- Always **validate on diverse test sets**
+- Consider **ethical implications** of deployment
+
+## 📝 License
+
+MIT License - Free to use with attribution
+
+## 🤝 Contributing
+
+This is a foundation model meant to be improved! Feel free to:
+- Add more training data
+- Experiment with architectures
+- Share your improvements
+- Create better versions
+
+## 📧 Contact
+
+For questions or improvements, open an issue on the repository.
+
+---
+
+**Generated by**: Deepfake Detector V8
+**Training Time**: 35.1 minutes
+**Date**: 2025-10-22 20:27:12

config.json

@@ -0,0 +1,11 @@
+{
+  "architecture": "tf_efficientnetv2_s",
+  "num_classes": 2,
+  "dropout": 0.5,
+  "input_size": [
+    3,
+    224,
+    224
+  ],
+  "pretrained_backbone": true
+}

metrics.json

@@ -0,0 +1,11 @@
+{
+  "epoch": 1,
+  "best_accuracy": 1.0,
+  "best_f1": 1.0,
+  "val_accuracy": 1.0,
+  "val_precision": 1.0,
+  "val_recall": 1.0,
+  "val_f1": 1.0,
+  "train_samples": 4800,
+  "val_samples": 1200
+}

model.safetensors

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

optimizer.pt

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

rng_state.pth

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

scheduler.pt

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

tokenizer.json

@@ -0,0 +1,5 @@
+{
+  "version": "1.0",
+  "type": "image",
+  "preprocessor": "ImageNet normalization"
+}

tokenizer_config.json

@@ -0,0 +1,5 @@
+{
+  "model_type": "image_classification",
+  "task": "deepfake_detection",
+  "image_size": 224
+}

training_args.json

@@ -0,0 +1,13 @@
+{
+  "target_real": 3000,
+  "target_fake": 3000,
+  "val_split": 0.2,
+  "epochs": 3,
+  "batch_size": 32,
+  "learning_rate": 0.0002,
+  "weight_decay": 0.0002,
+  "dropout": 0.5,
+  "architecture": "tf_efficientnetv2_s",
+  "img_size": 224,
+  "save_dir": "./deepfake_v8_model"
+}