okay bro

Dockerfile

@@ -6,4 +6,4 @@ RUN pip install --no-cache-dir torch torchvision --index-url https://download.py
 RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
 EXPOSE 7860
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -17,8 +17,8 @@ logger = logging.getLogger("deep-detect-api")
 # Initialize FastAPI App
 app = FastAPI(
     title="Deep-Detect API",
-    description="Production-grade API for AI-generated vs Real image detection. Uses a 3-model ensemble (Custom CNN + ViT Deepfake Detection + Deepfake vs Real ViT) with majority voting for robust predictions.",
-    version="2.0.0"
+    description="Production-grade API for AI vs Real Image Detection using a custom CNN.",
+    version="1.0.0"
 )
 
 # Enable CORS middleware
@@ -56,16 +56,13 @@ async def predict_image(file: UploadFile = File(...)):
     """
     logger.info(f"Received prediction request. File: {file.filename}")
 
-    # Validate file is a supported image format
+    # Validate file extension
     content_type = file.content_type or ""
-    allowed_extensions = (".png", ".jpg", ".jpeg", ".webp")
-    is_valid_type = content_type.startswith("image/")
-    is_valid_ext = file.filename.lower().endswith(allowed_extensions)
-    if not (is_valid_type or is_valid_ext):
+    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 image (JPEG, PNG, or WebP)."
+            detail="Uploaded file must be a valid JPEG or PNG image."
         )
 
     try:

inference.py

@@ -1,49 +1,36 @@
 import io
 import os
 import logging
-import warnings
-import threading
-
-# ─── Silence ALL third-party noise before any imports ──────────────────────────
-os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
-os.environ["TRANSFORMERS_VERBOSITY"] = "error"
-os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-warnings.filterwarnings("ignore")
-
-for _noisy in ("transformers", "huggingface_hub", "huggingface_hub.utils._http",
-               "urllib3", "httpx", "httpcore", "filelock", "fsspec"):
-    logging.getLogger(_noisy).setLevel(logging.CRITICAL)
-
 import torch
 from PIL import Image
 from torchvision import transforms
 
-# Set up logging for custom inference pipeline only
+# 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 — custom model uses same device as HF models
+# GPU/CPU Device mapping
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-hf_device = 0 if torch.cuda.is_available() else -1   # Fix: use GPU for HF models if available
 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]
+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),
-])
+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):
@@ -63,183 +50,51 @@ except Exception as e:
     raise e
 
 
-# ─── Image Loading (with validation) ──────────────────────────────────────────
-
-def _load_image(image_source: "str | bytes | Image.Image") -> Image.Image:
-    """
-    Load an image from filepath, raw bytes, or an existing PIL Image.
-    Raises ValueError with a clear message on any failure.
-    """
-    try:
-        if isinstance(image_source, Image.Image):
-            return image_source
-        if isinstance(image_source, bytes):
-            return Image.open(io.BytesIO(image_source))
-        if not os.path.exists(image_source):
-            raise FileNotFoundError(f"Image not found: {image_source}")
-        return Image.open(image_source)
-    except Exception as e:
-        raise ValueError(f"Failed to load image: {e}")
-
-
-# ─── Custom Model Inference ────────────────────────────────────────────────────
-
 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
 
 
-# ─── Hugging Face Models — thread-safe lazy load with sentinel pattern ─────────
-# Sentinel values:
-#   None  → not yet attempted  (first request will trigger load)
-#   False → permanently failed (never retry)
-#   obj   → loaded pipeline
-
-_model_2 = None
-_model_3 = None
-_hf_lock = threading.Lock()   # Fix: thread-safe loading
-
-
-def _load_hf_models() -> None:
+def _load_image(image_source: str | bytes | Image.Image) -> Image.Image:
     """
-    Load both HF models exactly once under a mutex.
-    Individual model failures are caught independently so one
-    bad model does not prevent the other from loading.
+    Load an image from filepath, raw bytes, or an existing PIL Image.
     """
-    global _model_2, _model_3
-    with _hf_lock:
-        try:
-            from transformers import pipeline
-
-            if _model_2 is None:
-                try:
-                    # Exp-02-21: balanced GAN + diffusion deepfake detector
-                    _model_2 = pipeline(
-                        "image-classification",
-                        model="prithivMLmods/Deepfake-Detection-Exp-02-21",
-                        device=hf_device,
-                    )
-                except Exception:
-                    _model_2 = False
-
-            if _model_3 is None:
-                try:
-                    # Deep-Fake-Detector-v2: diffusion-focused model (labels inverted)
-                    _model_3 = pipeline(
-                        "image-classification",
-                        model="prithivMLmods/Deep-Fake-Detector-v2-Model",
-                        device=hf_device,
-                    )
-                except Exception:
-                    _model_3 = False
-
-        except Exception:
-            if _model_2 is None:
-                _model_2 = False
-            if _model_3 is None:
-                _model_3 = False
-
-
-def _predict_hf_model_2(pil_image: Image.Image) -> str:
-    if _model_2 is None:
-        _load_hf_models()
-    if not _model_2:
-        return "unknown"
-    try:
-        results = _model_2(pil_image)
-        best = max(results, key=lambda x: x["score"])
-        # Exp-02-21 labels: "Deepfake" / "Real" (correct mapping)
-        return "ai" if best["label"].lower() == "deepfake" else "real"
-    except Exception:
-        return "unknown"
-
-
-def _predict_hf_model_3(pil_image: Image.Image) -> str:
-    if _model_3 is None:
-        _load_hf_models()
-    if not _model_3:
-        return "unknown"
-    try:
-        results = _model_3(pil_image)
-        best = max(results, key=lambda x: x["score"])
-        # Deep-Fake-Detector-v2 labels are inverted: "Realism" means Deepfake, "Deepfake" means Real
-        return "ai" if best["label"].lower() == "realism" else "real"
-    except Exception:
-        return "unknown"
-
-
-# ─── Public API ───────────────────────────────────────────────────────────────
-
-def predict_label(image_source: "str | bytes | Image.Image") -> str:
+    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' using majority voting.
+    Predict if the image is 'real' or 'ai'.
     """
-    label, _ = predict_with_confidence(image_source)
-    return label
+    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:
+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.
-
-    Execution strategy:
-      - All 3 models run concurrently via ThreadPoolExecutor for minimum latency.
-      - Majority vote determines the final label.
-      - Confidence is computed as (winning_votes / total_votes) * 100 — honest
-        and meaningful regardless of how many models are available.
-      - If only 1 model voted (both HF models failed), confidence is capped at
-        60% to reflect reduced certainty from the lack of ensemble.
+    
+    If probability > 0.5: Class 1 (real). Confidence is probability * 100
+    If probability <= 0.5: Class 0 (ai). Confidence is (1.0 - probability) * 100
     """
-    from concurrent.futures import ThreadPoolExecutor
-
     image = _load_image(image_source)
+    probability = _predict_probability(image)
 
-    # Run all 3 models concurrently
-    with ThreadPoolExecutor(max_workers=3) as executor:
-        future_custom = executor.submit(_predict_probability, image)
-        future_hf2    = executor.submit(_predict_hf_model_2, image)
-        future_hf3    = executor.submit(_predict_hf_model_3, image)
-
-        probability = future_custom.result()
-        m2_label    = future_hf2.result()
-        m3_label    = future_hf3.result()
-
-    # Resolve custom model label
-    custom_label = "real" if probability > OPTIMAL_THRESHOLD else "ai"
-
-    # Build vote list — only include models that returned a valid prediction
-    votes = [custom_label]
-    if m2_label != "unknown":
-        votes.append(m2_label)
-    if m3_label != "unknown":
-        votes.append(m3_label)
-
-    ai_votes    = votes.count("ai")
-    real_votes  = votes.count("real")
-    total_votes = len(votes)
-
-    if ai_votes > real_votes:
-        final_label = "ai"
-    elif real_votes > ai_votes:
-        final_label = "real"
-    else:
-        # Tie: trust the custom model as the primary authority
-        final_label = custom_label
-
-    # Vote-ratio confidence — honest and meaningful
-    winning_votes   = max(ai_votes, real_votes)
-    vote_confidence = (winning_votes / total_votes) * 100
-
-    # If only 1 model voted (both HF models failed), cap confidence to signal
-    # reduced certainty — the result is not an ensemble, just a single model.
-    if total_votes == 1:
-        vote_confidence = min(vote_confidence, 60.0)
+    if probability > OPTIMAL_THRESHOLD:
+        return "real", probability * 100
 
-    return final_label, round(vote_confidence, 2)
+    return "ai", (1.0 - probability) * 100

requirements.txt

@@ -4,6 +4,3 @@ python-multipart>=0.0.6
 torch>=2.0.0
 torchvision>=0.15.0
 pillow>=9.5.0
-transformers>=4.36.0
-huggingface_hub>=0.20.0
-accelerate>=0.25.0