feat: GPU enablement -- 3-tier CUDA Dockerfiles, TF32, health reporting (2026-04-02)

audio/aasist3/Dockerfile

@@ -1,32 +1,34 @@
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
 
-# Install system dependencies (no git/build-essential needed)
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    libsndfile1 \
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    ffmpeg libsndfile1 \
     && rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
-# Install Python dependencies
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Pre-cache wav2vec2 config (not weights, just the config JSON ~1KB)
 RUN python -c "from transformers import Wav2Vec2Config; Wav2Vec2Config.from_pretrained('facebook/wav2vec2-large-xlsr-53', cache_dir='/app/w2v_cache')"
 
-# Copy model code and API
 COPY model/ /app/model/
 COPY api.py .
-
-# Expected weight files in /app/weights/:
-#   - model.safetensors  (AASIST3 checkpoint)
-#   - config.json        (model configuration)
-# These are mounted from the host via docker-compose volumes.
+RUN mkdir -p /app/weights
+COPY weights/ /app/weights/
 
 EXPOSE 8005
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

audio/aasist3/api.py

@@ -75,6 +75,23 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 SAMPLE_RATE = 16000
 TARGET_SAMPLES = 64600  # ~4.04 seconds at 16kHz
 
@@ -151,6 +168,19 @@ async def startup_event():
     load_model()
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -160,6 +190,7 @@ async def health():
         "model_id": MODEL_ID,
         "device": str(DEVICE),
         "weights_found": os.path.exists(os.path.join(WEIGHTS_DIR, "model.safetensors")),
+        **_gpu_health_info(),
     }
 
 

audio/aasist3/requirements.txt

@@ -1,5 +1,5 @@
-torch==2.5.0
-torchaudio==2.5.0
+torch==2.5.1
+torchaudio==2.5.1
 transformers>=4.40.0
 huggingface-hub>=0.20.0
 safetensors>=0.4.0

audio/nes2net/Dockerfile

@@ -1,44 +1,40 @@
-FROM python:3.10-slim
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    ffmpeg \
-    libsndfile1 \
-    wget \
-    build-essential \
-    g++ \
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git ffmpeg libsndfile1 wget \
+    build-essential g++ \
     && rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
-# Install Python dependencies
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone fairseq at the specific commit required by Nes2Net,
-# then patch setup.py to skip C extensions (not needed for
-# checkpoint_utils), and install as editable without deps.
+# Clone fairseq with patched C extensions (same as ShiftySpeech)
 RUN git clone https://github.com/facebookresearch/fairseq.git /app/fairseq_repo && \
     cd /app/fairseq_repo && \
     git checkout a54021305d6b3c4c5959ac9395135f63202db8f1 && \
     sed -i 's/ext_modules=extensions/ext_modules=[]/' setup.py && \
     pip install --no-cache-dir --no-deps -e .
 
-# Copy model scripts
 COPY model_scripts /app/model_scripts
-
-# Copy API code
 COPY api.py .
-
-# Model weights are mounted from the host via docker-compose volumes.
-# Expected weight files in /app/weights/:
-#   - nes2net_itw_valaug.pt  (fine-tuned Nes2Net checkpoint)
-#   - xlsr2_300m.pt          (XLSR wav2vec 2.0 for architecture init)
+RUN mkdir -p /app/weights
+COPY weights/ /app/weights/
 
 EXPOSE 8004
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

audio/nes2net/api.py

@@ -88,6 +88,23 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 SAMPLE_RATE = 16000
 TARGET_SAMPLES = 64600  # ~4.04 seconds at 16kHz
 
@@ -174,6 +191,19 @@ async def startup_event():
     load_model()
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -183,6 +213,7 @@ async def health():
         "model_id": MODEL_ID,
         "device": str(DEVICE),
         "weights_found": os.path.exists(WEIGHTS_PATH),
+        **_gpu_health_info(),
     }
 
 

audio/nes2net/requirements.txt

@@ -1,5 +1,5 @@
-torch==2.5.0
-torchaudio==2.5.0
+torch==2.5.1
+torchaudio==2.5.1
 numpy==1.23.5
 librosa==0.9.1
 soundfile

audio/safeear/Dockerfile

@@ -1,24 +1,35 @@
-FROM python:3.9-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
 
-RUN apt-get update && apt-get install -y \
-    git \
-    ffmpeg \
-    libsndfile1 \
-    wget \
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git ffmpeg libsndfile1 wget \
     build-essential \
     && rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # Clone SafeEar repository (for model code imports)
 RUN git clone --depth 1 https://github.com/LetterLiGo/SafeEar.git /app/safeear_repo
 
-# Install the fairseq fork required by SafeEar's SpeechTokenizer
+# Install the fairseq fork with C extensions PATCHED OUT
+# (same proven patch used by ShiftySpeech and Nes2Net --
+#  C extensions are not needed for checkpoint loading)
 WORKDIR /app/safeear_repo/fairseq_ours
-RUN pip install --no-cache-dir -e .
+RUN sed -i 's/ext_modules=extensions/ext_modules=[]/' setup.py && \
+    pip install --no-cache-dir --no-deps -e .
 WORKDIR /app
 
 # Download model weights from HuggingFace
@@ -32,7 +43,6 @@ COPY api.py .
 
 EXPOSE 8002
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

audio/safeear/api.py

@@ -72,6 +72,23 @@ WEIGHTS_DIR = os.environ.get(
     os.path.join(os.path.dirname(__file__), "weights"),
 )
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 SAMPLE_RATE = 16000
 MAX_AUDIO_LENGTH = 64600  # ~4 seconds at 16kHz (ASVspoof standard)
 SOFTMAX_TEMPERATURE = 5.0  # Calibration temperature for out-of-distribution data
@@ -210,6 +227,19 @@ async def startup_event():
     load_models()
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Return service health status and model availability."""
@@ -222,6 +252,7 @@ async def health():
             os.path.exists(os.path.join(WEIGHTS_DIR, "SpeechTokenizer.pt"))
             and os.path.exists(os.path.join(WEIGHTS_DIR, "model.ckpt"))
         ),
+        **_gpu_health_info(),
     }
 
 

audio/safeear/requirements.txt

@@ -1,5 +1,5 @@
-torch>=1.13.0
-torchaudio>=0.13.0
+torch==2.5.1
+torchaudio==2.5.1
 librosa>=0.10.0
 soundfile>=0.11.0
 numpy>=1.23.0

audio/shiftyspeech/Dockerfile

@@ -1,52 +1,42 @@
-FROM python:3.10-slim
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    ffmpeg \
-    libsndfile1 \
-    wget \
-    build-essential \
-    g++ \
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git ffmpeg libsndfile1 \
+    build-essential g++ \
     && rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
-# Install Python dependencies
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone fairseq at the specific commit required by ShiftySpeech,
-# then patch setup.py to skip C extensions (not needed for
-# checkpoint_utils), and install as editable without deps.
+# Clone fairseq with patched C extensions
 RUN git clone https://github.com/facebookresearch/fairseq.git /app/fairseq_repo && \
     cd /app/fairseq_repo && \
     git checkout a54021305d6b3c4c5959ac9395135f63202db8f1 && \
     sed -i 's/ext_modules=extensions/ext_modules=[]/' setup.py && \
     pip install --no-cache-dir --no-deps -e .
 
-# Copy model code from the ShiftySpeech repo
 COPY synthetic_speech_detection /app/synthetic_speech_detection
-
-# Create models directory and symlink XLSR weights
-# (fairseq needs the checkpoint for architecture initialization;
-# the fine-tuned weights replace all parameters via load_state_dict)
 RUN mkdir -p /app/models
-
-# Copy API code
 COPY api.py .
-
-# Download weights at build time (or mount them as a volume)
-# Expected weight files in /app/weights/:
-#   - hfg_aug_1_2.pt    (augmented SSL-AASIST checkpoint, ~1.27GB)
-#   - xlsr_53_56k.pt    (XLSR wav2vec 2.0 for architecture init, ~3.5GB)
-# These are mounted from the host via docker-compose volumes.
-# Create symlink from models/xlsr2_300m.pt to the actual XLSR file.
+RUN mkdir -p /app/weights
+COPY weights/ /app/weights/
 RUN ln -sf /app/weights/xlsr_53_56k.pt /app/models/xlsr2_300m.pt
 
 EXPOSE 8001
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

audio/shiftyspeech/api.py

@@ -88,6 +88,23 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 SAMPLE_RATE = 16000
 TARGET_SAMPLES = 64600  # ~4.04 seconds at 16kHz
 
@@ -173,6 +190,19 @@ async def startup_event():
     load_model()
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -182,6 +212,7 @@ async def health():
         "model_id": MODEL_ID,
         "device": str(DEVICE),
         "weights_found": os.path.exists(WEIGHTS_PATH),
+        **_gpu_health_info(),
     }
 
 

audio/shiftyspeech/requirements.txt

@@ -1,8 +1,8 @@
 fastapi
 uvicorn
 python-multipart
-torch==2.5.0
-torchaudio==2.5.0
+torch==2.5.1
+torchaudio==2.5.1
 numpy==1.23.5
 scipy
 librosa==0.9.1

audio/sonics/Dockerfile

@@ -1,31 +1,33 @@
-FROM python:3.10-slim
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    ffmpeg \
-    libsndfile1 \
-    build-essential \
-    g++ \
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git ffmpeg libsndfile1 \
+    build-essential g++ \
     && rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
-# Install Python dependencies
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy API code
 COPY app.py .
 
-# Pre-download model weights at build time so startup is fast.
-# HFAudioClassifier.from_pretrained will cache in the default
-# huggingface_hub cache directory.
+# Pre-download model weights
 RUN python -c "from sonics import HFAudioClassifier; HFAudioClassifier.from_pretrained('awsaf49/sonics-spectttra-alpha-120s')"
 
 EXPOSE 8003
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

audio/sonics/app.py

@@ -70,6 +70,22 @@ def _get_device():
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 # Global model instance
 model = None
 
@@ -142,6 +158,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -149,6 +178,7 @@ async def health():
         "status": "healthy" if model is not None else "degraded",
         "model": MODEL_NAME,
         "device": str(DEVICE),
+        **_gpu_health_info(),
     }
 
 

image/aide/Dockerfile

@@ -1,38 +1,35 @@
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
 RUN apt-get update && \
-    apt-get install -y git wget build-essential && \
-    apt-get clean && \
+    apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git wget build-essential && \
     rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt .
+RUN ln -sf /usr/bin/python3 /usr/bin/python
 
 RUN pip install --no-cache-dir --upgrade pip "setuptools>=68" wheel
 
-# Install PyTorch — CPU-only build.
-# On arm64 (Apple Silicon / AWS Graviton) the default PyPI wheel is CPU-only.
-# On x86_64 we force the CPU wheel via the PyTorch index.
-RUN arch=$(uname -m) && \
-    if [ "$arch" = "aarch64" ] || [ "$arch" = "arm64" ]; then \
-        pip install --no-cache-dir torch==2.0.1 torchvision==0.15.2; \
-    else \
-        pip install --no-cache-dir \
-            torch==2.0.1+cpu torchvision==0.15.2+cpu \
-            --index-url https://download.pytorch.org/whl/cpu; \
-    fi
+# Install PyTorch with CUDA 12.1 (replaces CPU-only arch-conditional install)
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchvision==0.20.1 \
+    --index-url https://download.pytorch.org/whl/cu121
 
+COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone AIDE repo for model code and DCT module
 RUN git clone https://github.com/shilinyan99/AIDE.git model_code && \
     touch model_code/__init__.py && \
     touch model_code/models/__init__.py && \
     touch model_code/data/__init__.py
 
-# Weights and HF cache are provided via volume mounts at runtime
 RUN mkdir -p /app/weights /app/hf_cache
+COPY weights/ /app/weights/
 
 COPY app.py .
 
@@ -44,7 +41,6 @@ ENV PYTHONPATH=/app/model_code:$PYTHONPATH
 
 EXPOSE ${MODEL_PORT}
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

image/aide/app.py

@@ -84,6 +84,20 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))
 
@@ -300,6 +314,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -308,6 +335,7 @@ async def health():
         "model_name": MODEL_NAME,
         "device": str(DEVICE),
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

image/cospy/Dockerfile

@@ -1,26 +1,35 @@
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends git build-essential && \
-    apt-get clean && \
+    apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git build-essential && \
     rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt .
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+RUN pip install --no-cache-dir --upgrade pip "setuptools>=68" wheel
 
-RUN pip install --no-cache-dir --upgrade pip "setuptools>=68" wheel && \
-    pip install --no-cache-dir -r requirements.txt
+# 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.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone the CO-SPY repo for model architecture code (detector modules).
-# Pinned to a specific commit for reproducibility.
 RUN git clone https://github.com/Megum1/CO-SPY.git model_code && \
     cd model_code && \
     git checkout 9fb781d && \
     cd ..
 
-# Weights and HF cache are provided via volume mounts / downloaded at runtime
 RUN mkdir -p /app/weights /app/hf_cache
+COPY weights/ /app/weights/
 
 COPY app.py .
 
@@ -33,7 +42,6 @@ ENV PYTHONPATH=/app/model_code:$PYTHONPATH
 
 EXPOSE ${MODEL_PORT}
 
-# Drop root privileges -- chown hf_cache so appuser can write downloaded models
 RUN adduser --disabled-password --gecos '' appuser && \
     chown -R appuser:appuser /app/hf_cache
 USER appuser

image/cospy/app.py

@@ -106,6 +106,22 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))
 
@@ -309,6 +325,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -317,6 +346,7 @@ async def health():
         "model": MODEL_NAME,
         "device": str(DEVICE),
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

image/effort/Dockerfile

@@ -1,26 +1,35 @@
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends git build-essential && \
-    apt-get clean && \
+    apt-get install -y --no-install-recommends \
+    python3 python3-pip python3-dev \
+    git build-essential && \
     rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt .
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+RUN pip install --no-cache-dir --upgrade pip "setuptools>=68" wheel
 
-RUN pip install --no-cache-dir --upgrade pip "setuptools>=68" wheel && \
-    pip install --no-cache-dir -r requirements.txt
+# 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.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone the Effort repo for model architecture code (detector + SVD modules).
-# Pinned to a specific commit for reproducibility.
 RUN git clone https://github.com/YZY-stack/Effort-AIGI-Detection.git model_code && \
     cd model_code && \
     git checkout 96f5dea2b534d400cfd7003f053c7e93c8e16461 && \
     cd ..
 
-# Weights and HF cache are provided via volume mounts at runtime
 RUN mkdir -p /app/weights /app/hf_cache
+COPY weights/ /app/weights/
 
 COPY app.py .
 
@@ -34,7 +43,6 @@ ENV PYTHONPATH=/app/model_code/DeepfakeBench/training:/app/model_code/DeepfakeBe
 
 EXPOSE ${MODEL_PORT}
 
-# Drop root privileges — ensure appuser owns the HF cache dir
 RUN adduser --disabled-password --gecos '' appuser && \
     chown -R appuser:appuser /app/hf_cache
 USER appuser

image/effort/app.py

@@ -107,6 +107,22 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))
 
@@ -359,6 +375,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -367,6 +396,7 @@ async def health():
         "model": MODEL_NAME,
         "device": str(DEVICE),
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

image/fsd/Dockerfile

@@ -1,23 +1,29 @@
-FROM python:3.12-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
     git wget \
-    && apt-get clean && rm -rf /var/lib/apt/lists/*
+    && rm -rf /var/lib/apt/lists/*
+
+RUN ln -sf /usr/bin/python3 /usr/bin/python
 
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel && pip install uv
+RUN pip install --no-cache-dir --upgrade pip setuptools wheel
 
-# Clone the FSD repo — this vendors the source code inside the image layer.
-# The code is frozen at the pinned commit; rebuild to pick up upstream changes.
+# Clone the FSD repo
 RUN git clone https://github.com/ductai199x/Forensic-Self-Descriptions-CVPR25.git model_code
 
-# Install CPU-only PyTorch first (must precede FSD install to avoid CUDA variant)
-RUN uv pip install --system torch --extra-index-url https://download.pytorch.org/whl/cpu
+# Install PyTorch with CUDA 12.1 (replaces CPU-only install)
+RUN pip install --no-cache-dir \
+    torch==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
 
-# Install FSD inference dependencies manually, excluding heavy optional deps
-# (ray[serve] and gradio are listed in FSD's pyproject.toml but not needed here)
-RUN uv pip install --system --no-cache-dir \
+# Install FSD inference dependencies manually
+RUN pip install --no-cache-dir \
     "scipy>=1.17.0" \
     "pillow>=12.1.0" \
     pillow-heif \
@@ -25,16 +31,17 @@ RUN uv pip install --system --no-cache-dir \
     tqdm \
     "scikit-learn>=1.6.0"
 
-# Install the FSD package itself without pulling its deps again
-RUN uv pip install --system --no-deps -e ./model_code
+# Install FSD package without deps (bypasses upstream torch>=2.10.0 pin)
+RUN pip install --no-deps -e ./model_code
 
 # Install service-layer deps
 COPY requirements.txt .
-RUN uv pip install --system --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
 
 COPY app.py .
 
 RUN mkdir -p /app/weights
+COPY weights/ /app/weights/
 
 ENV MODEL_PORT=5005
 ENV PRELOAD_MODEL=false
@@ -43,7 +50,6 @@ ENV WEIGHTS_DIR=/app/weights
 
 EXPOSE 5005
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 

image/fsd/app.py

@@ -76,6 +76,21 @@ def _get_device():
 
 
 DEVICE = _get_device()
+if DEVICE == "cuda":
+    torch.backends.cudnn.benchmark = True
+    torch.set_float32_matmul_precision("high")
+
+if DEVICE == "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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
 
 # Z-score conversion constants (see design spec §4)
 THRESHOLD_Z: float = -2.0  # FSD paper's default fake/real boundary
@@ -233,6 +248,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() and DEVICE == "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")
 async def health():
     """Health check endpoint."""
@@ -241,6 +269,7 @@ async def health():
         "model_name": MODEL_NAME,
         "device": DEVICE,
         "model_loaded": detector is not None,
+        **_gpu_health_info(),
     }
 
 

image/npr/Dockerfile

@@ -1,49 +1,40 @@
-FROM python:3.9-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
 
-WORKDIR /app
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
-# Install git and wget
-RUN apt-get update && apt-get install -y --no-install-recommends git wget && apt-get clean && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
 
-# Copy requirements file
-COPY requirements.txt .
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    git wget \
+    && rm -rf /var/lib/apt/lists/*
 
-# Upgrade pip and install common build tools
-RUN pip install --no-cache-dir --upgrade pip setuptools wheel && pip install uv
+RUN ln -sf /usr/bin/python3 /usr/bin/python
 
-# Install NumPy first - use a common and stable version
-RUN uv pip install --system --no-cache-dir numpy==1.23.5 
+# Install PyTorch with CUDA 12.1 (replaces CPU-only install)
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchvision==0.20.1 \
+    --index-url https://download.pytorch.org/whl/cu121
 
-# Install PyTorch CPU version (2.0.1 from requirements.txt) and other dependencies
-# Ensure torch and torchvision are for CPU
-RUN uv pip install --system torch==2.0.1 torchvision==0.15.2 --extra-index-url https://download.pytorch.org/whl/cpu
-# Install other dependencies from requirements.txt
-# Pip should skip torch/torchvision if already installed with the correct version.
-RUN uv pip install --system --no-cache-dir -r requirements.txt
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application code
 COPY app.py .
 
-# Clone the repository
 RUN git clone https://github.com/chuangchuangtan/NPR-DeepfakeDetection.git npr_deepfakedetection
 
-# Download model weights
 RUN mkdir -p npr_deepfakedetection/weights && \
     wget -O npr_deepfakedetection/weights/NPR.pth \
     https://github.com/chuangchuangtan/NPR-DeepfakeDetection/raw/main/model_epoch_last_3090.pth
 
-# Set environment variables
 ENV MODEL_PORT=5001
-ENV USE_GPU=false
 ENV PRELOAD_MODEL=false
 ENV MODEL_TIMEOUT=600
 
-# Expose port
 EXPOSE 5001
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 
-# Run the application
-CMD ["python", "app.py"]
+CMD ["python", "app.py"]

image/npr/app.py

@@ -76,15 +76,11 @@ MODEL_NAME = "npr_deepfakedetection"
 WEIGHTS_FILENAME = "NPR.pth"
 MODEL_FULL_PATH = os.path.join(model_code_path, "weights", WEIGHTS_FILENAME)
 
-USE_GPU_ENV = os.environ.get("USE_GPU", "false").lower() == "true"
-
 
 def _get_device():
     """Select optimal device: MPS (Apple) > CUDA (NVIDIA) > CPU."""
     import platform
 
-    if not USE_GPU_ENV:
-        return torch.device("cpu")
     override = os.environ.get("DEEPSAFE_DEVICE", "").strip().lower()
     if override == "cpu":
         return torch.device("cpu")
@@ -110,9 +106,19 @@ def _get_device():
 
 
 DEVICE = _get_device()
-if USE_GPU_ENV and DEVICE.type == "cpu":
+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(
-        "USE_GPU is true but no accelerator is available. Falling back to CPU."
+        "Device: %s (no CUDA available -- check nvidia-container-toolkit)",
+        DEVICE,
     )
 logger.info(f"Using device: {DEVICE}")
 
@@ -298,6 +304,19 @@ async def root_endpoint():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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", tags=["System"])
 async def health_check_endpoint():
     model_file_exists = os.path.exists(MODEL_FULL_PATH)
@@ -316,6 +335,7 @@ async def health_check_endpoint():
         "model_definition_imported": "resnet50" in globals()
         and callable(globals()["resnet50"]),
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

image/npr/requirements.txt

@@ -1,8 +1,8 @@
 fastapi==0.103.1
 uvicorn==0.23.2
 pydantic==2.3.0
-torch==2.0.1
-torchvision==0.15.2
+torch==2.5.1
+torchvision==0.20.1
 pillow==10.0.1
 numpy==1.23.5
 scipy

image/universal/app.py

@@ -68,6 +68,20 @@ def _get_device():
 
 DEVICE = _get_device()
 USE_GPU = DEVICE.type != "cpu"
+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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
 MODEL_PORT = int(os.environ.get("MODEL_PORT", 5003))
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(
@@ -331,6 +345,19 @@ def read_root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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 {}
+
+
 # Health check endpoint
 @app.get("/health")
 def health_check():
@@ -338,7 +365,12 @@ def health_check():
     model_file_exists = os.path.exists(weights_path)
 
     if model is not None:
-        return {"status": "healthy", "device": str(DEVICE), "model_loaded": True}
+        return {
+            "status": "healthy",
+            "device": str(DEVICE),
+            "model_loaded": True,
+            **_gpu_health_info(),
+        }
     elif model_loading:
         return {
             "status": "loading",

image/yermandy/Dockerfile

@@ -1,42 +1,37 @@
-# Use a PyTorch base image
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
 
-RUN pip install --no-cache-dir \
-    torch==2.6.0 torchvision==0.21.0 \
-    -f https://download.pytorch.org/whl/cpu/torch_stable.html
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
-# Install git and wget for cloning repo and downloading weights
-RUN apt-get update && \
-    apt-get install -y git wget && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    git wget \
+    && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements file
-COPY requirements.txt .
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
+# Install PyTorch with CUDA 12.1 (downgraded from 2.6.0 -- no cu121 wheels for 2.6+)
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
 
-# Install Python dependencies
+COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Clone the model repository
-# We'll name the cloned directory "model_code" to avoid conflicts
 RUN git clone https://github.com/yermandy/deepfake-detection.git model_code
 
-# Download model weights
 RUN mkdir -p model_code/weights && \
     wget https://huggingface.co/yermandy/deepfake-detection/resolve/main/model.ckpt -O model_code/weights/model.ckpt
 
-# Set Hugging Face home to cache pre-trained models inside the container
 ENV HF_HOME=/app/huggingface_cache
 ENV TRANSFORMERS_CACHE=/app/huggingface_cache
 ENV HF_HUB_CACHE=/app/huggingface_cache
 RUN mkdir -p $HF_HOME
 
-# Upgrade transformers for safetensors support (HuggingFace removed pytorch_model.bin)
 RUN pip install --no-cache-dir --upgrade transformers
 
-# Pre-download Hugging Face CLIP models to be self-sustaining
 RUN python -c "from transformers import CLIPProcessor, CLIPModel; \
     CLIPProcessor.from_pretrained('openai/clip-vit-base-patch16'); \
     CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32'); \
@@ -44,27 +39,17 @@ RUN python -c "from transformers import CLIPProcessor, CLIPModel; \
     CLIPProcessor.from_pretrained('openai/clip-vit-large-patch14-336'); \
     CLIPModel.from_pretrained('openai/clip-vit-large-patch14')"
 
-# Copy the application file
 COPY app.py .
 
-# --- Environment Variables ---
-# MODEL_PORT will be set by docker-compose, defaulting here for clarity
 ENV MODEL_PORT=5002
 ENV MODEL_PATH=model_code/weights/model.ckpt
 ENV PRELOAD_MODEL="false"
-# MODEL_TIMEOUT: Seconds to keep model loaded if not preloaded
 ENV MODEL_TIMEOUT="600"
-
-# Add the cloned repository's root and src to PYTHONPATH
-# This allows app.py to import modules from the cloned model_code directory
 ENV PYTHONPATH=/app/model_code:/app/model_code/src:$PYTHONPATH
 
-# Expose the port the app runs on
 EXPOSE ${MODEL_PORT}
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos '' appuser
 USER appuser
 
-# Command to run the application
-CMD ["python", "app.py"]
+CMD ["python", "app.py"]

image/yermandy/app.py

@@ -147,13 +147,23 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))  # Default 10 minutes
 
-USE_GPU = (
-    os.environ.get("USE_GPU", "false").lower() == "true" and torch.cuda.is_available()
-)
-
 # Global variables for the model and related components
 model: Optional[DeepfakeDetectionModel] = None
 preprocessing_fn: Optional[callable] = None
@@ -309,6 +319,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     model_file_exists = os.path.exists(MODEL_PATH)
@@ -323,6 +346,7 @@ async def health():
         "device": str(DEVICE),
         "model_weights_found": model_file_exists,
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

image/yermandy/requirements.txt

@@ -5,9 +5,9 @@ Pillow>=9.0.0
 python-multipart
 numpy
 
-torch==2.6.0
-torchaudio==2.6.0
-torchvision==0.21.0
+torch==2.5.1
+torchaudio==2.5.1
+torchvision==0.20.1
 lightning==2.5.0 
 transformers==4.50.0
 tqdm==4.67.1 # progress bar

provenance/audioseal/Dockerfile

@@ -1,12 +1,23 @@
-FROM python:3.10-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
-# System deps: libsndfile for torchaudio, ffmpeg for format support
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends libsndfile1 ffmpeg && \
+    apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    libsndfile1 ffmpeg && \
     rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
+# Install PyTorch with CUDA 12.1
+RUN pip install --no-cache-dir \
+    torch==2.5.1 torchaudio==2.5.1 \
+    --index-url https://download.pytorch.org/whl/cu121
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
@@ -15,10 +26,8 @@ COPY app.py .
 ENV MODEL_PORT=9003
 ENV PRELOAD_MODEL=false
 ENV MODEL_TIMEOUT=600
-ENV USE_GPU=false
 EXPOSE 9003
 
-# Drop root privileges
 RUN adduser --disabled-password --gecos "" appuser
 USER appuser
 

provenance/audioseal/app.py

@@ -73,6 +73,22 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))
 
@@ -204,6 +220,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -214,6 +243,7 @@ async def health():
         "model_name": MODEL_NAME,
         "device": str(DEVICE),
         "model_loaded": detector is not None,
+        **_gpu_health_info(),
     }
 
 

provenance/videoseal/Dockerfile

@@ -1,18 +1,27 @@
-FROM python:3.11-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 # System deps: OpenCV headless needs libgl, ffmpeg for video decoding,
 # build-essential for pycocotools compilation
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \
+        python3 python3-pip python3-dev \
         libgl1 libglib2.0-0 ffmpeg build-essential && \
     rm -rf /var/lib/apt/lists/*
 
+RUN ln -sf /usr/bin/python3 /usr/bin/python
+
 WORKDIR /app
 
+# 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.txt .
 # Install videoseal without deps to avoid decord (no ARM64 wheels).
-# We use OpenCV for video frame extraction instead.
-# Runtime deps are listed explicitly in requirements.txt.
 RUN pip install --no-cache-dir -r requirements.txt && \
     pip install --no-cache-dir --no-deps videoseal==1.0.1 && \
     apt-get purge -y --auto-remove build-essential && \
@@ -24,12 +33,12 @@ COPY configs/ configs/
 ENV MODEL_PORT=9004
 ENV PRELOAD_MODEL=false
 ENV MODEL_TIMEOUT=600
-ENV USE_GPU=false
 EXPOSE 9004
 
 # Pre-create cache dirs that videoseal needs (before dropping root)
-RUN mkdir -p /app/ckpts /app/.cache && \
-    adduser --disabled-password --gecos "" appuser && \
+RUN mkdir -p /app/ckpts /app/.cache
+COPY ckpts/ /app/ckpts/
+RUN adduser --disabled-password --gecos "" appuser && \
     chown -R appuser:appuser /app/ckpts /app/.cache
 USER appuser
 

provenance/videoseal/app.py

@@ -78,6 +78,22 @@ def _get_device():
 
 
 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 available -- check nvidia-container-toolkit)",
+        DEVICE,
+    )
+
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 MODEL_TIMEOUT = int(os.environ.get("MODEL_TIMEOUT", "600"))
 
@@ -340,6 +356,19 @@ async def root():
     }
 
 
+def _gpu_health_info() -> dict:
+    """Return GPU metrics for the health endpoint."""
+    if torch.cuda.is_available() 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")
 async def health():
     """Health check endpoint."""
@@ -350,6 +379,7 @@ async def health():
         "model_name": MODEL_NAME,
         "device": str(DEVICE),
         "model_loaded": model is not None,
+        **_gpu_health_info(),
     }
 
 

video/fake-stormer/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.9-slim
+FROM pytorch/pytorch:1.8.0-cuda11.1-cudnn8-devel
 
 WORKDIR /app
 
@@ -27,7 +27,6 @@ COPY app.py .
 
 # Environment variables
 ENV MODEL_PORT=7001
-ENV USE_GPU=false
 ENV PRELOAD_MODEL=false
 
 # Expose port

video/fake-stormer/app.py

@@ -33,7 +33,6 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 MODEL_PORT = int(os.environ.get("MODEL_PORT", 7001))
-USE_GPU = os.environ.get("USE_GPU", "false").lower() == "true"
 PRELOAD_MODEL = os.environ.get("PRELOAD_MODEL", "false").lower() == "true"
 CONFIG_PATH = os.environ.get(
     "CONFIG_PATH", "model_code/configs/temporal/FakeSFormer_base_c23.yaml"
@@ -46,8 +45,6 @@ WEIGHTS_PATH = os.environ.get(
 
 def _get_device():
     """Select optimal device: MPS (Apple) > CUDA (NVIDIA) > CPU."""
-    if not USE_GPU:
-        return torch.device("cpu")
     override = os.environ.get("DEEPSAFE_DEVICE", "").strip().lower()
     if override == "cpu":
         return torch.device("cpu")
@@ -87,6 +84,23 @@ def _load_models():
         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 available -- check nvidia-container-toolkit)",
+            _device,
+        )
+
     logger.info(f"Loading FakeSTormer model on {_device}...")
 
     try:
@@ -160,12 +174,27 @@ def root():
     }
 
 
+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():
     return {
         "status": "ok",
         "model_loaded": _is_model_loaded(),
         "weights_exist": os.path.exists(WEIGHTS_PATH),
+        "device": str(_device) if _device else "cpu",
+        **_gpu_health_info(),
     }
 
 

video/sbi/Dockerfile

@@ -1,9 +1,13 @@
-FROM python:3.9-slim
+FROM nvidia/cuda:12.1.1-cudnn8-runtime-ubuntu22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
-# Install system dependencies for OpenCV
-RUN apt-get update && apt-get install -y \
+# 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 \
@@ -11,19 +15,27 @@ RUN apt-get update && apt-get install -y \
     libxrender-dev \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements and install
+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 -r 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
+COPY weights/ /app/weights/
 
 # Copy application code
 COPY app.py .
 
 # Environment variables
 ENV MODEL_PORT=7002
-ENV USE_GPU=false
 ENV PRELOAD_MODEL=false
 ENV MODEL_TIMEOUT=1800
 ENV WEIGHTS_PATH=/app/weights/FFc23.tar

video/sbi/app.py

@@ -35,7 +35,6 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 MODEL_PORT = int(os.environ.get("MODEL_PORT", 7002))
-USE_GPU = os.environ.get("USE_GPU", "false").lower() == "true"
 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/FFc23.tar")
@@ -69,8 +68,6 @@ class Detector(nn.Module):
 
 def _get_device() -> torch.device:
     """Select optimal device: MPS (Apple) > CUDA (NVIDIA) > CPU."""
-    if not USE_GPU:
-        return torch.device("cpu")
     override = os.environ.get("DEEPSAFE_DEVICE", "").strip().lower()
     if override == "cpu":
         return torch.device("cpu")
@@ -114,6 +111,20 @@ def _load_models() -> 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 available -- check nvidia-container-toolkit)",
+                _device,
+            )
         logger.info("Loading SBI model on %s ...", _device)
 
         # ── Face detector (MTCNN) ───────────────────────────────────────
@@ -193,6 +204,19 @@ def root():
     }
 
 
+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."""
@@ -202,6 +226,7 @@ def health():
         "device": str(_device) if _device else "cpu",
         "model_loaded": _is_model_loaded(),
         "weights_exist": os.path.exists(WEIGHTS_PATH),
+        **_gpu_health_info(),
     }