Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.9-slim
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user requirements.txt .
+
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,81 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import shutil
+import uuid
+import os
+
+from inference import run_inference, generate_heatmap
+
+app = FastAPI()
+
+@app.get("/")
+def root():
+    return {"status": "Deepfake API running"}
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.post("/predict")
+async def predict(video: UploadFile = File(...)):
+
+    file_id = f"{uuid.uuid4()}.mp4"
+    path = f"/tmp/{file_id}"
+
+    try:
+
+        with open(path, "wb") as buffer:
+            shutil.copyfileobj(video.file, buffer)
+
+        result = run_inference(path)
+
+        return result
+
+    except Exception as e:
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )
+
+    finally:
+
+        if os.path.exists(path):
+            os.remove(path)
+
+@app.post("/heatmap")
+async def heatmap(data: dict):
+
+    try:
+
+        frame_index = int(data.get("frame_index", -1))
+
+        if frame_index < 0:
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid frame index"
+            )
+
+        heatmap, regions = generate_heatmap(frame_index)
+
+        if heatmap is None:
+            raise HTTPException(
+                status_code=404,
+                detail="Frame not found"
+            )
+
+        return {
+            "heatmap": heatmap,
+            "regions": regions
+        }
+
+    except Exception as e:
+
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+        )

best_model.pth

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

cam.py

@@ -0,0 +1,70 @@
+import torch
+import cv2
+import numpy as np
+import base64
+
+
+class GradCAM:
+
+    def __init__(self, model, target_layer):
+
+        self.model = model
+        self.target_layer = target_layer
+
+        self.gradients = None
+        self.activations = None
+
+        self.target_layer.register_forward_hook(self.forward_hook)
+        self.target_layer.register_full_backward_hook(self.backward_hook)
+
+    def forward_hook(self, module, input, output):
+
+        self.activations = output.detach()
+
+    def backward_hook(self, module, grad_input, grad_output):
+
+        self.gradients = grad_output[0].detach()
+
+    def generate(self, input_tensor):
+
+        output = self.model(input_tensor)
+
+        pred_class = output.argmax()
+
+        self.model.zero_grad()
+
+        output[:, pred_class].backward()
+
+        gradients = self.gradients[0].cpu().numpy()
+        activations = self.activations[0].cpu().numpy()
+
+        weights = np.mean(gradients, axis=(1, 2))
+
+        cam = np.zeros(activations.shape[1:], dtype=np.float32)
+
+        for i, w in enumerate(weights):
+            cam += w * activations[i]
+
+        cam = np.maximum(cam, 0)
+
+        cam = cam / (cam.max() + 1e-8)
+
+        cam = cv2.resize(cam, (240, 240))
+
+        return cam
+
+
+def overlay_heatmap(frame, cam):
+
+    heatmap = cv2.applyColorMap(
+        np.uint8(255 * cam),
+        cv2.COLORMAP_JET
+    )
+
+    overlay = heatmap * 0.4 + frame * 0.6
+
+    overlay = overlay.astype(np.uint8)
+
+    _, buffer = cv2.imencode(".jpg", overlay)
+
+    return base64.b64encode(buffer).decode("utf-8")

face_crop.py

@@ -0,0 +1,32 @@
+import cv2
+
+face_detector = cv2.CascadeClassifier(
+    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+)
+
+def crop_face(frame):
+
+    if face_detector.empty():
+        return frame
+
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+    faces = face_detector.detectMultiScale(
+        gray,
+        scaleFactor=1.3,
+        minNeighbors=5
+    )
+
+    if len(faces) == 0:
+
+        h, w, _ = frame.shape
+        return frame[h//4:3*h//4, w//4:3*w//4]
+
+    x, y, w, h = faces[0]
+
+    x = max(0, x)
+    y = max(0, y)
+
+    face = frame[y:y+h, x:x+w]
+
+    return face

inference.py

@@ -0,0 +1,216 @@
+import torch
+import cv2
+import numpy as np
+import torchvision.transforms as T
+from collections import OrderedDict
+import base64
+
+from model import DeepfakeEffNetTransformer
+from cam import GradCAM, overlay_heatmap
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# LOAD MODEL
+
+model = DeepfakeEffNetTransformer()
+
+state_dict = torch.load(
+    "best_model.pth",
+    map_location="cpu"
+)
+
+new_state = OrderedDict()
+
+for k, v in state_dict.items():
+    name = k.replace("module.", "")
+    new_state[name] = v
+
+model.load_state_dict(new_state)
+
+model = model.to(device)
+model.eval()
+
+print("Model loaded")
+
+# GRADCAM TARGET LAYER
+
+target_layer = model.cnn.blocks[-1]
+grad_cam = GradCAM(model, target_layer)
+
+# FACE DETECTOR
+
+face_detector = cv2.CascadeClassifier(
+    cv2.data.haarcascades +
+    "haarcascade_frontalface_default.xml"
+)
+
+# FRAME CACHE
+
+LAST_FRAMES = []
+
+# FRAME EXTRACTION
+
+def extract_and_crop(video_path, num_frames=10):
+
+    cap = cv2.VideoCapture(video_path)
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    idx = np.linspace(0, total_frames - 1, num_frames).astype(int)
+
+    frames = []
+
+    for i in idx:
+
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i)
+
+        ret, frame = cap.read()
+
+        if not ret:
+            continue
+
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        faces = face_detector.detectMultiScale(
+            gray,
+            scaleFactor=1.3,
+            minNeighbors=5
+        )
+
+        if len(faces) > 0:
+
+            x, y, w, h = faces[0]
+
+            face = frame[y:y+h, x:x+w]
+
+        else:
+
+            face = frame
+
+        face = cv2.resize(face, (240,240))
+        face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+
+        frames.append(face)
+
+    cap.release()
+
+    return frames
+
+# TRANSFORM
+
+transform = T.Compose([
+    T.ToPILImage(),
+    T.Resize((240,240)),
+    T.ToTensor(),
+    T.Normalize([0.5]*3,[0.5]*3)
+])
+
+# INFERENCE
+
+def run_inference(video_path):
+
+    global LAST_FRAMES
+
+    frames = extract_and_crop(video_path)
+
+    LAST_FRAMES = frames
+
+    if len(frames) == 0:
+
+        return {
+            "label": "Video tidak terbaca",
+            "confidence": 0,
+            "frames": []
+        }
+
+    imgs = []
+
+    for f in frames:
+
+        img = transform(f)
+        imgs.append(img)
+
+    imgs = torch.stack(imgs).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+
+        outputs = model(imgs)
+
+        probs = torch.softmax(outputs, dim=1)[0]
+
+        pred = torch.argmax(probs).item()
+
+        confidence = probs[pred].item() * 100
+
+    label = "Real" if pred == 0 else "Fake"
+
+    encoded_frames = []
+
+    for f in frames:
+
+        _, buffer = cv2.imencode(
+            ".jpg",
+            cv2.cvtColor(f, cv2.COLOR_RGB2BGR)
+        )
+
+        encoded_frames.append(
+            base64.b64encode(buffer).decode("utf-8")
+        )
+
+    return {
+        "label": label,
+        "confidence": confidence,
+        "frames": encoded_frames
+    }
+
+# REGION IMPORTANCE
+
+def compute_regions(cam):
+
+    regions = {}
+
+    regions["Forehead"] = cam[0:60, :].mean()
+    regions["Eyes"] = cam[60:110, :].mean()
+    regions["Cheeks"] = cam[110:170, :].mean()
+    regions["Mouth"] = cam[170:220, :].mean()
+    regions["Chin"] = cam[220:240, :].mean()
+
+    total = sum(regions.values()) + 1e-8
+
+    result = []
+
+    for k,v in regions.items():
+
+        result.append({
+            "name": k,
+            "value": float(v / total)
+        })
+
+    return result
+
+# HEATMAP GENERATION
+
+def generate_heatmap(frame_index):
+
+    global LAST_FRAMES
+
+    if frame_index >= len(LAST_FRAMES):
+        return None, None
+
+    frame = LAST_FRAMES[frame_index]
+
+    img = transform(frame)
+
+    seq = torch.stack([img] * 10)
+    seq = seq.unsqueeze(0).to(device)
+
+    cam = grad_cam.generate(seq)
+
+    regions = compute_regions(cam)
+
+    heatmap = overlay_heatmap(
+        cv2.cvtColor(frame, cv2.COLOR_RGB2BGR),
+        cam
+    )
+
+    return heatmap, regions

model.py

@@ -0,0 +1,67 @@
+import torch
+import torch.nn as nn
+import timm
+
+
+class DeepfakeEffNetTransformer(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+
+        # CNN BACKBONE
+        self.cnn = timm.create_model(
+            "tf_efficientnetv2_b1",
+            pretrained=False,
+            num_classes=0,
+            global_pool=""
+        )
+
+        self.pool = nn.AdaptiveAvgPool2d(1)
+        feat_dim = self.cnn.num_features
+
+        # PROJECTION
+        self.proj = nn.Linear(feat_dim, 512)
+
+        # POSITIONAL EMBEDDING
+        self.pos_embed = nn.Parameter(
+            torch.randn(1, 10, 512)
+        )
+
+        # TRANSFORMER
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=512,
+            nhead=8,
+            dim_feedforward=1024,
+            batch_first=True
+        )
+
+        self.transformer = nn.TransformerEncoder(
+            encoder_layer,
+            num_layers=2
+        )
+
+        # CLASSIFIER
+        self.classifier = nn.Sequential(
+            nn.Linear(512, 128),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(128, 2)
+        )
+
+    def forward(self, x):
+        B, T, C, H, W = x.shape
+        x = x.view(B * T, C, H, W)
+
+        # CNN FEATURES
+        feats = self.cnn(x)
+        feats = self.pool(feats)
+        feats = feats.view(B, T, -1)
+
+        # PROJECTION
+        feats = self.proj(feats)
+        feats = feats + self.pos_embed
+
+        # TEMPORAL TRANSFORMER
+        out = self.transformer(feats)
+        out = out.mean(dim=1)
+        return self.classifier(out)

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn[standard]
+python-multipart
+
+numpy
+pillow
+
+torch
+torchvision
+timm
+
+opencv-python-headless

video_frames.py

@@ -0,0 +1,36 @@
+import cv2
+
+
+def extract_frames(video_path, num_frames=10):
+
+    cap = cv2.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        raise RuntimeError("Cannot open video")
+
+    total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    step = max(total // num_frames, 1)
+
+    frames = []
+
+    for i in range(num_frames):
+
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i * step)
+
+        ret, frame = cap.read()
+
+        if not ret:
+            break
+
+        frames.append(frame)
+
+    cap.release()
+
+    if len(frames) == 0:
+        raise RuntimeError("No frames extracted")
+
+    while len(frames) < num_frames:
+        frames.append(frames[-1])
+
+    return frames