Add model code and full model weights

.gitignore

@@ -0,0 +1,144 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to your project. Official documentation:
+#  https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+.idea/
+
+# VS Code
+.vscode/
+
+# Pyright
+.pyright/
+
+# Pyre type checker
+.pyre/
+
+__pycache__/
+*.pyc
+*.pyo
+logs/
+rnn_logs/
+backbone_logs/
+checkpoints/
+lightning_logs/
+wandb/
+runs/
+tensorboard/
+results/
+visualizations/

backbone/dataset.py

@@ -0,0 +1,221 @@
+import os
+import json
+from typing import Callable, Optional, Tuple, Any
+from pathlib import Path
+
+import numpy as np
+import pydicom
+import torch
+from torch import Tensor
+from torch.utils.data import Dataset
+
+
+class SyntaxDataset(Dataset):
+    """
+    PyTorch Dataset для обучения 3D-backbone по DICOM-видео.
+
+    Ожидается, что:
+      - meta (JSON) содержит список словарей с полями:
+          "path": относительный путь к DICOM-файлу от директории этого JSON
+          "artery": 0 (левая) или 1 (правая)
+          "<label>": численное значение SYNTAX score (например, "syntax_left")
+      - видео загружается из multi-frame DICOM (pydicom), как 3D-массив.
+    """
+
+    def __init__(
+        self,
+        root: str,
+        meta: str,
+        train: bool,
+        length: int,
+        label: str,
+        artery_bin: int,
+        validation: bool = False,
+        transform: Optional[Callable] = None,
+    ) -> None:
+        # Корень датасета (используется, если meta передан как относительный путь)
+        self.root = Path(root).resolve()
+        # Режим обучения/валидации
+        self.train = train
+        # Требуемая длина клипа (количество временных кадров)
+        self.length = int(length)
+        # Имя поля с меткой (например, "syntax_left")
+        self.label = label
+        # Функция аугментаций/преобразований
+        self.transform = transform
+        # Флаг: использовать только записи с положительным score
+        self.validation = validation
+
+        # Проверка валидности кода артерии: 0 — left, 1 — right
+        if artery_bin not in (0, 1):
+            raise ValueError("artery_bin must be 0 (left) or 1 (right)")
+        self.artery_bin = artery_bin
+
+        # Полный путь к JSON-файлу метаданных
+        meta_path = meta if os.path.isabs(meta) else self.root / meta
+        meta_path = Path(meta_path).resolve()
+
+        # Директория, в которой расположен JSON; пути в "path" задаются относительно неё
+        json_dir = meta_path.parent
+
+        print(f"Backbone dataset: root={self.root}, meta={meta_path}, json_dir={json_dir}")
+
+        # Загрузка списка записей из JSON
+        with open(meta_path, "r", encoding="utf-8") as f:
+            dataset = json.load(f)
+
+        # Фильтрация по артерии
+        dataset = [rec for rec in dataset if rec.get("artery") == artery_bin]
+
+        # Для валидации можно оставить только записи с положительным score
+        if validation:
+            dataset = [rec for rec in dataset if float(rec.get(self.label, 0.0)) > 0]
+
+        # Сохраняем базовую директорию JSON для последующей сборки путей DICOM
+        self.json_dir = json_dir
+        self.dataset = dataset
+
+        # Инициализация веса записи (если не задан) значением 1.0
+        for rec in self.dataset:
+            rec.setdefault("weight", 1.0)
+
+        print(f"Backbone dataset loaded: {len(self.dataset)} samples after filtering")
+
+    def get_sample_weights(self) -> Tensor:
+        """
+        Возвращает веса для выборки с помощью WeightedRandomSampler.
+
+        Логика:
+          - делим записи на интервалы по severity (score) отдельно для левой и правой артерии;
+          - чем реже встречается интервал, тем больше вес его записей.
+        """
+        # Пороговые значения score для разбиения на интервалы (по артерии)
+        bin_thresholds = {
+            0: [0, 5, 10, 15],  # левая
+            1: [0, 2, 5, 8],    # правая
+        }
+        thr0, thr1, thr2, thr3 = bin_thresholds[self.artery_bin]
+
+        # Функция определения номера бина по значению score
+        def in_bin(score: float) -> int:
+            if score == thr0:
+                return 0
+            if thr0 < score <= thr1:
+                return 1
+            if thr1 < score <= thr2:
+                return 2
+            if thr2 < score <= thr3:
+                return 3
+            return 4
+
+        # Список score'ов и соответствующих бинов
+        scores = [float(rec.get(self.label, 0.0)) for rec in self.dataset]
+        bins = [in_bin(s) for s in scores]
+
+        # Подсчёт количества элементов в каждом бине
+        counts = np.bincount(np.array(bins, dtype=np.int64), minlength=5)
+        total = int(counts.sum())
+
+        # Вес бина — обратная частота
+        weights_by_bin = np.array(
+            [(total / counts[b]) if counts[b] > 0 else 0.0 for b in range(5)],
+            dtype=np.float64,
+        )
+
+        # Веса для каждой записи по номеру её бина
+        weights = np.array([weights_by_bin[b] for b in bins], dtype=np.float64)
+
+        return torch.as_tensor(weights, dtype=torch.double)
+
+    def __len__(self) -> int:
+        # Размер датасета — количество записей в JSON после всех фильтров
+        return len(self.dataset)
+
+    def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor, Tensor, float, str, Tensor]:
+        """
+        Возвращает:
+          video: Tensor, видео-клип (T, H, W, C) до применения transform
+          label: Tensor(1,), бинарная метка для классификации
+          target: Tensor(1,), регрессионная цель (log1p(score))
+          sample_weight: float, исходный вес записи из JSON
+          path: str, относительный путь к DICOM (как в JSON)
+          original_label: Tensor(1,), исходное значение score
+        """
+        rec = self.dataset[idx]
+
+        # Относительный путь к DICOM, как он хранится в JSON
+        rel_path = rec["path"]
+        sample_weight = float(rec.get("weight", 1.0))
+
+        # Полный путь: директория JSON + относительный путь из JSON
+        full_path = (self.json_dir / rel_path).resolve()
+
+        if not full_path.exists():
+            raise FileNotFoundError(
+                f"DICOM not found: {full_path}\n"
+                f"  json_dir={self.json_dir}\n"
+                f"  rel_path='{rel_path}'"
+            )
+
+        # Загрузка DICOM и получение массива пикселей
+        video = pydicom.dcmread(str(full_path)).pixel_array
+
+        # Ожидается 3D-массив (T, H, W) или (H, W, T)
+        if video.ndim != 3:
+            raise ValueError(f"Expected 3D video array, got shape={video.shape} for {rel_path}")
+
+        # Если временная ось оказалась последней (H, W, T) — перенесём её в первую (T, H, W)
+        if video.shape[0] > 128 and video.shape[-1] <= 128:
+            video = np.moveaxis(video, -1, 0)
+
+        # Нормализация uint16 → uint8 с масштабированием на [0, 255]
+        if video.dtype == np.uint16:
+            vmax = int(np.max(video))
+            if vmax <= 0:
+                raise ValueError(f"Invalid vmax={vmax} for {rel_path}")
+            video = (video.astype(np.float32) * (255.0 / vmax)).clip(0, 255).astype(np.uint8)
+        else:
+            video = video.astype(np.uint8)
+
+        # Получение численного score из записи
+        score = float(rec.get(self.label, 0.0))
+
+        # Порог для бинарной классификации (отдельно для каждой артерии)
+        bin_thresholds = {
+            0: 15,  # левая
+            1: 5,   # правая
+        }
+
+        # Бинарная метка: 1, если score выше порога, иначе 0
+        label = torch.tensor(
+            [1.0 if score > bin_thresholds[self.artery_bin] else 0.0],
+            dtype=torch.float32,
+        )
+        # Регрессионная цель — логарифм score с единицей
+        target = torch.tensor([np.log1p(score)], dtype=torch.float32)
+        # Исходное значение score
+        original_label = torch.tensor([score], dtype=torch.float32)
+
+        # При необходимости "дублируем" видео по времени до нужной длины клипа
+        while video.shape[0] < self.length:
+            video = np.concatenate([video, video], axis=0)
+
+        # Случайная или фиксированная вырезка окна по времени
+        t = int(video.shape[0])
+        if self.train:
+            # В обучении берём случайный отрезок длины self.length
+            begin = torch.randint(low=0, high=t - self.length + 1, size=(1,)).item()
+            video = video[begin: begin + self.length]
+        else:
+            # На валидации можно взять первые self.length кадров
+            video = video[:self.length]
+
+        # Преобразуем (T, H, W) в (T, H, W, C), где C=3 (дублируем градации серого по каналам)
+        video = torch.from_numpy(np.stack([video, video, video], axis=-1))
+
+        # Применяем цепочку трансформаций, если задана
+        if self.transform is not None:
+            video = self.transform(video)
+
+        # Возвращаем видео, метки и относительный путь
+        return video, label, target, sample_weight, str(rel_path), original_label

backbone/pl_model.py

@@ -0,0 +1,275 @@
+from typing import Any, Optional
+
+import numpy as np
+import torch
+from torch import nn, optim
+import lightning.pytorch as pl
+import torchvision.models.video as tvmv
+import sklearn.metrics as skm
+
+
+class SyntaxLightningModule(pl.LightningModule):
+    """
+    LightningModule для обучения 3D-backbone на SYNTAX score.
+
+    Архитектура:
+      - backbone: ResNet3D (r3d_18) из torchvision
+      - выходной полносвязный слой: два нейрона
+          [0] — логит для бинарной классификации (значимое поражение)
+          [1] — регрессионный выход для SYNTAX score (log1p)
+
+    Режимы обучения:
+      - pretrain (weight_path is None):
+          замораживается весь backbone, обучается только финальный слой (fc)
+      - finetune (weight_path задан):
+          загружаются веса из чекпоинта и дообучается вся сеть целиком.
+    """
+
+    def __init__(
+        self,
+        num_classes: int,
+        lr: float,
+        weight_decay: float = 0.0,
+        max_epochs: Optional[int] = None,
+        weight_path: Optional[str] = None,
+        sigma_a: float = 0.0,
+        sigma_b: float = 1.0,
+        **kwargs,
+    ):
+        super().__init__()
+        self.save_hyperparameters()
+
+        self.num_classes = int(num_classes)
+        self.lr = float(lr)
+        self.weight_decay = float(weight_decay)
+        self.max_epochs = max_epochs
+        self.weight_path = weight_path
+
+        self.sigma_a = float(sigma_a)
+        self.sigma_b = float(sigma_b)
+
+        # Инициализация 3D-ResNet-18 с предобученными весами
+        self.model = tvmv.r3d_18(weights=tvmv.R3D_18_Weights.DEFAULT)
+
+        # Замена финального слоя fc на слой с num_classes выходами
+        in_features = self.model.fc.in_features
+        self.model.fc = nn.Linear(in_features=in_features, out_features=self.num_classes, bias=True)
+
+        # При наличии пути к весам загружаем backbone
+        if self.weight_path is not None:
+            self._load_backbone_weights(self.weight_path)
+
+        # Лоссы
+        self.loss_clf = nn.BCEWithLogitsLoss(reduction="none")
+        self.loss_reg = nn.MSELoss(reduction="none")
+
+        # Буферы для валидации
+        self._y_true = []
+        self._y_prob = []
+        self._y_pred = []
+        self._t_true = []
+        self._t_pred = []
+
+    def _load_backbone_weights(self, weight_path: str) -> None:
+        """
+        Загружает веса backbone из:
+          - Lightning чекпоинта (dict с ключом 'state_dict')
+          - или "голого" state_dict (.pt/.pth), сохранённого через model.state_dict().
+
+        Логирует источник и статистику по ключам.
+        """
+        obj = torch.load(weight_path, map_location="cpu", weights_only=False)
+
+        if isinstance(obj, dict) and "state_dict" in obj:
+            state_dict = obj["state_dict"]
+            state_dict = {k.replace("model.", ""): v for k, v in state_dict.items()}
+            src_type = "lightning_checkpoint"
+        else:
+            state_dict = obj
+            src_type = "raw_state_dict"
+
+        incompatible = self.model.load_state_dict(state_dict, strict=False)
+
+        loaded_keys = [k for k in state_dict.keys() if k not in incompatible.missing_keys]
+        print(
+            f"[Backbone] Loaded weights from '{weight_path}' "
+            f"(type={src_type}): {len(loaded_keys)} params, "
+            f"missing={len(incompatible.missing_keys)}, "
+            f"unexpected={len(incompatible.unexpected_keys)}"
+        )
+        if incompatible.missing_keys:
+            print(f"[Backbone] Missing keys example: {incompatible.missing_keys[:5]}")
+        if incompatible.unexpected_keys:
+            print(f"[Backbone] Unexpected keys example: {incompatible.unexpected_keys[:5]}")
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Вход:
+          x: (B, C, T, H, W)
+
+        Выход:
+          y_hat: (B, 2) — [clf_logit, reg_output]
+        """
+        return self.model(x)
+
+    def training_step(self, batch: Any, batch_idx: int) -> torch.Tensor:
+        """
+        Один шаг обучения backbone.
+        """
+        x, y, target, sample_weight, path, original_label = batch
+
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:2]
+
+        weights_clf = torch.where(y > 0, 1.0, 0.45).to(y.dtype)
+        clf_loss = (self.loss_clf(yp_clf, y) * weights_clf).mean()
+
+        reg_loss_raw = self.loss_reg(yp_reg, target)
+        sigma = self.sigma_a * target + self.sigma_b
+        reg_loss = (reg_loss_raw / (sigma ** 2)).mean()
+
+        loss = clf_loss + 0.5 * reg_loss
+
+        y_prob = torch.sigmoid(yp_clf).detach()
+        y_pred = (y_prob > 0.5).int().cpu().numpy()
+        y_true = y.detach().int().cpu().numpy()
+
+        self.log("train_clf_loss", clf_loss, prog_bar=True, sync_dist=True)
+        self.log("train_reg_loss", reg_loss, prog_bar=True, sync_dist=True)
+        self.log("train_loss", loss, prog_bar=True, sync_dist=True)
+
+        self.log("train_f1", skm.f1_score(y_true, y_pred, zero_division=0),
+                 prog_bar=True, sync_dist=True)
+        self.log("train_acc", skm.accuracy_score(y_true, y_pred),
+                 prog_bar=True, sync_dist=True)
+
+        return loss
+
+    def validation_step(self, batch: Any, batch_idx: int) -> torch.Tensor:
+        """
+        Один шаг валидации backbone.
+        """
+        x, y, target, sample_weight, path, original_label = batch
+
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:2]
+
+        clf_loss = self.loss_clf(yp_clf, y).mean()
+
+        reg_loss_raw = self.loss_reg(yp_reg, target)
+        sigma = self.sigma_a * target + self.sigma_b
+        reg_loss = (reg_loss_raw / (sigma ** 2)).mean()
+
+        loss = clf_loss + 0.5 * reg_loss
+
+        y_prob = torch.sigmoid(yp_clf).float()
+        self._y_true.append(float(y[..., 0].float().cpu()))
+        self._y_prob.append(float(y_prob[..., 0].cpu()))
+        self._y_pred.append(int((y_prob[..., 0] > 0.5).cpu()))
+
+        self._t_true.append(float(target[..., 0].float().cpu()))
+        self._t_pred.append(float(yp_reg[..., 0].cpu()))
+
+        self.log("val_loss", loss, prog_bar=True, sync_dist=True)
+        self.log("val_clf_loss", clf_loss, prog_bar=False, sync_dist=True)
+        self.log("val_reg_loss", reg_loss, prog_bar=False, sync_dist=True)
+
+        return loss
+
+    def on_validation_epoch_end(self) -> None:
+        """
+        Расчёт и логирование метрик по окончании валидации.
+        """
+        if len(self._t_true) > 0:
+            rmse = skm.root_mean_squared_error(self._t_true, self._t_pred)
+            mae = skm.mean_absolute_error(self._t_true, self._t_pred)
+            self.log("val_rmse", rmse, prog_bar=True, sync_dist=True)
+            self.log("val_reg_mae", mae, prog_bar=True, sync_dist=True)
+
+        if len(set(self._y_true)) > 1:
+            auc = skm.roc_auc_score(self._y_true, self._y_prob)
+            f1 = skm.f1_score(self._y_true, self._y_pred, zero_division=0)
+            acc = skm.accuracy_score(self._y_true, self._y_pred)
+            self.log("val_auc", auc, prog_bar=True, sync_dist=True)
+            self.log("val_f1", f1, prog_bar=True, sync_dist=True)
+            self.log("val_acc", acc, prog_bar=True, sync_dist=True)
+
+        self._y_true.clear()
+        self._y_prob.clear()
+        self._y_pred.clear()
+        self._t_true.clear()
+        self._t_pred.clear()
+
+    def on_train_epoch_end(self) -> None:
+        """
+        Логирование текущего learning rate.
+        """
+        opt = self.optimizers()
+        self.log(
+            "lr",
+            opt.optimizer.param_groups[0]["lr"],
+            on_step=False,
+            on_epoch=True,
+            sync_dist=True,
+        )
+
+    def configure_optimizers(self):
+        """
+        Настройка оптимизатора и OneCycleLR.
+
+        Если weight_path is None:
+          обучается только self.model.fc (pretrain).
+        Иначе:
+          обучается вся модель (full finetune).
+        """
+        if self.weight_path is None:
+            for p in self.parameters():
+                p.requires_grad = False
+            for p in self.model.fc.parameters():
+                p.requires_grad = True
+            params = self.model.fc.parameters()
+        else:
+            for p in self.parameters():
+                p.requires_grad = True
+            params = self.parameters()
+
+        optimizer = optim.AdamW(params, lr=self.lr, weight_decay=self.weight_decay)
+
+        if self.max_epochs is not None and getattr(self, "trainer", None) is not None:
+            total_steps = self.trainer.estimated_stepping_batches
+            scheduler = optim.lr_scheduler.OneCycleLR(
+                optimizer=optimizer,
+                max_lr=self.lr,
+                total_steps=total_steps,
+            )
+            return {
+                "optimizer": optimizer,
+                "lr_scheduler": {
+                    "scheduler": scheduler,
+                    "interval": "step",
+                },
+            }
+
+        return optimizer
+
+    def predict_step(self, batch: Any, batch_idx: int, dataloader_idx: int = 0) -> Any:
+        """
+        Шаг инференса backbone.
+        """
+        x, y, target, sample_weight, path, original_label = batch
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:2]
+        y_prob = torch.sigmoid(yp_clf)
+
+        return {
+            "y": y,
+            "y_pred": (y_prob > 0.5).int(),
+            "y_prob": y_prob,
+            "y_reg": yp_reg,
+            "target": target,
+            "original_label": original_label,
+            "path": path,
+        }

backbone/pl_train.py

@@ -0,0 +1,335 @@
+import os
+import warnings
+
+import click
+import lightning.pytorch as pl
+import torch
+from lightning.pytorch.callbacks import LearningRateMonitor, ModelCheckpoint
+from lightning.pytorch.loggers import TensorBoardLogger
+from pytorchvideo.transforms import Normalize, Permute, RandAugment
+from torch.utils.data import DataLoader, WeightedRandomSampler
+from torchvision.transforms import transforms as T
+from torchvision.transforms._transforms_video import ToTensorVideo
+from torchvision.transforms import InterpolationMode
+
+from backbone.dataset import SyntaxDataset
+from backbone.pl_model import SyntaxLightningModule
+
+
+# Отключаем предупреждение Lightning о device id при DDP-инициализации
+warnings.filterwarnings("ignore", message="No device id is provided via `init_process_group`")
+
+# Устанавливаем точность матричных умножений (оптимизация производительности)
+torch.set_float32_matmul_precision("medium")
+
+
+def get_transforms(video_size, imagenet_mean, imagenet_std, train: bool = True):
+    """
+    Создаёт пайплайн аугментаций/преобразований для видео.
+
+    Входные данные:
+      - видео в формате Tensor (T, H, W, C), dtype uint8
+
+    Результат:
+      - Tensor (C, T, H, W), нормализованный, готовый к подаче в 3D-ResNet.
+    """
+    interpolation_choices = [InterpolationMode.BILINEAR, InterpolationMode.BICUBIC]
+
+    if train:
+        return T.Compose([
+            # Переводит (T, H, W, C) → (C, T, H, W), значения в [0,1]
+            ToTensorVideo(),
+            # Меняем порядок осей: (C, T, H, W) → (T, C, H, W) для RandAugment
+            Permute(dims=[1, 0, 2, 3]),
+            # Случайные аугментации по времени/пространству
+            RandAugment(magnitude=10, num_layers=2),
+            # Случайное горизонтальное отражение
+            T.RandomHorizontalFlip(),
+            # Возвращаемся к формату (C, T, H, W)
+            Permute(dims=[1, 0, 2, 3]),
+            # Случайный выбор интерполяции для изменения размера
+            T.RandomChoice([
+                T.Resize(size=video_size, interpolation=interp, antialias=True)
+                for interp in interpolation_choices
+            ]),
+            # Нормализация по статистикам ImageNet
+            Normalize(mean=imagenet_mean, std=imagenet_std),
+        ])
+    else:
+        # Для валидации/инференса используем только приведение к тензору и resize
+        return T.Compose([
+            ToTensorVideo(),
+            T.Resize(size=video_size, interpolation=InterpolationMode.BICUBIC, antialias=True),
+            Normalize(mean=imagenet_mean, std=imagenet_std),
+        ])
+
+
+def make_dataloader(dataset, batch_size: int, num_workers: int, use_weighted_sampler: bool):
+    """
+    Создаёт DataLoader с опциональным WeightedRandomSampler.
+
+    Если use_weighted_sampler=True:
+      - семплирование идёт с учётом весов, возвращаемых dataset.get_sample_weights()
+      - shuffle выключается, так как порядок определяется сэмплером
+    """
+    if use_weighted_sampler:
+        sample_weights = dataset.get_sample_weights().cpu()
+        sampler = WeightedRandomSampler(sample_weights, num_samples=len(dataset), replacement=True)
+        shuffle = False
+    else:
+        sampler = None
+        shuffle = True
+
+    return DataLoader(
+        dataset,
+        batch_size=batch_size,
+        num_workers=num_workers,
+        sampler=sampler,
+        shuffle=shuffle,
+        drop_last=True,
+        pin_memory=True,
+        persistent_workers=(num_workers > 0),
+    )
+
+
+def make_model(num_classes: int, lr: float, weight_decay: float, max_epochs: int, weight_path: str = None):
+    """
+    Конструктор LightningModule для backbone.
+
+    num_classes:
+      количество выходных нейронов (обычно 2: классификация + регрессия).
+    """
+    return SyntaxLightningModule(
+        num_classes=num_classes,
+        lr=lr,
+        weight_decay=weight_decay,
+        max_epochs=max_epochs,
+        weight_path=weight_path,
+    )
+
+
+def make_callbacks(phase: str):
+    """
+    Создаёт список callback'ов для Trainer:
+      - мониторинг learning rate
+      - сохранение чекпоинтов по метрике val_rmse
+    """
+    lr_monitor = LearningRateMonitor(logging_interval="epoch")
+
+    checkpoint = ModelCheckpoint(
+        monitor="val_rmse",
+        save_top_k=1 if phase == "pre" else 3,
+        mode="min",
+        filename="model-{epoch:02d}-{val_rmse:.3f}",
+        save_last=True,
+    )
+    return [lr_monitor, checkpoint]
+
+
+def make_trainer(max_epochs: int, logdir: str, logger_name: str, devices: list[int], precision: str):
+    """
+    Создаёт объект Trainer с заданными параметрами:
+      - logdir: путь к директории для логов TensorBoard
+      - logger_name: имя поддиректории для текущего эксперимента
+      - devices: количество GPU-устройств
+      - precision: режим числовой точности (например, "bf16-mixed")
+    """
+    logger = TensorBoardLogger(save_dir=logdir, name=logger_name)
+
+    # Если устройств больше одного — используем DDP, иначе оставляем стратегию по умолчанию
+    strategy = "ddp_find_unused_parameters_true" if len(devices) > 1 else "auto"
+
+    return pl.Trainer(
+        max_epochs=max_epochs,
+        accelerator="gpu" if torch.cuda.is_available() else "cpu",
+        devices=devices,
+        strategy=strategy,
+        precision=precision,
+        callbacks=[],
+        log_every_n_steps=10,
+        logger=logger,
+    )
+
+
+@click.command()
+@click.option(
+    "-r",
+    "--dataset-root",
+    type=click.Path(exists=True),
+    default=".",
+    show_default=True,
+    help="Корень датасета (JSON и DICOM-пути считаются относительно него).",
+)
+@click.option("--fold", type=int, default=4, show_default=True, help="Номер фолда.")
+@click.option(
+    "-a",
+    "--artery",
+    type=str,
+    default="right",
+    show_default=True,
+    help="Название артерии: left или right.",
+)
+@click.option(
+    "-nc",
+    "--num-classes",
+    type=int,
+    default=2,
+    show_default=True,
+    help="Число выходных нейронов (обычно 2: clf + reg).",
+)
+@click.option("-b", "--batch-size", type=int, default=50, show_default=True, help="Размер batch.")
+@click.option("-f", "--frames-per-clip", type=int, default=32, show_default=True, help="Число кадров в клипе.")
+@click.option(
+    "-v",
+    "--video-size",
+    type=click.Tuple([int, int]),
+    default=(256, 256),
+    show_default=True,
+    help="Размер кадра (H, W).",
+)
+@click.option("--max-epochs", type=int, default=10, show_default=True, help="Число эпох для full train.")
+@click.option("--num-workers", type=int, default=8, show_default=True, help="Число DataLoader workers.")
+@click.option(
+    "--devices",
+    type=list[int],
+    multiple=True,
+    default=[0],
+    show_default=True,
+    help="Список GPU id",
+)
+@click.option("--precision", type=str, default="bf16-mixed", show_default=True, help="Режим точности.")
+@click.option(
+    "--logdir",
+    type=click.Path(),
+    default="./logs/backbone",
+    show_default=True,
+    help="Каталог для логов и чекпоинтов backbone.",
+)
+@click.option(
+    "--use-weighted-sampler",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Использовать ли WeightedRandomSampler по score-интервалам.",
+)
+@click.option("--seed", type=int, default=42, show_default=True, help="Сид для воспроизводимости.")
+def main(
+    dataset_root,
+    fold,
+    artery,
+    num_classes,
+    batch_size,
+    frames_per_clip,
+    video_size,
+    max_epochs,
+    num_workers,
+    devices,
+    precision,
+    logdir,
+    use_weighted_sampler,
+    seed,
+):
+    """
+    Точка входа для обучения backbone-модели.
+
+    Последовательность:
+      1) pretrain: обучение только финального слоя fc
+      2) full train: дообучение всей модели с началом из последнего чекпоинта pretrain.
+    """
+    # Фиксация сида во всех поддерживаемых библиотеках
+    pl.seed_everything(seed)
+
+    artery = artery.lower()
+    artery_bin = {"left": 0, "right": 1}.get(artery)
+    if artery_bin is None:
+        raise ValueError(f"Unknown artery '{artery}', expected 'left' or 'right'")
+
+    # Статистики ImageNet для нормализации входа
+    imagenet_mean = [0.485, 0.456, 0.406]
+    imagenet_std = [0.229, 0.224, 0.225]
+
+    # Пути к JSON-метаданным фолдов относительно dataset_root
+    train_meta = f"folds/step2_fold{fold:02d}_train.json"
+    eval_meta = f"folds/step2_fold{fold:02d}_eval.json"
+
+    # Инициализация тренировочного датасета
+    train_set = SyntaxDataset(
+        root=dataset_root,
+        meta=train_meta,
+        train=True,
+        length=frames_per_clip,
+        label=f"syntax_{artery}",
+        artery_bin=artery_bin,
+        validation=False,
+        transform=get_transforms(video_size, imagenet_mean, imagenet_std, train=True),
+    )
+
+    # Инициализация валидационного датасета
+    val_set = SyntaxDataset(
+        root=dataset_root,
+        meta=eval_meta,
+        train=False,
+        length=frames_per_clip,
+        label=f"syntax_{artery}",
+        artery_bin=artery_bin,
+        validation=True,
+        transform=get_transforms(video_size, imagenet_mean, imagenet_std, train=False),
+    )
+
+    # DataLoader'ы: для pretrain можно брать увеличенный batch
+    train_loader_pre = make_dataloader(train_set, batch_size * 2, num_workers, use_weighted_sampler)
+    train_loader_post = make_dataloader(train_set, batch_size, num_workers, use_weighted_sampler)
+    val_loader = make_dataloader(val_set, 1, num_workers, use_weighted_sampler=False)
+
+    # Получаем форму видео (C, T, H, W) из одного batch для информации
+    x, *_ = next(iter(train_loader_pre))
+    video_shape = x.shape[1:]
+    print(f"Backbone input video shape: {video_shape}")
+
+    # Callback'и для pretrain и full train
+    callbacks_pre = make_callbacks(phase="pre")
+    callbacks_full = make_callbacks(phase="full")
+
+    # ------------------- Pretrain (fc only) -------------------
+    num_pre_epochs = 10
+
+    model_pre = make_model(
+        num_classes=num_classes,
+        lr=3e-4,
+        weight_decay=0.01,
+        max_epochs=num_pre_epochs,
+        weight_path=None,
+    )
+
+    trainer_pre = make_trainer(
+        max_epochs=num_pre_epochs,
+        logdir=logdir,
+        logger_name=f"{artery}BinSyntax_R3D_pre_fold{fold:02d}",
+        devices=devices,
+        precision=precision,
+    )
+    trainer_pre.callbacks.extend(callbacks_pre)
+    trainer_pre.fit(model_pre, train_loader_pre, val_loader)
+
+    # ------------------- Full train (finetune) -------------------
+    model_full = make_model(
+        num_classes=num_classes,
+        lr=1e-4,
+        weight_decay=0.01,
+        max_epochs=max_epochs,
+        weight_path=trainer_pre.checkpoint_callback.last_model_path,
+    )
+
+    trainer_full = make_trainer(
+        max_epochs=max_epochs,
+        logdir=logdir,
+        logger_name=f"{artery}BinSyntax_R3D_full_fold{fold:02d}",
+        devices=devices,
+        precision=precision,
+    )
+    trainer_full.callbacks.extend(callbacks_full)
+    trainer_full.fit(model_full, train_loader_post, val_loader)
+
+
+if __name__ == "__main__":
+    main()

backbone_weights/leftBinSyntax_R3D_full_fold00.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:299db032713b8b8247fa42e1bfcf993d6c0ea162a2d47211cd4ef83e8e7083ac
+size 398135752

backbone_weights/leftBinSyntax_R3D_full_fold01.pt

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

backbone_weights/leftBinSyntax_R3D_full_fold02.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81b7f04e2d6735c505fe50101c2f7dedacb1503681c14f28c6fd8007bb7a4255
+size 398135752

backbone_weights/leftBinSyntax_R3D_full_fold03.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7decf5e0fec66d734901a8cb0c47a09b0d7ec33a341f245caa7aeee0011162fc
+size 398135752

backbone_weights/leftBinSyntax_R3D_full_fold04.pt

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

backbone_weights/rightBinSyntax_R3D_full_fold00.pt

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

backbone_weights/rightBinSyntax_R3D_full_fold01.pt

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

backbone_weights/rightBinSyntax_R3D_full_fold02.pt

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

backbone_weights/rightBinSyntax_R3D_full_fold03.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c3387e5bb99b615d7c8d5a67b41d53f4cc4d872e82f7b391be4da3321490fdb
+size 398135752

backbone_weights/rightBinSyntax_R3D_full_fold04.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e3cf35b8d0450f23bb105d6367efc8ab32bc73a0bc4170e0fc07fbe54e593f9
+size 398135752

full_model/rnn_dataset.py

@@ -0,0 +1,257 @@
+import json
+from pathlib import Path
+from typing import Any, Callable, Optional, Tuple
+
+import numpy as np
+import pydicom
+import torch
+from torch import Tensor
+from torch.utils.data import Dataset
+
+
+DTYPE = torch.float16
+
+
+class SyntaxDataset(Dataset):
+    """
+    Dataset для head‑модели (RNN/LSTM) поверх backbone.
+
+    Структура JSON:
+      [
+        {
+          "study_uid": "...",
+          "syntax_left": 12.5,
+          "syntax_right": 8.2,
+          "videos_left": [
+            {"path": "../data/anon_data/.../IM-0001-0001.dcm"},
+            ...
+          ],
+          "videos_right": [
+            {"path": "../data/anon_data/.../IM-0002-0001.dcm"},
+            ...
+          ],
+        },
+        ...
+      ]
+
+    ВАЖНО: поля "videos_{artery}[i]['path']" в JSON — пути к DICOM
+    относительно директории этого JSON (папка rnn_folds/).
+    """
+
+    def __init__(
+        self,
+        root: str,
+        meta: str,
+        train: bool,
+        length: int,
+        label: str,
+        artery: str,
+        inference: bool = False,
+        validation: bool = False,
+        transform: Optional[Callable] = None,
+    ) -> None:
+        # Корень датасета, если meta задан относительно него
+        self.root = Path(root).resolve()
+        # Режим: обучение/валидация
+        self.train = train
+        # Длина одного клипа (по времени)
+        self.length = int(length)
+        # Имя поля с численным score ("syntax_left"/"syntax_right" или пусто)
+        self.label = label
+        # Артерия: "left" или "right"
+        self.artery = artery.lower()
+        # Режим инференса: возвращать все клипы без случайного выбора
+        self.inference = inference
+        # Флаг: использовать только записи с положительным score
+        self.validation = validation
+        # Трансформации для каждого видео‑клипа
+        self.transform = transform
+
+        # Полный путь к JSON с метаданными
+        meta_path = Path(meta)
+        if not meta_path.is_absolute():
+            meta_path = self.root / meta_path
+        meta_path = meta_path.resolve()
+
+        # База для путей к DICOM — директория JSON
+        self.base_dir = meta_path.parent
+
+        print(f"RNN Dataset: root={self.root}, meta={meta_path}, base_dir={self.base_dir}")
+
+        # Загрузка JSON
+        with open(meta_path, "r", encoding="utf-8") as f:
+            dataset = json.load(f)
+
+        # Убираем записи без видео по указанной артерии в режиме обучения/валидации
+        if not self.inference:
+            dataset = [rec for rec in dataset if len(rec.get(f"videos_{self.artery}", [])) > 0]
+
+        # Для валидации при необходимости фильтруем только положительные score
+        if validation and self.label:
+            dataset = [rec for rec in dataset if float(rec.get(self.label, 0.0)) > 0]
+
+        self.dataset = dataset
+        print(f"RNN Dataset loaded: {len(self.dataset)} samples after filtering")
+
+        # Коды артерий для порогов
+        artery_bin = {"left": 0, "right": 1}.get(self.artery)
+        if artery_bin is None:
+            raise ValueError(f"Unknown artery '{artery}', expected 'left' or 'right'")
+        self.artery_bin = artery_bin
+
+    def __len__(self) -> int:
+        # Размер датасета = количество записей (исследований)
+        return len(self.dataset)
+
+    def get_sample_weights(self) -> Tensor:
+        """
+        Возвращает веса примеров для WeightedRandomSampler по интервалам score.
+
+        Для каждой артерии задаются свои пороги, далее считается обратная частота
+        попадания в интервал.
+        """
+        bin_thresholds = {
+            0: [0, 5, 10, 15],  # левая
+            1: [0, 2, 5, 8],    # правая
+        }
+        thr0, thr1, thr2, thr3 = bin_thresholds[self.artery_bin]
+
+        def in_bin(score: float) -> int:
+            if score == thr0:
+                return 0
+            if thr0 < score <= thr1:
+                return 1
+            if thr1 < score <= thr2:
+                return 2
+            if thr2 < score <= thr3:
+                return 3
+            return 4
+
+        scores = [float(rec.get(self.label, 0.0)) for rec in self.dataset]
+        bins = [in_bin(s) for s in scores]
+
+        counts = np.bincount(np.array(bins, dtype=np.int64), minlength=5)
+        total = int(counts.sum())
+
+        weights_by_bin = np.array(
+            [(total / counts[b]) if counts[b] > 0 else 0.0 for b in range(5)],
+            dtype=np.float64,
+        )
+
+        weights = np.array([weights_by_bin[b] for b in bins], dtype=np.float64)
+        print(
+            "RNN sample weights counts:",
+            int(counts[0]),
+            int(counts[1]),
+            int(counts[2]),
+            int(counts[3]),
+            int(counts[4]),
+        )
+        return torch.as_tensor(weights, dtype=DTYPE)
+
+    def __getitem__(self, idx: int) -> Tuple[Tensor, Tensor, Tensor, Any]:
+        """
+        Возвращает:
+          clips: Tensor, стек клипов (N_clips, C, T, H, W) после transform
+          label: Tensor(1,), бинарная метка (0/1)
+          target: Tensor(1,), регрессионная цель (log1p(score))
+          suid: идентификатор исследования (study_uid)
+        """
+        rec = self.dataset[idx]
+        suid = rec["study_uid"]
+
+        # Формируем метки, если имя поля задано
+        if self.label:
+            bin_thresholds = {
+                0: 15,  # левая
+                1: 5,   # правая
+            }
+            score = float(rec.get(self.label, 0.0))
+            label = torch.tensor(
+                [1.0 if score > bin_thresholds[self.artery_bin] else 0.0],
+                dtype=DTYPE,
+            )
+            target = torch.tensor([np.log1p(score)], dtype=DTYPE)
+        else:
+            # В режиме чистого инференса на неизвестных данных можно не задавать label/target
+            label = torch.tensor([0.0], dtype=DTYPE)
+            target = torch.tensor([0.0], dtype=DTYPE)
+
+        videos_list = rec.get(f"videos_{self.artery}", [])
+        nv = len(videos_list)
+
+        # Выбор индексов клипов
+        if self.inference:
+            # В инференсе возвращаем все доступные клипы
+            if nv == 0:
+                # Пустая последовательность в крайнем случае
+                return torch.zeros(0), label, target, suid
+            seq_indices = range(nv)
+        else:
+            if nv == 0:
+                raise ValueError(f"No videos for artery={self.artery} in record {suid}")
+            # Случайный набор индексов клипов (например, 4 штуки)
+            seq_indices = torch.randint(low=0, high=nv, size=(4,))
+
+        clips = []
+        for vi in seq_indices:
+            vi_idx = int(vi)
+            video_rec = videos_list[vi_idx]
+            rel_path = video_rec["path"]
+
+            # Полный путь к DICOM: директория JSON + относительный путь
+            full_path = (self.base_dir / rel_path).resolve()
+            if not full_path.exists():
+                raise FileNotFoundError(
+                    f"DICOM not found: {full_path}\n"
+                    f"  base_dir={self.base_dir}\n"
+                    f"  rel_path='{rel_path}'\n"
+                    f"  study={suid}"
+                )
+
+            # Загрузка DICOM
+            video = pydicom.dcmread(str(full_path)).pixel_array
+
+            # Ожидаем 3D‑массив по времени
+            if video.ndim != 3:
+                raise ValueError(f"Expected 3D video, got {video.shape} in {full_path}")
+
+            # Если время в последней оси, переносим её в первую
+            if video.shape[0] > 128 and video.shape[-1] <= 128:
+                video = np.moveaxis(video, -1, 0)
+
+            # Приведение к uint8
+            if video.dtype == np.uint16:
+                vmax = int(np.max(video))
+                if vmax <= 0:
+                    raise ValueError(f"Invalid vmax={vmax} in {full_path}")
+                video = (video.astype(np.float32) * (255.0 / vmax)).clip(0, 255).astype(np.uint8)
+            else:
+                video = video.astype(np.uint8)
+
+            # Дублируем по времени до нужной длины
+            while video.shape[0] < self.length:
+                video = np.concatenate([video, video], axis=0)
+
+            t = int(video.shape[0])
+            if self.train:
+                # В обучении берём случайное окно
+                begin = torch.randint(low=0, high=t - self.length + 1, size=(1,)).item()
+            else:
+                # В валидации можно взять центральное окно
+                begin = (t - self.length) // 2
+            video = video[begin: begin + self.length]
+
+            # (T, H, W) → (T, H, W, C) с C=3
+            video = torch.from_numpy(np.stack([video, video, video], axis=-1))
+
+            # Применяем трансформации
+            if self.transform is not None:
+                video = self.transform(video)  # ожидается (C, T, H, W)
+
+            clips.append(video)
+
+        # Стек клипов: (N_clips, C, T, H, W)
+        clips = torch.stack(clips, dim=0) if clips else torch.zeros(0, dtype=DTYPE)
+
+        return clips, label, target, suid

full_model/rnn_model.py

@@ -0,0 +1,386 @@
+from typing import Any, Callable, Optional, Tuple
+import torch
+import torch.nn.functional as F
+from torch import nn, optim
+import lightning.pytorch as pl
+import torchvision.models.video as tvmv
+import sklearn.metrics as skm
+
+
+"""
+The head of model
+"""
+class SyntaxLightningModule(pl.LightningModule):
+    def __init__(
+        self,
+        num_classes,
+        lr: float,
+        variant: str,  # mean, lstm_mean, lstm_last, gru_mean, gru_last, bert_mean, bert_cls, bert_cls2
+        weight_decay: float = 0,
+        max_epochs: int = None,
+        weight_path: str = None,      # веса backbone (r3d_18) (ckpt или pt)
+        save_path: str = None,        # путь для сохранения по лучшему auc (как было)
+        pl_weight_path: str = None,   # полный Lightning‑чекпоинт всей модели
+        pt_weights_format: bool = False,    # .pt формат
+        sigma_a: float = 0,
+        sigma_b: float = 1,
+        **kwargs,
+    ):
+        self.save_hyperparameters()
+        super().__init__()
+        self.num_classes = num_classes
+        self.save_path = save_path
+        self.weight_path = weight_path
+        self.variant = variant
+        self.sigma_a = sigma_a
+        self.sigma_b = sigma_b
+
+        # Video ResNet (backbone)
+        self.model = tvmv.r3d_18(weights=tvmv.R3D_18_Weights.DEFAULT)
+
+        self.lr = lr
+        self.loss_clf = nn.BCEWithLogitsLoss(reduction="none")
+        self.loss_reg = nn.MSELoss(reduction="none")
+
+        # Финальный слой backbone по умолчанию: 2 выхода (clf + reg)
+        in_features = self.model.fc.in_features
+        self.model.fc = nn.Linear(in_features=in_features, out_features=2, bias=True)
+
+        # Загрузка pretrain‑весов backbone (r3d_18), как раньше через weight_path,
+        # но теперь поддерживаются и .ckpt, и .pt/.pth
+        if weight_path is not None:
+            print("Load model weights (backbone)")
+            self.load_weights_backbone(weight_path, self.model)
+
+        # Выбор типа head
+        if self.variant != "mean_out":
+            self.model.fc = nn.Identity()
+
+        if self.variant == "mean_out":
+            # Только self.model с fc=Linear(…, 2)
+            pass
+        elif self.variant in ("gru_mean", "gru_last"):
+            self.rnn = nn.GRU(in_features, in_features // 4, batch_first=True)
+            self.dropout = nn.Dropout(0.2)
+            self.fc = nn.Linear(in_features=in_features // 4, out_features=num_classes, bias=True)
+        elif self.variant in ("lstm_mean", "lstm_last"):
+            self.lstm = nn.LSTM(
+                input_size=in_features,
+                hidden_size=in_features // 4,
+                proj_size=num_classes,
+                batch_first=True,
+            )
+        elif self.variant == "mean":
+            self.fc = nn.Linear(in_features=in_features, out_features=num_classes, bias=True)
+        elif self.variant in ("bert_mean", "bert_cls", "bert_cls2"):
+            encoder_layer = nn.TransformerEncoderLayer(
+                d_model=in_features,
+                nhead=4,
+                batch_first=True,
+                dim_feedforward=in_features // 4,
+            )
+            self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=1)
+            self.dropout = nn.Dropout(0.2)
+            self.fc = nn.Linear(in_features=in_features, out_features=num_classes, bias=True)
+            if self.variant == "bert_cls2":
+                self.cls = nn.Parameter(torch.randn(1, 1, in_features))
+        else:
+            raise ValueError(f"Unknown model variant {self.variant}")
+
+        # Загрузка полного Lightning‑чекпоинта (backbone + head), как было раньше
+        if pl_weight_path is not None:
+            print(f"Load LightningModule weights from {pl_weight_path}")
+
+            if pt_weights_format:
+                pl_state_dict = torch.load(pl_weight_path, weights_only=False)
+            else:
+                pl_state_dict = torch.load(pl_weight_path, weights_only=False)["state_dict"]
+
+            # Загружаем backbone
+            self.load_weights(pl_state_dict, self.model, "model")
+
+            # Загружаем head в зависимости от варианта
+            if self.variant == "mean_out":
+                pass  # только self.model
+            elif self.variant in ("gru_mean", "gru_last"):
+                self.load_weights(pl_state_dict, self.rnn, "rnn")
+                self.load_weights(pl_state_dict, self.fc, "fc")
+            elif self.variant in ("lstm_mean", "lstm_last"):
+                self.load_weights(pl_state_dict, self.lstm, "lstm")
+            elif self.variant == "mean":
+                self.load_weights(pl_state_dict, self.fc, "fc")
+            elif self.variant in ("bert_mean", "bert_cls", "bert_cls2"):
+                self.load_weights(pl_state_dict, self.encoder, "encoder")
+                self.load_weights(pl_state_dict, self.fc, "fc")
+                if self.variant == "bert_cls2":
+                    old_shape = self.cls.shape
+                    self.cls = nn.Parameter(pl_state_dict["cls"])
+                    assert old_shape == self.cls.shape
+            else:
+                raise ValueError(f"Unknown model variant {self.variant}")
+
+        self.max_epochs = max_epochs
+        self.weight_decay = weight_decay
+
+        self.y_val = []
+        self.p_val = []
+        self.r_val = []
+        self.ty_val = []
+        self.tp_val = []
+
+    def load_weights_backbone(self, weight_path: str, model: nn.Module) -> None:
+        """
+        Универсальная загрузка весов backbone (r3d_18):
+
+        - если файл — Lightning‑чекпоинт (dict с 'state_dict'),
+          берём state_dict['state_dict'] и убираем префикс 'model.'.
+        - если файл — "голый" state_dict (.pt/.pth), сохранённый через model.state_dict(),
+          загружаем его напрямую.
+
+        При этом перед загрузкой убираем из state_dict все ключи с несовпадающим размером
+        (например, fc.weight/fc.bias при разном числе выходов).
+        """
+        obj = torch.load(weight_path, weights_only=False, map_location="cpu")
+
+        if isinstance(obj, dict) and "state_dict" in obj:
+            raw_state = obj["state_dict"]
+            state_dict = {k.replace("model.", ""): v for k, v in raw_state.items()}
+            src_type = "lightning_checkpoint"
+        else:
+            state_dict = obj
+            src_type = "raw_state_dict"
+
+        current_state = model.state_dict()
+        filtered_state = {}
+        mismatched_keys = []
+
+        # Оставляем только те веса, у которых совпадает размер тензора
+        for k, v in state_dict.items():
+            if k in current_state and current_state[k].shape == v.shape:
+                filtered_state[k] = v
+            else:
+                # либо вообще нет такого ключа, либо размер не совпадает
+                mismatched_keys.append(k)
+
+        # Загружаем только совместимые веса
+        incompatible = model.load_state_dict(filtered_state, strict=False)
+
+        loaded_keys = [k for k in filtered_state.keys() if k not in incompatible.missing_keys]
+        print(
+            f"[Backbone] Loaded weights from '{weight_path}' "
+            f"(type={src_type}): {len(loaded_keys)} params, "
+            f"missing={len(incompatible.missing_keys)}, "
+            f"unexpected={len(incompatible.unexpected_keys)}, "
+            f"skipped_mismatched={len(mismatched_keys)}"
+        )
+        if mismatched_keys:
+            print(f"[Backbone] Size‑mismatched keys (skipped), example: {mismatched_keys[:5]}")
+        if incompatible.missing_keys:
+            print(f"[Backbone] Missing keys after filtering, example: {incompatible.missing_keys[:5]}")
+        if incompatible.unexpected_keys:
+            print(f"[Backbone] Unexpected keys after filtering, example: {incompatible.unexpected_keys[:5]}")
+
+    def load_weights(self, state_dict, module, prefix: str):
+        """Фильтруем и грузим только те веса, которые относятся к конкретному модулю."""
+        module_state = {
+            k.replace(f"{prefix}.", ""): v
+            for k, v in state_dict.items()
+            if k.startswith(prefix)
+        }
+        missing, unexpected = module.load_state_dict(module_state, strict=False)
+        if missing:
+            print(f"Missing keys for {prefix}: {missing}")
+        if unexpected:
+            print(f"Unexpected keys for {prefix}: {unexpected}")
+
+    def forward(self, x):
+        # x: (batch, seq, C, T, H, W)
+        batch_seq_shape = x.shape[0:2]
+        x = torch.flatten(x, start_dim=0, end_dim=1)  # (batch*seq, C, T, H, W)
+        x = self.model(x)
+        x = torch.unflatten(x, 0, batch_seq_shape)  # (batch, seq, feat)
+
+        if self.variant == "mean_out":
+            x = torch.mean(x, dim=1)
+        elif self.variant in ("gru_mean", "gru_last"):
+            _all_outs_, [_last_out_] = self.rnn(x)
+            if self.variant == "gru_mean":
+                x = torch.mean(_all_outs_, dim=1)
+            else:
+                x = _last_out_
+            x = self.dropout(x)
+            x = self.fc(x)
+        elif self.variant in ("lstm_mean", "lstm_last"):
+            _all_outs_, (_last_out_, _last_state_) = self.lstm(x)
+            if self.variant == "lstm_mean":
+                x = torch.mean(_all_outs_, dim=1)
+            else:
+                x = _last_out_
+        elif self.variant == "mean":
+            x = torch.mean(x, dim=1)
+            x = self.fc(x)
+        elif self.variant in ("bert_mean", "bert_cls", "bert_cls2"):
+            if self.variant == "bert_cls":
+                x = F.pad(x, (0, 0, 1, 0), "constant", 0)
+            elif self.variant == "bert_cls2":
+                bs = x.size(0)
+                x = torch.cat([self.cls.expand(bs, -1, -1), x], dim=1)
+            x = self.encoder(x)
+            if self.variant == "bert_mean":
+                x = torch.mean(x, dim=1)
+            else:
+                x = x[:, 0, :]
+            x = self.dropout(x)
+            x = self.fc(x)
+        else:
+            raise ValueError(f"Unknown model variant {self.variant}")
+
+        return x
+
+    def training_step(self, batch, batch_idx):
+        x, y, target, path = batch
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:]
+
+        weights_clf = torch.where(y > 0, 1.0, 0.2)
+        clf_loss = self.loss_clf(yp_clf, y)
+        clf_loss = (clf_loss * weights_clf).mean()
+
+        reg_loss_raw = self.loss_reg(yp_reg, target)
+        sigma = self.sigma_a * target + self.sigma_b
+        reg_loss = (reg_loss_raw / (sigma ** 2)).mean()
+
+        loss = clf_loss + 0.5 * reg_loss
+
+        y_pred = torch.sigmoid(yp_clf)
+        y_bin = torch.round(y.cpu().detach()).int()
+        y_pred_bin = torch.round(y_pred.cpu().detach()).int()
+
+        self.log("train_clf_loss", clf_loss, prog_bar=True, sync_dist=True)
+        self.log("train_val_loss", reg_loss, prog_bar=True, sync_dist=True)
+        self.log("train_full_loss", loss, prog_bar=True, sync_dist=True)
+        self.log("train_f1", skm.f1_score(y_bin, y_pred_bin, zero_division=0),
+                 prog_bar=True, sync_dist=True)
+        self.log("train_acc", skm.accuracy_score(y_bin, y_pred_bin),
+                 prog_bar=True, sync_dist=True)
+
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, y, target, path = batch
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:]
+
+        loss = self.loss_clf(yp_clf, y)
+        reg_loss_raw = self.loss_reg(yp_reg, target)
+        loss = loss.mean()
+
+        y_pred = torch.sigmoid(yp_clf)
+
+        self.y_val.append(int(y[..., 0].cpu()))
+        self.p_val.append(float(y_pred[..., 0].cpu()))
+        self.r_val.append(round(float(y_pred[..., 0].cpu())))
+
+        self.ty_val.append(float(target[..., 0].cpu()))
+        self.tp_val.append(float(yp_reg[..., 0].cpu()))
+
+        clf_loss = self.loss_clf(yp_clf, y)
+        reg_loss_raw = self.loss_reg(yp_reg, target)
+        sigma = self.sigma_a * target + self.sigma_b
+        reg_loss = (reg_loss_raw / (sigma ** 2)).mean()
+
+        loss = clf_loss + 0.5 * reg_loss
+
+        return loss
+
+    def on_validation_epoch_end(self):
+        try:
+            auc = skm.roc_auc_score(self.y_val, self.p_val)
+            f1 = skm.f1_score(self.y_val, self.r_val, zero_division=0)
+            acc = skm.accuracy_score(self.y_val, self.r_val)
+            mae = skm.mean_absolute_error(self.y_val, self.r_val)
+            self.log("val_auc", auc, prog_bar=True, sync_dist=True)
+            self.log("val_f1", f1, prog_bar=True, sync_dist=True)
+            self.log("val_acc", acc, prog_bar=True, sync_dist=True)
+            self.log("val_mae", mae, prog_bar=True, sync_dist=True)
+
+            rmse = skm.root_mean_squared_error(self.ty_val, self.tp_val)
+            self.log("val_rmse", rmse, prog_bar=True, sync_dist=True)
+
+        except ValueError as err:
+            print(err)
+            print("Y_VAL", self.y_val)
+            print("P_VAL", self.p_val)
+        self.y_val.clear()
+        self.p_val.clear()
+        self.r_val.clear()
+        self.ty_val.clear()
+        self.tp_val.clear()
+
+    def on_train_epoch_end(self) -> None:
+        self.log(
+            "lr",
+            self.optimizers().optimizer.param_groups[0]["lr"],
+            on_step=False,
+            on_epoch=True,
+            sync_dist=True,
+        )
+
+    def configure_optimizers(self):
+        # Сначала определяем, какие модули тренируем
+        if self.weight_path:  # pretrain without video backbone
+            if self.variant == "mean_out":
+                trainable_modules = [self.model.fc]
+            elif self.variant in ("gru_mean", "gru_last"):
+                trainable_modules = [self.rnn, self.fc]
+            elif self.variant in ("lstm_mean", "lstm_last"):
+                trainable_modules = [self.lstm]
+            elif self.variant == "mean":
+                trainable_modules = [self.fc]
+            elif self.variant in ("bert_mean", "bert_cls", "bert_cls2"):
+                trainable_modules = [self.encoder, self.fc]
+                if self.variant == "bert_cls2":
+                    trainable_modules.append(self.cls)
+            else:
+                trainable_modules = []
+
+            for param in self.parameters():
+                param.requires_grad = False
+
+            for m in trainable_modules:
+                for p in m.parameters():
+                    p.requires_grad = True
+
+            params = [p for m in trainable_modules for p in m.parameters()]
+        else:
+            for param in self.parameters():
+                param.requires_grad = True
+            params = self.parameters()
+
+        optimizer = optim.Adam(params, lr=self.lr, weight_decay=self.weight_decay)
+
+        if self.max_epochs is not None:
+            lr_scheduler = optim.lr_scheduler.OneCycleLR(
+                optimizer=optimizer, max_lr=self.lr, total_steps=self.max_epochs
+            )
+            return [optimizer], [lr_scheduler]
+        else:
+            return optimizer
+
+    def predict_step(self, batch: Any, batch_idx: int, dataloader_idx: int = 0) -> Any:
+        """Инференс"""
+        x, y, target, path = batch
+        y_hat = self(x)
+        yp_clf = y_hat[:, 0:1]
+        yp_reg = y_hat[:, 1:]
+        y_pred = torch.sigmoid(yp_clf)
+
+        return {
+            "y": y,
+            "y_pred": torch.round(y_pred),
+            "y_prob": y_pred,
+            "y_reg": yp_reg,
+            "target": target,
+        }

full_model/rnn_train.py

@@ -0,0 +1,418 @@
+# full_model/rnn_train.py
+import os
+import glob
+from typing import Any
+
+import click
+import lightning.pytorch as pl
+import torch
+from lightning.pytorch.callbacks import LearningRateMonitor, ModelCheckpoint
+from lightning.pytorch.loggers import TensorBoardLogger
+from pytorchvideo.transforms import Normalize, Permute, RandAugment
+from torch.utils.data import DataLoader, WeightedRandomSampler
+from torchvision.transforms import transforms as T
+from torchvision.transforms._transforms_video import ToTensorVideo
+from torchvision.transforms import InterpolationMode
+
+from full_model.rnn_dataset import SyntaxDataset
+from full_model.rnn_model import SyntaxLightningModule
+
+torch.set_float32_matmul_precision("medium")
+
+
+def get_transforms(video_size, imagenet_mean, imagenet_std, train: bool = True):
+    """Аугментации/преобразования для клипов."""
+    interpolation_choices = [InterpolationMode.BILINEAR, InterpolationMode.BICUBIC]
+
+    if train:
+        return T.Compose([
+            ToTensorVideo(),
+            Permute(dims=[1, 0, 2, 3]),  # (C, T, H, W) -> (T, C, H, W)
+            RandAugment(magnitude=10, num_layers=2),
+            T.RandomHorizontalFlip(),
+            Permute(dims=[1, 0, 2, 3]),  # обратно (C, T, H, W)
+            T.RandomChoice([
+                T.Resize(size=video_size, interpolation=interp, antialias=True)
+                for interp in interpolation_choices
+            ]),
+            Normalize(mean=imagenet_mean, std=imagenet_std),
+        ])
+    else:
+        return T.Compose([
+            ToTensorVideo(),
+            T.Resize(size=video_size, interpolation=InterpolationMode.BICUBIC, antialias=True),
+            Normalize(mean=imagenet_mean, std=imagenet_std),
+        ])
+
+
+def make_dataloader(dataset, batch_size: int, num_workers: int, use_weighted_sampler: bool):
+    """DataLoader c опциональным WeightedRandomSampler по score."""
+    if use_weighted_sampler:
+        sample_weights = dataset.get_sample_weights().cpu()
+        sampler = WeightedRandomSampler(sample_weights, num_samples=len(dataset), replacement=True)
+        shuffle = False
+    else:
+        sampler = None
+        shuffle = False
+
+    return DataLoader(
+        dataset,
+        batch_size=batch_size,
+        num_workers=num_workers,
+        sampler=sampler,
+        shuffle=shuffle,
+        drop_last=True,
+        pin_memory=True,
+        persistent_workers=(num_workers > 0),
+    )
+
+
+def make_model(
+    num_classes: int,
+    lr: float,
+    variant: str,
+    weight_decay: float,
+    max_epochs: int,
+    weight_path: str | None = None,
+    pl_weight_path: str | None = None,
+    pt_weights_format: bool = False,
+) -> SyntaxLightningModule:
+    """
+    Создание head‑модели.
+
+    weight_path      — pretrain для backbone (r3d_18), .pt или .ckpt.
+    pl_weight_path   — полный чекпоинт head‑модели (Lightning .ckpt или raw .pt).
+    pt_weights_format=True  → pl_weight_path — raw state_dict (.pt).
+    pt_weights_format=False → pl_weight_path — Lightning .ckpt с 'state_dict'.
+    """
+    return SyntaxLightningModule(
+        num_classes=num_classes,
+        lr=lr,
+        variant=variant,
+        weight_decay=weight_decay,
+        max_epochs=max_epochs,
+        weight_path=weight_path,
+        pl_weight_path=pl_weight_path,
+        yulie_model=pt_weights_format,  # параметр модели
+    )
+
+
+def make_callbacks(phase: str):
+    """Callback'и: LR‑монитор + ModelCheckpoint по val_rmse."""
+    lr_monitor = LearningRateMonitor(logging_interval="epoch")
+
+    if phase == "pre":
+        checkpoint = ModelCheckpoint(
+            monitor="val_rmse",
+            save_top_k=1,
+            mode="min",
+            filename="rnn_model-{epoch:02d}-{val_rmse:.3f}",
+            save_last=True,
+        )
+    elif phase == "full":
+        checkpoint = ModelCheckpoint(
+            monitor="val_rmse",
+            save_top_k=3,
+            mode="min",
+            filename="rnn_model-{epoch:02d}-{val_rmse:.3f}",
+            save_last=True,
+        )
+    else:
+        raise ValueError(f"Unknown phase '{phase}', expected 'pre' or 'full'")
+
+    return [lr_monitor, checkpoint]
+
+
+def make_trainer(max_epochs: int, logdir: str, logger_name: str, devices: list[int], precision: str, callbacks):
+    """Создание Trainer с TensorBoard‑логгером."""
+    logger = TensorBoardLogger(save_dir=logdir, name=logger_name)
+    strategy = "ddp_find_unused_parameters_true" if len(devices) > 1 else "auto"
+
+    trainer = pl.Trainer(
+        max_epochs=max_epochs,
+        accelerator="gpu" if torch.cuda.is_available() else "cpu",
+        devices=devices,
+        strategy=strategy,
+        precision=precision,
+        callbacks=callbacks,
+        log_every_n_steps=10,
+        logger=logger,
+    )
+    return trainer
+
+
+def find_backbone_ckpt_lightning(backbone_logdir: str, artery: str, fold: int, phase: str = "full") -> str:
+    """
+    Ищет Lightning‑чекпоинт backbone в каталоге логов.
+
+    Ожидаемая структура:
+      backbone_logdir/
+        {artery}BinSyntax_R3D_{phase}_foldXX/version_*/checkpoints/*.ckpt
+    """
+    logger_name = f"{artery}BinSyntax_R3D_{phase}_fold{fold:02d}"
+    pattern = os.path.join(backbone_logdir, logger_name, "version_*/checkpoints", "*.ckpt")
+    ckpts = glob.glob(pattern)
+    if not ckpts:
+        raise FileNotFoundError(
+            f"No backbone Lightning checkpoints found for\n"
+            f"  artery={artery}, fold={fold}, phase={phase}\n"
+            f"  in '{backbone_logdir}' (pattern: {pattern})"
+        )
+    best = max(ckpts, key=os.path.getctime)
+    print(f"[Backbone] Using Lightning checkpoint: {best}")
+    return best
+
+
+def build_backbone_pt_path(backbone_pt_dir: str, artery: str, fold: int) -> str:
+    """
+    Строит путь к .pt‑файлу backbone по соглашению:
+      rightBinSyntax_R3D_full_fold00.pt
+      leftBinSyntax_R3D_full_fold00.pt
+      ...
+    """
+    fname = f"{artery}BinSyntax_R3D_full_fold{fold:02d}.pt"
+    path = os.path.join(backbone_pt_dir, fname)
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"Backbone .pt not found for artery={artery}, fold={fold} in '{backbone_pt_dir}'\n"
+            f"Expected file: {fname}"
+        )
+    print(f"[Backbone] Using .pt file: {path}")
+    return path
+
+
+@click.command()
+@click.option(
+    "-r",
+    "--dataset-root",
+    type=click.Path(exists=True),
+    default=".",
+    show_default=True,
+    help="Корень датасета (JSON и DICOM‑пути считаются относительно него).",
+)
+@click.option("--fold", type=int, default=4, show_default=True, help="Fold number.")
+@click.option(
+    "-a",
+    "--artery",
+    type=str,
+    default="right",
+    show_default=True,
+    help="Артерия: left или right.",
+)
+@click.option(
+    "--variant",
+    type=str,
+    default="lstm_mean",
+    show_default=True,
+    help="Вариант head‑модели: mean_out, mean, lstm_mean, lstm_last, gru_mean, gru_last, bert_mean, bert_cls, bert_cls2.",
+)
+@click.option("-nc", "--num-classes", type=int, default=2, show_default=True,
+              help="Число выходов head‑модели (clf + reg).")
+@click.option("-b", "--batch-size", type=int, default=8, show_default=True, help="Batch size.")
+@click.option("-f", "--frames-per-clip", type=int, default=32, show_default=True,
+              help="Количество кадров в клипе.")
+@click.option(
+    "-v",
+    "--video-size",
+    type=click.Tuple([int, int]),
+    default=(256, 256),
+    show_default=True,
+    help="Размер кадра (H, W).",
+)
+@click.option("--max-epochs", type=int, default=10, show_default=True, help="Число эпох full train.")
+@click.option("--num-workers", type=int, default=16, show_default=True, help="DataLoader workers.")
+@click.option(
+    "--devices",
+    type=list[int],
+    multiple=True,
+    default=[0],
+    show_default=True,
+    help="Список GPU id",
+)
+@click.option("--precision", type=str, default="bf16-mixed", show_default=True, help="Режим числовой точности.")
+@click.option(
+    "--logdir",
+    type=click.Path(),
+    default="./logs/rnn",
+    show_default=True,
+    help="Каталог для логов и чекпоинтов head‑модели.",
+)
+@click.option(
+    "--backbone-logdir",
+    type=click.Path(exists=True),
+    default=None,
+    help="Каталог с логами backbone (Lightning .ckpt).",
+)
+@click.option(
+    "--backbone-pt-dir",
+    type=click.Path(exists=True),
+    default="backbone_weights",
+    show_default=True,
+    help="Каталог с .pt‑файлами backbone (rightBinSyntax_R3D_full_foldXX.pt, leftBinSyntax_R3D_full_foldXX.pt).",
+)
+@click.option(
+    "--backbone-from-pt",
+    is_flag=True,
+    default=True,
+    show_default=True,
+    help="Если включено — backbone берётся из .pt в backbone-pt-dir, иначе из Lightning‑логов backbone-logdir.",
+)
+@click.option(
+    "--rnn-folds-dir",
+    type=click.Path(),
+    default="rnn_folds",
+    show_default=True,
+    help="Каталог с rnn_folds (относительно dataset_root).",
+)
+@click.option(
+    "--use-weighted-sampler",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Использовать ли WeightedRandomSampler по score.",
+)
+@click.option(
+    "--pt-weights-format",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Формат pl_weight_path для full‑трейна: True → .pt (raw state_dict), False → Lightning .ckpt.",
+)
+@click.option("--seed", type=int, default=42, show_default=True, help="Random seed.")
+def main(
+    dataset_root: str,
+    fold: int,
+    artery: str,
+    variant: str,
+    num_classes: int,
+    batch_size: int,
+    frames_per_clip: int,
+    video_size: Any,
+    max_epochs: int,
+    num_workers: int,
+    devices: int,
+    precision: str,
+    logdir: str,
+    backbone_logdir: str | None,
+    backbone_pt_dir: str | None,
+    backbone_from_pt: bool,
+    rnn_folds_dir: str,
+    use_weighted_sampler: bool,
+    pt_weights_format: bool,
+    seed: int,
+):
+    """Обучение RNN‑head поверх backbone."""
+    VARIANTS = "mean_out mean lstm_mean lstm_last gru_mean gru_last bert_mean bert_cls bert_cls2".split()
+    if variant not in VARIANTS:
+        raise ValueError(f"Unknown variant '{variant}', expected one of: {VARIANTS}")
+
+    artery = artery.lower()
+    if artery not in ("left", "right"):
+        raise ValueError(f"Unknown artery '{artery}', expected 'left' or 'right'")
+
+    pl.seed_everything(seed)
+
+    imagenet_mean = [0.485, 0.456, 0.406]
+    imagenet_std = [0.229, 0.224, 0.225]
+
+    train_meta = os.path.join(rnn_folds_dir, f"rnn_fold{fold:02d}_train.json")
+    eval_meta = os.path.join(rnn_folds_dir, f"rnn_fold{fold:02d}_eval.json")
+
+    train_set = SyntaxDataset(
+        root=dataset_root,
+        meta=train_meta,
+        train=True,
+        length=frames_per_clip,
+        label=f"syntax_{artery}",
+        artery=artery,
+        inference=False,
+        validation=True,
+        transform=get_transforms(video_size, imagenet_mean, imagenet_std, train=True),
+    )
+
+    val_set = SyntaxDataset(
+        root=dataset_root,
+        meta=eval_meta,
+        train=False,
+        length=frames_per_clip,
+        label=f"syntax_{artery}",
+        artery=artery,
+        inference=False,
+        validation=True,
+        transform=get_transforms(video_size, imagenet_mean, imagenet_std, train=False),
+    )
+
+    train_loader_pre = make_dataloader(train_set, batch_size * 2, num_workers, use_weighted_sampler)
+    train_loader_post = make_dataloader(train_set, batch_size, num_workers, use_weighted_sampler)
+    val_loader = make_dataloader(val_set, 1, num_workers, use_weighted_sampler=False)
+
+    x, *_ = next(iter(train_loader_pre))
+    video_shape = x.shape[2:]
+    print(f"RNN head input per clip: {video_shape}")
+
+    # Выбор источника backbone
+    if backbone_from_pt:
+        if backbone_pt_dir is None:
+            raise ValueError("backbone-from-pt=True, но backbone-pt-dir не указан.")
+        backbone_weight_path = build_backbone_pt_path(backbone_pt_dir, artery=artery, fold=fold)
+    else:
+        if backbone_logdir is None:
+            raise ValueError("backbone-from-pt=False, но backbone-logdir не указан.")
+        backbone_weight_path = find_backbone_ckpt_lightning(
+            backbone_logdir=backbone_logdir,
+            artery=artery,
+            fold=fold,
+            phase="full",
+        )
+
+    # Pretrain head (замороженный backbone)
+    callbacks_pre = make_callbacks(phase="pre")
+
+    model_pre = make_model(
+        num_classes=num_classes,
+        lr=1e-4,
+        variant=variant,
+        weight_decay=0.01,
+        max_epochs=max_epochs,
+        weight_path=backbone_weight_path,
+        pl_weight_path=None,
+        pt_weights_format=False,
+    )
+
+    trainer_pre = make_trainer(
+        max_epochs=max_epochs,
+        logdir=logdir,
+        logger_name=f"{artery}BinSyntax_R3D_fold{fold:02d}_{variant}_pre",
+        devices=devices,
+        precision=precision,
+        callbacks=callbacks_pre,
+    )
+    trainer_pre.fit(model_pre, train_dataloaders=train_loader_pre, val_dataloaders=val_loader)
+
+    # Full train head
+    callbacks_full = make_callbacks(phase="full")
+
+    model_full = make_model(
+        num_classes=num_classes,
+        lr=2e-5,
+        variant=variant,
+        weight_decay=0.01,
+        max_epochs=max_epochs,
+        weight_path=None,
+        pl_weight_path=trainer_pre.checkpoint_callback.best_model_path,
+        pt_weights_format=pt_weights_format,
+    )
+
+    trainer_full = make_trainer(
+        max_epochs=max_epochs,
+        logdir=logdir,
+        logger_name=f"{artery}BinSyntax_R3D_fold{fold:02d}_{variant}_post",
+        devices=devices,
+        precision=precision,
+        callbacks=callbacks_full,
+    )
+    trainer_full.fit(model_full, train_dataloaders=train_loader_post, val_dataloaders=val_loader)
+
+
+if __name__ == "__main__":
+    main()

full_model_weights/LeftBinSyntax_R3D_fold00_lstm_mean_post_best.pt

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

full_model_weights/LeftBinSyntax_R3D_fold01_lstm_mean_post_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e8132d382b352afd22bb3fe3e1d4d7e3a9781f8a927018db9bc5085d0e8d109
+size 133809489

full_model_weights/LeftBinSyntax_R3D_fold02_lstm_mean_post_best.pt

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

full_model_weights/LeftBinSyntax_R3D_fold03_lstm_mean_post_best.pt

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

full_model_weights/LeftBinSyntax_R3D_fold04_lstm_mean_post_best.pt

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

full_model_weights/RightBinSyntax_R3D_fold00_lstm_mean_post_best.pt

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

full_model_weights/RightBinSyntax_R3D_fold01_lstm_mean_post_best.pt

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

full_model_weights/RightBinSyntax_R3D_fold02_lstm_mean_post_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59b3b3719e67aed73e8d087f1e748da852f7c30a390610d4b4f676d60fbc3f89
+size 133809614

full_model_weights/RightBinSyntax_R3D_fold03_lstm_mean_post_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15adb5ce5a9f3473dfcead2ac841c3c3e83ef9ad46dea9d4fa7f373e3b0df7c5
+size 133809614

full_model_weights/RightBinSyntax_R3D_fold04_lstm_mean_post_best.pt

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

inference/metrics_visualization.py

@@ -0,0 +1,426 @@
+"""
+SYNTAX predictions visualization:
+- points (SYNTAX ground truth vs model predictions) for multiple datasets;
+- risk zones (low / high risk);
+- ±σ and ±2σ bands around the diagonal;
+- logistic trends for each dataset.
+
+The script is independent of PyTorch/Lightning and is used at inference time.
+Output is saved to the `visualizations/` folder inside the project.
+"""
+
+import os
+import numpy as np
+import plotly.graph_objects as go
+from scipy.optimize import curve_fit  # type: ignore
+
+
+# ================= GLOBAL STYLE CONSTANTS =================
+
+DATA_MIN = 0.0
+DATA_MAX = 60.0
+PADDING = 0.5
+
+SIGMA_SLOPE = 0.15
+SIGMA_BASE = 1.4
+SIGMA_POINTS = 400
+TREND_POINTS = 500
+
+PLOT_WIDTH = 980
+PLOT_HEIGHT = 980
+
+# Fonts
+FONT_FAMILY = "Inter, Roboto, Helvetica Neue, Arial, sans-serif"
+BASE_FONT_SIZE = 20
+TITLE_FONT_SIZE = 26
+AXIS_TITLE_FONT_SIZE = 32
+AXIS_TICK_FONT_SIZE = 30
+LEGEND_FONT_SIZE = 20
+
+# Markers / lines
+MARKER_SIZE = 15
+MARKER_LINE_WIDTH = 1.5
+LINE_WIDTH = 3
+TREND_LINE_WIDTH = 3.5
+
+# Colors
+PLOT_BG_COLOR = "rgba(235,238,245,1)"
+PAPER_BG_COLOR = "white"
+LEGEND_BG_COLOR = "rgba(255,255,255,0.45)"
+GRID_COLOR = "rgba(100,116,139,0.18)"
+
+# Layout
+MARGIN_LEFT = 100
+MARGIN_RIGHT = 15
+MARGIN_TOP = 0
+MARGIN_BOTTOM = 100
+
+LEGEND_X = 0.008
+LEGEND_Y = 0.985
+
+COLORS = ["#1E88E5", "#8E24AA", "#A0D137", "#EA1D1D", "#06EE0D", "#FB8C00"]
+SYMBOLS = ["circle", "x", "square", "diamond", "triangle-up", "star"]
+
+
+def _logistic_time(t, R0, Rmax, t50, k):
+    """Logistic function over SYNTAX score."""
+    t = np.asarray(t, dtype=float)
+    t_safe = np.where(t <= 0, 1e-3, t)
+    return R0 + (Rmax - R0) / (1.0 + (t50 / t_safe) ** k)
+
+
+def _fit_logistic(x, y, domain, n=TREND_POINTS):
+    """
+    Fit logistic curve.
+    Returns X, Y or (None, None) if the fit fails.
+    """
+    x = np.asarray(x, dtype=float)
+    y = np.asarray(y, dtype=float)
+    m = np.isfinite(x) & np.isfinite(y)
+    if m.sum() < 4:
+        return None, None
+
+    x_m, y_m = x[m], y[m]
+    x_min = max(float(np.min(x_m)), float(domain[0]))
+    x_max = min(float(np.max(x_m)), float(domain[1]))
+    if not np.isfinite(x_min) or not np.isfinite(x_max) or x_max <= x_min:
+        return None, None
+
+    x_pos = x_m[x_m > 0]
+    if x_pos.size == 0:
+        return None, None
+
+    R0_init = float(np.percentile(y_m, 10))
+    Rmax_init = float(np.percentile(y_m, 90))
+    t50_init = float(np.median(x_pos))
+    k_init = 1.0
+
+    lower = [-10.0, 0.0, 1e-3, 0.01]
+    upper = [60.0, 80.0, 60.0, 10.0]
+
+    try:
+        popt, _ = curve_fit(
+            _logistic_time,
+            x_m,
+            y_m,
+            p0=[R0_init, Rmax_init, t50_init, k_init],
+            bounds=(lower, upper),
+            maxfev=20000,
+        )
+    except Exception:
+        return None, None
+
+    X = np.linspace(x_min, x_max, n)
+    Y = _logistic_time(X, *popt)
+    return X, Y
+
+
+def visualize_final_syntax_plotly_multi(
+    datasets,
+    r2_values,      # Pearson per dataset
+    gt_row,
+    postfix=None,
+    threshold: float = 22.0,
+    recall_values=None,
+    backbone: bool = False,
+    show_title: bool = False,
+):
+    """
+    Unified SYNTAX visualization: points, risk zones and logistic trends.
+
+    Parameters
+    ----------
+    datasets : dict[str, tuple[list[float], list[float]]]
+        {dataset_name: (syntax_true_list, syntax_pred_list)}.
+    r2_values : dict[str, float]
+        Pearson correlation per dataset.
+    gt_row : str
+        String for the plot title (e.g. "ENSEMBLE" or "BOTH").
+    postfix : str | None
+        Suffix for the saved file name.
+    threshold : float
+        SYNTAX threshold (typically 22.0) to separate risk zones.
+    recall_values : dict[str, float] | None
+        Mean recall per dataset (may be None).
+    backbone : bool
+        If True, saves into `visualizations/backbone`, else into `visualizations/`.
+    """
+    fig = go.Figure()
+
+    line_min = DATA_MIN - PADDING
+    line_max = DATA_MAX + PADDING
+    domain = (line_min, line_max)
+
+    base_font = dict(
+        family=FONT_FAMILY,
+        size=BASE_FONT_SIZE,
+    )
+
+    # ---------- Risk zones and bands (legendrank=0) ----------
+    fig.add_trace(
+        go.Scatter(
+            x=[line_min, threshold, threshold, line_min],
+            y=[line_min, line_min, threshold, threshold],
+            fill="toself",
+            fillcolor="rgba(255, 82, 82, 0.12)",
+            line=dict(color="rgba(0,0,0,0)"),
+            name="Low-risk zone",
+            legendgroup="zones",
+            legendgrouptitle_text="Thresholds & lines",
+            showlegend=True,
+            hoverinfo="skip",
+            legendrank=0,
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=[threshold, line_max, line_max, threshold],
+            y=[threshold, threshold, line_max, line_max],
+            fill="toself",
+            fillcolor="rgba(76, 175, 80, 0.14)",
+            line=dict(color="rgba(0,0,0,0)"),
+            name="High-risk zone",
+            legendgroup="zones",
+            showlegend=True,
+            hoverinfo="skip",
+            legendrank=0,
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=[threshold, threshold, None, line_min, line_max],
+            y=[line_min, line_max, None, threshold, threshold],
+            mode="lines",
+            name=f"SYNTAX = {threshold}",
+            legendgroup="zones",
+            showlegend=True,
+            line=dict(color="rgba(46,125,50,0.85)", width=LINE_WIDTH, dash="dash"),
+            legendrank=0,
+            hoverinfo="skip",
+        )
+    )
+
+    x_vals = np.linspace(line_min, line_max, SIGMA_POINTS)
+    sigma_upper = x_vals + SIGMA_BASE + SIGMA_SLOPE * x_vals
+    sigma_lower = x_vals - SIGMA_BASE - SIGMA_SLOPE * x_vals
+    two_sigma_upper = x_vals + 2 * SIGMA_BASE + 2 * SIGMA_SLOPE * x_vals
+    two_sigma_lower = x_vals - 2 * SIGMA_BASE - 2 * SIGMA_SLOPE * x_vals
+
+    fig.add_trace(
+        go.Scatter(
+            x=np.concatenate([x_vals, x_vals[::-1]]),
+            y=np.concatenate([two_sigma_lower, two_sigma_upper[::-1]]),
+            fill="toself",
+            fillcolor="rgba(255,193,7,0.18)",
+            line=dict(color="rgba(0,0,0,0)"),
+            name="± 2σ",
+            legendgroup="zones",
+            showlegend=True,
+            hoverinfo="skip",
+            legendrank=0,
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=np.concatenate([x_vals, x_vals[::-1]]),
+            y=np.concatenate([sigma_lower, sigma_upper[::-1]]),
+            fill="toself",
+            fillcolor="rgba(255,152,0,0.30)",
+            line=dict(color="rgba(0,0,0,0)"),
+            name="± σ",
+            legendgroup="zones",
+            showlegend=True,
+            hoverinfo="skip",
+            legendrank=0,
+        )
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=[line_min, line_max],
+            y=[line_min, line_max],
+            mode="lines",
+            name="Perfect prediction",
+            legendgroup="zones",
+            showlegend=True,
+            line=dict(color="rgba(30,30,30,0.85)", width=LINE_WIDTH),
+            legendrank=0,
+        )
+    )
+
+    # ---------- Datasets (legendrank=20) ----------
+    first_dataset = True
+    for i, (label, (syntax_true, syntax_pred)) in enumerate(datasets.items()):
+        x = np.array(syntax_true, dtype=float)
+        y = np.array(syntax_pred, dtype=float)
+        if x.size == 0 or y.size == 0:
+            continue
+
+        pearson = r2_values.get(label, None)
+        recall = recall_values.get(label, None) if recall_values else None
+        hover_lines = [f"<b>{label}</b>"]
+        if pearson is not None:
+            hover_lines.append(f"Pearson = {pearson:.3f}")
+        if recall is not None:
+            hover_lines.append(f"Mean recall = {recall:.3f}")
+        hovertemplate = (
+            "<br>".join(hover_lines)
+            + "<br>Ground truth: %{x:.3f}<br>Prediction: %{y:.3f}<extra></extra>"
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=y,
+                mode="markers",
+                name=label,
+                legendgroup="datasets",
+                legendgrouptitle_text=("Datasets" if first_dataset else None),
+                showlegend=True,
+                marker=dict(
+                    color=COLORS[i % len(COLORS)],
+                    size=MARKER_SIZE,
+                    opacity=0.96,
+                    symbol=SYMBOLS[i % len(SYMBOLS)],
+                    line=dict(
+                        width=MARKER_LINE_WIDTH,
+                        color="rgba(255,255,255,0.95)",
+                    ),
+                ),
+                hovertemplate=hovertemplate,
+                legendrank=20,
+            )
+        )
+        first_dataset = False
+
+    # ---------- Logistic trends (legendrank=30) ----------
+    first_trend = True
+    for i, (label, (syntax_true, syntax_pred)) in enumerate(datasets.items()):
+        x = np.array(syntax_true, dtype=float)
+        y = np.array(syntax_pred, dtype=float)
+        if x.size == 0 or y.size == 0:
+            continue
+
+        Xc, Yc = _fit_logistic(x, y, domain=domain)
+        if Xc is not None:
+            fig.add_trace(
+                go.Scatter(
+                    x=Xc,
+                    y=Yc,
+                    mode="lines",
+                    name=label,
+                    legendgroup="trends",
+                    legendgrouptitle_text=("Logistic trends" if first_trend else None),
+                    showlegend=True,
+                    line=dict(
+                        color=COLORS[i % len(COLORS)],
+                        width=TREND_LINE_WIDTH,
+                    ),
+                    hoverinfo="skip",
+                    legendrank=30,
+                )
+            )
+            first_trend = False
+
+    # ---------- Layout ----------
+    # title_text формируем как раньше, но применяем только если show_title=True
+    title_text = f"SYNTAX predictions ({gt_row})"
+    if postfix:
+        title_text += f" {postfix}"
+
+    layout_kwargs = dict(
+        font=dict(
+            family=FONT_FAMILY,
+            size=BASE_FONT_SIZE,
+        ),
+        width=PLOT_WIDTH,
+        height=PLOT_HEIGHT,
+        plot_bgcolor=PLOT_BG_COLOR,
+        paper_bgcolor=PAPER_BG_COLOR,
+        legend=dict(
+            x=LEGEND_X,
+            y=LEGEND_Y,
+            bgcolor=LEGEND_BG_COLOR,     # полупрозрачный белый фон [web:143]
+            bordercolor="rgba(203,213,225,0.7)",  # тоже чуть прозрачная рамка (по желанию) [web:145]
+            borderwidth=1,
+            font=dict(size=LEGEND_FONT_SIZE, family=FONT_FAMILY),
+            tracegroupgap=8,
+            itemclick="toggle",
+            itemdoubleclick="toggleothers",
+            groupclick="toggleitem",
+        ),
+        xaxis=dict(
+            title=dict(
+                text="SYNTAX ground truth",
+                font=dict(
+                    size=AXIS_TITLE_FONT_SIZE,
+                    family=FONT_FAMILY,
+                    color="rgba(15,23,42,1)",
+                ),
+            ),
+            showgrid=True,
+            gridcolor=GRID_COLOR,
+            gridwidth=1,
+            zeroline=False,
+            tickfont=dict(
+                size=AXIS_TICK_FONT_SIZE,
+                family=FONT_FAMILY,
+            ),
+            range=[line_min, line_max],
+            constrain="domain",
+        ),
+        yaxis=dict(
+            title=dict(
+                text="SYNTAX predictions",
+                font=dict(
+                    size=AXIS_TITLE_FONT_SIZE,
+                    family=FONT_FAMILY,
+                    color="rgba(15,23,42,1)",
+                ),
+            ),
+            showgrid=True,
+            gridcolor=GRID_COLOR,
+            gridwidth=1,
+            zeroline=False,
+            tickfont=dict(
+                size=AXIS_TICK_FONT_SIZE,
+                family=FONT_FAMILY,
+            ),
+            range=[line_min, line_max],
+            scaleanchor="x",
+            scaleratio=1,
+            constrain="domain",
+        ),
+        margin=dict(
+            l=MARGIN_LEFT,
+            r=MARGIN_RIGHT,
+            t=MARGIN_TOP,
+            b=MARGIN_BOTTOM,
+        ),
+    )
+
+    if show_title:
+        layout_kwargs["title"] = dict(
+            text=title_text,
+            x=0.5,
+            xanchor="center",
+            font=dict(
+                size=TITLE_FONT_SIZE,
+                family=FONT_FAMILY,
+                color="rgba(15,23,42,1)",
+            ),
+        )
+
+    fig.update_layout(**layout_kwargs)
+
+    # ---------- Saving ----------
+    save_dir = "visualizations"
+    if backbone:
+        save_dir = os.path.join(save_dir, "backbone")
+    os.makedirs(save_dir, exist_ok=True)
+
+    postfix_html = f"{postfix}" if postfix else "syntax"
+    save_path_html = os.path.join(save_dir, f"{postfix_html}.html")
+    fig.write_html(save_path_html, include_mathjax="cdn")
+    print(f"Saved visualization with logistic trends: {save_path_html}")

inference/rnn_apply.py

@@ -0,0 +1,344 @@
+# inference/rnn_apply.py
+import os
+import json
+import tqdm
+import torch
+import numpy as np
+import click
+from datetime import datetime
+import lightning.pytorch as pl
+import sklearn.metrics as skm
+
+from torch.utils.data import DataLoader
+from torchvision.transforms import transforms as T
+from torchvision.transforms._transforms_video import ToTensorVideo
+from pytorchvideo.transforms import Normalize
+
+from full_model.rnn_dataset import SyntaxDataset
+from full_model.rnn_model import SyntaxLightningModule
+from inference.metrics_visualization import visualize_final_syntax_plotly_multi
+
+
+DEVICE = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")
+print(f"DEVICE: {DEVICE}")
+
+
+def safe_sample_std(values):
+    """Sample std (ddof=1). Если значение одно/пусто — 0.0."""
+    arr = np.array(values, dtype=float)
+    if arr.size <= 1:
+        return 0.0
+    return float(arr.std(ddof=1))
+
+
+def compute_metrics(y_true, y_pred, thr=22.0):
+    """Pearson и Mean_Recall."""
+    y_true_arr = np.array(y_true, dtype=float)
+    y_pred_arr = np.array(y_pred, dtype=float)
+
+    pearson = float(np.corrcoef(y_true_arr, y_pred_arr)[0, 1]) if len(y_true_arr) > 1 else 0.0
+
+    y_true_bin = (y_true_arr >= thr).astype(int)
+    y_pred_bin = (y_pred_arr >= thr).astype(int)
+    unique_classes = np.unique(np.concatenate([y_true_bin, y_pred_bin]))
+    mean_recall = float(
+        np.mean(skm.recall_score(y_true_bin, y_pred_bin, average=None, labels=[0, 1]))
+    ) if len(unique_classes) > 1 else 0.0
+
+    return pearson, mean_recall
+
+
+@click.command()
+@click.option("-d", "--dataset-paths", multiple=True,
+              help="JSON с метаданными датасетов (относительно dataset_root).")
+@click.option("-n", "--dataset-names", multiple=True,
+              help="Имена датасетов для метрик/графиков.")
+@click.option("-p", "--postfixes", multiple=True,
+              help="Суффиксы для файлов предсказаний.")
+@click.option(
+    "-r",
+    "--dataset-root",
+    type=click.Path(exists=True),
+    default=".",
+    show_default=True,
+    help="Корень датасета (где лежат JSON и DICOM).",
+)
+@click.option(
+    "--model-dir",
+    type=click.Path(exists=True),
+    default="full_model_weights",
+    show_default=True,
+    help="Каталог с .pt/.ckpt весами full‑моделей (RNN‑head + backbone).",
+)
+@click.option("-v", "--video-size", type=click.Tuple([int, int]), default=(256, 256),
+              show_default=True, help="Размер видео (H, W).")
+@click.option("--frames-per-clip", type=int, default=32,
+              show_default=True, help="Количество кадров в клипе.")
+@click.option("--num-workers", type=int, default=8,
+              show_default=True, help="Число DataLoader workers.")
+@click.option("--seed", type=int, default=42,
+              show_default=True, help="Random seed.")
+@click.option(
+    "--pt-weights-format",
+    is_flag=True,
+    default=True,
+    show_default=True,
+    help="Формат весов full‑моделей: True → .pt (raw state_dict), False → Lightning .ckpt.",
+)
+@click.option("--use-scaling", is_flag=True, default=False,
+              show_default=True, help="Применить a*x+b scaling из JSON.")
+@click.option("--scaling-file",
+              help="JSON с коэффициентами scaling (относительно dataset_root).")
+@click.option(
+    "--variant",
+    type=str,
+    default="lstm_mean",
+    show_default=True,
+    help="Вариант head‑модели: mean, lstm_mean, lstm_last, gru_mean, gru_last, bert_mean, bert_cls, bert_cls2.",
+)
+@click.option("-e", "--ensemble-name",
+              help="Имя ансамбля в metrics.json.")
+@click.option("-m", "--metrics-file",
+              help="JSON с метриками экспериментов.")
+def main(dataset_paths, dataset_names, postfixes, dataset_root, model_dir, video_size,
+         frames_per_clip, num_workers, seed, pt_weights_format, use_scaling,
+         scaling_file, variant, ensemble_name, metrics_file):
+
+    pl.seed_everything(seed)
+    postfix_plotly = "Ensemble"
+
+    # Пути к моделям берутся из model_dir по шаблону
+    model_paths = {
+        "left": [
+            os.path.join(model_dir, f"LeftBinSyntax_R3D_fold{fold:02d}_{variant}_post_best.pt")
+            for fold in range(5)
+        ],
+        "right": [
+            os.path.join(model_dir, f"RightBinSyntax_R3D_fold{fold:02d}_{variant}_post_best.pt")
+            for fold in range(5)
+        ],
+    }
+
+    scaling_params_dict = {}
+    if use_scaling:
+        postfix_plotly += "_scaled"
+        ensemble_name += "_scaled"
+        scaling_path = os.path.join(dataset_root, scaling_file)
+        if os.path.exists(scaling_path):
+            with open(scaling_path, "r") as f:
+                scaling_params_dict = json.load(f)
+            print(f"Loaded scaling from {scaling_path}")
+        else:
+            print(f"⚠️ Scaling file not found: {scaling_path}")
+
+    ensemble_results = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "use_scaling": use_scaling,
+        "pt_weights_format": pt_weights_format,
+        "variant": variant,
+        "datasets": {},
+    }
+
+    all_datasets, all_pearson, all_recalls = {}, {}, {}
+
+    # вспомогательная функция для получения (a, b)
+    def get_ab(i: int):
+        params = scaling_params_dict.get(f"fold{i}", (1.0, 0.0))
+        if isinstance(params, dict):
+            return params.get("a", 1.0), params.get("b", 0.0)
+        return params[0], params[1]
+
+    for dataset_path, dataset_name, postfix in zip(dataset_paths, dataset_names, postfixes):
+        abs_dataset_path = os.path.join(dataset_root, dataset_path)
+        results_file = os.path.join("results", f"{postfix}.json")
+
+        if os.path.exists(results_file):
+            print(f"[{postfix}] Loading from {results_file}")
+            with open(results_file, "r") as f:
+                data = json.load(f)
+            syntax_true = data["syntax_true"]
+            left_preds_all = data["left_preds"]
+            right_preds_all = data["right_preds"]
+        else:
+            print(f"[{postfix}] Computing predictions...")
+            left_preds_all, left_sids = run_artery(
+                abs_dataset_path, "left", model_paths["left"],
+                video_size, frames_per_clip, num_workers,
+                variant=variant, pt_weights_format=pt_weights_format,
+            )
+            right_preds_all, right_sids = run_artery(
+                abs_dataset_path, "right", model_paths["right"],
+                video_size, frames_per_clip, num_workers,
+                variant=variant, pt_weights_format=pt_weights_format,
+            )
+            assert left_sids == right_sids
+
+            with open(abs_dataset_path, "r") as f:
+                dataset = json.load(f)
+            syntax_true = [rec.get("mean_syntax", rec.get("syntax")) for rec in dataset]
+
+            os.makedirs(os.path.dirname(results_file), exist_ok=True)
+            save_data = {
+                "syntax_true": syntax_true,
+                "left_preds": left_preds_all,
+                "right_preds": right_preds_all,
+            }
+            with open(results_file, "w") as f:
+                json.dump(save_data, f)
+            print(f"[{postfix}] Saved to {results_file}")
+
+        # -------- ансамбль с/без scaling --------
+        if use_scaling:
+            syntax_pred = []
+            for l_list, r_list in zip(left_preds_all, right_preds_all):
+                scaled_folds = []
+                for i, (l_val, r_val) in enumerate(zip(l_list, r_list)):
+                    s = l_val + r_val
+                    a, b = get_ab(i)
+                    scaled_folds.append(a * s + b)
+                syntax_pred.append(max(0.0, float(np.mean(scaled_folds))))
+        else:
+            syntax_pred = [
+                max(0.0, float(np.mean([l + r for l, r in zip(l_list, r_list)])))
+                for l_list, r_list in zip(left_preds_all, right_preds_all)
+            ]
+
+        pearson, mean_recall = compute_metrics(syntax_true, syntax_pred)
+        print(f"[{postfix}] ENSEMBLE: Pearson={pearson:.4f}, Recall={mean_recall:.4f}")
+
+        # -------- per-fold метрики --------
+        n_folds = len(left_preds_all[0]) if left_preds_all else 0
+        fold_metrics = {metric: [] for metric in ["Pearson", "Mean_Recall"]}
+
+        for k in range(n_folds):
+            pred_k = []
+            for l_list, r_list in zip(left_preds_all, right_preds_all):
+                s = l_list[k] + r_list[k]
+                if use_scaling:
+                    a, b = get_ab(k)
+                    s = a * s + b
+                pred_k.append(max(0.0, float(s)))
+
+            fold_pearson, fold_recall = compute_metrics(syntax_true, pred_k)
+            for metric, value in zip(
+                fold_metrics.keys(),
+                [fold_pearson, fold_recall],
+            ):
+                fold_metrics[metric].append(value)
+
+        fold_summary = {
+            k: {"mean": float(np.mean(v)), "std": safe_sample_std(v), "values": v}
+            for k, v in fold_metrics.items()
+        }
+
+        all_datasets[dataset_name] = (syntax_true, syntax_pred)
+        all_pearson[dataset_name] = pearson
+        all_recalls[dataset_name] = mean_recall
+
+        ensemble_results["datasets"][dataset_name] = {
+            "Pearson": round(pearson, 4),
+            "Mean_Recall": round(mean_recall, 4),
+            "N_samples": len(syntax_true),
+            **{f"{k}_mean": round(v["mean"], 4) for k, v in fold_summary.items()},
+            **{f"{k}_std": round(v["std"], 4) for k, v in fold_summary.items()},
+            **{f"{k}_folds": [round(x, 4) for x in v["values"]] for k, v in fold_summary.items()},
+        }
+
+    metrics_path = metrics_file
+    full_history = {}
+    if os.path.exists(metrics_path):
+        try:
+            with open(metrics_path, "r") as f:
+                full_history = json.load(f)
+        except json.JSONDecodeError:
+            print("⚠️ Metrics file corrupted. Creating new.")
+
+    full_history[ensemble_name] = ensemble_results
+    with open(metrics_path, "w") as f:
+        json.dump(full_history, f, indent=4)
+    print(f"✅ Metrics saved: {metrics_path}")
+
+    visualize_final_syntax_plotly_multi(
+        datasets=all_datasets,
+        r2_values=all_pearson,      # здесь теперь Pearson
+        gt_row="ENSEMBLE",
+        postfix=postfix_plotly,
+        recall_values=all_recalls,
+    )
+
+
+def run_artery(dataset_path, artery, model_paths, video_size, frames_per_clip,
+               num_workers, variant: str, pt_weights_format: bool):
+    """Инференс для одной артерии (5 фолдов)."""
+    imagenet_mean = [0.485, 0.456, 0.406]
+    imagenet_std = [0.229, 0.224, 0.225]
+    test_transform = T.Compose([
+        ToTensorVideo(),
+        T.Resize(size=video_size, antialias=True),
+        Normalize(mean=imagenet_mean, std=imagenet_std),
+    ])
+
+    val_set = SyntaxDataset(
+        root=os.path.dirname(dataset_path),
+        meta=dataset_path,
+        train=False,
+        length=frames_per_clip,
+        label="",
+        artery=artery,
+        inference=True,
+        transform=test_transform,
+    )
+    val_loader = DataLoader(
+        val_set,
+        batch_size=1,
+        num_workers=num_workers,
+        shuffle=False,
+        pin_memory=True,
+    )
+    print(f"{artery} artery: {len(val_loader)} samples")
+
+    models = []
+    for path in model_paths:
+        if not os.path.exists(path):
+            print(f"⚠️ Model not found: {path}")
+            continue
+
+        model = SyntaxLightningModule(
+            num_classes=2,
+            lr=1e-5,
+            variant=variant,
+            weight_decay=0.001,
+            max_epochs=1,
+            weight_path=None,
+            pl_weight_path=path,
+            pt_weights_format=pt_weights_format,
+        )
+        model.to(DEVICE)
+        model.eval()
+        models.append(model)
+
+    if not models:
+        raise RuntimeError(f"No models loaded for {artery}")
+
+    preds_all, sids = [], []
+    with torch.no_grad():
+        for x, [y], [t], [sid] in tqdm.tqdm(val_loader, desc=f"{artery} infer"):
+            if len(x.shape) == 1:
+                val_syntax_list = [0.0] * len(models)
+            else:
+                x = x.to(DEVICE)
+                val_syntax_list = []
+                for model in models:
+                    y_hat = model(x)
+                    yp_reg = y_hat[:, 1:]
+                    val_log = yp_reg.squeeze(-1)
+                    val = float(torch.exp(val_log).cpu()) - 1.0
+                    val_syntax_list.append(val)
+            preds_all.append(val_syntax_list)
+            sids.append(sid)
+
+    return preds_all, sids
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,21 @@
+# Core ML/DL
+torch>=2.0.0
+torchvision>=0.15.0
+lightning>=2.1.0
+pytorchvideo @ git+https://github.com/facebookresearch/pytorchvideo@main#egg=pytorchvideo
+
+# Data processing
+numpy>=1.24.0
+scikit-learn>=1.3.0
+tqdm>=4.65.0
+pydicom>=2.4.0
+python-gdcm>=3.0.10
+
+# Visualization
+plotly>=5.17.0
+scipy>=1.11.0
+tensorboard>=2.9
+tensorboardX>=2.6
+
+# CLI & Utilities
+click>=8.1.0

scaling_coeffs/scaling_coeffs.json

@@ -0,0 +1,27 @@
+{
+    "fold0": {
+        "a": 1.65,
+        "b": 0.4,
+        "mean_recall": 0.715961
+    },
+    "fold1": {
+        "a": 1.29,
+        "b": 0.38,
+        "mean_recall": 0.767792
+    },
+    "fold2": {
+        "a": 1.28,
+        "b": 0.365,
+        "mean_recall": 0.800703
+    },
+    "fold3": {
+        "a": 1.11,
+        "b": 0.42,
+        "mean_recall": 0.761545
+    },
+    "fold4": {
+        "a": 1.61,
+        "b": 0.385,
+        "mean_recall": 0.736111
+    }
+}