Интерпретируемость, устойчивость и безопасность моделей

Все предыдущие статьи трека отвечали на вопрос «как заставить сеть работать». Эта — на три вопроса, которые задают ровно в тот момент, когда сеть уже работает и её выпустили к живым пользователям:

1. Почему она выдала именно это? (интерпретируемость)
2. Что будет, если вход не такой, как в обучении — случайно или намеренно? (устойчивость)
3. Что она не должна делать никогда, и как это гарантировать? (безопасность)

Это три разных дисциплины с разной математикой, но в проде они срастаются в одну задачу: сделать поведение модели предсказуемым за пределами тестовой выборки. Точность на holdout — это оценка среднего случая на распределении, которое вы сами и выбрали. Инциденты живут в хвостах.

1. Зачем это нужно: четыре разных заказчика

Слово «интерпретируемость» размыто, потому что его требуют четыре группы людей с несовместимыми запросами.

Классическая ловушка: инженер строит SHAP-дэшборд, потому что регулятор попросил «объяснимость», и оба довольны, хотя SHAP не отвечает на вопрос регулятора («что нужно было изменить, чтобы решение было другим» — это контрфактическое объяснение, а не разложение вклада).

Второй мотив — чисто инженерный. Технический долг ML-систем (Sculley et al., NeurIPS 2015) — статья, которую стоит прочитать целиком: главный источник долга в том, что поведение системы определяется данными, а данные меняются молча. Интерпретируемость и мониторинг — это способ вернуть себе наблюдаемость, которую в обычном коде даёт чтение исходников.

2. Интерпретируемость: атрибуция

2.1 Постановка

Дана модель $f: \mathbb{R}^d \to \mathbb{R}$ (для классификации — логит нужного класса) и вход $x$. Атрибуция — вектор $\phi(x) \in \mathbb{R}^d$, где $\phi_i$ приписывает $i$-му признаку «вклад» в предсказание. Проблема в том, что «вклад» — не определённое математически понятие, пока вы не зафиксировали аксиомы. Разные наборы аксиом дают разные методы, и они не обязаны согласовываться.

2.2 Градиент как первое приближение

Самое наивное: $\phi_i = \partial f / \partial x_i$. Это saliency map (Simonyan et al., 2013) — линеаризация $f$ в точке $x$. Работает как индикатор чувствительности, но у метода есть фундаментальный дефект — насыщение.

Пусть $f(x) = \min(x, 1)$ и $x = 3$. Модель «уверенно да», но градиент равен нулю: признак важен, атрибуция нулевая. У ReLU-сетей это происходит постоянно, и потому чистый градиент выглядит зашумлённым.

2.3 Integrated Gradients: аксиоматически честный градиент

Integrated Gradients (Sundararajan et al., ICML 2017) чинит насыщение интегрированием по пути от базовой точки $x’$ (baseline — «отсутствие информации»: чёрная картинка, нулевой эмбеддинг, паддинг-токен) до $x$:

$$\mathrm{IG}_ i(x) = (x_i - x’_ i)\int_0^1 \frac{\partial f\big(x’ + \alpha (x - x’)\big)}{\partial x_i}, d\alpha$$

Метод удовлетворяет двум ключевым аксиомам:

• Completeness: $\sum_i \mathrm{IG}_ i(x) = f(x) - f(x’)$ — вклады складываются в реальную разницу предсказаний. Это дословно следует из формулы Ньютона–Лейбница вдоль пути.
• Sensitivity: если $x$ и $x’$ различаются одним признаком и дают разные предсказания, атрибуция этого признака ненулевая. Именно её нарушал чистый градиент.

Интеграл берут прямоугольниками или Гауссом–Лежандром за $m$ шагов; на практике $m = 32{-}256$, а критерий достаточности — насколько сумма атрибуций близка к $f(x) - f(x’)$ (ошибка completeness).

import torch

def integrated_gradients(model, x, target, baseline=None, steps=64,
                         batch=16):
    """Integrated Gradients для одного объекта.

    x        — тензор (1, ...) на нужном устройстве
    target   — индекс класса, который объясняем
    baseline — «нулевой» вход; по умолчанию нули
    Сложность: O(steps) форвардов и бэквордов, память O(batch * |x|).
    """
    if baseline is None:
        baseline = torch.zeros_like(x)

    # средняя точка прямоугольников: alpha_k = (k + 0.5) / steps
    alphas = (torch.arange(steps, device=x.device) + 0.5) / steps
    total = torch.zeros_like(x)

    for start in range(0, steps, batch):
        a = alphas[start:start + batch].view(-1, *([1] * (x.dim() - 1)))
        # точки на прямой baseline -> x
        pts = baseline + a * (x - baseline)
        pts.requires_grad_(True)
        logits = model(pts)
        score = logits[:, target].sum()          # суммируем: градиенты независимы
        grads, = torch.autograd.grad(score, pts)
        total = total + grads.sum(dim=0, keepdim=True)

    avg_grad = total / steps
    attribution = (x - baseline) * avg_grad

    # проверка completeness: расхождение должно быть < 5%
    with torch.no_grad():
        delta = (model(x)[0, target] - model(baseline)[0, target]).item()
    err = abs(attribution.sum().item() - delta) / (abs(delta) + 1e-9)
    return attribution, err

Выбор baseline — не техническая деталь, а определение вопроса. Чёрная картинка как baseline означает «объясни относительно полной темноты», поэтому чёрные пиксели на изображении получат нулевую атрибуцию, даже если они решающие. Для табличных данных разумнее медиана обучающей выборки, для текста — усреднение по нескольким baseline (маска, случайные токены).

2.4 SHAP: атрибуция как кооперативная игра

Другой набор аксиом. Считаем признаки игроками, а $f$ — выигрышем коалиции. Значение Шепли — единственная атрибуция, удовлетворяющая эффективности, симметрии, dummy и аддитивности:

$$\phi_i = \sum_{S \subseteq N \setminus {i}} \frac{|S|!,(|N| - |S| - 1)!}{|N|!}\big[f(S \cup {i}) - f(S)\big]$$

Точный расчёт — $O(2^d)$ коалиций, поэтому в жизни используют приближения: KernelSHAP (взвешенная линейная регрессия по сэмплированным коалициям, model-agnostic, дорого — тысячи форвардов на объект), TreeSHAP ($O(TLD^2)$ точно для ансамблей деревьев — поэтому SHAP так популярен в табличном ML) и DeepSHAP/GradientSHAP для сетей.

Тонкость, которую почти всегда игнорируют: чтобы вычислить $f(S)$, нужно как-то «выключить» признаки не из $S$. Их маргинализуют — но по какому распределению? Interventional (по маргиналам, ломает корреляции, отвечает на каузальный вопрос «что если вмешаться») против conditional (по условному, отвечает на вопрос «что если наблюдать»). Ответы различаются качественно; см. Chen et al., True to the Model or True to the Data?.

2.5 Grad-CAM для свёрточных сетей

Для CNN есть более дешёвая и более осмысленная альтернатива: взвесить карты признаков последнего свёрточного слоя средним градиентом по ним.

$$\alpha_k^c = \frac{1}{HW}\sum_{i,j}\frac{\partial y^c}{\partial A^k_{ij}}, \qquad L^c_{\mathrm{Grad\text{-}CAM}} = \mathrm{ReLU}\Big(\sum_k \alpha_k^c A^k\Big)$$

Стоит один прямой и один обратный проход — $O(1)$ относительно IG. Разрешение низкое (размер карты признаков), зато карта опирается на семантику высокого уровня, а не на пиксельный шум. Grad-CAM, Selvaraju et al., 2017.

2.6 Ошибки, которых почти никто не избегает

1. Красивая карта ≠ верное объяснение. Sanity Checks for Saliency Maps (Adebayo et al., NeurIPS 2018): если рандомизировать веса модели, некоторые популярные методы (Guided Backprop) выдают почти ту же карту. Значит, они работают как краевой детектор изображения, а не объясняют модель. Всегда прогоняйте model randomization test и data randomization test перед тем, как доверять методу.
2. Внимание — не объяснение. Веса attention интуитивно выглядят объяснением, но Jain & Wallace, Attention is not Explanation показали, что можно найти существенно иные веса с тем же предсказанием; Wiegreffe & Pinter уточнили: смотря что называть объяснением. Практический вывод: не стройте продуктовые обоснования на attention-картах из трансформера.
3. Атрибуция объясняет модель, а не мир. Если модель выучила спурьезную корреляцию, честная атрибуция покажет эту корреляцию. Это фича (так вы её и найдёте), но не основание для выводов о предметной области.
4. Объяснения хрупки. Существуют атаки, меняющие карту атрибуции почти без изменения предсказания (Ghorbani et al.). Для регуляторных сценариев это значит: объяснение нужно фиксировать в аудит-логе вместе со всеми входами и версией модели.

3. Механистическая интерпретируемость

Атрибуция говорит «эти входы важны». Механистическая интерпретируемость пытается ответить на вопрос какой алгоритм реализуют веса — то есть провести реверс-инжиниринг сети.

3.1 Признаки, нейроны и суперпозиция

Наивная надежда — «один нейрон = одно понятие». Реальность: нейроны полисемантичны — один и тот же нейрон активируется на кошачьих мордах, фасадах домов и слове «legal». Причина, показанная в Toy Models of Superposition (Elhage et al., 2022): признаков, которые модель хочет представлять, больше, чем измерений активации, и они разрежены (в конкретном входе активна лишь горстка). Тогда выгодно упаковать $m \gg d$ признаков как почти ортогональные направления — лемма Джонсона–Линденштрауса гарантирует, что в $\mathbb{R}^d$ можно разместить экспоненциально много векторов с малым попарным косинусом. Цена — интерференция, которую модель терпит ради ёмкости.

3.2 Разреженные автоэнкодеры (SAE)

Если признаки лежат «наискось», нужно найти правильный словарь направлений. Это задача разреженного кодирования: обучаем автоэнкодер с широким скрытым слоем и L1-штрафом поверх активаций замороженной модели.

$$h = \mathrm{ReLU}\big(W_{\mathrm{enc}}(a - b_{\mathrm{pre}}) + b_{\mathrm{enc}}\big), \quad \hat a = W_{\mathrm{dec}} h + b_{\mathrm{pre}}, \quad \mathcal{L} = |a - \hat a|_ 2^2 + \lambda |h|_ 1$$

import torch, torch.nn as nn, torch.nn.functional as F

class SparseAutoencoder(nn.Module):
    """SAE над активациями резидуального потока. m = expansion * d."""

    def __init__(self, d_model: int, expansion: int = 16, l1: float = 5e-4):
        super().__init__()
        m = d_model * expansion
        self.enc = nn.Linear(d_model, m)
        self.dec = nn.Linear(m, d_model, bias=False)
        self.b_pre = nn.Parameter(torch.zeros(d_model))
        self.l1 = l1
        # декодер стартует как транспонированный энкодер — ускоряет сходимость
        with torch.no_grad():
            self.dec.weight.copy_(self.enc.weight.t())
            self._normalize_decoder()

    @torch.no_grad()
    def _normalize_decoder(self):
        # столбцы декодера держим единичными: иначе L1 обходится масштабированием
        self.dec.weight.div_(self.dec.weight.norm(dim=0, keepdim=True) + 1e-8)

    def forward(self, a):
        h = F.relu(self.enc(a - self.b_pre))
        a_hat = self.dec(h) + self.b_pre
        mse = F.mse_loss(a_hat, a)
        sparsity = self.l1 * h.abs().sum(dim=-1).mean()
        return a_hat, h, mse + sparsity

    @torch.no_grad()
    def diagnostics(self, a):
        _, h, _ = self.forward(a)
        return {
            "l0": (h > 0).float().sum(-1).mean().item(),   # цель: 20-100 из тысяч
            "dead_frac": (h.sum(0) == 0).float().mean().item(),  # хотим < 5%
        }

Ключевые практические моменты: столбцы декодера обязательно нормировать (иначе L1 «обманывается» уменьшением $h$ при росте $W_{\mathrm{dec}}$), мёртвые латенты воскрешать (resampling), а качество мерить парой (L0, доля объяснённой дисперсии). Современные варианты — TopK-SAE и JumpReLU — заменяют L1 явным ограничением L0, что убирает систематическое занижение амплитуд. Масштабная демонстрация подхода: Scaling Monosemanticity (Anthropic, 2024) — извлечение миллионов интерпретируемых признаков из Claude 3 Sonnet с проверкой каузальности через steering.

3.3 Каузальные методы: activation patching

Корреляция активации с поведением ничего не доказывает. Каузальный тест — вмешательство: прогнать «чистый» и «испорченный» промпт, а затем подставить активацию из чистого прогона в испорченный на конкретной позиции и слое. Если предсказание восстановилось — компонент каузально необходим.

@torch.no_grad()
def activation_patch(model, clean_ids, corrupt_ids, layer, pos, metric):
    """Возвращает долю восстановленного эффекта при подстановке одной активации.

    Стоимость полной карты: O(L * T) прогонов, где L — слои, T — позиции.
    Для 32-слойной модели и 64 токенов это ~2k форвардов — минуты на одном GPU.
    """
    cache = {}
    h = model.layers[layer].register_forward_hook(
        lambda _m, _i, out: cache.__setitem__("act", out.detach()))
    model(clean_ids)                       # шаг 1: сохранили чистую активацию
    h.remove()

    def patch(_m, _i, out):
        out = out.clone()
        out[:, pos, :] = cache["act"][:, pos, :]
        return out

    h = model.layers[layer].register_forward_hook(patch)
    patched_logits = model(corrupt_ids)    # шаг 2: подставили в испорченный прогон
    h.remove()
    return metric(patched_logits)

Так были найдены индукционные головы — двухголовая цепь, реализующая правило «если раньше встречалось A B, то после A предсказывай B»; их появление совпадает по времени с резким скачком in-context learning (In-context Learning and Induction Heads, 2022). Развитие метода — attribution patching (линейная аппроксимация эффекта патча через градиент), которая даёт всю карту за $O(1)$ прогонов вместо $O(LT)$.

Полезный минимальный инструмент — logit lens: применить финальную unembedding-матрицу к промежуточным активациям и посмотреть, какое слово «созревает» на каком слое. Стоит один прогон и часто объясняет больше, чем сложная атрибуция.

4. Устойчивость к сдвигу распределения

4.1 Таксономия сдвигов

Обучение предполагает $p_{\text{train}}(x, y) = p_{\text{test}}(x, y)$. В проде это неверно почти сразу. Разложим $p(x, y) = p(y \mid x),p(x)$:

• Covariate shift: меняется $p(x)$, $p(y \mid x)$ прежнее. Новая камера, другой регион, другая когорта пользователей. Лечится взвешиванием по importance ratio, доменной адаптацией, дообучением.
• Label / prior shift: меняется $p(y)$. Сезонность фрода, эпидемия. Лечится пересчётом порогов и prior correction — часто достаточно сдвинуть логиты на $\log(\pi_{\text{new}} / \pi_{\text{train}})$.
• Concept drift: меняется сама $p(y \mid x)$. Мошенники сменили схему. Никакая калибровка не спасёт — нужны свежие метки.

4.2 Спурьезные корреляции

Самый частый источник провала — модель выучила признак, который коррелирует с меткой в обучении, но не каузален. Хрестоматийные примеры: детектор пневмонии, выучивший маркер конкретной больницы на снимке; классификатор «хаски против волка», смотрящий на снег; классификатор кожных образований, реагирующий на линейку в кадре.

Диагностика: не смотрите на среднюю метрику. Считайте метрику по срезам (устройство, регион, подгруппа, длина текста) и следите за worst-group accuracy. Методы вроде Group DRO оптимизируют именно худшую группу; часто достаточно простой перебалансировки или дообучения последнего слоя на сбалансированном срезе (DFR).

4.3 Калибровка: уверенность, которой можно верить

Модель калибрована, если среди предсказаний с уверенностью 0.8 действительно правы примерно 80%. Современные глубокие сети систематически переуверены (On Calibration of Modern Neural Networks, Guo et al., 2017).

Метрика — Expected Calibration Error: разбиваем предсказания на $M$ бинов по уверенности и усредняем разрыв между точностью и уверенностью:

$$\mathrm{ECE} = \sum_{m=1}^{M}\frac{|B_m|}{n}\Big|\mathrm{acc}(B_m) - \mathrm{conf}(B_m)\Big|$$

Лечится удивительно дёшево — temperature scaling: один скаляр $T$, подобранный на валидации, делит логиты. Не меняет argmax (значит, accuracy не страдает), но резко улучшает ECE.

import torch, torch.nn.functional as F

def fit_temperature(logits: torch.Tensor, labels: torch.Tensor) -> float:
    """Подбор температуры на ВАЛИДАЦИОННОЙ выборке (не на трейне и не на тесте!).

    Один параметр -> переобучиться почти невозможно; хватает нескольких сотен точек.
    Сложность: O(iters * n * C).
    """
    log_T = torch.zeros(1, requires_grad=True)      # оптимизируем log T > 0
    opt = torch.optim.LBFGS([log_T], lr=0.1, max_iter=60)

    def closure():
        opt.zero_grad()
        loss = F.cross_entropy(logits / log_T.exp(), labels)
        loss.backward()
        return loss

    opt.step(closure)
    return float(log_T.exp())


def ece(probs: torch.Tensor, labels: torch.Tensor, n_bins: int = 15) -> float:
    conf, pred = probs.max(dim=1)
    correct = pred.eq(labels).float()
    edges = torch.linspace(0, 1, n_bins + 1)
    total = 0.0
    for lo, hi in zip(edges[:-1], edges[1:]):
        m = (conf > lo) & (conf <= hi)
        if m.any():
            total += m.float().mean() * (correct[m].mean() - conf[m].mean()).abs()
    return float(total)

Важно: температура, подобранная на in-distribution валидации, перестаёт работать при сдвиге — модель снова становится переуверенной. Калибровку нужно перепроверять на каждом релевантном срезе.

4.4 Conformal prediction: гарантии без предположений о модели

Если нужна не «уверенность», а формальная гарантия покрытия — берите конформное предсказание. Идея: на калибровочной выборке из $n$ точек считаем меру нонконформности $s_i$ (например, $1 - \hat p(y_i \mid x_i)$), берём её $\lceil (n+1)(1-\alpha)\rceil$-ю порядковую статистику $\hat q$ и выдаём множество $C(x) = {y : s(x, y) \le \hat q}$.

Теорема (при обменности данных, для любой модели): $\mathbb{P}(y \in C(x)) \ge 1 - \alpha$. Никаких предположений о правильности модели — плохая модель просто выдаст большие множества. Это идеально ложится на сценарий «отдать сложные случаи человеку»: размер множества становится сигналом для эскалации.

import numpy as np

def conformal_threshold(probs_cal: np.ndarray, y_cal: np.ndarray,
                        alpha: float = 0.1) -> float:
    """probs_cal: (n, C) вероятности на КАЛИБРОВОЧНОЙ выборке, не участвовавшей нигде."""
    scores = 1.0 - probs_cal[np.arange(len(y_cal)), y_cal]
    n = len(scores)
    k = int(np.ceil((n + 1) * (1 - alpha)))     # поправка на конечную выборку
    return float(np.sort(scores)[min(k, n) - 1])

def predict_set(probs: np.ndarray, q: float):
    """Возвращает множества меток с гарантией покрытия 1 - alpha."""
    return [np.flatnonzero(1.0 - p <= q) for p in probs]

Разбор с доказательствами и рецептами: A Gentle Introduction to Conformal Prediction (Angelopoulos & Bates, 2021).

4.5 Детекция OOD

Отдельная задача: понять, что вход вообще вне области применимости. Простейший бейзлайн — максимум softmax-вероятности (MSP), и он на удивление силён. Лучше работает энергия $E(x) = -T\log\sum_c e^{f_c(x)/T}$ (Energy-based OOD) и расстояние Махаланобиса в пространстве признаков предпоследнего слоя. Для эмбеддинговых пайплайнов (см. эмбеддинги) хорошо работает kNN-расстояние до обучающей выборки.

Главная ошибка — валидировать OOD-детектор на том же наборе «аномалий», на котором его настраивали. Реальный OOD по определению неизвестен; держите как минимум два непересекающихся набора аномалий и репортите AUROC на обоих.

5. Состязательная устойчивость

5.1 Модель угроз

Без явно заданной threat model разговор об устойчивости бессмыслен. Задать нужно: что атакующий знает (белый/чёрный ящик), что может менять ($L_p$-шар, патч, физический объект), и какой у него бюджет запросов.

Классическая постановка — $L_\infty$-шар радиуса $\varepsilon$:

$$\max_{|\delta|_ \infty \le \varepsilon} \mathcal{L}\big(f_\theta(x + \delta), y\big)$$

Почему это вообще возможно? Goodfellow et al. дали линейное объяснение: при $\delta = \varepsilon,\mathrm{sign}(w)$ изменение логита равно $\varepsilon|w|_ 1$ и растёт линейно с размерностью. Более глубокий взгляд — Adversarial Examples Are Not Bugs, They Are Features (Ilyas et al., 2019): в данных реально есть предиктивные, но невоспринимаемые человеком признаки; модель их честно использует, а атака их и правит.

5.2 Атаки: FGSM и PGD

FGSM — один шаг по знаку градиента. PGD — итеративная версия со случайным стартом и проекцией на шар; де-факто стандарт оценки.

import torch, torch.nn.functional as F

def pgd_attack(model, x, y, eps=8/255, alpha=2/255, steps=10, random_start=True):
    """PGD в L∞-шаре. Стоимость: steps форвардов+бэквордов на батч.

    eps   — радиус шара (для изображений в [0,1] стандарт 8/255)
    alpha — шаг; эмпирическое правило alpha ≈ 2.5 * eps / steps
    """
    x_adv = x.clone().detach()
    if random_start:
        x_adv = x_adv + torch.empty_like(x_adv).uniform_(-eps, eps)
        x_adv = x_adv.clamp(0, 1)

    for _ in range(steps):
        x_adv.requires_grad_(True)
        loss = F.cross_entropy(model(x_adv), y)
        grad, = torch.autograd.grad(loss, x_adv)
        with torch.no_grad():
            x_adv = x_adv + alpha * grad.sign()          # шаг восхождения
            x_adv = x + (x_adv - x).clamp(-eps, eps)     # проекция на L∞-шар
            x_adv = x_adv.clamp(0, 1)                    # проекция в область значений
    return x_adv.detach()

Как НЕ надо оценивать защиту. История поля — это кладбище защит, сломанных через месяц после публикации. Obfuscated Gradients Give a False Sense of Security (Athalye et al., ICML 2018) сломали 7 из 9 защит с ICLR 2018: все они просто портили градиент, а не увеличивали реальный запас. Чек-лист адекватной оценки (Carlini et al., On Evaluating Adversarial Robustness): атака должна быть адаптивной (знать защиту), проверяться на сходимость (больше шагов — не выше accuracy), сравниваться с transfer-атакой и с атакой чёрного ящика; устойчивость 0% при $\varepsilon \to \infty$ обязана достигаться. Стандартный внешний бенчмарк — RobustBench и AutoAttack.

5.3 Adversarial training и его цена

Единственная защита, пережившая проверку временем, — обучение на атакованных примерах (Madry et al., 2017), то есть решение седловой задачи

$$\min_\theta ; \mathbb{E}_ {(x,y)}\Big[\max_{|\delta|_ \infty \le \varepsilon} \mathcal{L}(f_\theta(x+\delta), y)\Big]$$

def adversarial_train_step(model, opt, x, y, eps=8/255, steps=7):
    """Один шаг adversarial training. Стоимость: (steps + 1) раз дороже обычного шага."""
    model.eval()                                  # BN в eval: иначе статистики поедут
    x_adv = pgd_attack(model, x, y, eps=eps, steps=steps)
    model.train()

    opt.zero_grad()
    # смесь чистых и атакованных: держит accuracy на чистых данных
    loss = 0.5 * F.cross_entropy(model(x), y) + 0.5 * F.cross_entropy(model(x_adv), y)
    loss.backward()
    opt.step()
    return float(loss)

Trade-offs, которые нужно принять заранее:

• Вычисления: в $(k+1)$ раз дороже, где $k$ — число PGD-шагов. Дешёвые варианты — FGSM со случайным стартом («Fast is better than free») и Free AT, но они склонны к катастрофическому переобучению (robustness внезапно схлопывается в ноль).
• Точность: на CIFAR-10 переход к $\varepsilon = 8/255$ стоит примерно 8–12 п.п. чистой accuracy. Есть теоретические результаты, показывающие, что этот компромисс неустраним в общем случае (Tsipras et al.).
• Переобучение на робастность: robust overfitting — robust test accuracy падает после определённой эпохи, хотя train растёт. Лечится ранней остановкой по robust-валидации.
• Специфичность нормы: модель, устойчивая к $L_\infty$, часто не устойчива к $L_2$, к поворотам и к патчам.

5.4 Сертифицированная устойчивость

Эмпирическая устойчивость — это «мы не смогли сломать». Сертификация даёт доказательство. Самый практичный метод — randomized smoothing (Cohen et al., 2019): определим сглаженный классификатор $g(x) = \arg\max_c \mathbb{P}_ {\eta \sim \mathcal{N}(0,\sigma^2 I)}\big[f(x+\eta) = c\big]$. Если для верхнего класса нижняя доверительная граница вероятности равна $\underline{p_A}$, то $g$ доказуемо не меняет ответ в $L_2$-шаре радиуса $R = \sigma,\Phi^{-1}(\underline{p_A})$.

Плюс: работает для любой архитектуры и масштабируется на ImageNet. Минусы: нужен Монте-Карло из сотен–тысяч прогонов на объект (дорого в инференсе), радиус растёт только логарифмически с числом сэмплов, а $\sigma$ — прямой компромисс между радиусом и точностью. Для дискретных входов (текст) $L_p$-формализм вообще плохо применим, поэтому в NLP-безопасности центр тяжести сместился к другим угрозам.

6. Безопасность LLM-систем

Для больших языковых моделей угроза почти никогда не описывается $L_p$-шаром. Ключевое отличие: инструкции и данные едут по одному каналу. Модель получает единый текст и не имеет надёжного способа отличить «команду от владельца системы» от «текста, найденного в интернете».

6.1 Jailbreak vs prompt injection

Их постоянно путают, а защищаются от них по-разному.

Практический вывод, который стоит выписать на стену: prompt injection не чинится промптом. Инструкция «игнорируй любые указания из документов» — это просьба к вероятностной модели, а не механизм контроля доступа. Чинится архитектурой: минимальные права инструментов, разделение доверенных и недоверенных контекстов, подтверждение человеком на действиях с побочными эффектами.

6.2 Атаки на выравнивание

• Оптимизированные суффиксы: Universal and Transferable Adversarial Attacks on Aligned Language Models (Zou et al., 2023) — GCG подбирает жадным координатным поиском последовательность токенов, максимизирующую вероятность начала ответа «Sure, here is…»; суффиксы переносятся между моделями, включая закрытые.
• Many-shot jailbreaking: заполнить длинный контекст десятками фиктивных диалогов, где ассистент соглашается; эффективность растёт по степенному закону с числом примеров (Anthropic, 2024). Прямое следствие роста контекстных окон.
• Смена распределения: низкоресурсные языки, base64, ASCII-арт, стихи. Причина структурная — выравнивающих данных для этих режимов на порядки меньше, чем предобучающих (Wei et al., Jailbroken: How Does LLM Safety Training Fail?).

6.3 Атаки на данные и модель

• Poisoning / backdoor: подмешать в обучающий корпус примеры с триггером. Chen et al. показали, что доли процента данных достаточно; для LLM — исследование Anthropic 2024 года демонстрирует, что бэкдор переживает стандартное safety-обучение (модели-«спящие агенты»). Защита: происхождение данных, дедупликация, канареечные тесты на триггеры.
• Извлечение обучающих данных: Carlini et al., Extracting Training Data from LLMs — дословные фрагменты вытаскиваются из модели; риск пропорционален числу дубликатов в корпусе. Дедупликация — самая дешёвая и эффективная мера. Формальная гарантия — DP-SGD, но ценой качества.
• Membership inference: определить, был ли конкретный пример в обучении. Базовый сигнал — аномально низкий loss на примере.
• Model stealing: дистилляция чужой модели через API; частичное извлечение весов возможно даже через logit-API (Carlini et al., 2024). Отсюда стандартные меры: не отдавать полные логиты, лимитировать запросы.

6.4 Эшелонированная защита

Ни один одиночный фильтр не даёт достаточной надёжности. Работает конвейер, где каждый слой дешевле и специализированнее следующего.

Практические принципы этого конвейера:

1. Асимметрия стоимости. Классификатор входа должен быть маленькой моделью (единицы миллисекунд), иначе защита съест бюджет латентности. Приёмы дешёвого инференса — в статье про инференс и деплой.
2. Fail closed для действий, fail open для чтения. Если guardrail упал, запрет на отправку письма должен сохраниться, а простой ответ на вопрос — не обязан.
3. Разделение доверия в контексте. Инструкции системы, ввод пользователя и выдача retrieval — три разных уровня доверия. Помечайте их структурно и никогда не позволяйте нижнему уровню менять политику верхнего.
4. Логи как продукт. Заблокированные запросы — самый ценный источник данных для следующей итерации классификатора.

6.5 Оценка: evals и red teaming

Метрика безопасности — не число, а набор наборов. Минимальный состав:

• Capability evals — не деградировало ли качество после safety-тюнинга (safety tax измеряют явно, иначе он накапливается молча).
• Harm evals — отказы на явно вредных запросах, разбитые по категориям.
• Over-refusal evals — отказы на безобидных запросах, которые лишь звучат опасно («как убить процесс в Linux»). Без этого набора команда неизбежно оптимизирует модель в бесполезную.
• Robustness evals — те же вредные запросы, обёрнутые в известные jailbreak-шаблоны.
• Red teaming — люди, ищущие обходы, плюс автоматизация: одна модель генерирует атаки на другую (Red Teaming Language Models with Language Models).

Процессные рамки, на которые ссылаются регуляторы и аудиторы: NIST AI Risk Management Framework, EU AI Act (для высокорисковых систем — обязательные логирование, человеческий надзор, документация), Model Cards for Model Reporting (Mitchell et al., 2019) и Datasheets for Datasets (Gebru et al.). Model card — не бюрократия: это единственное место, где фиксируется, для чего модель не предназначена.

6.6 Приоритизация мер

Не всё нужно делать сразу. Полезно разложить меры по осям «стоимость внедрения» и «снижение риска» — и начинать с левого верхнего квадранта.

7. Как это выглядит в проде

Сведём в чек-лист того, что реально работает у команд, эксплуатирующих модели годами.

На этапе данных. Дедупликация (снижает и переобучение, и извлечение данных). Происхождение каждого источника зафиксировано. Отложены «золотые» срезы по подгруппам — они переживают смены моделей и служат регрессионным тестом.

На этапе обучения. Фиксированные сиды и версии данных, чтобы регрессия была воспроизводима. Отдельная валидация под калибровку. Робастные варианты обучения (аугментации, adversarial training) — только там, где threat model это оправдывает: для внутренней аналитики — нет, для модерации контента и биометрии — да.

На этапе релиза. Shadow-деплой, потом канарейка 1–5%. Сравнение не только средней метрики, но и метрик по срезам и доли abstain. Model card обновляется вместе с весами, а не после.

В рантайме. Логируются вход, версия модели, вероятности, сработавшие guardrails и решение — этого достаточно, чтобы через полгода восстановить причину любого конкретного ответа. Кнопка мгновенного отката весов важнее любой сложной защиты: среднее время восстановления определяет реальный ущерб от инцидента.

В мониторинге. Отдельно метрики качества (лаг из-за меток), метрики дрейфа (PSI/KL по фичам и эмбеддингам — мгновенно) и метрики безопасности (доля срабатывания фильтров, доля эскалаций). Алерты на дрейф ставятся на изменение дрейфа, а не на абсолютный порог, иначе они шумят.

Типичные организационные ошибки: измерять безопасность одной цифрой; ставить блокирующий LLM-классификатор без бюджета латентности; строить объяснимость «для регулятора», не спросив, какой именно артефакт ему нужен; лечить prompt injection промптом; выкатывать safety-тюнинг без capability-evals и обнаруживать через месяц, что модель поглупела.

8. Мини-итог

• Интерпретируемость — не одна задача, а четыре разных запроса. Начинайте с вопроса «кто и какое решение примет, увидев объяснение».
• Атрибуция осмысленна ровно настолько, насколько осмысленны её аксиомы и baseline. Integrated Gradients даёт completeness, SHAP — аксиомы Шепли, Grad-CAM — дешевизну; ни один не даёт «истины». Всегда прогоняйте sanity checks.
• Механистическая интерпретируемость обещает больше: не «что важно», а «какой алгоритм внутри». Суперпозиция объясняет, почему нейроны полисемантичны, SAE даёт словарь признаков, activation patching — каузальные утверждения.
• Устойчивость начинается с честного разделения сдвигов: covariate, label, concept. Средняя метрика скрывает провалы по срезам; worst-group accuracy — нет.
• Калибровка чинится температурой почти бесплатно, но ломается при сдвиге. Conformal prediction даёт формальную гарантию покрытия без предположений о модели.
• Состязательные примеры — следствие геометрии высоких размерностей и предиктивных, но нечеловеческих признаков. Adversarial training работает, но стоит вычислений и чистой точности. Оценивать защиту нужно адаптивными атаками.
• Безопасность LLM — задача архитектуры приложения, а не только выравнивания модели. Jailbreak лечится обучением и классификаторами, prompt injection — правами, изоляцией и human-in-the-loop.
• Всё вместе работает только как процесс: evals, red teaming, срезовые метрики, логи, быстрый откат.

Источники

• Molnar. Interpretable Machine Learning — свободная книга, лучший общий вход в тему.
• Sundararajan et al. Axiomatic Attribution for Deep Networks (2017) — Integrated Gradients.
• Lundberg & Lee. A Unified Approach to Interpreting Model Predictions (2017) — SHAP.
• Adebayo et al. Sanity Checks for Saliency Maps (2018).
• Elhage et al. Toy Models of Superposition (2022) и Transformer Circuits Thread целиком.
• Templeton et al. Scaling Monosemanticity (2024) — SAE на продакшн-модели.
• Madry et al. Towards Deep Learning Models Resistant to Adversarial Attacks (2017).
• Athalye et al. Obfuscated Gradients Give a False Sense of Security (2018) — как ломают защиты.
• Cohen et al. Certified Adversarial Robustness via Randomized Smoothing (2019).
• Guo et al. On Calibration of Modern Neural Networks (2017).
• Angelopoulos & Bates. A Gentle Introduction to Conformal Prediction (2021).
• Zou et al. Universal and Transferable Adversarial Attacks on Aligned LMs (2023).
• Bai et al. Constitutional AI: Harmlessness from AI Feedback (2022).
• OWASP Top 10 for LLM Applications — прикладной чек-лист угроз.
• NIST AI Risk Management Framework — процессная рамка для аудита.
• Библиотеки: Captum (атрибуция для PyTorch), SHAP, Foolbox и torchattacks, TransformerLens (механистическая интерпретируемость), Evidently (дрейф и мониторинг).

Что дальше

На этом трек «Нейронные сети» завершён: от перцептрона и обратного распространения через свёртки, рекуррентность, трансформеры и LLM до деплоя и того, как всё это не сломать. Если хочется освежить общую картину — вернитесь к карте трека.

Куда двигаться дальше:

• Фундамент. Многое из этой статьи (калибровка, сдвиг, метрики, срезы) — это классический ML, доведённый до предела. Систематически он разобран в треке Машинное обучение.
• Алгоритмическая база. Чтобы уверенно оценивать сложность и писать эффективный инференс, полезно вернуться к Алгоритмам и Структурам данных.
• Инженерия сервисов. ML-система на 90% состоит из обычного бэкенда: очереди, таймауты, обсервабилити. См. Go и Архитектурные паттерны.
• Данные. Пайплайны, качество и происхождение данных — Data Engineering.
• Процесс. Как встроить evals и релизы моделей в работу команды — Управление продуктом и Управление проектами.

Полная карта портала с рекомендованным порядком изучения — в Роадмапе.