| # 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 | |