feat: add 5 new video detection services (DFD-FCG, PwTF-DVD, LipFD, RECCE, MINTIME)

.gitattributes

@@ -127,3 +127,16 @@ audio/shiftyspeech/speech_synthesis/vocoders/univnet/docs/samples/unseen/officia
 image/aide/model_code/docs/Chameleon.jpg filter=lfs diff=lfs merge=lfs -text
 image/aide/model_code/docs/network.png filter=lfs diff=lfs merge=lfs -text
 video/fake-stormer/model_code/demo/method.png filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+video/mintime/weights/** filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+*.dat filter=lfs diff=lfs merge=lfs -text
+*.avi filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.hdf5 filter=lfs diff=lfs merge=lfs -text

video/dfd-fcg/Dockerfile

@@ -0,0 +1,59 @@
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Install Python 3.10 and system dependencies for OpenCV
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchvision==0.20.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
+# Copy requirements and install
+# facenet-pytorch needs --no-deps due to torch<2.3 pin
+COPY requirements.txt .
+RUN pip install --no-cache-dir --no-deps facenet-pytorch && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Create logs and weights directories
+RUN mkdir -p logs weights model_code
+
+# Copy model code (read-only reference, never modified)
+COPY model_code/ /app/model_code/
+
+# Copy weights
+COPY weights/ /app/weights/
+
+# Copy application code
+COPY app.py .
+
+# Environment variables
+ENV MODEL_PORT=7003
+ENV PRELOAD_MODEL=false
+ENV MODEL_TIMEOUT=1800
+ENV WEIGHTS_PATH=/app/weights/dfd_fcg_checkpoint.pth
+ENV MODEL_CODE_DIR=/app/model_code
+
+# Expose port
+EXPOSE 7003
+
+# Drop root privileges
+RUN adduser --disabled-password --gecos '' appuser && \
+    chown -R appuser:appuser /app/logs /app/weights
+USER appuser
+
+# Run the service
+CMD ["python", "app.py"]

video/dfd-fcg/app.py

@@ -0,0 +1,661 @@
+"""DFD-FCG (Deepfake Detection via Facial Component Guidance) service.
+
+Wraps the DFD-FCG (CVPR 2025) video deepfake detection model with a
+FastAPI endpoint. Uses CLIP ViT-L/14 with a Synoptic Video Learner
+and Facial Component Guidance for robust face forgery detection.
+
+The model analyses temporal and spatial inconsistencies across facial
+components (lips, skin, eyes, nose) using learned synoptic attention
+over multi-frame CLIP embeddings.
+
+Reference: "Deepfake Detection via Facial Component Guidance",
+CVPR 2025.
+"""
+
+import base64
+import gc
+import logging
+import math
+import os
+import platform
+import sys
+import tempfile
+import threading
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from PIL import Image
+from pydantic import BaseModel, ConfigDict, Field
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+MODEL_PORT = int(os.environ.get("MODEL_PORT", 7003))
+PRELOAD_MODEL = (
+    os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
+)
+MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", 1800))
+WEIGHTS_PATH = os.environ.get(
+    "WEIGHTS_PATH", "/app/weights/dfd_fcg_checkpoint.pth"
+)
+# Path to serialized face semantic features used by FFG module
+FACE_FEATURES_PATH = os.environ.get(
+    "FACE_FEATURES_PATH",
+    "/app/model_code/misc/L14_real_semantic_patches_v4_2000.pickle",
+)
+
+# DFD-FCG uses CLIP ViT-L/14 at 224x224 (standard CLIP resolution)
+IMAGE_SIZE = 224
+# Number of frames to sample per clip (matches config num_frames=10)
+NUM_FRAMES = 10
+# Frame sampling stride in seconds (matches demo.py stride=0.333)
+FRAME_STRIDE = 0.333
+# Face crop margin factor for MTCNN bounding boxes
+MARGIN_FACTOR = 0.5
+
+
+def _get_device() -> torch.device:
+    """Select optimal device: CUDA (NVIDIA) > MPS (Apple) > CPU."""
+    override = os.environ.get("DEEPSAFE_DEVICE", "").strip().lower()
+    if override == "cpu":
+        return torch.device("cpu")
+    if override == "cuda" and torch.cuda.is_available():
+        return torch.device("cuda")
+    if (
+        override == "mps"
+        and hasattr(torch.backends, "mps")
+        and torch.backends.mps.is_available()
+    ):
+        return torch.device("mps")
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    if (
+        platform.system() == "Darwin"
+        and hasattr(torch.backends, "mps")
+        and torch.backends.mps.is_available()
+    ):
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+def _build_model_from_config():
+    """Build FFGSynoVideoLearner from config parameters.
+
+    Instantiates the model directly using the same parameters
+    defined in configs/clip/L14/ffg.yaml and configs/base.yaml,
+    avoiding the heavy ODLightningCLI/trainer machinery that is
+    unnecessary for inference.
+
+    Returns:
+        An FFGSynoVideoLearner instance (unloaded weights).
+    """
+    # Add model_code to sys.path so src.* imports resolve
+    model_code_dir = os.environ.get(
+        "MODEL_CODE_DIR", "/app/model_code"
+    )
+    if model_code_dir not in sys.path:
+        sys.path.insert(0, model_code_dir)
+
+    # Suppress wandb import in svl.py (it imports wandb at top)
+    if "wandb" not in sys.modules:
+        import types
+        wandb_stub = types.ModuleType("wandb")
+        sys.modules["wandb"] = wandb_stub
+
+    from src.model.clip.svl import FFGSynoVideoLearner
+
+    model = FFGSynoVideoLearner(
+        # FFG-specific params (from configs/clip/L14/ffg.yaml)
+        face_feature_path=FACE_FEATURES_PATH,
+        face_parts=["lips", "skin", "eyes", "nose"],
+        architecture="ViT-L/14",
+        num_frames=NUM_FRAMES,
+        ksize_s=5,
+        ksize_t=5,
+        s_k_attr="k",
+        s_v_attr="emb",
+        t_attrs=["q", "k", "v"],
+        # Defaults from base model
+        text_embed=False,
+        op_mode=["S", "T"],
+    )
+    return model
+
+
+# ── Global state ───────────────────────────────────────────────────
+
+_model = None
+_face_detector = None
+_transform = None
+_device: Optional[torch.device] = None
+_load_lock = threading.Lock()
+
+
+def _load_models() -> None:
+    """Load DFD-FCG model and MTCNN face detector (thread-safe)."""
+    global _model, _face_detector, _transform, _device
+
+    if _model is not None:
+        return
+
+    with _load_lock:
+        if _model is not None:
+            return
+
+        _device = _get_device()
+        if _device.type == "cuda":
+            torch.backends.cudnn.benchmark = True
+            torch.set_float32_matmul_precision("high")
+        if _device.type == "cuda":
+            logger.info(
+                "Device: cuda (%s, %.1f GB VRAM)",
+                torch.cuda.get_device_name(0),
+                torch.cuda.get_device_properties(0).total_mem
+                / 1024**3,
+            )
+        else:
+            logger.warning(
+                "Device: %s (no CUDA -- check "
+                "nvidia-container-toolkit)",
+                _device,
+            )
+        logger.info("Loading DFD-FCG model on %s ...", _device)
+
+        # ── Face detector (MTCNN) ──────────────────────────────
+        from facenet_pytorch import MTCNN
+
+        _face_detector = MTCNN(
+            keep_all=True,
+            device=_device,
+            post_process=False,
+        )
+
+        # ── DFD-FCG model ──────────────────────────────────────
+        if not os.path.exists(WEIGHTS_PATH):
+            raise FileNotFoundError(
+                f"DFD-FCG weights not found at {WEIGHTS_PATH}"
+            )
+
+        model = _build_model_from_config()
+        model_cls = model.__class__
+
+        # The checkpoint stores face_feature_path as a
+        # relative path (e.g. "misc/..."). We must set CWD
+        # to model_code/ so load_from_checkpoint can resolve
+        # it when replaying the constructor.
+        model_code_dir = os.environ.get(
+            "MODEL_CODE_DIR", "/app/model_code"
+        )
+        original_cwd = os.getcwd()
+        os.chdir(model_code_dir)
+
+        try:
+            model = model_cls.load_from_checkpoint(
+                WEIGHTS_PATH
+            )
+        except Exception:
+            logger.info(
+                "Strict checkpoint load failed, "
+                "retrying non-strict."
+            )
+            model = model_cls.load_from_checkpoint(
+                WEIGHTS_PATH, strict=False
+            )
+        finally:
+            os.chdir(original_cwd)
+
+        model = model.to(_device)
+        model.requires_grad_(False)
+        # Use torch eval -- demo.py uses the same pattern
+        model.train(False)
+
+        _transform = model.transform
+        _model = model
+        logger.info("DFD-FCG model loaded successfully.")
+
+
+def _is_model_loaded() -> bool:
+    """Return True if model and face detector are loaded."""
+    return _model is not None and _face_detector is not None
+
+
+# ── FastAPI app ────────────────────────────────────────────────────
+
+app = FastAPI(
+    title="DFD-FCG Detection Service",
+    description=(
+        "Deepfake Detection via Facial Component Guidance "
+        "(CLIP ViT-L/14, CVPR 2025)"
+    ),
+    version="1.0.0",
+)
+
+
+class PredictRequest(BaseModel):
+    """Incoming prediction request."""
+
+    video_data: str  # Base64-encoded video bytes
+    threshold: float = 0.5
+
+
+class PredictResponse(BaseModel):
+    """Outgoing prediction result."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    model: str = "dfd_fcg_detection"
+    probability: float
+    prediction: int
+    class_name: str = Field(..., alias="class")
+    inference_time: float
+    metadata: Dict[str, Any]
+
+
+@app.on_event("startup")
+async def startup_event():
+    """Optionally preload model at startup."""
+    if PRELOAD_MODEL:
+        _load_models()
+
+
+@app.get("/")
+def root():
+    """Service info endpoint."""
+    return {
+        "service": "dfd_fcg_detection",
+        "port": MODEL_PORT,
+        "model_loaded": _is_model_loaded(),
+        "device": str(_device) if _device else "unknown",
+    }
+
+
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if (
+        torch.cuda.is_available()
+        and _device is not None
+        and _device.type == "cuda"
+    ):
+        return {
+            "gpu_name": torch.cuda.get_device_name(0),
+            "vram_used_mb": round(
+                torch.cuda.memory_allocated(0) / 1024**2
+            ),
+            "vram_total_mb": round(
+                torch.cuda.get_device_properties(0).total_mem
+                / 1024**2
+            ),
+        }
+    return {}
+
+
+@app.get("/health")
+def health():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "model": "dfd_fcg_detection",
+        "device": str(_device) if _device else "cpu",
+        "model_loaded": _is_model_loaded(),
+        "weights_exist": os.path.exists(WEIGHTS_PATH),
+        **_gpu_health_info(),
+    }
+
+
+# ── Video / face utilities ─────────────────────────────────────────
+
+
+def _extract_dense_frames(
+    video_path: str,
+) -> Tuple[List[np.ndarray], float]:
+    """Extract all frames from a video for clip-based sampling.
+
+    Args:
+        video_path: Path to the video on disk.
+
+    Returns:
+        Tuple of (list of RGB uint8 arrays, fps).
+    """
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    frames: List[np.ndarray] = []
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+
+    cap.release()
+    return frames, fps
+
+
+def _crop_face(
+    img: np.ndarray,
+    bbox: Tuple[float, float, float, float],
+    margin: float = MARGIN_FACTOR,
+) -> np.ndarray:
+    """Crop a face region from an image with a relative margin.
+
+    Args:
+        img: RGB image array (H, W, 3).
+        bbox: (x0, y0, x1, y1) face bounding box.
+        margin: Fraction of bbox dimension to add as padding.
+
+    Returns:
+        Cropped face region as a numpy array.
+    """
+    h_img, w_img = img.shape[:2]
+    x0, y0, x1, y1 = bbox
+    w = x1 - x0
+    h = y1 - y0
+
+    x0_new = max(0, int(x0 - w * margin / 2))
+    x1_new = min(w_img, int(x1 + w * margin / 2) + 1)
+    y0_new = max(0, int(y0 - h * margin / 2))
+    y1_new = min(h_img, int(y1 + h * margin / 2) + 1)
+
+    return img[y0_new:y1_new, x0_new:x1_new]
+
+
+def _detect_and_crop_face(
+    frame: np.ndarray,
+) -> Optional[np.ndarray]:
+    """Detect the largest face in a frame and return the crop.
+
+    Uses MTCNN for detection, selects the largest bounding box,
+    crops with margin, and returns the face region.
+
+    Args:
+        frame: RGB image array (H, W, 3).
+
+    Returns:
+        Face crop as uint8 array, or None if no face found.
+    """
+    assert _face_detector is not None
+
+    pil_img = Image.fromarray(frame)
+    boxes, _ = _face_detector.detect(pil_img)
+
+    if boxes is None or len(boxes) == 0:
+        return None
+
+    # Select the largest face by bounding box area
+    areas = [
+        (b[2] - b[0]) * (b[3] - b[1]) for b in boxes
+    ]
+    best_idx = int(np.argmax(areas))
+    box = boxes[best_idx]
+
+    x0, y0, x1, y1 = box.tolist()
+    face = _crop_face(frame, (x0, y0, x1, y1))
+    if face.size == 0:
+        return None
+
+    return face
+
+
+def _prepare_clip_tensor(
+    face_crops: List[np.ndarray],
+) -> Optional[torch.Tensor]:
+    """Apply the model's CLIP transform to face crops.
+
+    Converts a list of face crop arrays into a single tensor
+    of shape (1, num_frames, 3, 224, 224) suitable for the
+    DFD-FCG model.
+
+    Args:
+        face_crops: List of RGB uint8 face crop arrays.
+
+    Returns:
+        Tensor of shape (1, T, 3, 224, 224) or None.
+    """
+    if not face_crops or _transform is None:
+        return None
+
+    # The model transform expects either PIL or tensor input.
+    # Convert each crop to a torch tensor (C, H, W) uint8,
+    # which the custom _to_tensor in clip.py handles (divides
+    # by 255 if max > 1).
+    transformed = []
+    for crop in face_crops:
+        # Convert HWC uint8 -> CHW tensor
+        t = torch.from_numpy(crop).permute(2, 0, 1)
+        t = _transform(t)
+        transformed.append(t)
+
+    # Stack into (T, C, H, W), then add batch dim
+    clip_tensor = torch.stack(transformed, dim=0)
+    clip_tensor = clip_tensor.unsqueeze(0)  # (1, T, C, H, W)
+    return clip_tensor
+
+
+def _find_nearest_crop(
+    crops: List[Optional[np.ndarray]],
+    idx: int,
+) -> Optional[np.ndarray]:
+    """Find the nearest non-None face crop to a given index.
+
+    Searches outward from idx in both directions to find the
+    closest frame that had a detected face.
+
+    Args:
+        crops: List of face crops (may contain None entries).
+        idx: Target index.
+
+    Returns:
+        The nearest non-None crop, or None if all are None.
+    """
+    n = len(crops)
+    for offset in range(n):
+        for candidate in (idx - offset, idx + offset):
+            if (
+                0 <= candidate < n
+                and crops[candidate] is not None
+            ):
+                return crops[candidate]
+    return None
+
+
+# ── Prediction endpoint ────────────────────────────────────────────
+
+
+@app.post("/predict", response_model=PredictResponse)
+async def predict(request: PredictRequest):
+    """Run DFD-FCG deepfake detection on a base64-encoded video.
+
+    Pipeline:
+      1. Decode video and write to temp file.
+      2. Extract all frames from the video.
+      3. Detect and crop the main face per frame (MTCNN).
+      4. Build overlapping clips of NUM_FRAMES face crops.
+      5. Run each clip through the DFD-FCG model.
+      6. Average per-clip fake probabilities.
+
+    If no faces are detected in any frame, the service returns
+    probability=0.5 (undetermined) rather than raising an error.
+    """
+    if not _is_model_loaded():
+        _load_models()
+
+    start_time = time.time()
+
+    # ── Decode video ───────────────────────────────────────────
+    with tempfile.NamedTemporaryFile(
+        suffix=".mp4", delete=False
+    ) as tmp:
+        try:
+            video_bytes = base64.b64decode(request.video_data)
+            tmp.write(video_bytes)
+            tmp_path = tmp.name
+        except Exception as e:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Failed to decode video: {e}",
+            )
+
+    try:
+        # ── Extract frames ─────────────────────────────────────
+        frames, fps = _extract_dense_frames(tmp_path)
+        if not frames:
+            raise HTTPException(
+                status_code=400,
+                detail="Could not extract frames from video.",
+            )
+
+        # ── Detect and crop faces ──────────────────────────────
+        face_crops: List[Optional[np.ndarray]] = []
+        faces_detected = 0
+        for frame in frames:
+            crop = _detect_and_crop_face(frame)
+            face_crops.append(crop)
+            if crop is not None:
+                faces_detected += 1
+
+        if faces_detected == 0:
+            # No faces in any frame -- undetermined
+            return PredictResponse(
+                probability=0.5,
+                prediction=0,
+                class_name="real",
+                inference_time=time.time() - start_time,
+                metadata={
+                    "frames_total": len(frames),
+                    "frames_with_faces": 0,
+                    "clips_evaluated": 0,
+                    "device": str(_device),
+                },
+            )
+
+        # ── Build clips and run inference ──────────────────────
+        # Sample clip indices matching the demo.py pattern:
+        # indices spaced by stride*fps, NUM_FRAMES per clip
+        stride_frames = max(
+            1, int(math.floor(FRAME_STRIDE * fps))
+        )
+        clip_indices = [
+            i * stride_frames for i in range(NUM_FRAMES)
+        ]
+        max_start = len(frames) - clip_indices[-1] - 1
+
+        probs: List[float] = []
+        batch_size = 8
+
+        if max_start <= 0:
+            # Video too short for stride-based sampling;
+            # uniformly sample NUM_FRAMES frames instead.
+            sample_idx = np.linspace(
+                0,
+                len(frames) - 1,
+                NUM_FRAMES,
+                endpoint=True,
+                dtype=int,
+            )
+            clip_crops = []
+            for idx in sample_idx:
+                c = face_crops[idx]
+                if c is None:
+                    c = _find_nearest_crop(face_crops, idx)
+                if c is not None:
+                    clip_crops.append(c)
+
+            if len(clip_crops) == NUM_FRAMES:
+                tensor = _prepare_clip_tensor(clip_crops)
+                if tensor is not None:
+                    tensor = tensor.to(_device)
+                    with torch.no_grad():
+                        result = _model.evaluate(tensor)
+                        p = (
+                            result["logits"]
+                            .softmax(dim=-1)[:, 1]
+                            .cpu()
+                            .item()
+                        )
+                        probs.append(p)
+        else:
+            # Process clips in batches
+            clip_starts = list(range(0, max_start + 1))
+            for batch_start in range(
+                0, len(clip_starts), batch_size
+            ):
+                batch_clips = clip_starts[
+                    batch_start: batch_start + batch_size
+                ]
+                tensors = []
+                for start in batch_clips:
+                    clip_crops = []
+                    for offset in clip_indices:
+                        idx = start + offset
+                        c = face_crops[idx]
+                        if c is None:
+                            c = _find_nearest_crop(
+                                face_crops, idx
+                            )
+                        if c is not None:
+                            clip_crops.append(c)
+
+                    if len(clip_crops) == NUM_FRAMES:
+                        t = _prepare_clip_tensor(clip_crops)
+                        if t is not None:
+                            tensors.append(t)
+
+                if tensors:
+                    batch_tensor = torch.cat(
+                        tensors, dim=0
+                    ).to(_device)
+                    with torch.no_grad():
+                        result = _model.evaluate(
+                            batch_tensor
+                        )
+                        batch_probs = (
+                            result["logits"]
+                            .softmax(dim=-1)[:, 1]
+                            .flatten()
+                            .cpu()
+                            .tolist()
+                        )
+                        probs.extend(batch_probs)
+
+        # ── Aggregate ──────────────────────────────────────────
+        if probs:
+            probability = float(np.mean(probs))
+        else:
+            probability = 0.5
+
+        prediction = (
+            1 if probability >= request.threshold else 0
+        )
+        class_name = "fake" if prediction == 1 else "real"
+
+        return PredictResponse(
+            probability=probability,
+            prediction=prediction,
+            class_name=class_name,
+            inference_time=time.time() - start_time,
+            metadata={
+                "frames_total": len(frames),
+                "frames_with_faces": faces_detected,
+                "clips_evaluated": len(probs),
+                "device": str(_device),
+            },
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception("Error during DFD-FCG prediction")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+        gc.collect()
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=MODEL_PORT)

video/dfd-fcg/model_code/.gitignore

@@ -0,0 +1,20 @@
+logs
+__pycache__
+.ipynb_checkpoints
+.DS_Store
+*.swp
+wandb/
+*.env
+datasets/
+datasets
+.cache/
+.cache
+lightning_logs/
+.lr_find_*
+RealForensicPreds/
+results/
+checkpoint/
+.vscode/
+resources/cropped/
+resources/frame_data/
+*.pt

video/dfd-fcg/model_code/configs/base.yaml

@@ -0,0 +1,102 @@
+# lightning.pytorch==2.0.7
+seed_everything: 1019
+trainer:
+  accelerator: auto
+  strategy: auto
+  devices: 4
+  num_nodes: 1
+  precision: 16
+  logger: logger.yaml
+  callbacks: null
+  fast_dev_run: false
+  max_epochs: 30
+  min_epochs: null
+  max_steps: -1
+  min_steps: null
+  max_time: null
+  limit_train_batches: null
+  limit_val_batches: 10
+  limit_test_batches: null
+  limit_predict_batches: null
+  overfit_batches: 0.0
+  val_check_interval: 1.0
+  check_val_every_n_epoch: 1
+  num_sanity_val_steps: null
+  log_every_n_steps: 10
+  enable_checkpointing: null
+  enable_progress_bar: null
+  enable_model_summary: null
+  accumulate_grad_batches: 1
+  gradient_clip_val: 0.1
+  gradient_clip_algorithm: norm
+  deterministic: true
+  benchmark: null
+  inference_mode: true
+  use_distributed_sampler: true
+  profiler: null
+  detect_anomaly: false
+  barebones: false
+  plugins: null
+  sync_batchnorm: false
+  reload_dataloaders_every_n_epochs: 0
+  default_root_dir: "./logs/"
+early_stop:
+  monitor: "valid/FFPP/auc"
+  min_delta: 0.0
+  patience: 10
+  verbose: false
+  mode: max
+  strict: true
+  check_finite: true
+  stopping_threshold: null
+  divergence_threshold: null
+  check_on_train_epoch_end: null
+  log_rank_zero_only: false
+checkpoint:
+  dirpath: null
+  filename: null
+  monitor: "valid/FFPP/auc"
+  verbose: false
+  save_last: true
+  save_top_k: 1
+  save_weights_only: false
+  mode: max
+  auto_insert_metric_name: true
+  every_n_train_steps: null
+  train_time_interval: null
+  every_n_epochs: null
+  save_on_train_epoch_end: null
+lr_monitor:
+  logging_interval: epoch
+  log_momentum: false
+progress_bar:
+  refresh_rate: 1
+  leave: false
+  theme:
+    description: '#8250E5'
+    progress_bar: '#7FFF00'
+    progress_bar_finished: '#7FFF00'
+    progress_bar_pulse: '#7FFF00'
+    batch_progress: '#5398FE'
+    time: grey54
+    processing_speed: grey70
+    metrics: white
+  console_kwargs: null
+optimizer:
+  lr: 0.0001
+  betas:
+  - 0.9
+  - 0.999
+  eps: 1.0e-08
+  weight_decay: 0.001
+  amsgrad: false
+  maximize: false
+  foreach: null
+  differentiable: false
+lr_scheduler:
+  start_factor: 1.0
+  end_factor: 1.0
+  total_iters: 1
+  last_epoch: -1
+  verbose: false
+data: data.yaml

video/dfd-fcg/model_code/configs/clip/L14/evl.yaml

@@ -0,0 +1,7 @@
+model:
+  class_path: src.model.clip.evl.EfficientVideoLearner
+  init_args:
+    num_frames: 10
+    architecture: ViT-L/14
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/clip/L14/ffg.yaml

@@ -0,0 +1,15 @@
+model:
+  class_path: src.model.clip.svl.FFGSynoVideoLearner
+  init_args:
+    num_frames: 10
+    architecture: ViT-L/14
+    ksize_s: 5
+    ksize_t: 5
+    s_k_attr: 'k' 
+    s_v_attr: 'emb' 
+    t_attrs: ["q","k","v"]
+    face_feature_path: "misc/L14_real_semantic_patches_v4_2000.pickle"
+    face_parts: ["lips","skin","eyes","nose"] 
+
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/clip/L14/fulltune.yaml

@@ -0,0 +1,6 @@
+model:
+  class_path: src.model.clip.finetune.FullTuneVideoLearner
+  init_args:
+    architecture: ViT-L/14
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/clip/L14/linear.yaml

@@ -0,0 +1,6 @@
+model:
+  class_path: src.model.clip.linear.LinearVideoLearner
+  init_args:
+    architecture: ViT-L/14
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/clip/L14/svl.yaml

@@ -0,0 +1,12 @@
+model:
+  class_path: src.model.clip.svl.SynoVideoLearner
+  init_args:
+    num_frames: 10
+    architecture: ViT-L/14
+    ksize_s: 5
+    ksize_t: 5
+    s_k_attr: 'k' 
+    s_v_attr: 'emb' 
+    t_attrs: ["q","k","v"]
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/clip/L14/vpt.yaml

@@ -0,0 +1,7 @@
+model:
+  class_path: src.model.clip.vpt.PromptedLinearVideoLearner
+  init_args:
+    architecture: ViT-L/14
+    num_prompts: 1
+trainer:
+  accumulate_grad_batches: 1

video/dfd-fcg/model_code/configs/data.yaml

@@ -0,0 +1,54 @@
+class_path: src.dataset.base.ODDeepFakeDataModule
+init_args:
+  batch_size: 20
+  num_workers: 4
+  clip_duration: 3
+  num_frames: 10
+  train_datamodules:
+  - class_path: src.dataset.ffpp.FFPPDataModule
+    init_args:
+      batch_size: 30
+      df_types: ['REAL','DF','FS','F2F','NT']
+      compressions: ['c23']
+      strategy: FORCE_PAIR
+      augmentations:
+      - NORMAL
+      - VIDEO
+      - VIDEO_RRC
+      - FRAME
+      force_random_speed: null
+      data_dir: 'datasets/ffpp/'
+      vid_ext: '.avi'
+      pack: false
+      max_clips: 3
+  val_datamodules:
+  - class_path: src.dataset.ffpp.FFPPDataModule
+    init_args:
+      df_types: ['REAL','DF','FS','F2F','NT']
+      compressions: ['c23']
+      strategy: NORMAL
+      augmentations: 
+      - NONE
+      data_dir: 'datasets/ffpp/'
+      vid_ext: '.avi'
+      pack: false
+      max_clips: 1
+  - class_path: src.dataset.cdf.CDFDataModule
+    init_args:
+      data_dir: 'datasets/cdf/'
+      vid_ext: '.avi'
+      pack: false
+      max_clips: 1
+  - class_path: src.dataset.dfdc.DFDCDataModule
+    init_args:
+      data_dir: 'datasets/dfdc/'
+      vid_ext: '.avi'
+      pack: false
+      max_clips: 1
+  - class_path: src.dataset.fsh.FShDataModule
+    init_args:
+      compressions: ['c23']
+      data_dir: 'datasets/ffpp/'
+      vid_ext: '.avi'
+      pack: false
+      max_clips: 1

video/dfd-fcg/model_code/configs/inference.yaml

@@ -0,0 +1,39 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    # - class_path: src.dataset.ffpp.FFPPDataModule
+    #   init_args:
+    #     df_types: ['REAL','DF','FS','F2F','NT']
+    #     compressions: ['c23']
+    #     strategy: NORMAL
+    #     augmentations: 
+    #     - NONE
+    #     force_random_speed: null
+    #     data_dir: 'datasets/ffpp/'
+    #     vid_ext: .avi
+    - class_path: src.dataset.cdf.CDFDataModule
+      init_args:
+        data_dir: 'datasets/cdf/'
+        vid_ext: .avi
+    - class_path: src.dataset.dfdc.DFDCDataModule
+      init_args:
+        data_dir: 'datasets/dfdc/'
+        vid_ext: .avi
+    - class_path: src.dataset.fsh.FShDataModule
+      init_args:
+        data_dir: 'datasets/ffpp/'
+        compressions: ['c23']
+        vid_ext: .avi
+    - class_path: src.dataset.dfo.DFoDataModule
+      init_args:
+        data_dir: 'datasets/dfo/'
+        vid_ext: .avi
+    # - class_path: src.dataset.wdf.WDFDataModule
+    #   init_args:
+    #     data_dir: 'datasets/wdf/'
+    #     vid_ext: .avi
+    # - class_path: src.dataset.heygen.HeyGenDataModule
+    #   init_args:
+    #     data_dir: 'datasets/heygen/'
+    #     vid_ext: .avi

video/dfd-fcg/model_code/configs/logger.yaml

@@ -0,0 +1,14 @@
+class_path: lightning.pytorch.loggers.WandbLogger
+init_args:
+  name: null
+  save_dir: './logs/'
+  version: null
+  offline: false
+  dir: null
+  id: null
+  anonymous: null
+  project: 'DFD-FCG'
+  log_model: false
+  prefix: ''
+  checkpoint_name: null
+  entity: ""

video/dfd-fcg/model_code/configs/loo/DF.yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/ffpp/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/loo/F2F.yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','F2F']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/ffpp/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/loo/FS.yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','FS']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/ffpp/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/loo/NT.yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/ffpp/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/BW(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/BW/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/BW(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/BW/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/BW(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/BW/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/BW(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/BW/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/BW(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/BW/5/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CC(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CC/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CC(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CC/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CC(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CC/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CC(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CC/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CC(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CC/5/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CS(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CS/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CS(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CS/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CS(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CS/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CS(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CS/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/CS(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/CS/5/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GB(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GB/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GB(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GB/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GB(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GB/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GB(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GB/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GB(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GB/5/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GNC(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GNC/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GNC(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GNC/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GNC(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GNC/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GNC(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GNC/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/GNC(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/GNC/5/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/JPEG(1).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/JPEG/1/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/JPEG(2).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/JPEG/2/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/JPEG(3).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/JPEG/3/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/JPEG(4).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/JPEG/4/'
+        vid_ext: .avi

video/dfd-fcg/model_code/configs/robustness/JPEG(5).yaml

@@ -0,0 +1,14 @@
+data:
+  class_path: src.dataset.base.ODDeepFakeDataModule
+  init_args:
+    test_datamodules:
+    - class_path: src.dataset.ffpp.FFPPDataModule
+      init_args:
+        df_types: ['REAL','DF','FS','F2F','NT']
+        compressions: ['c23']
+        strategy: NORMAL
+        augmentations: 
+        - NONE
+        force_random_speed: null
+        data_dir: 'datasets/robustness/JPEG/5/'
+        vid_ext: .avi