Модуль 7. Модели награды и данные о предпочтениях

Корректный вывод:

При данном запросе, этих двух кандидатах, данной рубрике, этом разметчике и принятом протоколе ответ A был предпочтён ответу B.

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

Метка 1/0 является кодом наблюдения, а не доказанной истинной наградой. Если критерий смешивает «подробность» и «краткость» без правила компромисса, более мощная RM лишь точнее воспроизведёт непоследовательность данных. Мощность модели не заменяет спецификацию цели.

1. Для обязательного правила безопасности естественна бинарная метка или результат программной проверки: нарушение есть либо нет.

2. Для четырёх близких ответов полезно ранжирование списка, возможно с ничьими.

3. Для практически эквивалентных ответов нужна ничья; принудительный выбор создаёт ложный сигнал.

4. При отсутствии необходимого источника правильный исход — отказ от решения, а не случайная оценка.

Попарный формат не универсален. Он удобен для локального сравнения, но плохо выражает абсолютный порог, полный список и отсутствие достаточных данных.

Три источника завышения:

1. позиционный признак: первый ответ почти всегда победитель;

2. имя генератора: метка отражает репутацию модели;

3. утечка запроса между обучением и тестом.

Исправление: скрыть генератор от разметчика, случайно переставлять A/B, разрешить ничью или отказ, сохранять рубрику и собирать несколько решений для важных пар. Разбиение делается по идентификатору запроса, а дополнительные тесты — по генератору, домену и времени.

В служебных данных сохраняются модель и версия генератора, параметры декодирования, шаблон диалога, порядок показа, рубрика, разметчик или судья, дата, происхождение и лицензия. Эти поля нужны для аудита, даже когда они не показаны человеку.

1. Нет. В BT входит разность, поэтому добавка $c(x)$ сокращается.

2. Нет. Внутриподсказочные пары не фиксируют абсолютный нуль между запросами. Общая шкала нейросетевой RM появляется благодаря общим параметрам, регуляризации и данным, а не как прямое следствие пар.

3. Положительное масштабирование сохраняет знак каждой разности и порядок. Но вероятность $\sigma(\alpha\Delta)$ меняется: при $\alpha>1$ она становится увереннее. Поэтому точность может совпасть, а логарифмические потери и калибровка — нет.

Модели не эквивалентны. Точность учитывает только знак разности. Логарифмическая функция потерь сильно штрафует уверенную ошибку. Оценка Брайера измеряет средний квадрат ошибки вероятности. Диаграмма надёжности сравнивает заявленную уверенность с частотой побед; ECE агрегирует расхождение по интервалам.

Если обе модели ошибаются на 20% пар, модель с вероятностями $0.99$ понесёт гораздо больший штраф на ошибках. Но даже хорошая калибровка на фиксированном наборе не гарантирует поведение под оптимизацией: политика может найти новые ответы, где RM использует ложные признаки.

В узкой модели существует скрытый строгий порядок, а наблюдаемая метка независимо переворачивается с вероятностью $\eta$. Оракул, всегда восстанавливающий скрытый порядок, совпадает с одной шумной меткой с вероятностью $1-\eta$.

Перенос ломается, если есть настоящие ничьи, несколько допустимых критериев, различная компетентность, зависимые ошибки, позиционное смещение, неодинаковая сложность пар, изменение решения после проверки источников или агрегация нескольких меток. Кроме того, потолок относительно одиночной шумной метки не равен потолку относительно агрегированного решения.

Малое расхождение означает лишь согласие членов ансамбля. Они могут одинаково ошибаться из-за общей базовой модели, одного набора данных и одного ложного признака.

Величина $\bar r-\lambda s$ — консервативная эвристика. Чтобы считать её доверительной границей, нужны предположения о независимости или структуре корреляций ошибок, калибровке, распределении оценок и соответствии будущих данных обучающим.

Разнообразие увеличивают независимые источники предобучения, разные архитектуры, наборы данных, рубрики, источники разметки и состязательные задачи. Разные случайные начальные значения одного и того же дообучения дают более слабое разнообразие.

Программный проверяющий отвечает только за формализованные свойства, например прохождение тестов. LLM-судья оценивает открытые критерии по рубрике. Агрегатор объединяет компоненты и применяет ограничения.

Защищённый протокол скрывает имена генераторов, отделяет недоверенный текст от инструкций, использует структурированный формат, проверяет выход, переставляет A/B, допускает ничью и отказ, повторяет критические оценки и сохраняет модель, версию, системный запрос, температуру и рубрику. Несогласованные случаи направляются человеку.

Линейная сумма позволяет компенсировать опасность высокой полезностью. Если безопасность не подлежит обмену, условие $q_{\mathrm{safe}}\ge\tau$ должно отбрасывать ответ независимо от остальных компонентов.

Для $\Delta=2$:

Для $\Delta=-2$:

Градиентный спуск увеличивает $\Delta$ в обоих случаях, но уверенно неправильная пара создаёт намного более сильное обновление.

При $\Delta=1.2$:

Вероятность $\sigma(1.2)\approx0.768525$, поэтому

Градиентный спуск уменьшает $\Delta$ к нулю. Однако модель по-прежнему имеет только два логистических исхода; цель $1/2$ не вводит отдельную вероятность ничьей.

Вероятность выбрать A первым:

После этого вероятность выбрать B среди B и C:

Итого

Отрицательный логарифм:

Все четыре решения находятся по правильную сторону порога, поэтому точность равна $1$.

Оценка Брайера:

Логарифмическая функция потерь:

Потери не равны нулю, потому что правильным исходам не назначена вероятность $1$.

В первом порядке A выглядит сильным, а после перестановки судья также сильно поддерживает B. Это признак позиционной чувствительности или нестабильности. Усреднение уменьшает чистое позиционное смещение, но не исправляет общую фактическую ошибку: судья может одинаково неверно понимать содержание в обоих порядках.

Для первого ответа:

Для второго:

Линейная сумма выбирает второй ответ. При ограничении $q_{\mathrm{safe}}\ge0.8$ второй ответ недопустим, поэтому выбирается первый. Это различие между обменным штрафом и жёстким требованием.

Используем тождество

import numpy as np


def pairwise_nll(delta: np.ndarray, target: np.ndarray | None = None) -> float:
    delta = np.asarray(delta, dtype=np.float64)
    if not np.all(np.isfinite(delta)):
        raise ValueError("delta must be finite")
    if target is None:
        target = np.ones_like(delta)
    target = np.broadcast_to(np.asarray(target, dtype=np.float64), delta.shape)
    if np.any((target < 0.0) | (target > 1.0)):
        raise ValueError("target must lie in [0, 1]")
    softplus = np.log1p(np.exp(-np.abs(delta))) + np.maximum(delta, 0.0)
    return float(np.mean(softplus - target * delta))


value = pairwise_nll(np.array([-1000.0, 1000.0]))
assert np.isfinite(value)

При $\Delta=-1000$ потеря близка к $1000$, а не к бесконечности из-за преждевременного округления сигмоиды к нулю.

import numpy as np


def logsumexp(x: np.ndarray) -> float:
    x = np.asarray(x, dtype=np.float64)
    if x.size == 0 or not np.all(np.isfinite(x)):
        raise ValueError("x must be non-empty and finite")
    maximum = float(np.max(x))
    return maximum + float(np.log(np.sum(np.exp(x - maximum))))


def plackett_luce_nll(scores: np.ndarray, ranking: np.ndarray) -> float:
    scores = np.asarray(scores, dtype=np.float64).reshape(-1)
    ranking = np.asarray(ranking, dtype=np.int64).reshape(-1)
    if set(ranking.tolist()) != set(range(len(scores))):
        raise ValueError("ranking must be a complete permutation")
    loss = 0.0
    remaining = ranking.tolist()
    while len(remaining) > 1:
        selected = remaining[0]
        loss += logsumexp(scores[remaining]) - float(scores[selected])
        remaining.pop(0)
    return loss


assert np.isclose(
    plackett_luce_nll(np.log([4.0, 2.0, 1.0]), np.array([0, 1, 2])),
    -np.log(8.0 / 21.0),
)

Вычитание максимума не меняет нормированную вероятность, но предотвращает переполнение экспоненты.

from dataclasses import dataclass
import numpy as np


@dataclass(frozen=True)
class Pair:
    winner: int
    loser: int
    weight: float = 1.0


def stable_sigmoid(x: float) -> float:
    if x >= 0:
        return 1.0 / (1.0 + np.exp(-x))
    exp_x = np.exp(x)
    return float(exp_x / (1.0 + exp_x))


def fit_scores(n_items: int, pairs: list[Pair], steps: int = 2000, lr: float = 0.05) -> np.ndarray:
    if n_items <= 0 or not pairs:
        raise ValueError("non-empty problem required")
    scores = np.zeros(n_items, dtype=np.float64)
    total_weight = sum(pair.weight for pair in pairs)
    for _ in range(steps):
        gradient = np.zeros_like(scores)
        for pair in pairs:
            if pair.weight <= 0:
                raise ValueError("weights must be positive")
            delta = scores[pair.winner] - scores[pair.loser]
            g = (stable_sigmoid(float(delta)) - 1.0) * pair.weight
            gradient[pair.winner] += g
            gradient[pair.loser] -= g
        scores -= lr * gradient / total_weight
        scores -= scores.mean()  # fixes the additive gauge
    return scores


transitive = fit_scores(3, [Pair(0, 1), Pair(1, 2)])
assert transitive[0] > transitive[1] > transitive[2]

cycle = fit_scores(3, [Pair(0, 1), Pair(1, 2), Pair(2, 0)])
assert np.allclose(cycle, 0.0, atol=1e-8)

Центрирование не добавляет информации. Оно выбирает удобный нуль среди эквивалентных решений.

import numpy as np


def calibration_bins(prob: np.ndarray, label: np.ndarray, n_bins: int = 10) -> list[dict[str, float]]:
    prob = np.asarray(prob, dtype=np.float64).reshape(-1)
    label = np.asarray(label, dtype=np.float64).reshape(-1)
    if prob.shape != label.shape or prob.size == 0:
        raise ValueError("aligned non-empty arrays required")
    if np.any((prob < 0) | (prob > 1)) or np.any((label < 0) | (label > 1)):
        raise ValueError("values must lie in [0, 1]")
    if n_bins <= 0:
        raise ValueError("n_bins must be positive")
    index = np.minimum((prob * n_bins).astype(int), n_bins - 1)
    result = []
    for bin_id in range(n_bins):
        mask = index == bin_id
        if not np.any(mask):
            continue
        result.append({
            "count": float(mask.sum()),
            "mean_confidence": float(prob[mask].mean()),
            "empirical_frequency": float(label[mask].mean()),
        })
    return result


def expected_calibration_error(prob: np.ndarray, label: np.ndarray, n_bins: int = 10) -> float:
    bins = calibration_bins(prob, label, n_bins)
    total = len(np.asarray(prob).reshape(-1))
    return float(sum(
        item["count"] / total * abs(item["mean_confidence"] - item["empirical_frequency"])
        for item in bins
    ))

Правило minimum(..., n_bins - 1) помещает вероятность $1.0$ в последний интервал.

import numpy as np


def conservative_ensemble_score(scores: np.ndarray, coefficient: float = 1.0) -> tuple[float, float, float]:
    scores = np.asarray(scores, dtype=np.float64).reshape(-1)
    if scores.size == 0 or not np.all(np.isfinite(scores)):
        raise ValueError("scores must be non-empty and finite")
    if coefficient < 0:
        raise ValueError("coefficient must be non-negative")
    mean = float(scores.mean())
    std = float(scores.std(ddof=0))
    conservative = mean - coefficient * std
    return mean, std, conservative

Это эвристика. Статистическая доверительная граница потребовала бы модели зависимости членов ансамбля, калибровки и предположений о распределении будущих ошибок.

import numpy as np


def toy_overoptimization(pool_sizes: list[int], trials: int = 4000, seed: int = 7) -> tuple[np.ndarray, np.ndarray]:
    if trials <= 0 or not pool_sizes or any(size <= 0 for size in pool_sizes):
        raise ValueError("positive pool sizes and trials required")
    rng = np.random.default_rng(seed)
    proxy_mean = []
    target_mean = []
    for size in pool_sizes:
        useful = rng.normal(size=(trials, size))
        nuisance = rng.normal(size=(trials, size))
        proxy = useful + nuisance
        target = useful - np.maximum(nuisance - 1.0, 0.0) ** 2
        selected = np.argmax(proxy, axis=1)
        row = np.arange(trials)
        proxy_mean.append(proxy[row, selected].mean())
        target_mean.append(target[row, selected].mean())
    return np.asarray(proxy_mean), np.asarray(target_mean)


def assert_prompt_disjoint(train_prompt_ids: list[str], eval_prompt_ids: list[str]) -> None:
    overlap = set(train_prompt_ids) & set(eval_prompt_ids)
    if overlap:
        preview = sorted(overlap)[:5]
        raise ValueError(f"prompt leakage: {preview}")


sizes = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
proxy, target = toy_overoptimization(sizes)
assert np.all(np.diff(proxy) > 0)
assert np.argmax(target) < len(target) - 1
assert_prompt_disjoint(["p1", "p2"], ["p3"])

Монотонность прокси — свойство конкретного воспроизводимого протокола с фиксированным начальным значением генератора случайных чисел, а не теорема для любой конечной выборки. Главный диагностический признак — расхождение прокси и независимой цели при усилении отбора.