add files for inference

inference/metrics_visualization.py

@@ -0,0 +1,393 @@
+"""
+Визуализация предсказаний SYNTAX:
+- точки (SYNTAX GT vs предсказания модели) для нескольких датасетов;
+- зоны риска (низкий / высокий риск);
+- области ±σ и ±2σ вокруг диагонали;
+- логистические тренды для каждого датасета.
+
+Скрипт не зависит от PyTorch/Lightning и используется на этапе инференса.
+Сохранение осуществляется в папку `visualizations/` внутри проекта.
+"""
+
+import os
+import numpy as np
+import plotly.graph_objects as go
+from scipy.optimize import curve_fit  # type: ignore
+
+
+def visualize_final_syntax_plotly_multi(
+    datasets,
+    r2_values,
+    gt_row,
+    postfix=None,
+    threshold=22.0,
+    recall_values=None,
+    backbone=False,
+):
+    """
+    Единая визуализация SYNTAX: точки, зоны риска и логистические тренды.
+
+    Параметры
+    ---------
+    datasets : dict[str, tuple[list[float], list[float]]]
+        Словарь {имя_датасета: (syntax_true_list, syntax_pred_list)}.
+    r2_values : dict[str, float]
+        Словарь R^2 по датасетам.
+    gt_row : str
+        Строка, попадающая в заголовок (например, "ENSEMBLE" или "BOTH").
+    postfix : str | None
+        Суффикс для имени сохраняемого файла.
+    threshold : float
+        Порог SYNTAX (обычно 22.0) для разделения зон риска.
+    recall_values : dict[str, float] | None
+        Словарь Recall по датасетам (может быть None).
+    backbone : bool
+        Если True, сохраняет в `visualizations/backbone`, иначе в `visualizations/`.
+    """
+    # ========== КОНСТАНТЫ ДЛЯ НАСТРОЙКИ ==========
+    DATA_MIN = 0.0
+    DATA_MAX = 60.0
+
+    PADDING = 0.5
+
+    SIGMA_SLOPE = 0.15
+    SIGMA_BASE = 1.4
+
+    PLOT_WIDTH = 980
+    PLOT_HEIGHT = 980
+
+    BASE_FONT_SIZE = 16
+    TITLE_FONT_SIZE = 22
+    AXIS_LABEL_FONT_SIZE = BASE_FONT_SIZE
+    AXIS_TICK_FONT_SIZE = 15
+    LEGEND_FONT_SIZE = 14
+
+    MARKER_SIZE = 11
+    MARKER_LINE_WIDTH = 1.1
+    LINE_WIDTH = 2
+    TREND_LINE_WIDTH = 3
+
+    PLOT_BG_COLOR = "rgba(235,238,245,1)"
+    PAPER_BG_COLOR = "white"
+    LEGEND_BG_COLOR = "rgba(255,255,255,0.94)"
+    GRID_COLOR = "rgba(100,116,139,0.18)"
+
+    MARGIN_LEFT = 70
+    MARGIN_RIGHT = 24
+    MARGIN_TOP = 78
+    MARGIN_BOTTOM = 70
+
+    LEGEND_X = 0.04
+    LEGEND_Y = 0.99
+
+    COLORS = ["#1E88E5", "#8E24AA", "#A0D137", "#EA1D1D", "#06EE0D", "#FB8C00"]
+    SYMBOLS = ["circle", "x", "square", "diamond", "triangle-up", "star"]
+
+    SIGMA_POINTS = 400
+    TREND_POINTS = 500
+
+    # ========== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==========
+
+    def _logistic_time(t, R0, Rmax, t50, k):
+        """Логистическая функция по времени/оценке SYNTAX."""
+        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=(DATA_MIN, DATA_MAX), n=TREND_POINTS):
+        """
+        Аппроксимация логистической кривой.
+        Возвращает X, Y или (None, None), если фит не удался.
+        """
+        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
+
+    # ========== ОСНОВНОЙ КОД ==========
+    fig = go.Figure()
+
+    line_min = DATA_MIN - PADDING
+    line_max = DATA_MAX + PADDING
+    domain = (line_min, line_max)
+
+    base_font = dict(
+        family="Inter, Roboto, Helvetica Neue, Arial, sans-serif",
+        size=BASE_FONT_SIZE,
+    )
+
+    # ---------- Пороги и линии (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="Пороги и линии",
+            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=rf"$\mathrm{{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=r"$\pm 2\sigma$",
+            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=r"$\pm \sigma$",
+            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=r"$y=x$",
+            legendgroup="zones",
+            showlegend=True,
+            line=dict(color="rgba(30,30,30,0.85)", width=LINE_WIDTH),
+            legendrank=0,
+        )
+    )
+
+    # ---------- Датасеты (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
+
+        r2 = r2_values.get(label, None)
+        recall = recall_values.get(label, None) if recall_values else None
+        hover_lines = [f"<b>{label}</b>"]
+        if r2 is not None:
+            hover_lines.append(f"R² = {r2:.3f}")
+        if recall is not None:
+            hover_lines.append(f"Recall = {recall:.3f}")
+        hovertemplate = (
+            "<br>".join(hover_lines)
+            + "<br>GT: %{x:.3f}<br>Pred: %{y:.3f}<extra></extra>"
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=y,
+                mode="markers",
+                name=label,
+                legendgroup="datasets",
+                legendgrouptitle_text=("Датасеты" 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
+
+    # ---------- Тренды: логистические (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,  # без коротких alias, полное имя датасета
+                    legendgroup="trends",
+                    legendgrouptitle_text=(
+                        "Тренды (логистические)" 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
+
+    # ---------- оформление ----------
+    title_text = f"SYNTAX predictions ({gt_row})"
+    if postfix:
+        title_text += f" {postfix}"
+
+    fig.update_layout(
+        title=dict(
+            text=title_text,
+            x=0.5,
+            xanchor="center",
+            font=dict(
+                size=TITLE_FONT_SIZE,
+                family=base_font["family"],
+                color="rgba(15,23,42,1)",
+            ),
+        ),
+        font=base_font,
+        xaxis_title=r"$\mathrm{SYNTAX\ GT}$",
+        yaxis_title=r"$\mathrm{SYNTAX\ predictions}$",
+        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,
+            bordercolor="#CBD5E1",
+            borderwidth=1,
+            font=dict(size=LEGEND_FONT_SIZE, family=base_font["family"]),
+            tracegroupgap=8,
+            itemclick="toggle",
+            itemdoubleclick="toggleothers",
+            groupclick="toggleitem",
+        ),
+        xaxis=dict(
+            showgrid=True,
+            gridcolor=GRID_COLOR,
+            gridwidth=1,
+            zeroline=False,
+            tickfont=dict(size=AXIS_TICK_FONT_SIZE),
+            range=[line_min, line_max],
+            constrain="domain",
+        ),
+        yaxis=dict(
+            showgrid=True,
+            gridcolor=GRID_COLOR,
+            gridwidth=1,
+            zeroline=False,
+            tickfont=dict(size=AXIS_TICK_FONT_SIZE),
+            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,
+        ),
+    )
+
+    # ---------- сохранение ----------
+    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,305 @@
+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 metrics_visualization import visualize_final_syntax_plotly_multi
+
+DEVICE = torch.device("cuda:0" 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):
+    """R2, MAE, Pearson, MAPE, Mean_Recall."""
+    y_true_arr = np.array(y_true, dtype=float)
+    y_pred_arr = np.array(y_pred, dtype=float)
+
+    r2 = float(skm.r2_score(y_true_arr, y_pred_arr))
+    mae = float(skm.mean_absolute_error(y_true_arr, y_pred_arr))
+
+    pearson = float(np.corrcoef(y_true_arr, y_pred_arr)[0, 1]) if len(y_true_arr) > 1 else 0.0
+    mape = float(skm.mean_absolute_percentage_error(y_true_arr, y_pred_arr))
+
+    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 r2, mae, pearson, mape, 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),
+              help="Корень датасета (где лежат JSON и DICOM).")
+@click.option("-v", "--video-size", type=click.Tuple([int, int]),
+              help="Размер видео (H, W).")
+@click.option("--frames-per-clip",
+              help="Количество кадров в клипе.")
+@click.option("--num-workers",
+              help="Число DataLoader workers.")
+@click.option("--seed",
+              help="Random seed.")
+@click.option("--pt-weights-format", is_flag=True,
+              help="True → модели в .pt (torch.save), False → .ckpt (Lightning).")
+@click.option("--use-scaling", is_flag=True,
+              help="Применить a*x+b scaling из JSON.")
+@click.option("--scaling-file",
+              help="JSON с коэффициентами scaling (относительно dataset_root).")
+@click.option("-e", "--ensemble-name",
+              help="Имя ансамбля в metrics.json.")
+@click.option("-m", "--metrics-file",
+              help="JSON с метриками экспериментов.")
+def main(dataset_paths, dataset_names, postfixes, dataset_root, video_size,
+         frames_per_clip, num_workers, seed, pt_weights_format, use_scaling,
+         scaling_file, ensemble_name, metrics_file):
+
+    pl.seed_everything(seed)
+    postfix_plotly = "Ensemble"
+
+    # Пути к моделям (backbone + RNN-head)
+    model_paths = {
+        "left": [
+            "full_model/checkpoints/leftBinSyntax_R3D_fold00_lstm_mean_post_best.pt",
+            "full_model/checkpoints/leftBinSyntax_R3D_fold01_lstm_mean_post_best.pt",
+            "full_model/checkpoints/leftBinSyntax_R3D_fold02_lstm_mean_post_best.pt",
+            "full_model/checkpoints/leftBinSyntax_R3D_fold03_lstm_mean_post_best.pt",
+            "full_model/checkpoints/leftBinSyntax_R3D_fold04_lstm_mean_post_best.pt",
+        ],
+        "right": [
+            "full_model/checkpoints/rightBinSyntax_R3D_fold00_lstm_mean_post_best.pt",
+            "full_model/checkpoints/rightBinSyntax_R3D_fold01_lstm_mean_post_best.pt",
+            "full_model/checkpoints/rightBinSyntax_R3D_fold02_lstm_mean_post_best.pt",
+            "full_model/checkpoints/rightBinSyntax_R3D_fold03_lstm_mean_post_best.pt",
+            "full_model/checkpoints/rightBinSyntax_R3D_fold04_lstm_mean_post_best.pt",
+        ]
+    }
+
+    # Scaling параметры
+    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,
+        "datasets": {}
+    }
+
+    all_datasets, all_r2, all_recalls = {}, {}, {}
+
+    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(dataset_root, "coeffs", 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, pt_weights_format
+            )
+            right_preds_all, right_sids = run_artery(
+                abs_dataset_path, "right", model_paths["right"],
+                video_size, frames_per_clip, num_workers, 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 (fold-wise для left/right)
+        if use_scaling:
+            left_scaled_all, right_scaled_all = [], []
+            for pred_list in left_preds_all:
+                scaled = [scaling_params_dict.get(f"fold{i}", (1.0, 0.0))[0] * val +
+                         scaling_params_dict.get(f"fold{i}", (1.0, 0.0))[1]
+                         for i, val in enumerate(pred_list)]
+                left_scaled_all.append(scaled)
+            for pred_list in right_preds_all:
+                scaled = [scaling_params_dict.get(f"fold{i}", (1.0, 0.0))[0] * val +
+                         scaling_params_dict.get(f"fold{i}", (1.0, 0.0))[1]
+                         for i, val in enumerate(pred_list)]
+                right_scaled_all.append(scaled)
+        else:
+            left_scaled_all, right_scaled_all = left_preds_all, right_preds_all
+
+        # Ансамбль: mean по фолдам + left+right
+        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_scaled_all, right_scaled_all)]
+
+        # Метрики ансамбля
+        r2, mae, pearson, mape, mean_recall = compute_metrics(syntax_true, syntax_pred)
+        print(f"[{postfix}] ENSEMBLE: R2={r2:.4f}, Pearson={pearson:.4f}, "
+              f"MAE={mae:.4f}, MAPE={mape:.4f}, Recall={mean_recall:.4f}")
+
+        # STD по фолдам
+        n_folds = len(left_scaled_all[0]) if left_scaled_all else 0
+        fold_metrics = {metric: [] for metric in ["R2", "MAE", "Pearson", "MAPE", "Mean_Recall"]}
+        for k in range(n_folds):
+            pred_k = [max(0.0, l_list[k] + r_list[k])
+                     for l_list, r_list in zip(left_scaled_all, right_scaled_all)]
+            fold_r2, fold_mae, fold_pearson, fold_mape, fold_recall = compute_metrics(syntax_true, pred_k)
+            for metric, value in zip(fold_metrics.keys(),
+                                   [fold_r2, fold_mae, fold_pearson, fold_mape, 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_r2[dataset_name] = r2
+        all_recalls[dataset_name] = mean_recall
+
+        ensemble_results["datasets"][dataset_name] = {
+            # Ансамбль
+            "R2": round(r2, 4), "MAE": round(mae, 4),
+            "Pearson": round(pearson, 4), "MAPE": round(mape, 4),
+            "Mean_Recall": round(mean_recall, 4), "N_samples": len(syntax_true),
+            # По фолдам (mean±std)
+            **{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 = os.path.join(dataset_root, 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_r2, recall_values=all_recalls,
+        gt_row="ENSEMBLE", postfix=postfix_plotly
+    )
+
+
+def run_artery(dataset_path, artery, model_paths, video_size, frames_per_clip,
+               num_workers, pt_weights_format=False):
+    """Инференс для одной артерии (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="",  # inference mode
+        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="lstm_mean",
+            weight_decay=0.001, max_epochs=1,
+            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:
+                    pred = model(x)
+                    _, val_log = pred  # регрессионный logit
+                    val = float(torch.exp(val_log).cpu()) - 1
+                    val_syntax_list.append(val)
+            preds_all.append(val_syntax_list)
+            sids.append(sid[0])  # study_uid
+
+    return preds_all, sids
+
+
+if __name__ == "__main__":
+    main()