Deploy Deepfake Shield Backend v2.0

.gitattributes

@@ -1,35 +0,0 @@
-*.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

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies untuk OpenCV dan MediaPipe
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements dan install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source code
+COPY . .
+
+# Buat direktori cache untuk HuggingFace models
+RUN mkdir -p models/hf_cache models/torch_cache
+
+# Port yang digunakan HF Spaces
+EXPOSE 7860
+
+# Jalankan server
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +0,0 @@
----
-title: Deepfake Shield Api
-emoji: 📚
-colorFrom: indigo
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,220 @@
+"""
+app.py - Entry point untuk Hugging Face Spaces
+===============================================
+Versi backend yang dioptimalkan untuk HF Spaces:
+- Tanpa WebSocket (diganti HTTP polling dari frontend)
+- CORS terbuka untuk domain Vercel
+- Graceful fallback jika model gagal dimuat
+
+Deploy: Upload folder backend/ ke HF Spaces sebagai Gradio/Docker App.
+"""
+
+import cv2
+import json
+import base64
+import logging
+import asyncio
+import numpy as np
+import os
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import torch
+
+# Import modul internal
+from model_loader import model_loader
+from detector import FaceDeepfakeDetector
+from audio_detector import AudioDeepfakeDetector
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+face_detector: Optional[FaceDeepfakeDetector]  = None
+audio_detector: Optional[AudioDeepfakeDetector] = None
+startup_error: Optional[str] = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global face_detector, audio_detector, startup_error
+
+    logger.info("🚀 Deepfake Shield Backend (HF Spaces) starting...")
+
+    try:
+        model_loader.initialize()
+        face_detector  = FaceDeepfakeDetector()
+        audio_detector = AudioDeepfakeDetector()
+        logger.info("✅ Semua model berhasil dimuat!")
+    except Exception as e:
+        startup_error = str(e)
+        logger.error(f"❌ Gagal memuat model: {e}")
+
+    yield
+
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+app = FastAPI(
+    title="Deepfake Shield API",
+    description="Real-time deepfake detection — hosted on Hugging Face Spaces",
+    version="2.0.0",
+    lifespan=lifespan
+)
+
+# CORS: Izinkan Vercel + localhost
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],   # Vercel generates random preview URLs, so allow all
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ─── Health Check ───────────────────────────────────────────────────────────
+
+@app.get("/api/health")
+async def health_check():
+    if startup_error:
+        return JSONResponse({
+            "status"        : "error",
+            "error"         : startup_error,
+            "models_loaded" : False,
+        }, status_code=500)
+
+    return JSONResponse({
+        "status"        : "online",
+        "version"       : "2.0.0",
+        "models_loaded" : face_detector is not None,
+        "cuda_available": torch.cuda.is_available(),
+        "device"        : str(model_loader.device),
+    })
+
+
+# ─── Analisis Gambar / Frame ─────────────────────────────────────────────────
+
+@app.post("/api/analyze/image")
+async def analyze_image(file: UploadFile = File(...)):
+    """
+    Analisis gambar untuk deteksi deepfake.
+    Frontend mengirim frame kamera atau foto upload ke endpoint ini.
+    """
+    import time
+
+    if face_detector is None:
+        raise HTTPException(
+            status_code=503,
+            detail=startup_error or "Face detector belum siap. Coba lagi dalam beberapa detik."
+        )
+
+    image_bytes = await file.read()
+    if len(image_bytes) == 0:
+        raise HTTPException(status_code=400, detail="File gambar kosong")
+
+    frame_array = np.frombuffer(image_bytes, dtype=np.uint8)
+    frame_bgr   = cv2.imdecode(frame_array, cv2.IMREAD_COLOR)
+
+    if frame_bgr is None:
+        raise HTTPException(status_code=400, detail="Format gambar tidak valid (gunakan JPG/PNG/WEBP)")
+
+    start = time.perf_counter()
+
+    result = await asyncio.get_event_loop().run_in_executor(
+        None, face_detector.process_frame, frame_bgr
+    )
+
+    result["processing_time_ms"] = round((time.perf_counter() - start) * 1000, 2)
+    result["filename"] = file.filename or "frame.jpg"
+
+    return JSONResponse(result)
+
+
+@app.post("/api/analyze/frame")
+async def analyze_frame_base64(request: dict):
+    """
+    Analisis frame kamera yang dikirim sebagai base64 JSON.
+    Digunakan sebagai pengganti WebSocket untuk polling dari frontend.
+
+    Body: { "frame": "data:image/jpeg;base64,/9j/..." }
+    """
+    import time
+
+    if face_detector is None:
+        raise HTTPException(status_code=503, detail="Detektor belum siap")
+
+    frame_data_url = request.get("frame", "")
+    if not frame_data_url:
+        raise HTTPException(status_code=400, detail="Key 'frame' tidak ditemukan")
+
+    # Hapus prefix data URL
+    if "," in frame_data_url:
+        frame_b64 = frame_data_url.split(",", 1)[1]
+    else:
+        frame_b64 = frame_data_url
+
+    try:
+        frame_bytes = base64.b64decode(frame_b64)
+        frame_array = np.frombuffer(frame_bytes, dtype=np.uint8)
+        frame_bgr   = cv2.imdecode(frame_array, cv2.IMREAD_COLOR)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Gagal decode frame base64")
+
+    if frame_bgr is None:
+        raise HTTPException(status_code=400, detail="Gagal membaca gambar dari frame")
+
+    start  = time.perf_counter()
+    result = await asyncio.get_event_loop().run_in_executor(
+        None, face_detector.process_frame, frame_bgr
+    )
+    result["processing_time_ms"] = round((time.perf_counter() - start) * 1000, 2)
+
+    return JSONResponse(result)
+
+
+# ─── Audio Analysis ──────────────────────────────────────────────────────────
+
+@app.post("/api/analyze/audio")
+async def analyze_audio(file: UploadFile = File(...)):
+    if audio_detector is None:
+        raise HTTPException(status_code=503, detail="Audio detector belum siap")
+
+    audio_bytes = await file.read()
+    if len(audio_bytes) == 0:
+        raise HTTPException(status_code=400, detail="File audio kosong")
+
+    result = audio_detector.analyze_bytes(audio_bytes)
+    return JSONResponse(result)
+
+
+# ─── Reset Buffer ─────────────────────────────────────────────────────────────
+
+@app.get("/api/reset")
+async def reset():
+    if face_detector:
+        face_detector.reset_temporal_buffer()
+    return {"status": "reset"}
+
+
+# ─── Root ─────────────────────────────────────────────────────────────────────
+
+@app.get("/")
+async def root():
+    return {
+        "name"   : "Deepfake Shield API",
+        "status" : "online",
+        "docs"   : "/docs",
+        "health" : "/api/health",
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))  # HF Spaces default port
+    uvicorn.run("app:app", host="0.0.0.0", port=port, log_level="info")

audio_detector.py

@@ -0,0 +1,203 @@
+"""
+audio_detector.py
+=================
+Modul deteksi deepfake audio (voice forgery detection).
+Pipeline:
+  1. Terima chunk audio PCM (numpy array)
+  2. Librosa → Ekstrak mel-spectrogram (representasi visual suara)
+  3. MobileNetV3 → Klasifikasikan REAL vs FAKE voice
+
+Mel-spectrogram mengubah sinyal audio menjadi "gambar" frekuensi
+yang bisa diklasifikasikan oleh CNN, sama seperti klasifikasi gambar biasa.
+"""
+
+import torch
+import numpy as np
+import librosa
+import logging
+from PIL import Image
+import torchvision.transforms as transforms
+
+from model_loader import model_loader, DEVICE
+
+logger = logging.getLogger(__name__)
+
+# --- Konfigurasi Mel-Spectrogram ---
+SAMPLE_RATE     = 16000   # Sample rate audio (Hz) - standar untuk speech models
+N_MELS          = 128     # Jumlah filter mel bank (resolusi frekuensi)
+HOP_LENGTH      = 512     # Jumlah sample antara dua kolom spectrogram
+N_FFT           = 2048    # Ukuran window FFT
+DURATION        = 2.0     # Durasi chunk audio yang dianalisis (detik)
+MAX_SAMPLES     = int(SAMPLE_RATE * DURATION)  # 32000 samples per chunk
+
+# --- Transformasi untuk input MobileNetV3 ---
+SPECTROGRAM_TRANSFORM = transforms.Compose([
+    transforms.Resize((224, 224)),   # Resize spectrogram ke input size MobileNetV3
+    transforms.ToTensor(),            # Konversi ke tensor [1, H, W] (grayscale)
+    transforms.Normalize(
+        mean=[0.5],                   # Normalisasi single channel
+        std=[0.5]
+    ),
+])
+
+
+class AudioDeepfakeDetector:
+    """
+    Detektor deepfake audio menggunakan Mel-Spectrogram + MobileNetV3.
+    
+    Cara kerja:
+    - Audio chunk (PCM float32) → Mel-Spectrogram (2D matrix)
+    - Spectrogram diperlakukan sebagai gambar grayscale
+    - MobileNetV3 mengklasifikasikan gambar tersebut sebagai REAL/FAKE
+    """
+
+    def __init__(self):
+        logger.info("✅ AudioDeepfakeDetector siap digunakan")
+
+    def analyze_chunk(self, audio_data: np.ndarray, sample_rate: int = SAMPLE_RATE) -> dict:
+        """
+        Analisis chunk audio dan kembalikan skor keaslian.
+        
+        Args:
+            audio_data : numpy array PCM float32, shape [N_samples]
+            sample_rate: Sample rate audio (default 16000 Hz)
+            
+        Returns:
+            dict dengan keys:
+              - 'authenticity_score': float 0.0 (FAKE) - 1.0 (REAL)
+              - 'label'             : str 'REAL' / 'FAKE' / 'UNCERTAIN'
+              - 'confidence'        : float
+              - 'spectrogram_shape' : tuple, dimensi spectrogram yang dihasilkan
+        """
+        # Resample jika sample rate berbeda dari yang diharapkan
+        if sample_rate != SAMPLE_RATE:
+            audio_data = librosa.resample(
+                audio_data,
+                orig_sr=sample_rate,
+                target_sr=SAMPLE_RATE
+            )
+
+        # Pastikan panjang audio sesuai (padding/truncation)
+        audio_data = self._normalize_length(audio_data)
+
+        # Ekstrak mel-spectrogram dari audio
+        spectrogram = self._extract_mel_spectrogram(audio_data)
+
+        # Klasifikasikan spectrogram menggunakan MobileNetV3
+        score = self._classify_spectrogram(spectrogram)
+
+        return {
+            "authenticity_score": round(score, 4),
+            "label"             : self._score_to_label(score),
+            "confidence"        : round(max(score, 1 - score), 4),
+            "spectrogram_shape" : spectrogram.shape,
+        }
+
+    def _normalize_length(self, audio: np.ndarray) -> np.ndarray:
+        """
+        Normalisasi panjang audio chunk ke durasi tetap (2 detik).
+        - Jika terlalu panjang: truncate
+        - Jika terlalu pendek: padding dengan nol (silence)
+        """
+        if len(audio) > MAX_SAMPLES:
+            # Truncate dari tengah untuk mengurangi efek silence di awal/akhir
+            start = (len(audio) - MAX_SAMPLES) // 2
+            return audio[start:start + MAX_SAMPLES]
+        elif len(audio) < MAX_SAMPLES:
+            # Padding nol di kanan
+            pad_length = MAX_SAMPLES - len(audio)
+            return np.pad(audio, (0, pad_length), mode='constant')
+        return audio
+
+    def _extract_mel_spectrogram(self, audio: np.ndarray) -> np.ndarray:
+        """
+        Konversi sinyal audio ke mel-spectrogram.
+        
+        Mel-spectrogram adalah representasi visual dari sinyal audio
+        yang menunjukkan distribusi energi pada frekuensi tertentu seiring waktu.
+        Deepfake voice sering meninggalkan artefak pada frekuensi tertentu.
+        
+        Returns:
+            numpy array shape [N_MELS, T], nilai dalam dB
+        """
+        # Hitung mel-spectrogram menggunakan librosa
+        mel_spec = librosa.feature.melspectrogram(
+            y=audio,
+            sr=SAMPLE_RATE,
+            n_mels=N_MELS,        # 128 filter bank
+            hop_length=HOP_LENGTH, # Step antar frame
+            n_fft=N_FFT,           # FFT window size
+            fmin=20,               # Frekuensi minimum (Hz) - batas pendengaran manusia
+            fmax=8000              # Frekuensi maksimum (Hz) - cukup untuk speech
+        )
+
+        # Konversi ke decibel scale (lebih intuitif dan stabil untuk training)
+        mel_db = librosa.power_to_db(mel_spec, ref=np.max)
+
+        return mel_db
+
+    def _classify_spectrogram(self, spectrogram: np.ndarray) -> float:
+        """
+        Klasifikasikan mel-spectrogram menggunakan MobileNetV3.
+        
+        Args:
+            spectrogram: numpy array [N_MELS, T] dalam dB scale
+            
+        Returns:
+            float: Skor keaslian (0.0 = FAKE, 1.0 = REAL)
+        """
+        # Normalisasi nilai ke range [0, 255] untuk konversi ke PIL Image
+        spec_normalized = ((spectrogram - spectrogram.min()) /
+                          (spectrogram.max() - spectrogram.min() + 1e-8) * 255).astype(np.uint8)
+
+        # Konversi ke PIL Image grayscale
+        pil_image = Image.fromarray(spec_normalized, mode='L')
+
+        # Terapkan transformasi
+        tensor = SPECTROGRAM_TRANSFORM(pil_image)  # Shape: [1, 224, 224]
+
+        # Tambahkan dimensi batch
+        tensor = tensor.unsqueeze(0).to(DEVICE)    # Shape: [1, 1, 224, 224]
+
+        # Konversi ke FP16 jika pakai GPU
+        if DEVICE.type == "cuda":
+            tensor = tensor.half()
+
+        # Inferensi
+        with torch.no_grad():
+            logits = model_loader.audio_model(tensor)   # Shape: [1, 2]
+            probs  = torch.softmax(logits, dim=1)        # Probabilitas
+
+        # Index 0 = FAKE, Index 1 = REAL
+        real_prob = probs[0, 1].item()
+        return real_prob
+
+    def _score_to_label(self, score: float) -> str:
+        """Konversi skor ke label teks."""
+        if score >= 0.75:
+            return "REAL"
+        elif score <= 0.35:
+            return "FAKE"
+        else:
+            return "UNCERTAIN"
+
+    def analyze_bytes(self, audio_bytes: bytes, sample_rate: int = SAMPLE_RATE) -> dict:
+        """
+        Analisis audio dari raw bytes (dari upload file).
+        
+        Args:
+            audio_bytes: Audio dalam format bytes (WAV/MP3/etc)
+            sample_rate: Sample rate (jika diketahui)
+        """
+        import io
+        import soundfile as sf
+
+        # Baca audio dari bytes menggunakan soundfile
+        audio_buffer = io.BytesIO(audio_bytes)
+        audio_data, sr = sf.read(audio_buffer, dtype='float32')
+
+        # Jika stereo, konversi ke mono dengan rata-rata kedua channel
+        if audio_data.ndim == 2:
+            audio_data = np.mean(audio_data, axis=1)
+
+        return self.analyze_chunk(audio_data, sample_rate=sr)

detector.py

@@ -0,0 +1,238 @@
+"""
+detector.py
+===========
+Core engine deteksi deepfake wajah secara real-time.
+Menggunakan pipeline 2 tahap:
+  1. MediaPipe Face Mesh → Deteksi & crop wajah dari frame
+  2. EfficientNet-B4     → Klasifikasi REAL vs FAKE per wajah
+
+Mendukung temporal smoothing untuk mengurangi false positive
+pada stream video yang bergerak cepat.
+"""
+
+import cv2
+import torch
+import numpy as np
+import mediapipe as mp
+import logging
+from collections import deque
+from typing import Optional
+from PIL import Image
+import torchvision.transforms as transforms
+
+from model_loader import model_loader, DEVICE
+
+logger = logging.getLogger(__name__)
+
+# --- Konfigurasi MediaPipe Face Mesh ---
+MP_FACE_MESH = mp.solutions.face_mesh
+MP_DRAWING   = mp.solutions.drawing_utils
+MP_STYLES    = mp.solutions.drawing_styles
+
+# --- Transformasi gambar untuk input EfficientNet ---
+# ImageNet normalization + resize ke 224x224
+FACE_TRANSFORM = transforms.Compose([
+    transforms.Resize((224, 224)),          # EfficientNet-B4 input size
+    transforms.ToTensor(),                   # [H,W,C] uint8 → [C,H,W] float32
+    transforms.Normalize(                    # Normalisasi ImageNet
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    ),
+])
+
+# Padding (%) di sekitar bounding box wajah agar konteks wajah lebih lengkap
+FACE_PADDING_RATIO = 0.20
+
+# Jumlah frame untuk temporal smoothing (rolling average)
+TEMPORAL_WINDOW = 10
+
+
+class FaceDeepfakeDetector:
+    """
+    Detektor deepfake wajah berbasis MediaPipe + EfficientNet.
+    
+    Cara kerja:
+    - Terima frame BGR dari OpenCV
+    - MediaPipe deteksi wajah & ekstrak bounding box
+    - EfficientNet klasifikasikan setiap wajah sebagai REAL/FAKE
+    - Temporal smoothing untuk stabilitas score
+    """
+
+    def __init__(self):
+        # Inisialisasi MediaPipe Face Detection (lebih cepat dari Face Mesh untuk bounding box)
+        self.face_detection = mp.solutions.face_detection.FaceDetection(
+            model_selection=1,        # Model 1 = full-range (jarak jauh), 0 = short-range
+            min_detection_confidence=0.6
+        )
+
+        # Buffer rolling untuk temporal smoothing score
+        self._score_buffer: deque = deque(maxlen=TEMPORAL_WINDOW)
+
+        # Score terakhir yang sudah di-smooth
+        self.last_smoothed_score: float = 0.5
+
+        logger.info("✅ FaceDeepfakeDetector siap digunakan")
+
+    def process_frame(self, frame_bgr: np.ndarray) -> dict:
+        """
+        Proses satu frame video dan kembalikan hasil deteksi.
+        
+        Args:
+            frame_bgr: Frame dari OpenCV dalam format BGR, shape [H, W, 3]
+            
+        Returns:
+            dict dengan keys:
+              - 'authenticity_score': float 0.0 (FAKE) - 1.0 (REAL)
+              - 'smoothed_score'    : float, hasil temporal smoothing
+              - 'faces_detected'   : int, jumlah wajah terdeteksi
+              - 'face_boxes'       : list of [x, y, w, h] dalam pixel
+              - 'label'            : str, 'REAL' / 'FAKE' / 'UNCERTAIN'
+              - 'confidence'       : float, confidence tertinggi
+        """
+        h, w = frame_bgr.shape[:2]
+
+        # Konversi BGR → RGB (MediaPipe butuh RGB)
+        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+
+        # --- Step 1: Deteksi Wajah dengan MediaPipe ---
+        results = self.face_detection.process(frame_rgb)
+
+        # Jika tidak ada wajah terdeteksi, kembalikan nilai netral
+        if not results.detections:
+            return self._empty_result()
+
+        face_boxes    = []
+        face_scores   = []
+
+        # --- Step 2: Proses Setiap Wajah yang Terdeteksi ---
+        for detection in results.detections:
+            # Ekstrak bounding box relatif (0.0 - 1.0) dari MediaPipe
+            bbox = detection.location_data.relative_bounding_box
+
+            # Konversi ke koordinat piksel
+            x = int(bbox.xmin * w)
+            y = int(bbox.ymin * h)
+            bw = int(bbox.width * w)
+            bh = int(bbox.height * h)
+
+            # Tambahkan padding di sekitar wajah
+            pad_x = int(bw * FACE_PADDING_RATIO)
+            pad_y = int(bh * FACE_PADDING_RATIO)
+
+            # Pastikan koordinat tidak keluar dari batas frame
+            x1 = max(0, x - pad_x)
+            y1 = max(0, y - pad_y)
+            x2 = min(w, x + bw + pad_x)
+            y2 = min(h, y + bh + pad_y)
+
+            # Crop region wajah dari frame RGB
+            face_crop = frame_rgb[y1:y2, x1:x2]
+
+            # Skip jika crop kosong (edge case)
+            if face_crop.size == 0:
+                continue
+
+            # Jalankan EfficientNet untuk klasifikasi
+            score = self._classify_face(face_crop)
+            face_scores.append(score)
+            face_boxes.append([x1, y1, x2 - x1, y2 - y1])
+
+        # Jika tidak ada wajah valid yang berhasil di-crop
+        if not face_scores:
+            return self._empty_result()
+
+        # Ambil score terendah (wajah paling mencurigakan) sebagai output utama
+        min_score = min(face_scores)
+
+        # Tambahkan ke buffer temporal smoothing
+        self._score_buffer.append(min_score)
+
+        # Hitung rata-rata dari buffer (temporal smoothing)
+        smoothed = float(np.mean(self._score_buffer))
+        self.last_smoothed_score = smoothed
+
+        # Jika buffer hanya berisi 1 data (misal: langsung setelah reset = mode foto),
+        # gunakan raw score agar tidak ada efek smoothing dari data lama
+        effective_score = min_score if len(self._score_buffer) == 1 else smoothed
+
+        return {
+            "authenticity_score": round(min_score, 4),
+            "smoothed_score"    : round(effective_score, 4),
+            "faces_detected"    : len(face_scores),
+            "face_boxes"        : face_boxes,
+            "label"             : self._score_to_label(effective_score),
+            "confidence"        : round(max(effective_score, 1 - effective_score), 4),
+        }
+
+    def _classify_face(self, face_rgb: np.ndarray) -> float:
+        """
+        Klasifikasikan crop wajah menggunakan HuggingFace Pipeline.
+        
+        Args:
+            face_rgb: Crop wajah dalam format RGB numpy array
+            
+        Returns:
+            float: Skor keaslian (0.0 = FAKE, 1.0 = REAL)
+        """
+        # Konversi numpy array → PIL Image
+        pil_image = Image.fromarray(face_rgb)
+
+        try:
+            # Jalankan inferensi menggunakan pipeline transformers
+            results = model_loader.face_model(pil_image)
+            
+            # Log output mentah model untuk debugging
+            logger.debug(f"🔍 Raw model output: {results}")
+            logger.info(f"📊 Model output: {results}")
+            
+            # Parsing label model prithivMLmods/deepfake-detector-model-v1
+            # Label: Class 0 = 'fake', Class 1 = 'real'
+            real_prob = 0.5
+            fake_prob = 0.5
+            
+            for res in results:
+                lbl = str(res.get('label', '')).strip().lower()
+                score = float(res.get('score', 0.5))
+                
+                # Match label 'real' atau 'Real' atau '1'
+                if lbl in ('real', '1', 'label_1') or 'real' in lbl:
+                    real_prob = score
+                # Match label 'fake' atau 'Fake' atau '0'
+                elif lbl in ('fake', '0', 'label_0') or 'fake' in lbl or 'ai' in lbl or 'manipulated' in lbl or 'artificial' in lbl:
+                    fake_prob = score
+                    real_prob = 1.0 - score
+            
+            logger.info(f"✅ real_prob={real_prob:.3f}, fake_prob={fake_prob:.3f}")
+            return float(real_prob)
+            
+        except Exception as e:
+            logger.error(f"Error inferensi pipeline: {e}")
+            return 0.5
+
+    def _score_to_label(self, score: float) -> str:
+        """Konversi skor numerik menjadi label teks."""
+        # score = probabilitas REAL (0.0 = pasti FAKE, 1.0 = pasti REAL)
+        # Zona UNCERTAIN dipersempit: 0.45 - 0.55 (lebih decisive)
+        if score >= 0.55:
+            return "REAL"
+        elif score <= 0.45:
+            return "FAKE"
+        else:
+            return "UNCERTAIN"
+
+    def _empty_result(self) -> dict:
+        """Kembalikan hasil kosong ketika tidak ada wajah terdeteksi."""
+        return {
+            "authenticity_score": 0.5,
+            "smoothed_score"    : self.last_smoothed_score,
+            "faces_detected"    : 0,
+            "face_boxes"        : [],
+            "label"             : "NO_FACE",
+            "confidence"        : 0.0,
+        }
+
+    def reset_temporal_buffer(self):
+        """Reset buffer temporal smoothing. Berguna saat sumber video berganti."""
+        self._score_buffer.clear()
+        self.last_smoothed_score = 0.5
+        logger.info("Buffer temporal smoothing direset.")

model_loader.py

@@ -0,0 +1,185 @@
+"""
+model_loader.py
+===============
+Singleton pattern untuk memuat semua model AI sekali saat startup.
+Mencegah OOM (Out of Memory) pada VRAM 4GB RTX 3050 Ti dengan
+manajemen memori yang ketat dan Mixed Precision (FP16).
+"""
+
+# ============================================================
+# PENTING: Set cache directory SEBELUM import timm/huggingface
+# Ini menghindari PermissionError di Windows saat timm mencoba
+# menulis ke C:\Users\..\.cache\huggingface yang diblokir ACL.
+# ============================================================
+import os
+from pathlib import Path
+
+# Gunakan folder 'models/hf_cache' di dalam project sebagai cache
+_PROJECT_ROOT = Path(__file__).parent
+_HF_CACHE_DIR = str(_PROJECT_ROOT / "models" / "hf_cache")
+
+# Set env var SEBELUM huggingface_hub / timm diinisialisasi
+os.environ["HF_HOME"]               = _HF_CACHE_DIR
+os.environ["HUGGINGFACE_HUB_CACHE"] = _HF_CACHE_DIR
+os.environ["TORCH_HOME"]            = str(_PROJECT_ROOT / "models" / "torch_cache")
+
+# Pastikan direktori cache ada
+Path(_HF_CACHE_DIR).mkdir(parents=True, exist_ok=True)
+Path(os.environ["TORCH_HOME"]).mkdir(parents=True, exist_ok=True)
+# ============================================================
+
+import torch
+import timm
+from transformers import pipeline
+import logging
+
+# Konfigurasi logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- Konfigurasi Global ---
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+MODEL_DIR = Path(__file__).parent / "models"
+MODEL_DIR.mkdir(exist_ok=True)
+
+# Nama model EfficientNet yang digunakan (bisa diganti ke efficientnet_b3 jika VRAM kurang)
+EFFICIENTNET_VARIANT = "efficientnet_b4"
+NUM_CLASSES = 2  # [REAL, FAKE]
+
+
+class ModelLoader:
+    """
+    Singleton class untuk mengelola semua model AI.
+    Memastikan model hanya dimuat satu kali ke VRAM.
+    """
+    _instance = None          # Referensi singleton
+    _face_model = None        # Model klasifikasi wajah deepfake
+    _audio_model = None       # Model klasifikasi suara deepfake
+    _is_initialized = False   # Flag apakah sudah diinisialisasi
+
+    def __new__(cls):
+        """Implementasi singleton: hanya buat satu instance."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def initialize(self):
+        """
+        Muat semua model ke device (GPU/CPU).
+        Dipanggil sekali saat startup FastAPI.
+        """
+        if self._is_initialized:
+            logger.info("Models sudah diinisialisasi, skip loading.")
+            return
+
+        logger.info(f"🚀 Menginisialisasi ModelLoader pada device: {DEVICE}")
+        self._log_device_info()
+
+        # Muat model klasifikasi wajah
+        self._face_model = self._load_face_model()
+
+        # Muat model klasifikasi audio (CNN sederhana)
+        self._audio_model = self._load_audio_model()
+
+        self._is_initialized = True
+        logger.info("✅ Semua model berhasil dimuat!")
+
+    def _log_device_info(self):
+        """Tampilkan informasi GPU/CUDA untuk debugging."""
+        if torch.cuda.is_available():
+            gpu_name = torch.cuda.get_device_name(0)
+            vram_total = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            logger.info(f"🎮 GPU Terdeteksi: {gpu_name}")
+            logger.info(f"💾 VRAM Total: {vram_total:.1f} GB")
+        else:
+            logger.warning("⚠️ CUDA tidak tersedia. Menggunakan CPU (performa lebih lambat).")
+
+    def _load_face_model(self):
+        """
+        Muat model pre-trained Deepfake Detection dari HuggingFace (prithivMLmods/Deep-Fake-Detector-Model).
+        Model ini (ViT) sudah dilatih khusus untuk membedakan Real vs AI-Generated/Deepfake.
+        """
+        logger.info(f"📦 Memuat model wajah dari HuggingFace: prithivMLmods/Deep-Fake-Detector-Model...")
+
+        try:
+            # Gunakan transformers pipeline untuk image-classification
+            device_id = 0 if DEVICE.type == "cuda" else -1
+            model_pipeline = pipeline(
+                "image-classification",
+                model="prithivMLmods/Deep-Fake-Detector-Model",
+                device=device_id
+            )
+            logger.info("✅ Model wajah HuggingFace siap digunakan!")
+            return model_pipeline
+        except Exception as e:
+            logger.error(f"❌ Gagal memuat model HuggingFace: {e}")
+            raise e
+
+    def _load_audio_model(self) -> torch.nn.Module:
+        """
+        Muat model CNN sederhana untuk analisis spektrogram audio.
+        Menggunakan MobileNetV3-Small untuk efisiensi VRAM.
+        """
+        logger.info("📦 Memuat model audio: mobilenetv3_small_100...")
+
+        # MobileNetV3 lebih ringan dari EfficientNet, cocok untuk audio spectrogram
+        model = timm.create_model(
+            "mobilenetv3_small_100",
+            pretrained=True,
+            num_classes=NUM_CLASSES,
+            in_chans=1  # Spectrogram adalah grayscale (1 channel)
+        )
+
+        model.eval()
+        model = model.to(DEVICE)
+
+        if DEVICE.type == "cuda":
+            model = model.half()
+            logger.info("✅ Model audio: FP16 (half-precision) diaktifkan")
+
+        logger.info("✅ Model audio 'MobileNetV3-Small' siap digunakan")
+        return model
+
+    @property
+    def face_model(self):
+        """Akses model wajah yang sudah dimuat."""
+        if not self._is_initialized:
+            raise RuntimeError("ModelLoader belum diinisialisasi! Panggil .initialize() dulu.")
+        return self._face_model
+
+    @property
+    def audio_model(self) -> torch.nn.Module:
+        """Akses model audio yang sudah dimuat."""
+        if not self._is_initialized:
+            raise RuntimeError("ModelLoader belum diinisialisasi! Panggil .initialize() dulu.")
+        return self._audio_model
+
+    @property
+    def device(self) -> torch.device:
+        """Kembalikan device yang sedang digunakan (cuda/cpu)."""
+        return DEVICE
+
+    def get_vram_usage(self) -> dict:
+        """
+        Kembalikan informasi penggunaan VRAM saat ini.
+        Berguna untuk monitoring di endpoint /api/health.
+        """
+        if DEVICE.type != "cuda":
+            return {"available": False, "reason": "CUDA not available"}
+
+        allocated = torch.cuda.memory_allocated(0) / 1024**3   # GB
+        reserved  = torch.cuda.memory_reserved(0) / 1024**3    # GB
+        total     = torch.cuda.get_device_properties(0).total_memory / 1024**3
+
+        return {
+            "available": True,
+            "gpu_name": torch.cuda.get_device_name(0),
+            "vram_total_gb": round(total, 2),
+            "vram_allocated_gb": round(allocated, 3),
+            "vram_reserved_gb": round(reserved, 3),
+            "vram_free_gb": round(total - reserved, 3),
+        }
+
+
+# Instance singleton global - diimport oleh modul lain
+model_loader = ModelLoader()

requirements.txt

@@ -0,0 +1,32 @@
+# Deepfake Shield - Backend untuk Hugging Face Spaces
+# Requirements yang ringan (tanpa CUDA, pakai CPU di HF Spaces tier gratis)
+
+# --- Web Framework ---
+fastapi==0.111.0
+uvicorn[standard]==0.29.0
+python-multipart==0.0.9
+
+# --- Deep Learning (CPU version untuk HF Spaces gratis) ---
+torch==2.2.2
+torchvision==0.17.2
+timm==0.9.16
+transformers==4.40.0
+
+# --- Computer Vision ---
+opencv-python-headless==4.9.0.80
+mediapipe==0.10.14
+Pillow==10.3.0
+
+# --- Audio Processing ---
+librosa==0.10.2
+soundfile==0.12.1
+scipy==1.13.0
+
+# --- Data Processing ---
+numpy==1.26.4
+
+# --- Utilities ---
+python-dotenv==1.0.1
+aiofiles==23.2.1
+pydantic==2.7.1
+httpx==0.27.0

utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+__init__.py untuk package utils
+"""

utils/audio_processor.py

@@ -0,0 +1,86 @@
+"""
+audio_processor.py
+==================
+Utilitas untuk preprocessing audio chunk sebelum dianalisis.
+"""
+
+import numpy as np
+import librosa
+import io
+import soundfile as sf
+from typing import Tuple, Optional
+
+
+def bytes_to_audio(audio_bytes: bytes) -> Tuple[np.ndarray, int]:
+    """
+    Konversi bytes audio ke numpy array PCM.
+    Mendukung format: WAV, MP3, OGG, FLAC.
+    
+    Returns:
+        Tuple (audio_array float32 mono, sample_rate)
+    """
+    buffer = io.BytesIO(audio_bytes)
+
+    # Coba baca dengan soundfile terlebih dahulu
+    try:
+        audio, sr = sf.read(buffer, dtype='float32')
+    except Exception:
+        # Fallback ke librosa (lebih lambat tapi mendukung lebih banyak format)
+        buffer.seek(0)
+        audio, sr = librosa.load(buffer, sr=None, mono=True)
+        return audio, sr
+
+    # Konversi stereo ke mono jika diperlukan
+    if audio.ndim == 2:
+        audio = np.mean(audio, axis=1)
+
+    return audio, sr
+
+
+def normalize_audio(audio: np.ndarray) -> np.ndarray:
+    """
+    Normalisasi amplitudo audio ke range [-1.0, 1.0].
+    Mencegah saturasi dan memastikan konsistensi input model.
+    """
+    max_val = np.max(np.abs(audio))
+    if max_val > 0:
+        audio = audio / max_val
+    return audio
+
+
+def split_audio_chunks(
+    audio: np.ndarray,
+    sample_rate: int,
+    chunk_duration: float = 2.0,
+    overlap: float = 0.5
+) -> list:
+    """
+    Bagi audio panjang menjadi chunks kecil dengan overlap.
+    
+    Args:
+        audio         : Array audio PCM
+        sample_rate   : Sample rate (Hz)
+        chunk_duration: Durasi setiap chunk (detik)
+        overlap       : Overlap antar chunk (detik)
+        
+    Returns:
+        List of numpy arrays, masing-masing adalah satu chunk
+    """
+    chunk_samples = int(chunk_duration * sample_rate)
+    hop_samples   = int((chunk_duration - overlap) * sample_rate)
+    
+    chunks = []
+    start = 0
+
+    while start + chunk_samples <= len(audio):
+        chunk = audio[start:start + chunk_samples]
+        chunks.append(chunk)
+        start += hop_samples
+
+    # Tambahkan sisa audio jika belum masuk (dengan padding)
+    if start < len(audio):
+        remainder = audio[start:]
+        padded = np.pad(remainder, (0, chunk_samples - len(remainder)))
+        chunks.append(padded)
+
+    return chunks

utils/frame_processor.py

@@ -0,0 +1,124 @@
+"""
+frame_processor.py
+==================
+Utilitas untuk preprocessing frame video sebelum dimasukkan ke model.
+Termasuk: resize, quality enhancement, dan konversi format.
+"""
+
+import cv2
+import numpy as np
+from typing import Tuple, Optional
+
+
+def decode_base64_frame(b64_string: str) -> Optional[np.ndarray]:
+    """
+    Decode string base64 menjadi frame OpenCV BGR.
+    
+    Args:
+        b64_string: String base64 (dengan atau tanpa data URL prefix)
+        
+    Returns:
+        numpy array [H, W, 3] BGR, atau None jika gagal
+    """
+    import base64
+
+    # Hapus prefix data URL jika ada
+    if "," in b64_string:
+        b64_string = b64_string.split(",", 1)[1]
+
+    try:
+        # Decode base64 → bytes → numpy
+        raw_bytes = base64.b64decode(b64_string)
+        arr = np.frombuffer(raw_bytes, dtype=np.uint8)
+        frame = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+        return frame
+    except Exception:
+        return None
+
+
+def preprocess_frame(
+    frame: np.ndarray,
+    target_size: Tuple[int, int] = (640, 480),
+    enhance_quality: bool = True
+) -> np.ndarray:
+    """
+    Preprocess frame video untuk optimasi deteksi.
+    
+    Args:
+        frame       : Frame BGR dari OpenCV
+        target_size : (width, height) target untuk resize
+        enhance_quality: Terapkan CLAHE untuk perbaikan kontras
+        
+    Returns:
+        Frame BGR yang sudah dipreprocess
+    """
+    # Resize frame jika terlalu besar (menghemat waktu proses)
+    h, w = frame.shape[:2]
+    target_w, target_h = target_size
+
+    # Hanya resize jika lebih besar dari target
+    if w > target_w or h > target_h:
+        frame = cv2.resize(frame, target_size, interpolation=cv2.INTER_LINEAR)
+
+    # CLAHE (Contrast Limited Adaptive Histogram Equalization)
+    # Meningkatkan kontras lokal untuk membantu deteksi wajah
+    if enhance_quality:
+        lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)  # Konversi ke LAB color space
+        l_channel, a, b = cv2.split(lab)
+
+        # Terapkan CLAHE hanya pada channel L (luminance/kecerahan)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        l_enhanced = clahe.apply(l_channel)
+
+        # Gabungkan kembali channel
+        enhanced_lab = cv2.merge([l_enhanced, a, b])
+        frame = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2BGR)
+
+    return frame
+
+
+def draw_detection_overlay(
+    frame: np.ndarray,
+    face_boxes: list,
+    label: str,
+    score: float
+) -> np.ndarray:
+    """
+    Gambar bounding box dan label deteksi di atas frame.
+    
+    Args:
+        frame    : Frame BGR
+        face_boxes: List of [x, y, w, h] dalam piksel
+        label    : Label deteksi ('REAL', 'FAKE', 'UNCERTAIN')
+        score    : Skor keaslian (0.0 - 1.0)
+        
+    Returns:
+        Frame dengan overlay
+    """
+    # Pilih warna berdasarkan label
+    color_map = {
+        "REAL"     : (0, 255, 100),    # Hijau neon
+        "FAKE"     : (0, 50, 255),      # Merah
+        "UNCERTAIN": (0, 165, 255),     # Oranye
+        "NO_FACE"  : (128, 128, 128),   # Abu-abu
+    }
+    color = color_map.get(label, (255, 255, 255))
+
+    # Gambar bounding box untuk setiap wajah
+    for (x, y, w, h) in face_boxes:
+        # Bounding box utama
+        cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
+
+        # Label teks di atas bounding box
+        label_text = f"{label} {score:.0%}"
+        cv2.putText(
+            frame, label_text,
+            (x, max(y - 10, 10)),        # Posisi: di atas bbox, minimal y=10
+            cv2.FONT_HERSHEY_SIMPLEX,     # Font
+            0.7,                           # Scale
+            color,                         # Warna
+            2,                             # Tebal
+            cv2.LINE_AA                    # Anti-aliasing
+        )
+
+    return frame