Integrate Deep-Fake-Detector-v2 visual teacher and exam logging.

Pre-cache ViT teacher at Docker build, fuse teacher scores into EXM bands, append JSONL exam records for distillation.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -11,6 +11,9 @@ WORKDIR /app
 COPY backend/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+ENV HF_HOME=/app/.cache/huggingface
+RUN python -c "from transformers import ViTForImageClassification, ViTImageProcessor; mid='prithivMLmods/Deep-Fake-Detector-v2-Model'; ViTImageProcessor.from_pretrained(mid); ViTForImageClassification.from_pretrained(mid)"
+
 COPY backend/app ./app
 COPY models ./models
 

backend/app/config.py

@@ -11,6 +11,16 @@ class Settings(BaseSettings):
     models_dir: str = "/app/models"
     visual_model_file: str = "IDF_Solid_Final.pth"
     audio_model_file: str = "IDF_Audio_Scientific_Solid.pth"
+    enable_open_visual_teacher: bool = True
+    open_visual_model_id: str = "prithivMLmods/Deep-Fake-Detector-v2-Model"
+    enable_open_audio_teacher: bool = False
+    open_audio_model_id: str = ""
+    exam_log_enabled: bool = True
+    exam_log_dir: str = "/app/data/exam_logs"
+    teacher_pseudo_fake_threshold: float = 0.85
+    teacher_pseudo_real_threshold: float = 0.15
+    teacher_elevated_threshold: float = 0.65
+    teacher_suspicious_threshold: float = 0.55
     max_frames_sample: int = 48
     sample_fps: float = 2.0
     dense_sample_fps: float = 5.0

backend/app/jobs.py

@@ -21,6 +21,7 @@ STAGES = [
     "audio_extract",
     "frame_extract",
     "visual_model",
+    "open_visual_teacher",
     "audio_model",
     "ela_analysis",
     "temporal_analysis",

backend/app/main.py

@@ -12,6 +12,7 @@ from pydantic import BaseModel
 
 from app.config import settings
 from app.jobs import JobStatus, create_job, get_job, job_to_dict
+from app.pipeline import open_audio, open_visual
 from app.pipeline.orchestrator import run_pipeline
 
 app = FastAPI(
@@ -54,9 +55,20 @@ def root():
 @app.get("/health")
 def health():
     ready = models_ready()
+    model_flags = {k: v for k, v in ready.items() if isinstance(v, bool)}
+    teachers = {
+        "open_visual_teacher": open_visual.teacher_available(),
+        "open_audio_teacher": open_audio.teacher_available(),
+        "open_visual_model_id": settings.open_visual_model_id if settings.enable_open_visual_teacher else None,
+        "exam_log_enabled": settings.exam_log_enabled,
+    }
+    degraded = not all(model_flags.values())
+    if settings.enable_open_visual_teacher and not teachers["open_visual_teacher"]:
+        degraded = True
     return {
-        "status": "healthy" if all(ready.values()) else "degraded",
+        "status": "healthy" if not degraded else "degraded",
         "models": ready,
+        "teachers": teachers,
         "limits": {
             "max_upload_mb": settings.max_upload_mb,
             "max_video_seconds": settings.max_video_seconds,

backend/app/pipeline/context.py

@@ -30,7 +30,9 @@ class PipelineContext:
     frames: list[FrameSample] = field(default_factory=list)
     waveform: list[float] = field(default_factory=list)
     visual_scores: list[float] = field(default_factory=list)
+    teacher_visual_scores: list[float] = field(default_factory=list)
     audio_score: float | None = None
+    teacher_audio_score: float | None = None
     visual_embedding: list[float] | None = None
     audio_embedding: list[float] | None = None
     visual_source_frame: str | None = None

backend/app/pipeline/detection.py

@@ -22,12 +22,16 @@ def _clip_stats(scores: list[float]) -> dict[str, float]:
 
 def compute_clip_assessment(ctx: PipelineContext) -> dict[str, Any]:
     """
-    Fuse neural, temporal, provenance, reference, and edit signals into a court-facing band.
+    Fuse open teacher, student IDF, temporal, provenance, reference, and edit signals.
     Does NOT render a legal verdict — indicates examination outcome band for expert review.
     """
-    stats = _clip_stats(ctx.visual_scores)
-    peak = stats["peak"]
-    mean = stats["mean"]
+    student_stats = _clip_stats(ctx.visual_scores)
+    teacher_stats = _clip_stats(ctx.teacher_visual_scores) if ctx.teacher_visual_scores else None
+
+    peak = student_stats["peak"]
+    mean = student_stats["mean"]
+    teacher_peak = teacher_stats["peak"] if teacher_stats else None
+    teacher_mean = teacher_stats["mean"] if teacher_stats else None
 
     temporal = ctx.temporal or {}
     mean_drift = float(temporal.get("mean_drift") or 0.0)
@@ -57,6 +61,23 @@ def compute_clip_assessment(ctx: PipelineContext) -> dict[str, Any]:
     corroborating = 0
     reasons: list[str] = []
 
+    if teacher_stats:
+        reasons.insert(
+            0,
+            f"Open teacher peak {teacher_peak:.2f}, mean {teacher_mean:.2f} "
+            f"({settings.open_visual_model_id})",
+        )
+        if teacher_peak >= settings.teacher_elevated_threshold:
+            corroborating += 2
+            reasons.append(
+                f"Open deepfake detector elevated on sampled frames (peak {teacher_peak:.2f})"
+            )
+        elif teacher_peak >= settings.teacher_suspicious_threshold:
+            corroborating += 1
+            reasons.append(
+                f"Open deepfake detector borderline/suspicious (peak {teacher_peak:.2f})"
+            )
+
     if mean_drift >= 0.35 or max_drift >= 0.55:
         corroborating += 1
         reasons.append(
@@ -84,65 +105,91 @@ def compute_clip_assessment(ctx: PipelineContext) -> dict[str, Any]:
         corroborating += 2
         reasons.append("Generative-tool metadata indicator matched")
 
-    neural_elevated = peak >= settings.visual_threshold
-    neural_borderline = peak >= settings.visual_borderline
+    student_elevated = peak >= settings.visual_threshold
+    teacher_elevated = teacher_peak is not None and teacher_peak >= settings.teacher_elevated_threshold
+    teacher_suspicious = teacher_peak is not None and teacher_peak >= settings.teacher_suspicious_threshold
 
-    if neural_elevated:
+    if teacher_elevated:
         band = "ELEVATED"
         headline = (
-            f"Visual neural engine elevated — peak score {peak:.2f} across {len(ctx.visual_scores)} frame(s)"
+            f"Open deepfake detector elevated — teacher peak {teacher_peak:.2f} "
+            f"across {len(ctx.teacher_visual_scores)} frame(s)"
         )
-    elif neural_borderline and corroborating >= 2:
+    elif student_elevated:
+        band = "ELEVATED"
+        headline = (
+            f"Student visual engine elevated — peak score {peak:.2f} across {len(ctx.visual_scores)} frame(s)"
+        )
+    elif teacher_suspicious and corroborating >= 1:
         band = "SUSPICIOUS"
         headline = (
-            f"Borderline neural response (peak {peak:.2f}) with {corroborating} corroborating signal(s) — "
+            f"Open teacher suspicious (peak {teacher_peak:.2f}) with corroborating signals — "
             "expert review recommended"
         )
+    elif teacher_suspicious:
+        band = "SUSPICIOUS"
+        headline = (
+            f"Open deepfake detector suspicious — teacher peak {teacher_peak:.2f}; "
+            "student model remained near baseline"
+        )
+    elif peak >= settings.visual_borderline and corroborating >= 2:
+        band = "SUSPICIOUS"
+        headline = (
+            f"Borderline student response (peak {peak:.2f}) with {corroborating} corroborating signal(s)"
+        )
     elif corroborating >= 3:
         band = "SUSPICIOUS"
         headline = (
-            f"Neural scores in baseline band (peak {peak:.2f}) but {corroborating} independent indicators "
-            "align — synthetic or heavily processed media cannot be ruled out"
+            f"Neural scores in baseline band (peak {peak:.2f}) but {corroborating} independent indicators align"
         )
     elif corroborating >= 1 and (mean_drift >= 0.25 or edit_count >= 1):
         band = "INCONCLUSIVE"
         headline = (
-            f"Mixed signals — peak neural {peak:.2f}, {corroborating} secondary indicator(s); "
-            "insufficient for definitive classification"
+            f"Mixed signals — peak student {peak:.2f}"
+            + (f", teacher {teacher_peak:.2f}" if teacher_peak is not None else "")
+            + f", {corroborating} secondary indicator(s)"
         )
-    elif peak <= settings.visual_borderline and corroborating == 0:
+    elif peak <= settings.visual_borderline and corroborating == 0 and not teacher_suspicious:
         band = "BASELINE"
         headline = (
-            f"No elevated neural or corroborating indicators in {len(ctx.visual_scores)} frame sample(s) "
-            f"(peak {peak:.2f})"
+            f"No elevated indicators in {len(ctx.visual_scores)} frame sample(s) (peak {peak:.2f})"
         )
     else:
         band = "INCONCLUSIVE"
-        headline = f"Examination inconclusive — peak neural {peak:.2f}, review secondary findings"
+        headline = "Examination inconclusive — review teacher and secondary findings"
 
+    fusion_peak = teacher_peak if teacher_peak is not None else peak
     fusion_score = min(
         1.0,
-        (peak * 0.45)
-        + (corroborating * 0.12)
-        + (min(mean_drift, 1.0) * 0.25)
-        + (stats["elevated_ratio"] * 0.18),
+        (fusion_peak * 0.50)
+        + (corroborating * 0.10)
+        + (min(mean_drift, 1.0) * 0.20)
+        + (student_stats["elevated_ratio"] * 0.10),
     )
 
-    court_summary = _court_narrative(band, peak, mean, len(ctx.visual_scores), reasons, ctx)
+    court_summary = _court_narrative(
+        band, peak, mean, len(ctx.visual_scores), reasons, ctx, teacher_peak, teacher_mean
+    )
 
     return {
         "band": band,
         "headline": headline,
         "fusion_score": round(fusion_score, 3),
-        "frame_stats": stats,
+        "student_stats": student_stats,
+        "teacher_stats": teacher_stats,
+        "frame_stats": student_stats,
         "frames_analyzed": len(ctx.visual_scores),
         "corroborating_count": corroborating,
         "corroborating_reasons": reasons,
         "court_summary": court_summary,
         "neural_note": (
-            "Primary visual model did not strongly elevate"
-            if peak < settings.visual_threshold
-            else "Primary visual model elevated on at least one frame"
+            f"Open teacher peak {teacher_peak:.2f}; student peak {peak:.2f}"
+            if teacher_peak is not None
+            else (
+                "Primary visual model did not strongly elevate"
+                if peak < settings.visual_threshold
+                else "Primary visual model elevated on at least one frame"
+            )
         ),
     }
 
@@ -154,36 +201,40 @@ def _court_narrative(
     n_frames: int,
     reasons: list[str],
     ctx: PipelineContext,
+    teacher_peak: float | None,
+    teacher_mean: float | None,
 ) -> str:
     prov = ctx.provenance or {}
     origin = prov.get("origin_class", "unknown")
 
+    teacher_line = ""
+    if teacher_peak is not None:
+        teacher_line = (
+            f" Open deepfake teacher scores mean {teacher_mean:.2f}, peak {teacher_peak:.2f}."
+        )
+
     intro = (
-        f"The examination analyzed {n_frames} full-frame sample(s) with dense regional scanning. "
-        f"Neural anomaly scores ranged mean {mean:.2f}, peak {peak:.2f}."
+        f"The examination analyzed {n_frames} full-frame sample(s) with dense regional scanning."
+        f" Student model scores mean {mean:.2f}, peak {peak:.2f}."
+        f"{teacher_line}"
     )
 
     if band == "ELEVATED":
         body = (
-            "The primary detection engine flagged elevated synthetic or manipulation indicators. "
+            "The detection engines flagged elevated synthetic or manipulation indicators. "
             "This supports further expert review; it is not a standalone legal conclusion."
         )
     elif band == "SUSPICIOUS":
         body = (
-            "The primary engine remained in or near the baseline band, but multiple independent indicators "
-            "(temporal instability, provenance, edit boundaries, and/or reference profiling) align in a pattern "
-            "consistent with synthetic generation, re-encoding, or non-camera-origin media. "
-            "This profile is commonly seen in AI-generated or heavily processed exhibits and requires expert review."
+            "One or more engines or independent indicators align with synthetic generation, "
+            "re-encoding, or non-camera-origin media. Expert review is recommended."
         )
     elif band == "INCONCLUSIVE":
-        body = (
-            "Signals are mixed or partial. The exhibit cannot be confidently classified from automated analysis alone."
-        )
+        body = "Signals are mixed or partial. The exhibit cannot be confidently classified from automated analysis alone."
     else:
         body = (
-            "No strong automated indicators of synthetic generation or localized manipulation were observed "
-            "in the sampled frames. This does not prove authenticity — metadata may be stripped and unsampled "
-            "regions may differ."
+            "No strong automated indicators were observed in sampled frames. "
+            "This does not prove authenticity."
         )
 
     prov_line = ""
@@ -196,6 +247,6 @@ def _court_narrative(
 
     reason_block = ""
     if reasons:
-        reason_block = " Key observations: " + "; ".join(reasons[:4]) + "."
+        reason_block = " Key observations: " + "; ".join(reasons[:5]) + "."
 
     return intro + body + prov_line + reason_block

backend/app/pipeline/exam_log.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from app.config import settings
+from app.pipeline.context import PipelineContext
+
+
+def _log_path() -> Path:
+    root = Path(settings.exam_log_dir)
+    root.mkdir(parents=True, exist_ok=True)
+    day = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    return root / f"exams_{day}.jsonl"
+
+
+def append_exam_record(
+    *,
+    ctx: PipelineContext,
+    warnings: list[str],
+    clip_assessment: dict[str, Any],
+) -> dict[str, Any] | None:
+    """
+    Append one JSONL record for distillation / benchmarking.
+    Stores scores only — no raw media bytes.
+    """
+    if not settings.exam_log_enabled:
+        return None
+
+    frames: list[dict[str, Any]] = []
+    for i, frame in enumerate(ctx.frames):
+        frame_id = f"F{i + 1:03d}"
+        student = ctx.visual_scores[i] if i < len(ctx.visual_scores) else None
+        teacher = ctx.teacher_visual_scores[i] if i < len(ctx.teacher_visual_scores) else None
+        frames.append(
+            {
+                "id": frame_id,
+                "time_sec": round(float(frame.timestamp_sec), 3),
+                "student_score": round(float(student), 4) if student is not None else None,
+                "teacher_score": round(float(teacher), 4) if teacher is not None else None,
+            }
+        )
+
+    record: dict[str, Any] = {
+        "logged_at": datetime.now(timezone.utc).isoformat(),
+        "job_id": ctx.job_id,
+        "sha256": ctx.sha256,
+        "filename": ctx.filename,
+        "media_kind": ctx.media_kind,
+        "size_bytes": ctx.size_bytes,
+        "duration_sec": ctx.duration_sec,
+        "frames": frames,
+        "audio": {
+            "student_score": ctx.audio_score,
+            "teacher_score": ctx.teacher_audio_score,
+        },
+        "clip_assessment": {
+            "band": clip_assessment.get("band"),
+            "fusion_score": clip_assessment.get("fusion_score"),
+            "teacher_peak": clip_assessment.get("teacher_stats", {}).get("peak"),
+            "student_peak": clip_assessment.get("student_stats", {}).get("peak"),
+        },
+        "provenance": ctx.provenance,
+        "warnings": warnings,
+        "teacher_models": {
+            "visual": settings.open_visual_model_id if settings.enable_open_visual_teacher else None,
+            "audio": settings.open_audio_model_id if settings.enable_open_audio_teacher else None,
+        },
+    }
+
+    path = _log_path()
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(record, separators=(",", ":")) + "\n")
+
+    return {"path": str(path), "record_count_hint": "append-only jsonl"}

backend/app/pipeline/findings.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from datetime import datetime, timezone
 
+from app.config import settings
 from app.pipeline.context import PipelineContext
 from app.pipeline.observations import describe_audio_score, describe_dna_composite, describe_ela_score
 
@@ -54,6 +55,24 @@ def build_findings(ctx: PipelineContext, ela_scores: list[float], warnings: list
         )
 
     clip_mean = sum(ctx.visual_scores) / len(ctx.visual_scores) if ctx.visual_scores else 0.0
+    if ctx.teacher_visual_scores:
+        tpeak = max(ctx.teacher_visual_scores)
+        tmean = sum(ctx.teacher_visual_scores) / len(ctx.teacher_visual_scores)
+        indexed_t = sorted(enumerate(ctx.teacher_visual_scores), key=lambda x: x[1], reverse=True)
+        t_obs = [
+            f"Open teacher peak {tpeak:.2f}, mean {tmean:.2f}",
+            f"Model: {settings.open_visual_model_id}",
+            f"Sampled {len(ctx.teacher_visual_scores)} frame(s)",
+        ]
+        for rank, (idx, tscore) in enumerate(indexed_t[:3], start=1):
+            frame_id = f"F{idx + 1:03d}"
+            student = ctx.visual_scores[idx] if idx < len(ctx.visual_scores) else None
+            pair = f"Frame {frame_id}: teacher {tscore:.2f}"
+            if student is not None:
+                pair += f", student {student:.2f}"
+            t_obs.append(pair)
+        findings.append(_finding("TCH-001", t_obs))
+
     if ctx.visual_scores:
         indexed = sorted(enumerate(ctx.visual_scores), key=lambda x: x[1], reverse=True)
         for rank, (idx, score) in enumerate(indexed[:6], start=1):

backend/app/pipeline/open_audio.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+from app.config import settings
+
+
+@lru_cache(maxsize=1)
+def _teacher_ready() -> bool:
+    """Phase 2: wire an open anti-spoof / synthetic-speech teacher (e.g. ASVspoof/AASIST)."""
+    if not settings.enable_open_audio_teacher or not settings.open_audio_model_id:
+        return False
+    return False
+
+
+def teacher_available() -> bool:
+    return _teacher_ready()
+
+
+def score_audio(path: Path) -> float | None:
+    """Return P(synthetic/spoof) from open audio teacher when enabled."""
+    if not teacher_available():
+        return None
+    return None

backend/app/pipeline/open_visual.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Any
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+
+from app.config import settings
+
+
+def _fake_class_index(id2label: dict[int, str]) -> int:
+    for idx, label in id2label.items():
+        lower = label.lower()
+        if any(k in lower for k in ("fake", "deepfake", "ai", "synthetic", "generated")):
+            return int(idx)
+    return max(id2label.keys())
+
+
+@lru_cache(maxsize=1)
+def _load_teacher() -> tuple[Any, Any, int] | None:
+    if not settings.enable_open_visual_teacher:
+        return None
+    try:
+        from transformers import ViTForImageClassification, ViTImageProcessor
+
+        processor = ViTImageProcessor.from_pretrained(settings.open_visual_model_id)
+        model = ViTForImageClassification.from_pretrained(settings.open_visual_model_id)
+        model.eval()
+        fake_idx = _fake_class_index(model.config.id2label)
+        return model, processor, fake_idx
+    except Exception:
+        return None
+
+
+def teacher_available() -> bool:
+    return _load_teacher() is not None
+
+
+def score_bgr_frame(bgr: np.ndarray) -> float | None:
+    """Return P(fake) from the open ViT teacher, or None if unavailable."""
+    loaded = _load_teacher()
+    if loaded is None:
+        return None
+    model, processor, fake_idx = loaded
+
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+    pil = Image.fromarray(rgb)
+    inputs = processor(images=pil, return_tensors="pt")
+    with torch.no_grad():
+        logits = model(**inputs).logits
+        probs = torch.softmax(logits, dim=-1)
+    return float(probs[0, fake_idx].item())
+
+
+def score_bgr_batch(frames_bgr: list[np.ndarray]) -> list[float | None]:
+    return [score_bgr_frame(bgr) for bgr in frames_bgr]

backend/app/pipeline/orchestrator.py

@@ -38,6 +38,8 @@ from app.pipeline.media import (
     probe_metadata,
 )
 from app.pipeline import models as model_runtime
+from app.pipeline import open_visual, open_audio
+from app.pipeline.exam_log import append_exam_record
 
 
 ProgressCallback = Callable[[str, int], None]
@@ -76,6 +78,7 @@ def _build_flagged_frames(
     frames_out: list[dict[str, Any]] = []
     for i, frame in enumerate(ctx.frames):
         score = ctx.visual_scores[i] if i < len(ctx.visual_scores) else 0.0
+        teacher_score = ctx.teacher_visual_scores[i] if i < len(ctx.teacher_visual_scores) else None
         ela = ela_scores[i] if i < len(ela_scores) else None
         bgr = _frame_bgr(frame)
         thumb = frame_thumbnail_data_url(bgr) if bgr is not None else None
@@ -119,6 +122,7 @@ def _build_flagged_frames(
             {
                 "id": frame_id,
                 "peak": round(float(score), 4),
+                "teacher_score": round(float(teacher_score), 4) if teacher_score is not None else None,
                 "ela": round(float(ela), 4) if ela is not None else None,
                 "time": time_label,
                 "thumbnail_url": thumb or None,
@@ -130,7 +134,12 @@ def _build_flagged_frames(
                 "observations": package["observations"],
             }
         )
-    frames_out.sort(key=lambda f: f["peak"], reverse=True)
+    def _rank_score(i: int) -> float:
+        s = ctx.visual_scores[i] if i < len(ctx.visual_scores) else 0.0
+        t = ctx.teacher_visual_scores[i] if i < len(ctx.teacher_visual_scores) else 0.0
+        return max(s, t)
+
+    frames_out.sort(key=lambda f: _rank_score(int(f["id"][1:]) - 1), reverse=True)
     return frames_out[: settings.max_flagged_frames]
 
 
@@ -168,9 +177,13 @@ def _build_audio_segments(ctx: PipelineContext) -> list[dict[str, Any]]:
 
 def _integrity_index(ctx: PipelineContext) -> float:
     parts: list[float] = []
-    if ctx.visual_scores:
+    if ctx.teacher_visual_scores:
+        parts.append(max(ctx.teacher_visual_scores))
+    elif ctx.visual_scores:
         parts.append(max(ctx.visual_scores))
-    if ctx.audio_score is not None:
+    if ctx.teacher_audio_score is not None:
+        parts.append(ctx.teacher_audio_score)
+    elif ctx.audio_score is not None:
         parts.append(ctx.audio_score)
     if not parts:
         return 0.0
@@ -257,6 +270,24 @@ def run_pipeline(
             ctx.visual_embedding = peak_emb
             ctx.visual_source_frame = peak_id
 
+        _set_stage(on_progress, "open_visual_teacher")
+        if ctx.frames and settings.enable_open_visual_teacher:
+            try:
+                if open_visual.teacher_available():
+                    for frame in ctx.frames:
+                        bgr = _frame_bgr(frame)
+                        if bgr is None:
+                            continue
+                        tscore = open_visual.score_bgr_frame(bgr)
+                        if tscore is not None:
+                            ctx.teacher_visual_scores.append(tscore)
+                else:
+                    warnings.append(
+                        "Open visual teacher unavailable — check transformers install and HF model cache"
+                    )
+            except Exception as exc:
+                warnings.append(f"Open visual teacher: {exc}")
+
         _set_stage(on_progress, "audio_model")
         if ctx.audio_path and ctx.audio_path.exists():
             try:
@@ -311,6 +342,12 @@ def run_pipeline(
         ctx.findings = build_findings(ctx, ela_scores, warnings)
         ctx.executive_summary = build_executive_summary(ctx)
 
+        exam_log_meta = append_exam_record(
+            ctx=ctx,
+            warnings=warnings,
+            clip_assessment=ctx.clip_assessment,
+        )
+
         _set_stage(on_progress, "report")
         result = {
             "sha256": ctx.sha256,
@@ -334,6 +371,8 @@ def run_pipeline(
             "expert_annotations": ctx.expert_annotations,
             "clip_assessment": ctx.clip_assessment,
         }
+        if exam_log_meta:
+            result["exam_log"] = exam_log_meta
         result["report_package"] = build_report_package(result)
         if warnings:
             ctx.message = "; ".join(warnings)

backend/requirements.txt

@@ -12,3 +12,5 @@ torch==2.5.1
 torchvision==0.20.1
 reportlab==4.2.5
 timm==1.0.12
+transformers==4.47.1
+huggingface-hub==0.27.0