«Кот съел мышь» и «мышь съела кота» состоят почти из тех же слов, а смысл противоположный. Человек читает порядок сам собой, а блок внимания, на котором стоит любая языковая модель, сам по себе порядка не видит: для него вход — это набор векторов, а не очередь. Сведения о позиции модели приходится подмешивать отдельно, и от того, как именно это сделано, зависит, сколько текста модель способна прочитать и что происходит, когда ей дают больше, чем она видела на обучении. Разберём, зачем нужны позиции, как их добавляли раньше, как устроены вращения RoPE, которые стоят в большинстве нынешних открытых моделей, почему контекст нельзя просто «увеличить в настройках» и как читать эти параметры в конфигурации модели. Весь код на странице мы запускали, выводы взяты из этих запусков; сведения о настоящих моделях подписаны источником.
Все дорожки — /put. Прошлая — смесь экспертов.
Зачем это в работе. Почти все неприятности с длинным контекстом — модель «теряет» середину документа, путает, что было раньше, ломается на длине больше заявленной — растут из того, как модель узнаёт позицию токена. Если понимать, что сведения о порядке не берутся из воздуха, а специально подмешиваются в вычисления, становится ясно, почему длина контекста — это свойство обучения, а не настройка сервера, и почему у двух моделей одного размера поведение на длинных текстах может различаться в разы.
Вспомним дорожку про внимание. Каждый токен превращается в три вектора: запрос (query) — «что я ищу», ключ (key) — «что я могу предложить» и значение (value) — «что я отдам, если меня выберут». Оценка связи двух токенов — это скалярное произведение запроса одного на ключ другого: перемножаем координаты попарно и складываем. Потом оценки превращаются в веса, и токен получает взвешенную сумму значений.
Посмотрим, чего в этой формуле нет. Запрос, ключ и значение зависят только от самого вектора токена, а оценка — только от пары векторов. Номер места в тексте нигде не участвует. Значит, если переставить токены, каждый получит тот же самый набор оценок, просто в другом порядке, а сумма от порядка слагаемых не зависит. Математики называют это так: внимание без позиций переставочно-равноправно (permutation equivariant) — переставишь входы, выходы переставятся точно так же, но по содержанию не изменятся.
Есть одна оговорка. В языковых моделях, которые пишут текст слева направо, стоит маска будущего (causal mask): токен видит только себя и тех, кто левее. Она косвенно выдаёт позицию — первый токен видит одного себя, сотый видит сотню. В работе Kazemnejad и соавторов (2023) показано, что такие модели и без явных позиций (их называют NoPE, no positional encoding) способны научиться понимать порядок. Но это косвенный и капризный сигнал, поэтому почти все практические модели всё-таки добавляют позиции явно.
Отличие от соседнего понятия — токенизации из дорожки о токенах. Токенизатор решает, на какие куски резать текст, и порядок кусков он, конечно, сохраняет в виде последовательности номеров. Но дальше эта последовательность превращается в векторы, и порядок живёт только в том, какой номер позиции мы приписали каждому вектору. Потерять его можно уже после токенизатора.
Подробный пример. Возьмём три слова со случайными векторами и одну голову внимания со случайными матрицами. Подадим «кот съел мышь» и «мышь съел кот» и сравним, что внимание выдаёт для слова «кот» в обоих порядках, — сначала без маски будущего, потом с ней.
import numpy as np
rng = np.random.default_rng(0)
d = 16
vocab = {w: rng.normal(size=d) for w in ["кот", "съел", "мышь"]}
Wq, Wk, Wv = (rng.normal(size=(d, d)) / d**0.5 for _ in range(3))
def attention(X, causal=False):
Q, K, V = X @ Wq, X @ Wk, X @ Wv
s = Q @ K.T / d**0.5
if causal:
s = s + np.triu(np.full(s.shape, -np.inf), 1)
w = np.exp(s - s.max(1, keepdims=True)); w /= w.sum(1, keepdims=True)
return w @ V
a = ["кот", "съел", "мышь"]
b = ["мышь", "съел", "кот"]
for causal in (False, True):
A = attention(np.array([vocab[t] for t in a]), causal)
B = attention(np.array([vocab[t] for t in b]), causal)
same = np.allclose(A[a.index("кот")], B[b.index("кот")])
print(f"маска будущего={causal}: выход для «кот» в двух порядках одинаков? {same}")
У нас этот код напечатал:
маска будущего=False: выход для «кот» в двух порядках одинаков? True
маска будущего=True: выход для «кот» в двух порядках одинаков? False
Без маски выход для «кот» совпал до последнего знака: внимание буквально не отличает, кто кого съел. С маской выход изменился, но только потому, что в первой фразе «кот» стоит первым и видит одного себя, а во второй стоит последним и видит всех. Это и есть косвенный сигнал позиции, о котором шла речь выше: модель может догадаться, где она, считая, сколько токенов ей видно, но различить «съел мышь» и «мышь съел» в середине длинного текста так гораздо труднее.
Где обычно ошибаются.
Позиционное кодирование (positional encoding). способ подмешать в вычисления модели номер места каждого токена в тексте.
Запрос, ключ, значение (query, key, value). три вектора, которые внимание строит из каждого токена: что он ищет, чем отвечает на поиск и что отдаёт.
Скалярное произведение (dot product). сумма попарных произведений координат двух векторов; во внимании это оценка связи двух токенов.
Переставочная равноправность (permutation equivariance). свойство: переставишь входы — выходы переставятся так же, не изменившись по содержанию.
Маска будущего (causal mask). запрет токену смотреть на тех, кто стоит правее него.
NoPE. модель вообще без явного позиционного кодирования, которая выводит порядок только из маски будущего.
Зачем это в работе. Старые и некоторые нынешние модели хранят позицию как «адрес» — номер места, превращённый в вектор и прибавленный к вектору токена. Отсюда жёсткий потолок длины у таких моделей и их особые ошибки. Когда в конфигурации модели видишь поле вроде n_positions, а в документации — «контекст 1024 токена», это прямое следствие абсолютных позиций, и знать механику нужно, чтобы понимать, что в такой модели длину не поднять никакой настройкой.
Самый простой вариант — обучаемая таблица позиций (learned positional embeddings). Это матрица, в которой на каждую позицию от 0 до максимума заведена своя строка-вектор той же ширины, что и векторы токенов. Перед первым слоем к вектору токена на месте 7 прибавляется строка номер 7. Строки таблицы обучаются вместе со всей моделью, как обычные веса. Так устроена GPT-2: в её файле config.json на Hugging Face стоит n_positions 1024, то есть в таблице ровно 1024 строки, и токену на месте 1025 прибавлять просто нечего.
Второй вариант предложили авторы самого трансформера в статье «Attention Is All You Need» (Vaswani и соавторы, 2017): вместо обучаемой таблицы — синусоиды. Вектор позиции p собирается из пар чисел sin(p·w) и cos(p·w), где у каждой пары своя частота w: у первой пары угол растёт на радиан с каждым токеном, у следующих всё медленнее, до самой медленной, которая делает оборот за десятки тысяч токенов. Частоты задаются формулой с основанием 10000. Это похоже на стрелки часов: секундная различает соседние моменты, часовая — далёкие, а вместе они однозначно задают время.
У синусоид есть важное свойство: скалярное произведение векторов двух позиций зависит только от расстояния между ними, а не от того, где они стоят. Это прямо следует из формулы косинуса разности. Авторы рассчитывали, что так модели будет проще выучить относительные связи вроде «слово на три токена левее», и что формула позволит хотя бы вычислить вектор для позиции, которой не было на обучении. Обучаемая таблица такого не умеет.
Ограничение у обоих вариантов общее: позиция прибавляется к вектору токена один раз на входе, смешивается с его смыслом, и дальше каждый слой должен сам выпутывать, где тут «что», а где «где». А главное, модель видела на обучении только позиции до какого-то максимума, и вектора для позиции 5000 она не видела никогда, даже если формула его выдаёт. Именно поэтому синусоиды на практике плохо работали за пределами длины обучения — это отмечали авторы последующих работ, в том числе ALiBi, о котором пойдёт речь на пятой ступени.
Подробный пример. Построим синусоидальные позиции ширины 64 и проверим свойство из третьего абзаца: произведение позиций p и p+3 должно быть одним и тем же, где бы ни стояло p. Заодно посчитаем длину волны самой быстрой и самой медленной пары.
import numpy as np
d = 64
def pe(p):
i = np.arange(d // 2)
w = 1 / 10000 ** (2 * i / d)
return np.concatenate([np.sin(p * w), np.cos(p * w)])
for p in (0, 10, 500, 5000):
print(f"pe({p})·pe({p}+3) = {pe(p) @ pe(p + 3):.4f} pe({p})·pe({p}+40) = {pe(p) @ pe(p + 40):.4f}")
print("длина волны самой быстрой пары:", round(2*np.pi, 2), " самой медленной:", round(2*np.pi*10000**((d-2)/d)))
У нас этот код напечатал:
pe(0)·pe(0+3) = 25.5870 pe(0)·pe(0+40) = 15.3975
pe(10)·pe(10+3) = 25.5870 pe(10)·pe(10+40) = 15.3975
pe(500)·pe(500+3) = 25.5870 pe(500)·pe(500+40) = 15.3975
pe(5000)·pe(5000+3) = 25.5870 pe(5000)·pe(5000+40) = 15.3975
длина волны самой быстрой пары: 6.28 самой медленной: 47117
Для расстояния 3 произведение равно 25,5870 и на позиции 0, и на позиции 5000; для расстояния 40 — 15,3975 везде. Чем дальше позиции, тем меньше похожи их векторы, но зависит это только от расстояния. Самая быстрая пара делает оборот за 6,28 токена, самая медленная — примерно за 47 тысяч: вот диапазон «стрелок», которыми закодировано место. Для сравнения, обучаемая таблица GPT-2 на 1025-м токене выдаёт ошибку индекса, потому что строки 1025 у неё просто нет — это мы тоже проверили на таблице того же размера.
Где обычно ошибаются.
Абсолютная позиция. кодирование, где каждому номеру места соответствует свой вектор, прибавляемый к токену.
Обучаемая таблица позиций (learned positional embeddings). матрица со строкой на каждую позицию, обучаемая вместе с моделью; задаёт жёсткий потолок длины.
Синусоидальное кодирование (sinusoidal encoding). позиция, записанная синусами и косинусами разных частот, как набор стрелок часов.
Частота пары. на сколько радиан поворачивается угол пары координат при сдвиге на один токен.
Длина волны. через сколько токенов пара делает полный оборот и значения повторяются.
Основание (base). число в формуле частот, обычно 10000; чем оно больше, тем медленнее самые медленные пары.
n_positions. поле конфигурации GPT-2 и похожих моделей: размер таблицы позиций, то есть предельная длина текста.
Зачем это в работе. Вращения RoPE стоят в большинстве нынешних открытых моделей: в конфигурациях Llama, Qwen, Mistral, DeepSeek есть поле rope_theta, и это оно. Все современные приёмы удлинения контекста, о которых пойдёт речь дальше, — это способы подправить именно вращения. Без понимания, что вращается и с какой скоростью, строки вроде «rope_theta 1000000» или «rope_scaling yarn, factor 4» остаются заклинаниями, которые копируют из чужих настроек.
RoPE (rotary position embedding, вращательное позиционное кодирование) предложили Su и соавторы в статье RoFormer (2021). Идея: не прибавлять позицию к токену на входе, а в каждом слое поворачивать запрос и ключ на угол, пропорциональный позиции. Шаги такие. Вектор запроса ширины d делится на d/2 пар соседних координат. Каждая пара — это точка на плоскости. Для токена на месте m пара номер i поворачивается на угол m·θᵢ, где θᵢ — частота этой пары, задаваемая той же формулой с основанием, что у синусоид. С ключом делают то же самое. Значения (value) не поворачивают вовсе.
Почему это работает. Если повернуть запрос на угол mθ, а ключ на угол nθ, то их скалярное произведение зависит от разности углов, то есть от (m−n)θ. Абсолютные номера исчезают, остаётся только расстояние между токенами. Так модель получает относительную позицию прямо в оценке внимания, в каждом слое, и при этом ни одного числа к смыслу токена не прибавлено. Поворот не меняет длину вектора, поэтому «громкость» токена тоже не искажается.
Ещё одно удобство — для кэша ключей из дорожки про внимание. Ключ токена поворачивается один раз, по его собственной позиции, и в таком виде кладётся в кэш. Когда приходят новые токены, старые ключи пересчитывать не нужно: угол нового запроса сам даёт правильную разность. Поэтому RoPE легко совмещается с генерацией по токену за шаг.
Ограничение то же, что у синусоид, но в другой форме. Модель на обучении видела разности углов только для расстояний до длины обучения. У быстрых пар углы за это время прокрутились много раз и все варианты встречались. А медленные пары успели повернуться меньше чем на полный оборот, и угол, который они дадут на расстоянии вдвое больше, модели незнаком. Отличие от синусоид: там позиция смешивается со смыслом один раз на входе, здесь она живёт в каждом слое и только в сравнении запроса с ключом.
Подробный пример. Реализуем поворот для вектора ширины 8 (четыре пары) и проверим главное свойство: оценка запроса на месте m и ключа на месте n должна зависеть только от m−n. Ставим одну и ту же пару векторов на позиции 5 и 2, потом 105 и 102, потом 4005 и 4002, и для контроля 5 и 4.
import numpy as np
d, base = 8, 10000
theta = 1 / base ** (np.arange(0, d, 2) / d) # своя скорость вращения у каждой пары
def rope(x, m):
x1, x2 = x[0::2], x[1::2] # пары соседних координат
c, s = np.cos(m * theta), np.sin(m * theta)
out = np.empty_like(x)
out[0::2] = x1 * c - x2 * s # поворот пары на угол m*theta
out[1::2] = x1 * s + x2 * c
return out
rng = np.random.default_rng(1)
q, k = rng.normal(size=d), rng.normal(size=d)
for m, n in [(5, 2), (105, 102), (4005, 4002), (5, 4)]:
print(f"запрос на {m:>4}, ключ на {n:>4}, расстояние {m-n}: оценка {rope(q, m) @ rope(k, n):+.4f}")
print("длина вектора до и после поворота:", round(np.linalg.norm(q), 4), round(np.linalg.norm(rope(q, 777)), 4))
У нас этот код напечатал:
запрос на 5, ключ на 2, расстояние 3: оценка -1.1262
запрос на 105, ключ на 102, расстояние 3: оценка -1.1262
запрос на 4005, ключ на 4002, расстояние 3: оценка -1.1262
запрос на 5, ключ на 4, расстояние 1: оценка -0.7765
длина вектора до и после поворота: 2.0608 2.0608
Для расстояния 3 оценка одинакова — минус 1,1262 — и в начале текста, и через четыре тысячи токенов. При расстоянии 1 она другая. Длина вектора после поворота на позицию 777 не изменилась. Значит, всё, что модель узнаёт о положении через RoPE, — это «насколько далеко ключ от запроса», и абсолютного номера места в оценке нет. Запомни строку с theta: в ней стоит основание 10000, и именно его меняют, когда удлиняют контекст.
Где обычно ошибаются.
RoPE (rotary position embedding). позиция токена задаётся поворотом пар координат запроса и ключа на угол, пропорциональный номеру места.
RoFormer. статья Su и соавторов 2021 года, где RoPE впервые описан.
Относительная позиция. сведения о расстоянии между двумя токенами, а не о номере места каждого.
θ (тета) пары. угол поворота пары за один токен; у каждой пары свой.
rope_theta. поле конфигурации, где хранится основание для частот RoPE.
Раскладка пар. какие именно координаты вектора образуют пару для поворота; должна совпадать с той, на которой учили модель.
Зачем это в работе. Если подать модели текст длиннее, чем она видела на обучении, она обычно не выдаёт ошибку, а начинает писать бессмыслицу или повторяться. Обучать модель сразу на сотнях тысяч токенов очень дорого, поэтому почти все длинные контексты получены удлинением: модель учат на коротких текстах, а потом подправляют вращения и коротко дообучают. Понимание этих приёмов нужно, чтобы правильно включать длинный контекст при развёртывании и не удивляться, что на коротких запросах модель после этого стала чуть хуже.
Причина поломки — незнакомые углы. Как мы видели, у каждой пары RoPE своя длина волны. Пары, которые за длину обучения не успели сделать полного оборота, видели только часть возможных углов. На позициях дальше длины обучения эти пары дают углы, которых модель не встречала, и оценки внимания становятся непредсказуемыми. Быстрым парам удлинение не страшно: их углы и так много раз прокрутились.
Первый приём — сжатие позиций (Position Interpolation), его описали Chen и соавторы из Meta в 2023 году. Если модель обучена на длине L, а мы хотим 4L, делим все номера позиций на 4: токен на месте 16000 получает «позицию» 4000. Все углы снова в знакомом диапазоне. Цена: соседние токены теперь отличаются на четверть прежнего угла, быструю «стрелку» мы замедлили, и различать соседей модели труднее. Авторы показали, что короткого дообучения на длинных текстах хватает, чтобы модель к этому привыкла.
Второй приём — смена основания, в сообществе его называют NTK-aware scaling (появился в 2023 году в обсуждениях энтузиастов, а не в статье). Вместо деления позиций увеличивают основание в формуле частот. Быстрые пары от этого почти не меняются, а медленные замедляются сильно. Получается, что соседей модель различает как раньше, а для дальних расстояний углы снова в знакомом диапазоне. Третий приём, YaRN (Peng и соавторы, 2023), объединяет оба: высокие частоты не трогает, низкие сжимает, промежуточные смешивает и вдобавок немного меняет масштаб оценок внимания. Именно YaRN предлагают в описании моделей Qwen2.5 для длинных текстов.
Отличие удлинения от окна контекста из дорожки про окно контекста: окно — это сколько токенов сервер позволит подать, а удлинение — это изменение самой модели, чтобы на таком числе токенов она работала осмысленно. Можно разрешить серверу 128 тысяч токенов, не включив удлинение, и получить модель, которая после длины обучения пишет ерунду.
Подробный пример. Голова шириной 128, основание 10000, модель обучена на 4096 токенах, и мы хотим вчетверо больше. Посчитаем, сколько пар не успели сделать оборот на длине обучения и что делают с самой быстрой и самой медленной парой два приёма: сжатие позиций и смена основания по формуле основание·s^(d/(d−2)).
import numpy as np
d, base, L = 128, 10000, 4096 # ширина головы, основание, длина при обучении
i = np.arange(0, d, 2)
theta = 1 / base ** (i / d)
wave = 2 * np.pi / theta # через сколько токенов пара делает полный оборот
print("пар всего:", len(theta))
print("пар, которые за 4096 токенов не делают и одного оборота:", int((wave > L).sum()))
s = 4 # хотим 16384 токена
print("быстрая пара: угол между соседями", round(theta[0], 3), "-> после сжатия позиций", round(theta[0] / s, 3))
base_ntk = base * s ** (d / (d - 2))
theta_ntk = 1 / base_ntk ** (i / d)
print("смена основания: новое основание", round(base_ntk))
print("быстрая пара: угол между соседями", round(theta_ntk[0], 3), "| медленная пара: длина волны",
round(wave[-1]), "->", round(2 * np.pi / theta_ntk[-1]))
У нас этот код напечатал:
пар всего: 64
пар, которые за 4096 токенов не делают и одного оборота: 18
быстрая пара: угол между соседями 1.0 -> после сжатия позиций 0.25
смена основания: новое основание 40890
быстрая пара: угол между соседями 1.0 | медленная пара: длина волны 54410 -> 217641
18 из 64 пар не делают полного оборота за 4096 токенов — это они дадут незнакомые углы на большей длине. Сжатие позиций уменьшает угол между соседями у быстрой пары с 1 радиана до 0,25: дальние позиции спасены, но соседние стали вчетверо ближе друг к другу. Смена основания на 40890 оставляет у быстрой пары тот же угол в 1 радиан, а длину волны медленной пары растягивает с 54 тысяч до 218 тысяч токенов, то есть примерно вчетверо. Так видно, почему смена основания мягче к коротким расстояниям, а YaRN пошёл ещё дальше и разделил пары по частотам явно.
Где обычно ошибаются.
Длина обучения. максимальная длина текстов, на которых модель обучали; за ней углы медленных пар незнакомы.
Сжатие позиций (Position Interpolation). деление номеров позиций на коэффициент, чтобы все углы попали в знакомый диапазон.
Смена основания (NTK-aware scaling). увеличение основания частот, которое замедляет медленные пары и почти не трогает быстрые.
YaRN. способ удлинения, который по-разному обрабатывает пары разных частот и подправляет масштаб внимания.
Коэффициент удлинения (factor). во сколько раз хотят увеличить длину относительно длины обучения.
rope_scaling. поле конфигурации, где указывают способ удлинения и коэффициент.
Статическое масштабирование. коэффициент, одинаковый для любой длины запроса, даже короткой.
Зачем это в работе. Когда разворачиваешь открытую модель или выбираешь её для задачи с длинными документами, всё, что мы разобрали, сводится к нескольким строкам в файле config.json и к паре проверок. Умение их прочитать отвечает на практические вопросы: какой длины текст модель рассчитана принимать, нужно ли что-то включать для большей длины и чему верить в цифре «контекст 128 тысяч» из описания.
Что смотреть в конфигурации. Поле max_position_embeddings — длина, на которую модель рассчитана без удлинения. Поле rope_theta — основание частот: чем оно больше, тем медленнее самые медленные пары и тем дальше модель различает расстояния. Многие современные модели обучают сразу с основанием гораздо больше классических 10000 — у Qwen2.5-7B-Instruct в конфигурации стоит 1000000. Поле rope_scaling, если оно есть, говорит, какой приём удлинения включён и с каким коэффициентом. Ширину одной головы, от которой зависит число пар, можно получить делением hidden_size на num_attention_heads.
Не все модели используют RoPE. Заметная альтернатива — ALiBi (Press, Smith и Lewis, статья «Train Short, Test Long», 2021). Там вообще нет векторов позиций: к оценке внимания просто прибавляется штраф, пропорциональный расстоянию между токенами, с разной крутизной для разных голов. Чем дальше ключ, тем ниже оценка. Авторы показали, что такая модель лучше переносит тексты длиннее обучения, чем синусоиды. ALiBi использовали, например, BLOOM и MPT. Цена — жёстко заложенное предпочтение близкого: голове труднее смотреть далеко, если это нужно.
Как проверять, что длинный контекст работает. Самый известный тест — «иголка в стоге сена» (needle in a haystack): в длинный посторонний текст в разные места вставляют одну фразу-факт и спрашивают о ней, проверяя каждую комбинацию длины и места. Он показывает, видит ли модель все позиции. Но найти одну фразу проще, чем рассуждать по всему документу, поэтому появились более строгие наборы задач, например RULER (Hsieh и соавторы из NVIDIA, 2024), где есть несколько иголок, отслеживание переменных и подсчёт. Авторы RULER сообщают, что у многих проверенных моделей длина, на которой качество держится, заметно меньше заявленной.
Отличие от поиска по документам из дорожки про поиск: длинный контекст означает «положить всё в запрос», а поиск — «найти несколько кусков и положить только их». Позиционное кодирование определяет, справится ли модель с первым вариантом; если не справляется, второй часто дешевле и надёжнее.
Подробный пример. Прочитаем конфигурацию Qwen2.5-7B-Instruct с Hugging Face. Значения ниже переписаны из её config.json, а настройка rope_scaling — из README модели, где её советуют добавить для текстов длиннее 32768 токенов. Посчитаем ширину головы, самую длинную волну, сколько пар не делают оборота на длине без удлинения и какую длину даёт YaRN.
import numpy as np
# значения из config.json модели Qwen2.5-7B-Instruct на Hugging Face
cfg = {"hidden_size": 3584, "num_attention_heads": 28,
"max_position_embeddings": 32768, "rope_theta": 1000000.0}
yarn = {"type": "yarn", "factor": 4.0, "original_max_position_embeddings": 32768} # из README модели
d = cfg["hidden_size"] // cfg["num_attention_heads"]
theta = 1 / cfg["rope_theta"] ** (np.arange(0, d, 2) / d)
wave = 2 * np.pi / theta
L = cfg["max_position_embeddings"]
print("ширина одной головы:", d, "-> пар для вращения:", d // 2)
print("самая длинная волна, токенов:", round(wave[-1]))
print("пар без полного оборота на 32768 токенах:", int((wave > L).sum()))
print("длина после YaRN:", int(yarn["factor"] * yarn["original_max_position_embeddings"]))
У нас этот код напечатал:
ширина одной головы: 128 -> пар для вращения: 64
самая длинная волна, токенов: 5063256
пар без полного оборота на 32768 токенах: 24
длина после YaRN: 131072
Голова шириной 128 даёт 64 пары. Из-за основания в миллион самая медленная пара делает оборот примерно за 5 миллионов токенов, и на длине 32768 таких «недокрученных» пар 24 из 64 — больше, чем в примере с основанием 10000 на четвёртой ступени. Это нормально: большое основание выбирают, чтобы медленные пары различали очень далёкие расстояния, а модель обучали на тех углах, которые на её длине встречаются. С YaRN и коэффициентом 4 длина становится 131072 токена — та самая цифра «128K», которую пишут в описании. Вывод для практики: 128 тысяч у этой модели — это режим, который нужно включить в настройках сервера, а не значение по умолчанию.
Где обычно ошибаются.
max_position_embeddings. поле конфигурации: на какую длину рассчитана модель без удлинения.
ALiBi. кодирование без векторов позиций: к оценке внимания прибавляется штраф, растущий с расстоянием.
Иголка в стоге сена (needle in a haystack). тест, где факт прячут в разные места длинного текста и проверяют, найдёт ли его модель.
RULER. набор задач NVIDIA для проверки, какую длину модель реально использует, а не только принимает.
Эффективная длина контекста. длина, на которой качество ответов ещё держится; часто меньше заявленной.
hidden_size и num_attention_heads. ширина модели и число голов; их частное — ширина одной головы.
config.json. файл с параметрами устройства модели, который лежит рядом с весами.
Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.