Model's backend

.dockerignore

@@ -0,0 +1,5 @@
+venv/
+.git/
+__pycache__/
+*.pyc
+.DS_Store

Dcokerfile

@@ -0,0 +1,9 @@
+FROM python:3.10-slim
+WORKDIR /app
+RUN apt-get update && apt-get install -y build-essential rm -rf /var/lib/apt/lists/*
+COPY requirements.txt .
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,160 @@
+# Image_Detector — FastAPI Backend 🐍
+
+This directory contains the complete Python backend for Deep-Detect. It exposes a REST API that accepts image uploads and returns an AI vs. Real classification result using a custom-trained PyTorch CNN.
+
+---
+
+## 📁 Directory Structure
+
+```
+Image_Detector/
+├── app.py              # FastAPI application — server entry point, routes, CORS
+├── inference.py        # Model loading, image preprocessing, prediction pipeline
+├── model.py            # Custom CNN architecture (PyTorch nn.Module definition)
+├── predict.py          # Standalone Tkinter desktop GUI for local inference
+├── requirements.txt    # All Python package dependencies
+├── models/             # Trained model weights (gitignored — download separately)
+│   └── custom_cnn_standalone.pt   # TorchScript model (~103 MB)
+└── notebooks/          # Jupyter notebooks for research and training
+    ├── Preprocessing.ipynb         # Dataset loading, augmentation, visualization
+    ├── Model_training.ipynb        # Full training loop with loss/accuracy tracking
+    ├── Model_evaluation.ipynb      # Confusion matrix, ROC, per-class metrics
+    └── Pretrained_Models.ipynb     # Experiments with ResNet50, EfficientNet, ViT
+```
+
 ---
-title: Deep Detect Api
-emoji: 📚
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
+
+## ⚙️ Setup
+
+### 1. Create Virtual Environment
+
+```bash
+cd Image_Detector
+
+python -m venv venv
+
+# Windows
+.\venv\Scripts\activate
+
+# macOS / Linux
+source venv/bin/activate
+```
+
+### 2. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+**Dependencies:**
+| Package | Version | Purpose |
+|---|---|---|
+| `fastapi` | ≥0.100.0 | REST API framework |
+| `uvicorn` | ≥0.20.0 | ASGI server |
+| `python-multipart` | ≥0.0.6 | File upload parsing |
+| `torch` | ≥2.0.0 | PyTorch deep learning |
+| `torchvision` | ≥0.15.0 | Image transforms |
+| `pillow` | ≥9.5.0 | Image I/O |
+
+### 3. Download Model Weights
+
+The model file `custom_cnn_standalone.pt` is too large for GitHub (103 MB > 100 MB limit). Download it from the project's [Releases](../../../releases) page and place it at:
+
+```
+Image_Detector/models/custom_cnn_standalone.pt
+```
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🚀 Running the Server
+
+```bash
+python app.py
+```
+
+The server starts on **`http://0.0.0.0:8000`**. Verify it's healthy:
+
+```bash
+curl http://localhost:8000/
+```
+
+Expected response:
+```json
+{
+  "status": "healthy",
+  "api_name": "Deep-Detect Image Classification Service",
+  "model_architecture": "Custom CNN Standalone (PyTorch)",
+  "device_running": "cpu"
+}
+```
+
+---
+
+## 🔌 API Endpoints
+
+### `POST /predict`
+
+Classifies an uploaded image as Deep-Fake or Real.
+
+```bash
+curl -X POST http://localhost:8000/predict \
+  -F "file=@/path/to/image.jpg"
+```
+
+**Success Response:**
+```json
+{
+  "prediction": "ai",
+  "confidence": 94.85,
+  "status": "success"
+}
+```
+
+- `prediction`: `"ai"` or `"real"`
+- `confidence`: percentage confidence (0–100)
+
+---
+
+## 🧠 Model Details
+
+| Property | Value |
+|---|---|
+| Architecture | Custom CNN (defined in `model.py`) |
+| Input Size | 224 × 224 (RGB) |
+| Normalization | ImageNet mean/std |
+| Output | Single logit → Sigmoid → binary probability |
+| Format | TorchScript (`.pt`) — runs without class definition at load time |
+| Inference Device | CPU (configurable) |
+
+**Inference Pipeline** (see [`inference.py`](inference.py)):
+1. Load image bytes → convert to RGB PIL Image
+2. Resize to 224×224
+3. Normalize with ImageNet statistics
+4. Run forward pass through TorchScript model
+5. Apply Sigmoid to raw logit → confidence score
+6. Threshold at 0.5: `< 0.5` → `"real"`, `≥ 0.5` → `"ai"`
+
+---
+
+## 🖥️ Desktop Utility
+
+Run local inference via a GUI without starting the API server:
+
+```bash
+python predict.py
+```
+
+Opens a Tkinter window where you can browse and classify local image files directly.
+
+---
+
+## 📓 Notebooks
+
+The [`notebooks/`](notebooks/) directory contains the full ML research workflow:
+
+| Notebook | Description |
+|---|---|
+| [`Preprocessing.ipynb`](notebooks/Preprocessing.ipynb) | Dataset exploration, augmentation strategy, class balance analysis |
+| [`Model_training.ipynb`](notebooks/Model_training.ipynb) | Custom CNN training from scratch with loss curves and checkpointing |
+| [`Model_evaluation.ipynb`](notebooks/Model_evaluation.ipynb) | Confusion matrix, ROC-AUC, precision/recall metrics |
+| [`Pretrained_Models.ipynb`](notebooks/Pretrained_Models.ipynb) | Transfer learning experiments: ResNet50, EfficientNet, ViT |

app.py

@@ -0,0 +1,102 @@
+import logging
+from fastapi import FastAPI, UploadFile, File, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from inference import predict_with_confidence, device
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("deep-detect-api")
+
+# Initialize FastAPI App
+app = FastAPI(
+    title="Deep-Detect API",
+    description="Production-grade API for AI vs Real Image Detection using a custom CNN.",
+    version="1.0.0"
+)
+
+# Enable CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/", tags=["General"])
+async def root():
+    """
+    Health check and system information endpoint.
+    """
+    return {
+        "status": "healthy",
+        "api_name": "Deep-Detect Image Classification Service",
+        "model_architecture": "Custom CNN Standalone (PyTorch)",
+        "device_running": str(device),
+        "endpoints": {
+            "health_check": "/",
+            "inference": "/predict"
+        }
+    }
+
+
+@app.post("/predict", tags=["Inference"])
+async def predict_image(file: UploadFile = File(...)):
+    """
+    Accepts an uploaded image file, preprocesses it, runs it through
+    the custom CNN, and returns whether it is Deep-Fake ('ai') or 'real'.
+    """
+    logger.info(f"Received prediction request. File: {file.filename}")
+
+    # Validate file extension
+    content_type = file.content_type or ""
+    if not (content_type.startswith("image/") or file.filename.lower().endswith((".png", ".jpg", ".jpeg"))):
+        logger.warning(f"Rejected invalid file format: {file.filename} (Content-Type: {content_type})")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Uploaded file must be a valid JPEG or PNG image."
+        )
+
+    try:
+        # Read image bytes
+        image_bytes = await file.read()
+        if len(image_bytes) == 0:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Uploaded file is empty."
+            )
+
+        # Run inference
+        label, confidence = predict_with_confidence(image_bytes)
+        logger.info(f"Prediction successful for {file.filename} -> Result: {label} (Confidence: {confidence:.2f}%)")
+
+        return {
+            "prediction": label,
+            "confidence": round(confidence, 2),
+            "status": "success"
+        }
+
+    except Exception as e:
+        logger.error(f"Inference pipeline error: {str(e)}", exc_info=True)
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                "status": "error",
+                "message": "Internal error processing the image. Ensure the image is not corrupted.",
+                "details": str(e)
+            }
+        )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("Starting Deep-Detect backend server...")
+    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=False)

inference.py

@@ -0,0 +1,96 @@
+import io
+import os
+import logging
+import torch
+from PIL import Image
+from torchvision import transforms
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("inference")
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+# Note: The folder is "models", and model is "custom_cnn_standalone.pt"
+MODEL_PATH = os.path.join(BASE_DIR, "models", "custom_cnn_standalone.pt")
+
+# GPU/CPU Device mapping
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Using device: {device} for inference.")
+
+# Hyperparameters matching the Custom CNN Standalone training
+IMG_SIZE = 224
+MEAN = [0.485, 0.456, 0.406]
+STD = [0.229, 0.224, 0.225]
+OPTIMAL_THRESHOLD = 0.5
+
+# Image Preprocessing Transformation Pipeline
+transform = transforms.Compose(
+    [
+        transforms.Resize((IMG_SIZE, IMG_SIZE)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=MEAN, std=STD),
+    ]
+)
+
+# Load the compiled TorchScript model
+if not os.path.exists(MODEL_PATH):
+    raise FileNotFoundError(f"Model file not found at: {MODEL_PATH}")
+
+try:
+    logger.info(f"Loading TorchScript model from {MODEL_PATH}...")
+    model = torch.jit.load(MODEL_PATH, map_location=device)
+    model.eval()
+    logger.info("Model loaded successfully and set to evaluation mode.")
+except Exception as e:
+    logger.error(f"Failed to load model: {str(e)}")
+    raise e
+
+
+def _predict_probability(image: Image.Image) -> float:
+    """
+    Pass the preprocessed image through the loaded Custom CNN model.
+    Applies Sigmoid to the output logit to compute probability.
+    """
+    input_tensor = transform(image.convert("RGB")).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        output = model(input_tensor)
+        # Apply sigmoid since model outputs a single class raw logit
+        probability = torch.sigmoid(output).item()
+        return probability
+
+
+def _load_image(image_source: str | bytes | Image.Image) -> Image.Image:
+    """
+    Load an image from filepath, raw bytes, or an existing PIL Image.
+    """
+    if isinstance(image_source, Image.Image):
+        return image_source
+    if isinstance(image_source, bytes):
+        return Image.open(io.BytesIO(image_source))
+    return Image.open(image_source)
+
+
+def predict_label(image_source: str | bytes | Image.Image) -> str:
+    """
+    Predict if the image is 'real' or 'ai'.
+    """
+    image = _load_image(image_source)
+    probability = _predict_probability(image)
+    return "real" if probability > OPTIMAL_THRESHOLD else "ai"
+
+
+def predict_with_confidence(image_source: str | bytes | Image.Image) -> tuple[str, float]:
+    """
+    Predict if the image is 'real' or 'ai' and return the confidence percentage.
+    
+    If probability > 0.5: Class 1 (real). Confidence is probability * 100
+    If probability <= 0.5: Class 0 (ai). Confidence is (1.0 - probability) * 100
+    """
+    image = _load_image(image_source)
+    probability = _predict_probability(image)
+
+    if probability > OPTIMAL_THRESHOLD:
+        return "real", probability * 100
+
+    return "ai", (1.0 - probability) * 100

model.py

@@ -0,0 +1,13 @@
+from inference import predict_label
+
+def predict(image_path: str) -> str:
+    """
+    Predict if the image is real or Deep-Fake.
+
+    Args:
+        image_path (str): Absolute or relative path to the image file.
+
+    Returns:
+        str: "ai" or "real".
+    """
+    return predict_label(image_path)

predict.py

@@ -0,0 +1,38 @@
+import tkinter as tk
+from tkinter import filedialog, Label, Button
+from PIL import Image, ImageTk
+from model import predict
+
+root = tk.Tk()
+root.title("AI vs Real Image Detector")
+root.geometry("600x500")
+
+def upload_image():
+    file_path = filedialog.askopenfilename(
+        filetypes=[("Image files", "*.jpg;*.jpeg;*.png")]
+    )
+    if not file_path:
+        return
+
+    # Display image
+    img = Image.open(file_path)
+    img_resized = img.resize((300, 300))
+    img_tk = ImageTk.PhotoImage(img_resized)
+    label_image.config(image=img_tk)
+    label_image.image = img_tk
+
+    # Predict
+    label = predict(file_path)
+    result_text = "Deep-Fake" if label.lower() in ("fake", "ai") else "Real"
+    label_result.config(text=f"Prediction: {result_text}")
+
+btn_upload = Button(root, text="Upload Image", command=upload_image)
+btn_upload.pack(pady=20)
+
+label_image = Label(root)
+label_image.pack()
+
+label_result = Label(root, text="Prediction: ", font=("Arial", 16))
+label_result.pack(pady=20)
+
+root.mainloop()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.100.0
+uvicorn>=0.20.0
+python-multipart>=0.0.6
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.5.0