Расширение контекста — PI, NTK, YaRN

Зачем это нужно

Длинный контекстдлинный контекстEN long context стал обязательной частью современных LLM. Qwen3 «из коробки» работает с 32K токенов и растягивается до 128K, DeepSeek-V3 — со 128K, Qwen2.5-1M и MiniMax-01 — с миллионом. Агенту для работы с кодом нужно держать в голове весь репозиторий, юристу — договор на 300 страниц.

Но обучать модель на 128K токенов с первого шага — разорительно. Внимание стоит $O(n^2)$ (квадратичная сложность вниманияквадратичная сложность вниманияEN quadratic complexity (O(n²))Каждый из n токенов сравнивается с каждым — n² оценок на голову. При длинном контексте это главная стоимость внимания; отсюда FlashAttention, разреженное и линейное внимание., урок 4.4.3), а большинство документов в корпусе всё равно короче нескольких тысяч токенов. Поэтому все делают одинаково: претрейн на коротком контексте (4K–32K), затем короткое дообучение на длинном. DeepSeek-V3 прошла 14.8 трлн токенов на длине 4K, а расширение до 128K стоило около 126 млрд токенов — 0.85% бюджета.

Чтобы такое дообучение вообще сработало, нужно правильно «растянуть» позиционное кодирование. Этим и занимается урок: почему наивное удлинение ломает модель и как три приёма — PI, NTK-aware и YaRN — это исправляют. В китайском сообществе вся тема называется «экстраполяцией по длине»экстраполяция по длинеEN length extrapolationСпособность модели работать на последовательностях длиннее тех, на которых её обучали. В китайском сообществе так называют всю тему расширения контекста..

Напоминание: RoPE как часы с 64 стрелками

В уроке 4.5.2 мы разобрали ротационные позиционные эмбеддингиротационные позиционные эмбеддинги (RoPE)EN rotary position embedding (RoPE)RoPE предложен в Китае (Су Цзяньлинь и соавторы, компания Zhuiyi). Сейчас используется почти во всех LLM.. Вектор запроса (и ключа) размера $d$ делится на $d/2$ пар координат. Пару номер $i$ на позиции $m$ поворачивают на угол $m\theta_i$, где

$$\theta_i = b^{-2i/d}, \qquad i = 0, 1, \ldots, \tfrac{d}{2} - 1 .$$

Здесь $b$ — база RoPEбаза RoPEEN RoPE base (rope_theta)Число b в частотах RoPE θ_i = b^(−2i/d). Классическое значение 10 000; в длинноконтекстных моделях его увеличивают (Llama 3 — 500 000, Qwen2.5 — 1 000 000). (в конфигах rope_theta), классически $b = 10\,000$. Скалярное произведение повёрнутых $q$ и $k$ зависит только от разности позиций $m - n$ — за это RoPE и любят.

Удобно представить часы с 64 стрелками (для $d = 128$). Пара 0 поворачивается на 1 радиан за токен: полный оборот за $2\pi \approx 6.3$ токена, как секундная стрелка. Последняя пара — очень медленная «часовая». Время полного оборота называют длиной волны $\lambda_i = 2\pi / \theta_i$ (частота и период волны — урок 1.0.4):

Пара $i$	Частота $\theta_i$	Длина волны $\lambda_i$, токенов	Оборотов за 4096 токенов
0	1	6.3	652
16	0.1	63	65
32	0.01	628	6.5
46	0.0013	4 712	0.87
63	0.000115	54 410	0.075

Посмотрите на последний столбец. Быстрые пары за обучающие 4096 токенов провернулись десятки и сотни раз и видели все возможные углы. А пары с 46-й по 63-ю (18 пар из 64) не сделали ни одного полного оборота.

Почему модель ломается за границей обучающей длины

Возьмите модель, обученную на 4K, и подайте ей 16K токенов. Perplexity ровная до 4096, а сразу за границей резко взлетает, и модель начинает выдавать бессмыслицу. Причин две.

1. Невиданные углы. Пара 63 за всё обучение повернулась максимум на $4096 \cdot 0.000115 \approx 0.47$ радиана. Её веса выучили «мир», в котором угол этой пары лежит между 0 и 0.47. На позиции 16 000 угол будет 1.85 — почти в четыре раза больше всего, что модель видела. Это как человек, который видел часы только между часом и половиной второго: покажите ему девять вечера — и он не поймёт, что происходит. Для быстрых пар всё в порядке: позиция 16 000 даёт угол, который уже встречался тысячи раз (углы повторяются через $2\pi$).

2. Размывание внимания. Чем больше ключей, тем сильнее softmax «размазывает» веса: энтропия внимания растёт примерно как $\ln n$. Модель, привыкшая выбирать среди 4 тысяч токенов, на 16 тысячах смотрит «расфокусированно». Мы обсуждали это в уроке 4.4.2 вместе со статьёй Су Цзяньлиня об энтропии и множителе $\log n$.

Значит, рецепт расширения должен (а) не выводить медленные пары за обученный диапазон углов и (б) вернуть вниманию прежнюю «резкость». Первую задачу решают PI и NTK, обе — YaRN.

Заявленный контекст ≠ рабочий контекст

То, что модель не выдаёт мусор на 128K, ещё не значит, что она умеет пользоваться всеми 128K. Простейшая проверка — «иголка в стоге сена»тест «иголка в стоге сена»EN needle in a haystack (NIAH)В длинный посторонний текст вставляют факт («иголку») и спрашивают о нём. Проверяет поиск по контексту, но не рассуждение. (по-китайски — «выловить иголку в море»): в длинный посторонний текст прячут фразу «пароль — 7319» и спрашивают пароль. Сложнее — бенчмарк RULER (NVIDIA, 2024) с многошаговым поиском и агрегацией. Известный эффект «lost in the middle» (Liu et al., 2023): факты из середины длинного контекста модели находят хуже, чем из начала и конца.

Метод 1: Position Interpolation — сжать линейку

Летом 2023 года энтузиаст kaiokendev (проект SuperHOT) и группа Meta (Chen et al.) независимо предложили одно и то же. Если модель не умеет экстраполировать на невиданные позиции, давайте интерполировать: позицию $m$ заменим на $m/s$, где $s = L'/L$ — во сколько раз растягиваем контекст. Позиции от 0 до $sL$ превращаются в числа от 0 до $L$, и все углы остаются в обученном диапазоне. Для частот это то же самое, что поделить каждую на $s$:

$$\theta_i^{\mathrm{PI}} = \frac{\theta_i}{s}.$$

интерполяция позицийинтерполяция позиций (PI)EN position interpolation (PI)Позиции делятся на коэффициент растяжения s, и все углы RoPE остаются в обученном диапазоне. В китайских текстах — дословный перевод того же термина. работает поразительно хорошо: Meta растянула LLaMA до 32 768 токенов, дообучив её не более чем за 1000 шагов. Но у метода есть цена — разрешение.

Пара 0 теперь поворачивается не на 1, а на 0.25 радиана за токен (при $s = 4$). Соседние токены стали в 4 раза «ближе» друг к другу по самой точной стрелке. Представьте линейку, которую сжали вчетверо: миллиметровые деления превратились в четвертинки миллиметра, и их трудно различить. Ниже в практике мы посчитаем: разница между оценкой внимания соседнего токена и оценкой токена «с самим собой» у PI в 16 раз меньше, чем у исходного RoPE. Без дообучения модель путает порядок близких слов, с дообучением — заново учится различать мелкие углы.

Метод 2: NTK-aware — поменять систему счисления

Через несколько дней после PI пользователь Reddit bloc97 заметил: быстрым парам помощь не нужна, они и так видели все углы. Страдают только медленные. Значит, надо экстраполировать быстрые частоты и интерполировать медленные. Сделать это можно одной строкой — увеличить базу RoPE:

$$b' = b \cdot s^{d/(d-2)}, \qquad \theta'_i = b'^{-2i/d} = \theta_i \cdot s^{-2i/(d-2)} .$$

Проверим края. При $i = 0$ множитель $s^0 = 1$ — самая быстрая пара не изменилась. При $i = d/2 - 1$ показатель равен $-1$, и самая медленная частота делится ровно на $s$, как в PI. Между ними множитель плавно убывает. Для $d = 128$, $s = 4$ новая база $b' = 10\,000 \cdot 4^{128/126} \approx 40\,890$.

Метод назвали NTK-awareNTK-aware масштабирование RoPEEN NTK-aware scaled RoPEВместо позиций увеличивают базу RoPE в s^(d/(d−2)) раз — быстрые частоты почти не меняются, медленные интерполируются. — это отсылка к теории нейронного касательного ядра (NTK): сетям трудно выучивать высокочастотные зависимости, поэтому сжимать быстрые частоты, как PI, вредно. По словам автора, LLaMA 7B с такой правкой работала на 8K+ токенах без всякого дообучения.

Интуиция Су Цзяньлиня: RoPE — это система счисления

Лучшее объяснение NTK-aware написал Су Цзяньлинь в статье «RoPE — это кодирование в β-ичной системе». Позицию $m$ можно записать в системе счисления с основанием $\beta$: младшая цифра меняется на каждом шаге, старшие — всё реже. RoPE устроен так же: быстрые пары — «младшие цифры», медленные — «старшие», и $\beta = b^{2/d}$.

Теперь аналогия. Трёхзначный десятичный счётчик считает до 999. Как досчитать до 3999, не добавляя цифр?

• PI: сжать шкалу — каждый реальный шаг сдвигает счётчик на 0.25. Числа до 3999 уложатся в диапазон 0–999.75, но младший разряд теперь меняется на четверть деления за шаг: соседние числа становятся трудно различимы.
• NTK-aware: перейти в шестнадцатеричную систему. Три цифры дают $16^3 = 4096$ значений, а младший разряд по-прежнему меняется на 1 за шаг. Локальная точность не пострадала, старшие разряды просто «растянулись». Цена — «цифры» 10–15, которых счётчик раньше не видел. В младших разрядах это не страшно, они и так перебрали все положения, а в старших это и есть те «невиданные углы», которые NTK-aware прячет не до конца.

Цена и варианты

NTK-aware не идеален. В практике ниже вы увидите, что при $s = 4$ у 17 медленных пар углы всё же выходят за виденный диапазон — до 1.45 раза. Поэтому без дообучения коэффициент обычно берут с запасом. Есть и Dynamic NTK: коэффициент пересчитывают под текущую длину, $s = \max(1, n/L)$, и короткие тексты вообще не затрагиваются. Так в 2023 году растягивала контекст первая Qwen (подробнее — в «Китайском угле»).

Ещё проще поступают при обучении: сразу берут большую базу и дообучают на длинных текстах. Этот приём называют ABF (adjusted base frequency). Code Llama взяла $b = 10^6$, Llama 3 — $5 \cdot 10^5$, Qwen2.5 и Qwen3 поднимают базу с $10^4$ до $10^6$ на этапе с длиной 32K, Qwen2.5-1M — до $10^7$. У Су Цзяньлиня есть отдельная статья о выборе базы («Принципы выбора базы RoPE»): чем длиннее нужный контекст, тем больше должна быть база.

Метод 3: YaRN — каждой частоте свой режим

YaRN (Yet another RoPE extensioN; Peng, Quesnelle, Fan, Shippole, 2023; среди авторов и сам bloc97) соединяет обе идеи аккуратнее. Каждая пара сама решает, интерполироваться ей или нет, по числу оборотов за обучающую длину $L$:

$$\begin{gathered} r_i = \frac{L}{\lambda_i} = \frac{L\,\theta_i}{2\pi}, \qquad \gamma_i = \mathrm{clip}\!\left(\frac{r_i - \alpha}{\beta - \alpha},\; 0,\; 1\right), \\ \theta^{\mathrm{YaRN}}_i = (1 - \gamma_i)\,\frac{\theta_i}{s} + \gamma_i\,\theta_i . \end{gathered}$$

Функция $\mathrm{clip}(x, 0, 1)$ «обрезает» число до отрезка от 0 до 1: всё меньше нуля становится 0, всё больше единицы — 1 (np.clip в NumPy). Что здесь написано:

• $r_i > \beta$ (у LLaMA и DeepSeek $\beta = 32$): пара сделала больше 32 оборотов, она видела все углы. $\gamma = 1$, частота не меняется.
• $r_i < \alpha$ ($\alpha = 1$): пара не сделала ни одного оборота. $\gamma = 0$, частота делится на $s$, как в PI.
• Между ними — плавный переход по линейной «рампе».

Пример для пары 32 из таблицы выше ($\theta = 0.01$, длина волны 628 токенов) при $s = 4$: $r = 4096 / 628 \approx 6.5$, $\gamma = (6.5 - 1) / 31 \approx 0.18$, новая частота $0.82 \cdot \theta / 4 + 0.18 \cdot \theta \approx 0.38\,\theta$ — пара замедлилась, но не вчетверо, как в PI, а примерно в 2.6 раза.

Эта часть называется NTK-by-parts. Для $d = 128$, $b = 10^4$, $L = 4096$ получается 21 нетронутая пара (длина волны меньше 128 токенов), 25 пар в переходной зоне и 18 интерполированных — ровно тех медленных, что не успели сделать оборот.

flowchart LR
P["Пара i: оборотов за L токенов<br/>r = L·θ/2π"] --> Q{"r ?"}
Q -->|"r > 32"| A["быстрая: θ без изменений"]
Q -->|"1 ≤ r ≤ 32"| B["средняя: смесь θ и θ/s"]
Q -->|"r меньше 1"| C["медленная: θ/s, как в PI"]

NTK-by-parts в YaRN: решение принимает каждая пара частот

Вторая часть YaRN — температура внимания. Против размывания внимания логиты делят на $t$, где

$$\sqrt{1/t} = 0.1 \ln s + 1 .$$

На практике таблицы $\cos$ и $\sin$ RoPE умножают на $0.1 \ln s + 1$. Этот множитель попадает и в $q$, и в $k$, поэтому логиты растут в $(0.1 \ln s + 1)^2$ раз, а на инференсе это ничего не стоит (в коде DeepSeek-V3 тот же квадрат множителя просто вшит в масштаб softmax). При $s = 4$ множитель логитов 1.30, при $s = 40$ — 1.87. Коэффициент 0.1 подобран авторами эмпирически.

По данным статьи, YaRN требует в 10 раз меньше токенов и в 2.5 раза меньше шагов дообучения, чем предыдущие методы, и растягивает Llama 2 до 128K. Похожую схему по частям использует Llama 3.1 (тип llama3 в rope_scaling).

Метод	Что меняет	Быстрые пары	Медленные пары	Дообучение	Где встречается
Без изменений	ничего	как были	невиданные углы	не помогает	—
PI	позиции $m \to m/s$	сжаты в $s$ раз	в диапазоне	~1000 шагов	ранние расширения LLaMA
NTK-aware	базу $b \to b\,s^{d/(d-2)}$	почти как были	частично в диапазоне	можно без него	llama.cpp, Qwen (2023, динамический вариант)
ABF	базу (сильно), с обучением	как были	в диапазоне после обучения	обязательно	Code Llama, Qwen, Llama 3
YaRN	частоты по частям + температура	как были	в диапазоне	сотни шагов	DeepSeek-V2/V3, Qwen

Как расширяют контекст DeepSeek и Qwen

Обе лаборатории растягивают контекст поэтапно: короткий претрейн, затем несколько ступенек длины.

flowchart TB
subgraph D["DeepSeek-V3"]
  direction LR
  d1["Претрейн<br/>14.8T токенов, 4K"] --> d2["YaRN s=40<br/>1000 шагов, 32K"] --> d3["1000 шагов<br/>128K"]
end
subgraph Q["Qwen2.5 / Qwen3"]
  direction LR
  q1["Претрейн, 4K<br/>база 10^4"] --> q2["Длинный этап, 32K<br/>база 10^6 (ABF)"] --> q3["Инференс: YaRN x4 + DCA<br/>до 128K"]
end

Поэтапное расширение контекста у DeepSeek и Qwen

DeepSeek-V3 после претрейна на 4K делает два этапа по 1000 шагов. Первый — длина 32K, батч 1920 последовательностей. Второй — длина 128K, батч 480. Каждый этап — около 62.9 млрд токенов ($1000 \cdot 1920 \cdot 32\,768$ и $1000 \cdot 480 \cdot 131\,072$). Параметры YaRN одинаковы: $s = 40$, $\alpha = 1$, $\beta = 32$, $\sqrt{1/t} = 0.1 \ln s + 1$. В опубликованном конфиге:

"rope_scaling": {"type": "yarn", "factor": 40, "original_max_position_embeddings": 4096,
                 "beta_fast": 32, "beta_slow": 1, "mscale": 1.0, "mscale_all_dim": 1.0}

$4096 \cdot 40 = 163\,840$ — формальный потолок с запасом над 128K. Тонкость, связанная с уроком 5.2.2: в MLA позиции несёт только развязанная RoPE-часть ключа (64 измерения из 192), поэтому YaRN применяется только к ней.

Qwen идёт двумя дорогами одновременно. При обучении — ABF: Qwen2.5 и Qwen3 проходят основной претрейн на 4K, а на завершающем этапе удлиняют последовательности до 32K и поднимают базу RoPE с $10^4$ до $10^6$. На инференсе — YaRN и Dual Chunk Attention (DCA) дают ещё четырёхкратный запас, до 128K. В карточках моделей Qwen предлагают дописать в config.json:

"rope_scaling": {"type": "yarn", "factor": 4.0, "original_max_position_embeddings": 32768}

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

Qwen2.5-1M доводит идею до предела: пять ступенек длины при обучении (4K → 32K → 65K → 131K → 262K) с базой $10^7$, а до миллиона токенов модель дотягивается на инференсе через DCA. Идея DCA (статья HKU и Alibaba, 2024): длинную последовательность режут на куски и пересчитывают относительные расстояния так, чтобы ни одно не превышало обученного. Ближние токены сохраняют точные расстояния, дальние получают «сжатые». Для ускорения prefill на таких длинах добавлено разреженное вниманиеразреженное вниманиеEN sparse attention — о нём следующий урок.

Практика

Задание в браузере

Реализуйте частоты RoPE и три способа их растянуть. Тесты проверят края NTK-aware, три режима YaRN и главное свойство: на длине $sL$ у PI и YaRN нет ни одной медленной пары с «невиданным» углом.

Частоты RoPE при PI, NTK-aware и YaRNnumpy · нужен интернет7 тестов

import math

import numpy as np


def rope_freqs(d, base=10000.0):
    """Частоты RoPE для головы размера d (d чётное).

    Возвращает массив из d // 2 чисел: theta_i = base ** (-2 * i / d), i = 0, 1, ..., d/2 - 1.
    Пара координат i поворачивается на угол m * theta_i, где m — позиция токена.
    Пример: rope_freqs(8) -> [1.0, 0.1, 0.01, 0.001].
    """
    # TODO: np.arange(0, d, 2) даёт 0, 2, 4, ... — это и есть 2i
    ...


def pi_freqs(freqs, s):
    """Position Interpolation: позиции сжимаются в s раз, m -> m / s.

    Для частот это то же самое, что поделить каждую частоту на s.
    Входной массив не изменяйте — верните новый.
    """
    # TODO
    ...


def ntk_freqs(d, base, s):
    """NTK-aware: позиции не трогаем, увеличиваем базу RoPE.

    Новая база: base * s ** (d / (d - 2)). Самая высокая частота остаётся 1.0,
    самая низкая уменьшается ровно в s раз.
    """
    # TODO: одна строка через rope_freqs
    ...


def yarn_freqs(freqs, s, L, alpha=1.0, beta=32.0):
    """YaRN (NTK-by-parts): каждая пара решает сама, интерполироваться ей или нет.

    freqs — исходные частоты, s — во сколько раз растягиваем контекст,
    L — обучающая длина контекста (в токенах).
    1) r_i = L * theta_i / (2 * pi) — сколько полных оборотов пара успела сделать за L токенов;
    2) gamma_i = clip((r_i - alpha) / (beta - alpha), 0, 1);
    3) новая частота = (1 - gamma_i) * theta_i / s + gamma_i * theta_i.
    Быстрые пары (r > beta) не меняются, медленные (r < alpha) делятся на s, средние — плавный переход.
    """
    # TODO
    ...


def yarn_attention_factor(s):
    """Множитель YaRN для q и k: 0.1 * ln(s) + 1 при s > 1, иначе 1.0.

    Он умножает и q, и k, поэтому логиты внимания растут в (0.1 ln s + 1)^2 раз —
    распределение внимания становится чуть острее.
    """
    # TODO
    ...


# Проверьте себя кнопкой «Запустить»:
np.set_printoptions(precision=6, suppress=True)
f = rope_freqs(8)
print("RoPE:", f)                                  # ожидается [1. 0.1 0.01 0.001]
if f is not None:
    print("PI x4:", pi_freqs(f, 4))                # ожидается [0.25 0.025 0.0025 0.00025]
    print("NTK x4:", ntk_freqs(8, 10000.0, 4))     # [1. 0.062996 0.003969 0.00025]: первая как у RoPE, последняя как у PI
    print("YaRN x4:", yarn_freqs(f, 4, L=1024))    # [1. 0.06201 0.002652 0.00025]: быстрая пара не тронута, медленная /4
print("множитель YaRN при s=40:", yarn_attention_factor(40))   # ≈ 1.3689

ЗапуститьПроверитьПодсказкаСбросить

Сравнение методов на NumPy

Скрипт ниже сравнивает четыре варианта для типичной головы ($d = 128$, $b = 10^4$), обученной на 4K, при растяжении до 16K. Для каждого метода он считает, сколько медленных пар получают невиданные углы, во сколько раз худший угол больше виденного и насколько оценка внимания соседнего токена отличается от оценки токена «с самим собой» (чем больше, тем легче отличить соседа).

import numpy as np


def rope_freqs(d, base=10000.0):
    return base ** (-np.arange(0, d, 2) / d)


def yarn_freqs(f, s, L, alpha=1.0, beta=32.0):
    r = L * f / (2 * np.pi)                        # оборотов за обучающую длину
    gamma = np.clip((r - alpha) / (beta - alpha), 0, 1)
    return (1 - gamma) * f / s + gamma * f


d, base, L, s = 128, 10000.0, 4096, 4              # голова 128, обучали на 4K, хотим 16K
f = rope_freqs(d, base)
methods = {
    "без изменений": f,
    "PI": f / s,
    "NTK-aware": rope_freqs(d, base * s ** (d / (d - 2))),
    "YaRN": yarn_freqs(f, s, L),
}

seen = L * f                                       # максимальный угол каждой пары в обучении
slow = seen < 2 * np.pi                            # пары, не сделавшие за 4K токенов ни одного оборота
print(f"медленных пар: {slow.sum()} из {d // 2}")
print(f"{'метод':<14}{'новых углов':>12}{'превышение':>12}{'различие соседей':>18}")
for name, g in methods.items():
    new = s * L * g                                # максимальный угол на длине 16K
    n_bad = int(np.sum(slow & (new > seen + 1e-9)))
    excess = np.max(new[slow] / seen[slow])        # во сколько раз худший угол больше виденного
    near = 1 - np.mean(np.cos(g))                  # насколько оценка соседа (Δ = 1) ниже оценки «самого себя»
    print(f"{name:<14}{n_bad:>12}{excess:>11.2f}x{near:>18.4f}")

Ожидаемый вывод:

медленных пар: 18 из 64
метод          новых углов  превышение  различие соседей
без изменений           18       4.00x            0.0298
PI                       0       1.00x            0.0019
NTK-aware               17       1.45x            0.0264
YaRN                     0       1.00x            0.0298

Таблица — весь урок в четырёх строках. Без изменений 18 пар уходят в неизвестность с четырёхкратным превышением. PI убирает проблему, но различие соседей падает с 0.0298 до 0.0019, в 16 раз ($s^2$: косинус малого угла $\approx 1 - x^2/2$, урок 1.0.4). NTK-aware сохраняет разрешение, но не до конца прячет медленные пары. YaRN получает лучшее от обоих.

Зачем температура: энтропия внимания

Второй скрипт показывает размывание внимания. Логиты здесь — случайные числа с разбросом $\sigma = 2$; у настоящей модели распределение другое, но тенденция та же.

import numpy as np

rng = np.random.default_rng(0)


def attn_entropy(n, mult=1.0, sigma=2.0, trials=50):
    """Средняя энтропия softmax по n ключам; логиты ~ N(0, sigma²), умноженные на mult."""
    out = []
    for _ in range(trials):
        z = rng.normal(0, sigma, size=n) * mult
        p = np.exp(z - z.max())
        p /= p.sum()
        out.append(-(p * np.log(p)).sum())
    return np.mean(out)


m = (0.1 * np.log(4) + 1) ** 2                     # YaRN, s = 4: логиты умножаются на ≈ 1.2965
print(f"4K ключей:              энтропия {attn_entropy(4096):.2f}")
print(f"16K ключей:             энтропия {attn_entropy(16384):.2f}")
print(f"16K ключей + YaRN x{m:.4f}: энтропия {attn_entropy(16384, m):.2f}")

Ожидаемый вывод:

4K ключей:              энтропия 6.33
16K ключей:             энтропия 7.72
16K ключей + YaRN x1.2965: энтропия 6.47

Энтропия в натах: $e^{6.33} \approx 560$ — внимание «эффективно» распределено по нескольким сотням ключей. На 16K таких ключей уже $e^{7.72} \approx 2250$, внимание расфокусировано. Множитель YaRN возвращает его почти к исходной резкости.

🖥 На вашей машине (4×GPU)

Qwen2.5-7B-Instruct на 128K токенов. Посчитаем KV-кэш (урок 4.6.4): 28 слоёв, 4 KV-головы по 128, BF16 — $2 \cdot 28 \cdot 4 \cdot 128 \cdot 2 = 57\,344$ байта на токен, на 131 072 токена около 7 ГиБ. С весами (около 15 ГБ) модель помещается даже на одну вашу карту.

1. Скачайте модель и допишите в её config.json блок rope_scaling с YaRN (factor 4.0, как выше).
2. Запустите сервер: vllm serve <путь к модели> --max-model-len 131072 --tensor-parallel-size 2. Флаги меняются от версии к версии vLLM — сверьтесь с vllm serve --help.
3. Устройте «иголку в стоге сена»: склейте 100K токенов любого текста (например, «Войну и мир»), вставьте в случайное место «Секретный пароль — 7319» и спросите пароль. Повторите для позиций 10%, 50%, 90% и сравните с запуском без rope_scaling на длине 40K. Без YaRN vLLM откажется ставить --max-model-len больше 32 768 из конфига; для эксперимента задайте переменную окружения VLLM_ALLOW_LONG_MAX_MODEL_LEN=1. Prefill 100K токенов на 2 GPU займёт от десятков секунд до пары минут.
4. Тензорный параллелизм по PCIe. Модель вместе с кэшем на 128K помещается и на одну карту, поэтому перезапустите сервер с --tensor-parallel-size 1 и сравните время prefill и скорость генерации. При TP каждый слой делает all-reduce активаций (урок 5.4.3), а у вас он идёт по PCIe без NVLink: ждите выигрыша меньше двукратного, особенно на генерации, где на каждый токен приходятся десятки мелких пересылок.

Чем это лучше CPU: prefill 100K токенов для 7B-модели — это порядка $10^{15}$ FLOPs только на матрицы весов ($2 \cdot 7.6 \cdot 10^9 \cdot 10^5$) и ещё больше на само внимание. На процессоре такой запрос шёл бы порядка часа, на картах — минуты. Настройка карт и проверка связи — на странице «Ваша лаборатория (4×GPU)».

Китайский угол: экстраполяция по длине — тема, которую двигал китайский блог

RoPE и его продолжения. RoPE предложил Су Цзяньлинь (тогда Zhuiyi Technology, позже Moonshot AI) в 2021 году — сначала в блоге «Научное пространство», затем в статье RoFormer. Когда в 2023 году началась гонка за длинным контекстом, его серия «Путь улучшения трансформера» стала главным китайским источником по теме: части с 7-й по 16-ю посвящены экстраполяции по длине. Через несколько дней после поста bloc97 Су опубликовал объяснение NTK-aware через системы счисления (статья 10), а в январе 2024-го — обзор всего направления.

Qwen первого поколения (2023, техотчёт) растягивала контекст вообще без дообучения: динамический NTK, LogN-масштабирование (та самая поправка $\log n$ против размывания внимания из урока 4.4.2) и оконное внимание. По таблице техотчёта, perplexity Qwen-7B (обучали на 2K) на длине 16K без этих приёмов — 2645, с ними — 4.32. Хорошая иллюстрация обеих причин поломки из начала урока.

DeepSeek. YaRN используется с DeepSeek-V2 (май 2024): контекст расширили с 4K до 128K, применив YaRN к развязанному RoPE-ключу MLA. В V3 расширение стало двухэтапным (32K, затем 128K) и заняло менее 1% токенов претрейна. В техотчёте приведён тест «иголка в стоге сена» по всей длине 128K.

Qwen. Комбинирует ABF (база $10^6$ на этапе 32K у Qwen2.5 и Qwen3), YaRN и DCA. Метод DCA предложили исследователи Гонконгского университета и Alibaba (arXiv:2402.17463), а Qwen2.5-1M (arXiv:2501.15383) довела связку до миллиона токенов.

Kimi. Moonshot AI сделала длинный контекст продуктовой фишкой: по сообщениям компании, в октябре 2023 года Kimi Chat принимала около 200 тысяч иероглифов, а весной 2024-го — до 2 миллионов. После этого «длинный текст» на год стал главным полем конкуренции китайских чат-ботов, а «иголка в море» — обязательным графиком в техотчётах.

Проверь себя

Проверь себя6 вопросов·

1 Модель с RoPE ($d = 128$, $b = 10^4$) обучили на 4K токенов. Какие пары частот виноваты в том, что на 16K она ломается?

Быстрые пары: за 16K токенов они делают слишком много оборотовМедленные пары: за 4K токенов они не сделали ни одного оборота, и дальше их углы — невиданныеВсе пары одинаковоНикакие: виноват только softmax

2 Какие утверждения о Position Interpolation верны?Можно выбрать несколько ответов

Углы на позиции $sL$ совпадают с углами на позиции $L$ без масштабированияСамая быстрая пара частот не меняетсяСоседние токены становятся хуже различимыХорошо работает совсем без дообучения на любом $s$

3 Чему равна новая база NTK-aware для $d = 128$, $b = 10\,000$, $s = 4$? Ответ округлите до сотен.

4 Во сколько раз YaRN увеличивает логиты внимания при $s = 16$? Округлите до двух знаков.

5 YaRN, $d = 128$, $b = 10^4$, $L = 4096$, $\alpha = 1$, $\beta = 32$. Что произойдёт с парой $i = 10$ (длина волны около 26.5 токена)?

Частота не изменитсяЧастота разделится на $s$Частота окажется в переходной зонеПару отключат

6 Какую долю токенов претрейна DeepSeek-V3 потратила на расширение контекста с 4K до 128K?

Меньше 1%Около 10%Около половиныМодель пришлось обучать заново

Проверить ответы

Итоги

• RoPE-модель ломается за обучающей длиной из-за медленных пар частот, которые не сделали ни одного оборота, и из-за размывания внимания на большем числе ключей.
• PI делит позиции на $s$: углы в диапазоне, но падает разрешение на быстрых частотах. NTK-aware увеличивает базу: быстрые частоты почти не трогаются, медленные интерполируются. ABF — то же с большой базой и дообучением.
• YaRN решает за каждую пару отдельно (по числу оборотов $r$) и добавляет температуру $(0.1 \ln s + 1)^2$.
• DeepSeek-V3 растянула контекст с 4K до 128K двумя этапами YaRN за 0.85% бюджета. Qwen сочетает ABF при обучении с YaRN и DCA на инференсе, Qwen2.5-1M доходит до миллиона токенов.

Дальше: растянуть позиции — полдела. Внимание на 128K всё ещё стоит $O(n^2)$. В следующем уроке разберём, как DeepSeek научила модель смотреть не на все токены, — скользящее окно, NSA и DSA: Разреженное внимание.