В дорожке про эмбеддинги мы пользовались готовыми векторами смысла, а в дорожке про поиск — искали по ним куски текста. Сегодня — откуда берутся такие векторы: как модель учат ставить вопрос рядом с нужным текстом и подальше от остальных. Узкий вопрос дня: контрастное обучение (contrastive learning) — потеря InfoNCE, негативы внутри пакета, температура, трудные негативы и ловушки вроде ложных негативов. Все примеры ниже запускались на коробке на игрушечных данных с известным «смыслом»: обучаем маленькую линейную модель вручную на numpy. Цифры из чужих работ и библиотек помечены как опубликованные, а не измеренные нами.
Все дорожки — /put. Прошлая — почти-дубли.
Зачем это в работе. Поиск по смыслу в RAG, в базе знаний или в почте работает так: каждый текст заранее превращают в эмбеддинг — вектор из нескольких сотен чисел, — а вопрос пользователя превращают в такой же вектор и ищут ближайшие. Качество такого поиска почти целиком определяется тем, как обучена модель, которая делает векторы. Если вы выбираете готовую модель эмбеддингов, дообучаете её на своих документах или разбираетесь, почему поиск находит «похожее, но не то», нужно понимать, чему именно её учили. Почти все современные модели эмбеддингов текста и картинок учат одним способом — контрастным обучением (contrastive learning): показывают пары, которые должны быть рядом, и пары, которые должны быть далеко.
Как это устроено. Исходный материал — пары (pairs): вопрос и текст, который на него отвечает; заголовок и тело статьи; картинка и подпись к ней. Такие пары называют позитивами (positives): «эти два объекта про одно и то же». Разметить, что вопрос и текст про одно и то же, гораздо проще, чем выставить каждому тексту оценку близости по шкале, поэтому пар можно собрать миллионы — из поисковых логов, форумов вопрос-ответ, подписей к картинкам.
Модель-кодировщик (encoder) превращает каждый текст в вектор. Обычно векторы нормируют — делят на длину, чтобы длина была равна 1, — и тогда близость двух векторов равна косинусу угла между ними (косинусное сходство, cosine similarity): 1 — смотрят в одну сторону, 0 — перпендикулярны. Цель обучения: косинус у своей пары высокий, у чужих — низкий. Важно, что «чужих» никто отдельно не размечает: ими считаются все остальные тексты, которые не являются парой этому вопросу. Такие чужие примеры называют негативами (negatives).
Ограничение: модель учится ровно тому понятию близости, которое заложено в пары. Если пары собраны из «заголовок — статья», модель научится находить статьи по заголовкам, но не обязательно ответы на вопросы. Если в парах почти не было кода, код она будет размещать плохо. Поэтому для своей области модель часто дообучают на своих парах.
Чем это отличается от соседей. Языковая модель учится предсказывать следующее слово, и её внутренние векторы не обязаны делать «похожие по смыслу тексты близкими». Перекрёстный кодировщик (cross-encoder), который в дорожке про поиск делал пересортировку, читает вопрос и текст вместе и выдаёт одну оценку — он точнее, но его нельзя посчитать заранее для всей базы. Модель, которую учат контрастно, — двойной кодировщик (bi-encoder): вопрос и текст кодируются по отдельности, векторы текстов считают один раз и складывают в индекс.
Подробный пример. Чтобы видеть, что происходит, нужны данные с известным смыслом. Мы сделали игрушечный набор: 300 «семей» по 10 документов. Семья — общая тема, у каждого документа ещё свои детали. Вопрос и нужный текст — два разных зашумлённых взгляда на один и тот же смысл, по 64 признака (признак — просто одно число в описании объекта). 16 признаков из 64 — громкий шум, не связанный со смыслом: так в настоящих текстах длина, стиль и служебные слова мешают сравнивать по содержанию. Модель — одна матрица 64 × 8, которая сжимает 64 признака в эмбеддинг из 8 чисел; учим её вручную на numpy потерей, которую разберём на второй ступени. Обучение — на 250 семьях, проверка — на 50 других семьях, которых модель не видела.
import numpy as np
from common import l2n, recall_at_1, infonce, train
def make_data(n_fam=300, per_fam=10, d_f=16, d_i=16, d_x=64, fam_scale=1.0, ind_scale=0.5,
noise=0.3, nuis=3.0, seed=0):
rng = np.random.default_rng(seed)
f = np.repeat(rng.normal(size=(n_fam, d_f)), per_fam, axis=0) # общая тема семьи
i = rng.normal(size=(n_fam * per_fam, d_i)) # свои детали документа
Af = rng.normal(size=(d_f, d_x)) / np.sqrt(d_f)
Ai = rng.normal(size=(d_i, d_x)) / np.sqrt(d_i)
def view(s):
r = np.random.default_rng(s)
x = fam_scale * f @ Af + ind_scale * i @ Ai + noise * r.normal(size=(len(f), d_x))
x[:, :16] += nuis * r.normal(size=(len(f), 16))
return x
return view(seed + 1), view(seed + 2), np.repeat(np.arange(n_fam), per_fam)
from common2 import *
# 300 «семей» по 10 документов: семья = общая тема, у каждого документа свои детали.
# Xq — признаки вопросов, Xp — признаки нужных текстов; 16 из 64 признаков — громкий шум.
Xq, Xp, fam = make_data(ind_scale=0.3, noise=0.2)
NTR = 2500 # 250 семей на обучение, 50 семей (500 пар) — проверка
te = slice(NTR, None)
def evaluate(W):
q, _ = l2n(Xq[te] @ W); p, _ = l2n(Xp[te] @ W)
top = (q @ p.T).argmax(1)
exact = np.mean(top == np.arange(len(q))) # нашли именно тот текст
same = np.mean(fam[te][top] == fam[te]) # нашли хотя бы текст той же семьи
return exact, same
def fam_batches(k):
ftr = fam[:NTR]; fams = np.unique(ftr)
def h(rng, B): # пакет из B/k семей по k документов
fs = rng.choice(fams, B // k, replace=False)
return np.concatenate([rng.choice(np.where(ftr == f)[0], k, replace=False) for f in fs])
return h
from data import *
def cos_stats(A, B):
a, _ = l2n(A); b, _ = l2n(B); S = a @ b.T; f = fam[te]
same = (f[:, None] == f[None, :]) & ~np.eye(len(f), dtype=bool)
other = f[:, None] != f[None, :]
return np.diag(S).mean(), S[same].mean(), S[other].mean()
print("косинус: своя пара | та же семья | чужая семья")
print("сырые признаки %.3f | %.3f | %.3f" % cos_stats(Xq[te], Xp[te]))
W, _ = train(Xq[:NTR], Xp[:NTR], tau=0.05, batch=64, steps=2000, d_out=8)
print("после обучения %.3f | %.3f | %.3f" % cos_stats(Xq[te] @ W, Xp[te] @ W))
print("поиск среди 500 текстов (точно / та же семья):")
print(" сырые признаки (64 числа): %.3f / %.3f" % evaluate(np.eye(64)))
W0 = np.random.default_rng(0).normal(size=(64, 8)) / 8
print(" случайная проекция в 8 чисел: %.3f / %.3f" % evaluate(W0))
print(" обученная проекция в 8 чисел: %.3f / %.3f" % evaluate(W))
У нас этот код напечатал:
косинус: своя пара | та же семья | чужая семья
сырые признаки 0.306 | 0.291 | -0.003
после обучения 0.972 | 0.831 | -0.008
поиск среди 500 текстов (точно / та же семья):
сырые признаки (64 числа): 0.072 / 0.554
случайная проекция в 8 чисел: 0.010 / 0.080
обученная проекция в 8 чисел: 0.870 / 0.994
Что видно. На сырых признаках своя пара в среднем похожа на вопрос (0,31) почти так же, как любой документ той же семьи (0,29): шум и общая тема заглушают детали, и среди 500 текстов нужный находится первым лишь в 7% случаев. Случайное сжатие до 8 чисел делает только хуже — 1%. После обучения та же по размеру матрица даёт 87% точных попаданий и 99% попаданий хотя бы в нужную семью: своя пара поднялась до 0,97, документы той же семьи — до 0,83, чужие семьи остались около нуля. Модель сама нашла, какие признаки выбросить и какие сохранить, — только по парам.
Где обычно ошибаются.
Словарь ступени.
Контрастное обучение (contrastive learning). Обучение, при котором модель сближает векторы своих пар и отдаляет векторы чужих.
Позитив (positive). Объект, который должен оказаться рядом с данным: нужный текст для вопроса, подпись для картинки.
Негатив (negative). Объект, который должен оказаться далеко от данного; обычно это просто чужие примеры.
Кодировщик (encoder). Модель, которая превращает текст или картинку в вектор фиксированной длины.
Косинусное сходство (cosine similarity). Косинус угла между векторами, от −1 до 1; для векторов длины 1 равен их скалярному произведению.
Двойной кодировщик (bi-encoder). Схема, где вопрос и текст кодируются по отдельности, а сравниваются уже готовые векторы.
Перекрёстный кодировщик (cross-encoder). Модель, которая читает вопрос и текст вместе и выдаёт одну оценку их соответствия.
Признак (feature). Одно число в описании объекта, которое модель получает на вход.
Зачем это в работе. Почти все библиотеки для обучения эмбеддингов по умолчанию предлагают одну и ту же потерю: в sentence-transformers она называется MultipleNegativesRankingLoss, в статьях — InfoNCE или потерей с негативами внутри пакета. Когда вы дообучаете модель на своих парах, вы почти наверняка будете пользоваться именно ей. Понимая, что она считает, вы поймёте, почему важны размер пакета, температура и отсутствие дублей в пакете — им посвящены следующие ступени.
Как это устроено. Шаг первый: берут пакет (batch) из B пар — B вопросов и B нужных им текстов. Шаг второй: кодируют всё и считают матрицу сходства B × B: в строке i — косинусы вопроса i со всеми B текстами пакета. На диагонали стоят свои пары, вне диагонали — чужие. Шаг третий: каждый косинус делят на температуру τ (о ней — третья ступень) и по каждой строке считают софтмакс (softmax) — превращают строку чисел в вероятности, которые в сумме дают 1. Получается ответ на вопрос «какой из B текстов — мой?».
Шаг четвёртый: потеря строки — минус логарифм вероятности своей пары, то есть ровно та же перекрёстная энтропия, которой учат языковую модель угадывать следующий токен (дорожка про потерю), только «словарь» здесь — тексты пакета. Потеря пакета — среднее по строкам. Эту потерю ввели под названием InfoNCE ван ден Оорд и соавторы (2018), а для поиска текстов её с негативами внутри пакета использовала, например, опубликованная модель DPR (Karpukhin и соавторы, 2020).
Главная хитрость — негативы внутри пакета (in-batch negatives): для вопроса i негативами служат тексты остальных B − 1 пар. Их не нужно собирать и кодировать отдельно: они уже посчитаны. Один пакет из B пар даёт B задач «угадай из B», то есть B·(B − 1) сравнений с негативами за цену кодирования 2B текстов. Часто считают потерю в обе стороны — «для вопроса найди текст» и «для текста найди вопрос» — и складывают; так делали, например, в CLIP.
Ограничение: потеря ничего не знает о том, насколько чужой текст чужой. Все негативы для неё одинаково «неправильные», даже если какой-то из них на самом деле тоже отвечает на вопрос (пятая ступень). Чем это отличается от соседей: тройная потеря (triplet loss) берёт один позитив и один негатив и требует, чтобы позитив был ближе на заданный зазор; InfoNCE сравнивает сразу со многими негативами и обходится без зазора.
Подробный пример. Три проверки. Первая — матрица сходства и вероятности по строкам для пакета из четырёх пар после обучения: две пары из одной семьи и две из других. Вторая — потеря необученной модели: при равных шансах она должна быть около log B. Третья — сверяем наш ручной градиент с численным, посчитанным конечными разностями (чуть сдвигаем каждый вес вверх и вниз и смотрим, как меняется потеря).
from data import *
np.set_printoptions(precision=2, suppress=True)
# 1) пакет из 4 пар после обучения: матрица сходства и вероятности по строкам
W, _ = train(Xq[:NTR], Xp[:NTR], tau=0.05, batch=64, steps=2000, d_out=8)
idx = np.array([2500, 2501, 2600, 2700]) # два документа одной семьи + два из других
q, _ = l2n(Xq[idx] @ W); p, _ = l2n(Xp[idx] @ W)
S = q @ p.T
print("косинусы (строка — вопрос, столбец — текст):"); print(S)
for tau in (1.0, 0.05):
L = S / tau; P = np.exp(L - L.max(1, keepdims=True)); P /= P.sum(1, keepdims=True)
print(f"tau={tau}: вероятности по строкам"); print(P)
print(" потеря по строкам:", -np.log(np.diag(P)), " средняя:", round(float(-np.log(np.diag(P)).mean()), 3))
# 2) необученная модель: при tau=1 потеря около log B, при малой tau — больше (уверенно ошибается)
rng = np.random.default_rng(1)
W0 = rng.normal(size=(64, 8)) / 8
for B in (4, 64, 256):
i = rng.choice(NTR, B, replace=False)
l1, _ = infonce(Xq[i], Xp[i], W0, tau=1.0)
l2, _ = infonce(Xq[i], Xp[i], W0, tau=0.05)
print(f"B={B:3d}: log B = {np.log(B):.2f}; без обучения при tau=1: {l1:.2f}, при tau=0.05: {l2:.2f}")
# 3) проверка ручного градиента конечными разностями
i = rng.choice(NTR, 16, replace=False)
l, g = infonce(Xq[i], Xp[i], W0, tau=0.1)
num = np.zeros_like(W0); e = 1e-5
for a in range(64):
for b in range(8):
Wp = W0.copy(); Wp[a, b] += e; Wm = W0.copy(); Wm[a, b] -= e
num[a, b] = (infonce(Xq[i], Xp[i], Wp, 0.1)[0] - infonce(Xq[i], Xp[i], Wm, 0.1)[0]) / (2 * e)
print("отн. расхождение ручного и численного градиента:", f"{np.linalg.norm(g - num) / np.linalg.norm(num):.1e}")
У нас этот код напечатал:
косинусы (строка — вопрос, столбец — текст):
[[ 0.97 0.87 0.09 -0.43]
[ 0.91 0.99 0.15 -0.38]
[ 0.15 0.23 0.95 0.03]
[-0.41 -0.1 0.27 0.97]]
tau=1.0: вероятности по строкам
[[0.39 0.35 0.16 0.1 ]
[0.35 0.38 0.17 0.1 ]
[0.19 0.21 0.43 0.17]
[0.12 0.16 0.24 0.48]]
потеря по строкам: [0.94 0.96 0.85 0.74] средняя: 0.872
tau=0.05: вероятности по строкам
[[0.88 0.12 0. 0. ]
[0.19 0.81 0. 0. ]
[0. 0. 1. 0. ]
[0. 0. 0. 1. ]]
потеря по строкам: [0.13 0.21 0. 0. ] средняя: 0.084
B= 4: log B = 1.39; без обучения при tau=1: 1.41, при tau=0.05: 7.31
B= 64: log B = 4.16; без обучения при tau=1: 3.98, при tau=0.05: 11.21
B=256: log B = 5.55; без обучения при tau=1: 5.31, при tau=0.05: 11.77
отн. расхождение ручного и численного градиента: 1.6e-07
Что видно. Первые два вопроса из одной семьи: их тексты похожи на оба вопроса (0,87 и 0,91 вне диагонали) — это и есть трудные негативы друг для друга. При τ = 1 вероятности почти ровные (0,39 против 0,35), и потеря высокая, хотя порядок правильный; при τ = 0,05 те же косинусы дают своей паре 0,88 и 0,81. Необученная модель при τ = 1 даёт потерю около log B (1,41 при log 4 = 1,39; 5,31 при log 256 = 5,55), то есть угадывает наугад; при τ = 0,05 случайные косинусы, умноженные на 20, делают её уверенно неправой, и потеря выше — 7–12. Ручной градиент совпал с численным с относительной разницей 1,6·10⁻⁷ — формулы в infonce верные.
Где обычно ошибаются.
Словарь ступени.
InfoNCE. Потеря: минус логарифм вероятности своей пары после софтмакса по сходствам с позитивом и негативами.
Пакет (batch). Группа примеров, которые обрабатываются вместе за один шаг обучения.
Негативы внутри пакета (in-batch negatives). Чужие тексты из того же пакета, используемые как негативы без отдельного сбора.
Матрица сходства. Таблица B × B косинусов всех вопросов пакета со всеми текстами пакета; свои пары — на диагонали.
Софтмакс (softmax). Превращение строки чисел в вероятности: экспонента каждого числа, делённая на сумму экспонент.
Перекрёстная энтропия (cross-entropy). Минус логарифм вероятности, которую модель дала правильному варианту.
Тройная потеря (triplet loss). Потеря на тройках «объект, позитив, негатив» с требуемым зазором между их расстояниями.
Проверка градиента конечными разностями. Сравнение ручного градиента с численным, полученным малыми сдвигами весов.
Зачем это в работе. Температура — одно число, но от него сильно зависит результат: в нашем опыте ниже поиск на одних и тех же данных находит нужный текст то в 60%, то в 88% случаев только из-за её значения. В настройках библиотек она часто спрятана под другим именем: в sentence-transformers это параметр scale = 1/τ, по умолчанию 20, то есть τ = 0,05; в CLIP её учат вместе с моделью. Чтобы менять её осознанно, нужно понимать, что она делает с обучением.
Как это устроено. Косинус лежит между −1 и 1. Без деления на температуру (τ = 1) разница между лучшим и худшим текстом в строке не больше 2, и софтмакс физически не может дать своей паре вероятность, близкую к единице, если негативов много. Отсюда нижняя граница потери: даже при идеальной раскладке она остаётся заметно выше нуля, и градиент продолжает толкать все пары, уже правильно разложенные. Деление на маленькое τ растягивает шкалу: при τ = 0,05 разница в косинусе 0,1 превращается в разницу 2 в «логитах» — числах перед софтмаксом.
Второй эффект важнее. Градиент от каждого негатива пропорционален его вероятности после софтмакса. При большой температуре вероятности почти ровные, и толчок размазан по всем негативам, большинство из которых и так далеко. При маленькой температуре почти весь толчок получает самый похожий негатив — тот, который модель путает со своей парой. Это свойство разобрали Ван и Лю («Understanding the Behaviour of Contrastive Loss», 2021): температура управляет тем, насколько потеря сосредоточена на трудных негативах.
Ограничение: слишком маленькая τ тоже вредит. Обучение начинает реагировать почти только на самый похожий негатив в каждой строке, а им часто оказывается шум или почти-правильный ответ; остальные негативы перестают учить. Кроме того, логиты становятся огромными, и шаги делаются нестабильными. В опубликованной работе CLIP (Radford и соавторы, 2021) температуру учили как параметр, начиная с 0,07, и ограничивали так, чтобы логиты умножались не больше чем на 100 (τ не меньше 0,01): авторы пишут, что без этого ограничения обучение было нестабильным.
Чем это отличается от соседей. Температура при выборе следующего слова в первой дорожке работает на выдаче готовой модели и меняет только разброс ответов. Здесь температура стоит внутри потери при обучении и меняет, чему модель научится.
Подробный пример. Три части. Первая — арифметика без обучения: строка из своей пары с косинусом 0,8, одного трудного негатива 0,7 и 62 лёгких по 0,2; смотрим, какая доля «толчка» от негативов приходится на трудный. Вторая — нижняя граница потери при τ = 1 и пакете 64. Третья — обучаем модель из первой ступени при шести температурах, по три запуска с разными начальными весами.
from data import *
# 1) куда уходит «толчок» от негативов при разной температуре
sims = np.array([0.8, 0.7] + [0.2] * 62) # своя пара 0.8, один трудный негатив 0.7, 62 лёгких 0.2
print("доля веса негативов, приходящаяся на трудный (из 63 негативов):")
for tau in (1.0, 0.3, 0.1, 0.05, 0.02):
L = sims / tau; P = np.exp(L - L.max()); P /= P.sum()
print(f" tau={tau:<4}: {P[1] / P[1:].sum():.3f} вероятность своей пары {P[0]:.3f}")
# 2) нижняя граница потери при tau=1: даже идеальная раскладка не даёт нуля
B = 64
best = -np.log(np.e / (np.e + (B - 1) * np.exp(-1 / (B - 1))))
print(f"tau=1, B=64: минимально возможная потеря {best:.2f} (своя пара cos=1, чужие cos=-1/63)")
# 3) обучение при разных температурах: 3 запуска, пакеты 64 случайные
print("tau | точно (3 запуска) | среднее | та же семья")
for tau in (1.0, 0.3, 0.1, 0.05, 0.02, 0.01):
r = [evaluate(train(Xq[:NTR], Xp[:NTR], tau=tau, steps=2000, d_out=8, seed=s)[0]) for s in range(3)]
ex = [a for a, _ in r]; sm = np.mean([b for _, b in r])
print(f"{tau:<5} | {' '.join(f'{x:.3f}' for x in ex)} | {np.mean(ex):.3f} | {sm:.3f}")
У нас этот код напечатал:
доля веса негативов, приходящаяся на трудный (из 63 негативов):
tau=1.0 : 0.026 вероятность своей пары 0.028
tau=0.3 : 0.079 вероятность своей пары 0.099
tau=0.1 : 0.705 вероятность своей пары 0.657
tau=0.05: 0.997 вероятность своей пары 0.881
tau=0.02: 1.000 вероятность своей пары 0.993
tau=1, B=64: минимально возможная потеря 3.17 (своя пара cos=1, чужие cos=-1/63)
tau | точно (3 запуска) | среднее | та же семья
1.0 | 0.604 0.588 0.620 | 0.604 | 0.999
0.3 | 0.700 0.628 0.698 | 0.675 | 0.999
0.1 | 0.888 0.870 0.864 | 0.874 | 0.994
0.05 | 0.870 0.892 0.874 | 0.879 | 0.989
0.02 | 0.814 0.828 0.856 | 0.833 | 0.993
0.01 | 0.782 0.754 0.782 | 0.773 | 0.997
Что видно. При τ = 1 трудному негативу достаётся 2,6% веса — почти столько же, сколько каждому из 62 лёгких; при τ = 0,1 — уже 70%, при 0,05 — практически всё. Нижняя граница потери при τ = 1 и B = 64 — 3,17, то есть потеря никогда не опустится ниже, как бы хорошо ни училась модель. В обучении τ = 1 даёт 60% точных попаданий: модель прекрасно отличает семьи (99,9%), но не детали внутри семьи, — толчок от «соседей по семье» тонет среди лёгких негативов. Лучше всего у нас τ = 0,05–0,1 (87–88%), дальше качество снова падает: 83% при 0,02 и 77% при 0,01. Это наши данные и наша маленькая модель; на других данных лучшая точка будет другой, но форма «горба» — типичная.
Где обычно ошибаются.
Словарь ступени.
Температура (temperature, τ). Число, на которое делят сходства перед софтмаксом; меньше τ — резче распределение.
Scale. Обратная температура, 1/τ; так её задают, например, в sentence-transformers (по умолчанию 20).
Логит (logit). Число перед софтмаксом; здесь — косинус, делённый на температуру.
Трудный негатив (hard negative). Чужой пример, который модель пока считает похожим на свою пару.
Лёгкий негатив (easy negative). Чужой пример, который и так далеко; почти ничему не учит.
Нижняя граница потери. Наименьшее значение, ниже которого потеря не опустится при данных τ и B, даже при идеальной модели.
Обучаемая температура. Температура как параметр модели, который подбирается градиентом вместе с весами.
Зачем это в работе. Негативы внутри пакета — случайные тексты, и большинство из них слишком непохожи, чтобы чему-то научить. Есть два рычага: увеличить пакет, чтобы среди случайных негативов чаще попадались трудные, или подбирать трудные негативы намеренно. Оба стоят денег — памяти ускорителя или дополнительного поиска по корпусу, — и оба могут навредить, если перестараться. Это главные решения при дообучении модели эмбеддингов на своих данных.
Как это устроено. Размер пакета. Каждая строка матрицы сходства — задача «угадай из B». Чем больше B, тем больше негативов на каждый вопрос и тем выше шанс, что среди них окажется трудный. Поэтому контрастные модели учат на огромных пакетах: в опубликованной работе CLIP пакет был 32 768 пар. Цена — матрица B × B и активации всех 2B примеров в памяти; при обучении на многих ускорителях векторы собирают со всех устройств, чтобы негативов стало больше (в sentence-transformers для этого есть параметр gather_across_devices).
Трудные негативы. Вместо того чтобы ждать удачи, для каждого вопроса заранее находят тексты, которые похожи, но не являются ответом: лучшие результаты поиска по словам (BM25) или текущей версией модели, кроме размеченного ответа. Их добавляют в пакет как лишние столбцы матрицы. В опубликованной модели DPR к каждому вопросу добавляли один такой негатив из выдачи BM25. Другой дешёвый способ — собирать пакет из близких тем, чтобы негативы внутри пакета сами стали трудными; именно его мы пробуем в примере.
Ограничение. Трудные негативы смещают обучение: если в пакете почти не осталось лёгких негативов, модель перестаёт тренироваться отличать далёкие темы и может начать путать то, что раньше различала. Кроме того, самые трудные «негативы» часто на самом деле правильные ответы, которые просто не разметили (пятая ступень). Поэтому смешивают: часть случайных, часть трудных.
Связь с температурой. Маленькая τ уже сосредотачивает градиент на трудных негативах внутри случайного пакета; трудные пакеты делают то же самое через данные. Два рычага частично заменяют друг друга, и выкрутить оба до предела — частая ошибка.
Подробный пример. Первая часть — размер пакета 4, 16, 64 и 256 при τ = 0,05 со случайными пакетами. Вторая — трудные пакеты: 64 пары как 16 семей по 4 документа, так что у каждого вопроса три негатива из той же семьи; сравниваем при трёх температурах. Третья — делаем пакеты ещё «труднее»: 32 семьи по 2, 16 по 4, 8 по 8. Везде среднее трёх запусков.
import time
from data import *
def run(n=3, **kw):
r = [evaluate(train(Xq[:NTR], Xp[:NTR], steps=2000, d_out=8, seed=s, **kw)[0]) for s in range(n)]
return np.mean([a for a, _ in r]), np.mean([b for _, b in r])
print("1) размер пакета, tau=0.05, случайные пакеты (среднее 3 запусков):")
for B in (4, 16, 64, 256):
t = time.time(); ex, sm = run(tau=0.05, batch=B)
print(f" B={B:3d}: точно {ex:.3f}, та же семья {sm:.3f}, время 3 запусков {time.time() - t:.1f} с")
print("2) трудные негативы: пакет 64 = 16 семей по 4 документа")
for tau in (1.0, 0.3, 0.05):
a = run(tau=tau); b = run(tau=tau, hard=fam_batches(4))
print(f" tau={tau:<4}: случайные {a[0]:.3f} -> по семьям {b[0]:.3f}")
print("3) насколько «трудным» делать пакет: 64 = 64/k семей по k документов, tau=0.05")
for k in (2, 4, 8):
ex, sm = run(tau=0.05, hard=fam_batches(k))
print(f" k={k}: точно {ex:.3f}, та же семья {sm:.3f}")
У нас этот код напечатал:
1) размер пакета, tau=0.05, случайные пакеты (среднее 3 запусков):
B= 4: точно 0.353, та же семья 0.983, время 3 запусков 0.3 с
B= 16: точно 0.679, та же семья 0.996, время 3 запусков 0.4 с
B= 64: точно 0.879, та же семья 0.989, время 3 запусков 0.6 с
B=256: точно 0.901, та же семья 0.979, время 3 запусков 3.7 с
2) трудные негативы: пакет 64 = 16 семей по 4 документа
tau=1.0 : случайные 0.604 -> по семьям 0.842
tau=0.3 : случайные 0.675 -> по семьям 0.883
tau=0.05: случайные 0.879 -> по семьям 0.845
3) насколько «трудным» делать пакет: 64 = 64/k семей по k документов, tau=0.05
k=2: точно 0.875, та же семья 0.943
k=4: точно 0.845, та же семья 0.897
k=8: точно 0.809, та же семья 0.857
Что видно. С пакетом 4 модель различает семьи (98%), но точный текст находит в 35% случаев; рост пакета до 64 поднимает точность до 88%, до 256 — до 90%, а время выросло примерно в пять раз — отдача падает. Трудные пакеты сильно помогают там, где температура высокая: при τ = 1 точность растёт с 60% до 84%, при τ = 0,3 — с 68% до 88%. Но при τ = 0,05, где температура уже сделала эту работу, трудные пакеты немного вредят: 88% → 85%. Третья часть показывает, почему: чем больше документов одной семьи в пакете, тем хуже модель различает сами семьи — 94%, 90%, 86% попаданий в нужную семью против 99% у случайных пакетов. Модель перестала видеть лёгкие негативы и разучилась отличать далёкие темы.
Где обычно ошибаются.
Словарь ступени.
Размер пакета (batch size). Число пар в пакете; в контрастном обучении задаёт число негативов на каждый вопрос.
Добыча трудных негативов (hard negative mining). Подбор похожих, но неправильных текстов поиском по корпусу.
BM25. Классический поиск по совпадению слов с учётом их редкости; часто служит источником трудных негативов.
DPR. Опубликованная в 2020 году модель поиска текстов для ответов на вопросы, обученная с негативами внутри пакета и негативами из BM25.
Сбор векторов с устройств (gather). Объединение векторов со всех ускорителей, чтобы каждый вопрос видел больше негативов.
Накопление градиента (gradient accumulation). Сложение градиентов нескольких маленьких пакетов перед шагом; число негативов при этом не растёт.
Отложенные данные (held-out set). Примеры, на которых не учили и на которых проверяют качество.
Зачем это в работе. Контрастная потеря считает негативом всё, что не размечено как пара. На реальных данных это предположение нарушается постоянно: в пакет попадают два одинаковых вопроса, в корпусе лежат несколько правильных ответов, а среди «трудных негативов» половина на самом деле хорошие ответы. Ошибки не видны в логах как исключения — они проявляются как высокая потеря, которая не падает, или как модель, которая отталкивает правильные ответы. Знание этих ловушек экономит недели дообучения.
Как это устроено. Ложные негативы (false negatives). Если вопрос i в пакете имеет второй правильный ответ j, потеря требует отодвинуть j подальше. Модель не может этого сделать честно, ведь смысл одинаковый, — и либо остаётся с высокой потерей, либо, если она достаточно большая, учится различать их по случайным мелочам, то есть запоминает шум. Опубликованная работа RocketQA (Qu и соавторы, 2021) вручную проверила верхушку выдачи для 100 вопросов MSMARCO, не размеченную как правильные ответы, и нашла, что около 70% этих текстов на самом деле правильные или очень близкие; авторы сообщают, что трудные негативы без очистки ухудшили качество, и фильтровали их перекрёстным кодировщиком.
Дубли в пакете. Самый простой случай ложного негатива — один и тот же вопрос или текст дважды в пакете. В sentence-transformers для этого есть отдельный режим формирования пакетов NO_DUPLICATES, который не кладёт в один пакет повторяющиеся тексты. Лечится и маской: известные дубли и близнецов исключают из знаменателя софтмакса. Отсюда связь со вчерашней дорожкой про почти-дубли: дедупликация пар до обучения прямо снижает число ложных негативов.
Асимметрия вопроса и текста. Вопрос короткий, текст длинный, и они устроены по-разному. Многие модели учат с префиксами: например, в опубликованной модели E5 к вопросу приписывают «query: », а к тексту — «passage: ». Если при поиске забыть префиксы или поставить один и тот же к обоим, качество падает, хотя ничего не ломается явно. Правило: при использовании модели кодируйте так же, как кодировали при обучении.
Короткие пути (shortcuts). Если позитивы можно отличить по поверхностному признаку — одинаковый язык, совпадающие слова, общий формат, — модель выучит этот признак вместо смысла. В нашем первом опыте при τ = 1 модель выучила «семью» и не выучила детали: это та же болезнь в мягкой форме.
Подробный пример. Делаем данные, где документы в семье идут парами-близнецами: одинаковый смысл, разный шум. Для вопроса к одному близнецу второй — тоже правильный ответ, но в разметке он чужой. Учим на пакетах по семьям (близнецы часто оказываются рядом) без маски и с маской близнецов; затем на одном и том же контрольном пакете смотрим потерю строк, где есть близнец, и строк, где его нет.
from common2 import *
# Данные как раньше, но в каждой семье документы идут парами-«близнецами»:
# у пары одинаковый смысл (те же детали), различается только шум. Для вопроса к одному
# из близнецов второй — тоже правильный ответ, но в разметке он записан как негатив.
rng = np.random.default_rng(0)
f = np.repeat(rng.normal(size=(300, 16)), 10, axis=0); i = rng.normal(size=(3000, 16))
i[1::2] = i[0::2]; twin = np.arange(3000) // 2 # 0 и 1 — близнецы, 2 и 3 — близнецы ...
Af = rng.normal(size=(16, 64)) / 4; Ai = rng.normal(size=(16, 64)) / 4
def view(s):
r = np.random.default_rng(s); x = f @ Af + 0.3 * i @ Ai + 0.2 * r.normal(size=(3000, 64))
x[:, :16] += 3 * r.normal(size=(3000, 16)); return x
Xq, Xp = view(1), view(2); fam = np.arange(3000) // 10; NTR = 2500
def batches(rng, B): # 16 семей по 4 документа: близнецы часто рядом
fs = rng.choice(250, B // 4, replace=False)
return np.concatenate([rng.choice(np.arange(f * 10, f * 10 + 10), 4, replace=False) for f in fs])
def mask_twins(idx):
M = twin[idx][:, None] == twin[idx][None, :]; np.fill_diagonal(M, False); return M
fixed = batches(np.random.default_rng(99), 64) # один и тот же пакет для замера потери
has_twin = mask_twins(fixed).any(1)
print(f"в контрольном пакете строк с близнецом: {has_twin.sum()} из 64")
for name, mf in (("без маски", None), ("с маской", mask_twins)):
rows_t, rows_o, rec = [], [], []
for s in range(3):
W, _ = train(Xq[:NTR], Xp[:NTR], tau=0.05, steps=2000, d_out=8, seed=s, hard=batches, mask_fn=mf)
q, _ = l2n(Xq[fixed] @ W); p, _ = l2n(Xp[fixed] @ W)
S = q @ p.T / 0.05; P = np.exp(S - S.max(1, keepdims=True)); P /= P.sum(1, keepdims=True)
lr = -np.log(np.diag(P)); rows_t.append(lr[has_twin].mean()); rows_o.append(lr[~has_twin].mean())
q, _ = l2n(Xq[NTR:] @ W); p, _ = l2n(Xp[NTR:] @ W); top = (q @ p.T).argmax(1)
rec.append(np.mean(twin[NTR:][top] == twin[NTR:]))
print(f"{name}: потеря строк с близнецом {np.mean(rows_t):.2f}, без близнеца {np.mean(rows_o):.2f}; "
f"поиск (близнец засчитан) {np.mean(rec):.3f}")
print(f"для сравнения: log 2 = {np.log(2):.2f} — потеря, когда модель честно делит вероятность между близнецами")
У нас этот код напечатал:
в контрольном пакете строк с близнецом: 24 из 64
без маски: потеря строк с близнецом 0.70, без близнеца 0.09; поиск (близнец засчитан) 0.943
с маской: потеря строк с близнецом 0.72, без близнеца 0.08; поиск (близнец засчитан) 0.944
для сравнения: log 2 = 0.69 — потеря, когда модель честно делит вероятность между близнецами
Что видно. Строки с близнецом застревают на потере около 0,70 — это почти точно log 2: модель честно делит вероятность пополам между двумя одинаковыми по смыслу текстами, и лучше без ошибки сделать нельзя. Строки без близнеца — 0,08–0,09. В контрольном пакете 24 строки из 64 имеют близнеца, и они дают около 82% всей потери пакета (24 × 0,70 против 40 × 0,09). Если смотреть только на среднюю потерю, кажется, что модель учится плохо, хотя она делает всё правильно. Качество поиска с маской и без неё у нас одинаковое (94%): наша линейная модель слишком мала, чтобы запомнить шум и растащить близнецов. Большая сеть так сделать может, и тогда ложные негативы бьют уже по качеству — именно это, по их отчёту, наблюдали авторы RocketQA.
Где обычно ошибаются.
Словарь ступени.
Ложный негатив (false negative). Пример, помеченный как чужой, хотя на самом деле он тоже правильный ответ.
Маска (mask). Исключение известных ложных негативов из софтмакса, чтобы потеря их не отталкивала.
NO_DUPLICATES. Режим формирования пакетов в sentence-transformers, который не кладёт повторяющиеся тексты в один пакет.
RocketQA. Опубликованный в 2021 году способ обучения поиска, известный очисткой трудных негативов перекрёстным кодировщиком.
MSMARCO. Большой открытый набор поисковых вопросов Bing и текстов-ответов, стандарт для обучения и проверки поиска.
Префикс (prefix). Служебная приписка к тексту перед кодированием, например «query: », сообщающая модели роль текста.
Короткий путь (shortcut). Поверхностный признак, по которому модель угадывает пары вместо настоящего смысла.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.