Upload 5 files

README.md

@@ -1,14 +1,58 @@
+# 🫀 SYNTAX-Video — Multi-study Inference
+
+**SYNTAX-Video** — это интерфейс для автоматической оценки **SYNTAX-score** по видеозаписям коронарной ангиографии.
+Модель анализирует DICOM-файлы левой и правой коронарной артерии, вычисляя вклад каждой и итоговый суммарный показатель.
+
+---
+
+## 🚀 Возможности
+
+* Загрузка исследований в формате **DICOM**
+* Поддержка **многомодельного ансамбля** (усреднение только по моделям)
+* Обработка **нескольких клипов** одной артерии как единой последовательности
+* Интерфейс для **множественных исследований** в одном сеансе
+* Автоматическое определение весов модели (`weights/left`, `weights/right`)
+
+---
+
+## 🧭 Как использовать
+
+1. Укажите **ID исследования** и при необходимости краткое **описание**.
+2. Загрузите **DICOM-файлы** для **левой** и/или **правой** артерии.
+3. Нажмите **“Add study”**, затем **“Run inference”**.
+4. Результаты отобразятся в виде JSON-структуры с:
+
+   * предсказаниями по каждой модели,
+   * средним значением для каждой артерии,
+   * суммарным SYNTAX-score,
+   * пометкой «High-risk» при превышении порога.
+
 ---
-title: Syntax Video Infer
-emoji: 💻
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: unknown
-short_description: Интерфейс для автоматической оценки SYNTAX-score
+
+## ⚙️ Технические детали
+
+* **Backbone:** `r3d_18` (torchvision)
+* **Head:** `lstm_mean` (возможно использование других вариантов: GRU, mean, BERT-head и др.)
+* **Формат входа:** `(1, S, C, T, H, W)` — пакет клипов одной артерии
+* **Нормализация:** стандарт ImageNet
+* **Усреднение:** только по моделям ансамбля (без усреднения по клипам внутри исследования)
+* **Пороговые значения:**
+
+  * левая артерия ≥ 15
+  * правая артерия ≥ 5
+  * общее исследование ≥ 22
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🧩 Структура проекта
+
+```
+configs/
+ └── default.yaml         # Основная конфигурация
+src/syntax_pred/
+ ├── model.py             # Архитектура и загрузка весов
+ ├── preprocess.py        # Обработка DICOM и трансформации
+ ├── data.py              # Минималистичный датасет для инференса
+ ├── utils.py             # Поддержка: выбор устройства, поиск весов
+app.py                    # Gradio-интерфейс
+```

app.py

@@ -0,0 +1,240 @@
+# app.py — SYNTAX-Video (multi-study UI) — pack-per-study, average only over models
+import os
+import base64
+from dataclasses import dataclass, asdict
+from typing import List, Dict, Any, Tuple
+
+import numpy as np
+import torch
+import gradio as gr
+from omegaconf import OmegaConf
+
+from src.syntax_pred.utils import pick_device, discover_weights
+from src.syntax_pred.model import SyntaxLightningModule
+from src.syntax_pred.preprocess import (
+    read_dicom_uint8,
+    ensure_length_center_crop,
+    test_like_transform,
+    IMAGENET_MEAN,
+    IMAGENET_STD,
+)
+
+# -------- Globals --------
+CFG = OmegaConf.load("configs/default.yaml")
+DEVICE = pick_device(CFG.device)
+
+# ===== Logo handling (base64) =====
+DEFAULT_LOGO = "assets/logo.png"
+LOGO_PATH = os.environ.get("LOGO_PATH", DEFAULT_LOGO)
+
+def _logo_html() -> str:
+    path = LOGO_PATH
+    if not path or not os.path.exists(path):
+        return ""
+    try:
+        with open(path, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("ascii")
+        ext = os.path.splitext(path)[1].lower()
+        mime = "image/png" if ext in {".png", ""} else "image/jpeg" if ext in {".jpg", ".jpeg"} else "image/png"
+        data_uri = f"data:{mime};base64,{b64}"
+        return (
+            f'<img src="{data_uri}" alt="logo" '
+            f'style="height:40px;vertical-align:middle;display:inline-block;'
+            f'image-rendering:auto;object-fit:contain;margin-right:12px;" />'
+        )
+    except Exception:
+        return ""
+
+# ===== Models =====
+def build_model(weight_path: str):
+    return SyntaxLightningModule(
+        num_classes=CFG.num_classes,
+        lr=1e-5,
+        variant=CFG.variant,
+        pl_weight_path=weight_path,
+        rnn_hidden_div=CFG.a_rnn.hidden_div,
+        rnn_dropout=CFG.a_rnn.dropout,
+        bert_nhead=CFG.bert.nhead,
+        bert_layers=CFG.bert.num_layers,
+        bert_ff_div=CFG.bert.ff_div,
+        bert_dropout=CFG.bert.dropout,
+        precision=CFG.precision,
+    ).to(DEVICE).eval()
+
+def list_weights() -> Tuple[List[str], List[str]]:
+    left = CFG.weights.left or discover_weights("weights/left")
+    right = CFG.weights.right or discover_weights("weights/right")
+    return left, right
+
+# ===== Data structures =====
+@dataclass
+class Study:
+    name: str
+    description: str
+    left_paths: List[str]
+    right_paths: List[str]
+
+def _files_to_paths(files) -> List[str]:
+    return [f.name for f in (files or []) if hasattr(f, "name") and os.path.exists(f.name)]
+
+# ===== Packing: внутри исследования все клипы одной артерии → одна последовательность =====
+def _pack_study_side_to_tensor(
+    file_paths: List[str],
+    frames_per_clip: int,
+    video_size: Tuple[int, int],
+) -> torch.Tensor:
+    if not file_paths:
+        return None
+    tx = test_like_transform(video_size)
+    clips = []
+    for p in file_paths:
+        arr = read_dicom_uint8(p)                          # (T,H,W) uint8
+        arr = ensure_length_center_crop(arr, frames_per_clip)
+        thwc = np.stack([arr, arr, arr], axis=-1)          # (T,H,W,3)
+        thwc = torch.tensor(thwc, dtype=torch.uint8)
+        cthw = tx(thwc)                                     # (C,T,H,W)
+        clips.append(cthw)
+    if not clips:
+        return None
+    return torch.stack(clips, dim=0).unsqueeze(0)          # (1,S,C,T,H,W)
+
+# ===== Inference logic (среднее только по моделям) =====
+@torch.no_grad()
+def _score_side_by_models(
+    side_paths: List[str],
+    model_paths: List[str],
+    frames_per_clip: int,
+    video_size: Tuple[int, int],
+) -> Dict[str, Any]:
+    if not side_paths:
+        return {"mean": 0.0, "per_model": [], "n_files": 0}
+
+    x = _pack_study_side_to_tensor(side_paths, frames_per_clip, video_size)
+    if x is None:
+        return {"mean": 0.0, "per_model": [], "n_files": 0}
+    x = x.to(DEVICE)
+
+    per_model_scores: List[float] = []
+    used_models: List[str] = []
+
+    for wp in model_paths:
+        try:
+            m = build_model(wp)
+            y = m(x)                                        # (1,2)
+            reg_log = float(y[0, 1].detach().cpu().numpy())
+            score = float(max(0.0, np.exp(reg_log) - 1.0))  # inverse log(1+score)
+            per_model_scores.append(score)
+            used_models.append(os.path.basename(wp))
+        except Exception as e:
+            print(f"[WARN] model {wp} failed: {e}")
+
+    mean_score = float(np.mean(per_model_scores)) if per_model_scores else 0.0
+    return {
+        "mean": mean_score,
+        "per_model": [{"model": n, "score": round(s, 3)} for n, s in zip(used_models, per_model_scores)],
+        "n_files": len(side_paths),
+    }
+
+def run_inference(studies: List[Study]) -> Dict[str, Any]:
+    left_w, right_w = list_weights()
+    if not left_w and not right_w:
+        return {"error": "No weights found. Upload to weights/left and weights/right."}
+
+    results = {"studies": []}
+    thr = CFG.thresholds.both
+    video_size = tuple(CFG.video_size)
+    frames = CFG.frames_per_clip
+
+    for st in studies:
+        left_res  = _score_side_by_models(st.left_paths,  left_w, frames, video_size)
+        right_res = _score_side_by_models(st.right_paths, right_w, frames, video_size)
+        total = left_res["mean"] + right_res["mean"]
+
+        results["studies"].append({
+            "study": st.name,
+            "description": st.description or "",
+            "left":  {"mean": round(left_res["mean"], 3),  "per_model": left_res["per_model"],  "n_files": left_res["n_files"]},
+            "right": {"mean": round(right_res["mean"], 3), "per_model": right_res["per_model"], "n_files": right_res["n_files"]},
+            "total": {"mean": round(total, 3), f"High-risk (≥{thr:.1f})": bool(total >= thr)},
+        })
+    return results
+
+# ===== UI =====
+def ui():
+    with gr.Blocks() as demo:
+        gr.HTML(
+            f"""
+            <div style="display:flex;align-items:center;gap:10px;margin-bottom:8px;">
+                {_logo_html()}
+                <h1 style="margin:0;font-weight:800;text-align:center;flex:1;">SYNTAX-Video — Multi-study Inference</h1>
+            </div>
+            <ol style="margin:0 0 12px 20px; color:#475569; line-height:1.5;">
+            <li>Укажите ID исследования и (необязательно) описание.</li>
+            <li>Загрузите DICOM-файлы для ЛЕВОЙ и/или ПРАВОЙ артерии.</li>
+            <li>Нажмите “Add study”, чтобы добавить исследование, и затем “Run inference” для запуска анализа.</li>
+            </ol>
+            """
+        )
+
+
+        studies_state = gr.State([])  # list[dict]
+
+        # --- ВЕРХНИЙ РЯД: Study ID + Description ---
+        with gr.Row():
+            study_name = gr.Textbox(label="Study ID", placeholder="e.g., S1234")
+            study_desc = gr.Textbox(label="Description (optional)", placeholder="Free text...")
+
+        # --- НИЖНИЙ РЯД: два загрузчика бок-о-бок ---
+        with gr.Row():
+            add_left  = gr.File(label="LEFT artery DICOM(s)",  file_count="multiple")
+            add_right = gr.File(label="RIGHT artery DICOM(s)", file_count="multiple")
+
+        with gr.Row():
+            btn_add   = gr.Button("➕ Add study")
+            btn_clear = gr.Button("🗑️ Clear all")
+
+        queue_table = gr.Dataframe(
+            headers=["Study", "Description", "Left paths", "Right paths"],
+            datatype=["str", "str", "str", "str"],
+            interactive=False,
+            label="Queued studies (full paths)",
+            row_count=(0, "dynamic"),
+        )
+
+        def _add_study_fn(studies: List[Dict[str, Any]], name, desc, left_files, right_files):
+            name = (name or "").strip() or f"Study_{len(studies)+1}"
+            desc = (desc or "").strip()
+            left_paths  = _files_to_paths(left_files)
+            right_paths = _files_to_paths(right_files)
+            new = Study(name=name, description=desc, left_paths=left_paths, right_paths=right_paths)
+            studies = studies + [asdict(new)]
+            table = [[s["name"], s.get("description",""), "\n".join(s["left_paths"]), "\n".join(s["right_paths"])] for s in studies]
+            return studies, table, "", "", None, None
+
+        btn_add.click(
+            _add_study_fn,
+            inputs=[studies_state, study_name, study_desc, add_left, add_right],
+            outputs=[studies_state, queue_table, study_name, study_desc, add_left, add_right],
+        )
+
+        def _clear_all():
+            return [], []
+
+        btn_clear.click(_clear_all, inputs=None, outputs=[studies_state, queue_table])
+
+        run_btn = gr.Button("🚀 Run inference", variant="primary")
+        out_json = gr.JSON(label="Results")
+
+        def _run_infer(studies):
+            study_objs = [Study(**s) for s in (studies or [])]
+            return run_inference(study_objs)
+
+        run_btn.click(_run_infer, inputs=[studies_state], outputs=[out_json])
+
+        gr.Markdown("⚠️ Research-only. Not a medical device. Predictions depend on input quality and domain shift.")
+    return demo
+
+
+if __name__ == "__main__":
+    favicon = LOGO_PATH if (LOGO_PATH and os.path.exists(LOGO_PATH)) else None
+    ui().launch(favicon_path=favicon)

huggingface.yaml

@@ -0,0 +1,3 @@
+sdk: gradio
+python_version: "3.11"
+app_file: app.py

inference.py

@@ -0,0 +1,120 @@
+# inference.py — pack-per-side, average only over models (parity with app.py)
+
+from __future__ import annotations
+import argparse
+import os
+import numpy as np
+import torch
+from omegaconf import OmegaConf
+
+from src.syntax_pred.model import SyntaxLightningModule
+from src.syntax_pred.utils import pick_device, discover_weights
+from src.syntax_pred.preprocess import (
+    read_dicom_uint8,
+    ensure_length_center_crop,
+    test_like_transform,
+)
+
+def build_model(cfg, weight_path: str) -> SyntaxLightningModule:
+    """Создаёт модель и загружает веса целого модуля."""
+    m = SyntaxLightningModule(
+        num_classes=cfg.num_classes,
+        lr=1e-5,
+        variant=cfg.variant,
+        weight_decay=0.0,
+        max_epochs=1,
+        pl_weight_path=weight_path,
+        rnn_hidden_div=cfg.a_rnn.hidden_div,
+        rnn_dropout=cfg.a_rnn.dropout,
+        bert_nhead=cfg.bert.nhead,
+        bert_layers=cfg.bert.num_layers,
+        bert_ff_div=cfg.bert.ff_div,
+        bert_dropout=cfg.bert.dropout,
+        precision=cfg.precision,
+    )
+    m.eval()
+    return m
+
+def _pack_side_to_tensor(file_paths, frames_per_clip, video_size) -> torch.Tensor | None:
+    """
+    Собирает список DICOM в один батч тензоров формы (1, S, C, T, H, W),
+    где S — число клипов/файлов для одной артерии.
+    """
+    paths = [p for p in (file_paths or []) if os.path.exists(p)]
+    if not paths:
+        return None
+    tx = test_like_transform(tuple(video_size))
+    clips = []
+    for p in paths:
+        arr = read_dicom_uint8(p)                      # (T,H,W) uint8
+        arr = ensure_length_center_crop(arr, int(frames_per_clip))
+        thwc = np.stack([arr, arr, arr], axis=-1)      # (T,H,W,3)
+        thwc = torch.tensor(thwc, dtype=torch.uint8)
+        cthw = tx(thwc)                                # (C,T,H,W)
+        clips.append(cthw)
+    if not clips:
+        return None
+    return torch.stack(clips, dim=0).unsqueeze(0)      # (1,S,C,T,H,W)
+
+@torch.no_grad()
+def score_side_by_models(file_paths, model_paths, frames_per_clip, video_size, device) -> dict:
+    """
+    Внутри одной артерии: пакуем все DICOM в одну последовательность и
+    прогоняем через каждую модель. Итог — среднее по моделям.
+    """
+    x = _pack_side_to_tensor(file_paths, frames_per_clip, video_size)
+    if x is None:
+        return {"mean": 0.0, "per_model": [], "n_files": 0}
+    x = x.to(device)
+
+    per_model = []
+    scores = []
+    for wp in model_paths:
+        try:
+            m = build_model(CFG, wp).to(device)
+            y = m(x)                          # (1,2): [logit, log(1+score)]
+            reg_log = float(y[0, 1].item())
+            s = float(max(0.0, np.exp(reg_log) - 1.0))
+            per_model.append({"model": os.path.basename(wp), "score": round(s, 6)})
+            scores.append(s)
+        except Exception as e:
+            print(f"[WARN] model {wp} failed: {e}")
+    mean_score = float(np.mean(scores)) if scores else 0.0
+    return {"mean": mean_score, "per_model": per_model, "n_files": len(file_paths or [])}
+
+def list_weights(cfg) -> tuple[list[str], list[str]]:
+    """Берёт пути из конфига или ищет по директориям weights/left и weights/right."""
+    left = cfg.weights.left or discover_weights("weights/left")
+    right = cfg.weights.right or discover_weights("weights/right")
+    return left, right
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--config", default="configs/default.yaml")
+    ap.add_argument("--left", nargs="*", default=[], help="List of LEFT DICOM files")
+    ap.add_argument("--right", nargs="*", default=[], help="List of RIGHT DICOM files")
+    args = ap.parse_args()
+
+    global CFG
+    CFG = OmegaConf.load(args.config)
+
+    device = pick_device(CFG.device)
+    left_w, right_w = list_weights(CFG)
+
+    if not left_w and not right_w:
+        print({"error": "No weights found. Upload to weights/left and weights/right."})
+        return
+
+    left_res  = score_side_by_models(args.left,  left_w,  CFG.frames_per_clip, CFG.video_size, device)
+    right_res = score_side_by_models(args.right, right_w, CFG.frames_per_clip, CFG.video_size, device)
+
+    total = left_res["mean"] + right_res["mean"]
+    out = {
+        "left":  {"mean": round(left_res["mean"], 6),  "per_model": left_res["per_model"],  "n_files": left_res["n_files"]},
+        "right": {"mean": round(right_res["mean"], 6), "per_model": right_res["per_model"], "n_files": right_res["n_files"]},
+        "total": {"mean": round(total, 6)},
+    }
+    print(out)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,10 @@
+torch
+torchvision
+lightning
+pydicom
+pytorchvideo
+omegaconf
+gradio
+numpy
+scikit-learn
+plotly