Куда движется архитектура LLM в 2026

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

Если сравнить блок трансформера 2023 года (Llama 2) и 2026 года (DeepSeek-V4, Kimi K3, Qwen3.8-Next), отличаются почти все детали. Но перемены не хаотичны. Лаборатории независимо пришли к четырём идеям:

1. Внимание — разреженное, сжатое или гибридное с линейным, чтобы контекст в 1M токенов стал дешёвым.
2. Остаточный поток — уже не просто x + f(x), а несколько потоков или внимание по глубине.
3. Память — отдельная «таблица знаний», к которой обращаются по хешу последних токенов.
4. Точность и пост-трейнинг — обучение сразу в 4 битах (QAT) и сборка одной модели из доменных учителей через on-policy дистилляцию.

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

Речь пойдёт о языковом ядре. Генерация картинок, видео и звука развивается по своим законам — это было в модуле 9.1: flow matching и речевые и omni-модели. Но в центре omni-модели стоит та же LLM, так что тренды ниже касаются и её.

Как читать факты в этом уроке

Урок написан по состоянию на 03.10.2026, факты о моделях 2026 года перепроверены 04.10.2026. Числа и утверждения без пометки взяты из аннотаций и текстов самих статей, из README и карточек моделей, а детали архитектуры V4 — ещё и из её описания в библиотеке Transformers. Пометка ⚠️ вторично означает, что факт известен из блогов, обзоров или СМИ и с первоисточником не сверен: используйте его как ориентир, но проверьте сами, прежде чем цитировать. Как это делать — в следующем уроке.

Тренд 1. Контекст 1M: разреженное и гибридное внимание

Сколько стоит миллион токенов

Агенту, который читает репозиторий целиком, или модели, которая держит в голове многочасовую сессию, нужен длинный контекстдлинный контекстEN long context в сотни тысяч и миллион токенов. Обычное внимание упирается в две стены: вычисления растут как $O(n^2)$, а KV-кэшKV-кэшEN KV cache — линейно, но с огромным коэффициентом. Формулу кэша вы знаете из урока 4.6; посчитаем её на миллионе токенов:

# KV-кэш на 1 000 000 токенов контекста (BF16 = 2 байта на число)
CTX, BYTES = 1_000_000, 2

def gb(per_token_bytes):
    return per_token_bytes * CTX / 1e9

# MHA/GQA: на каждый слой храним K и V: 2 · n_kv_heads · head_dim чисел
mha = 2 * 80 * 64 * 128 * BYTES      # 80 слоёв, 64 KV-головы по 128 (MHA)
gqa = 2 * 80 * 8 * 128 * BYTES       # те же 80 слоёв, но 8 KV-голов (GQA, как в Llama-3-70B)
mla = 61 * (512 + 64) * BYTES        # MLA DeepSeek-V3: 61 слой, латент 512 + RoPE-ключ 64

rows = [
    ("MHA, 80 слоёв", mha),
    ("GQA, 8 KV-голов", gqa),
    ("MLA (как в V3)", mla),
    ("MLA + сжатие ×4 по оси токенов", mla / 4),
    ("MLA + сжатие ×128", mla / 128),
    ("чередуем ×4 и ×128 (поровну слоёв)", (mla / 4 + mla / 128) / 2),
]
for name, b in rows:
    print(f"{name:36s} {b/1024:8.1f} КиБ/токен   {gb(b):8.1f} ГБ на 1M")

MHA, 80 слоёв                          2560.0 КиБ/токен     2621.4 ГБ на 1M
GQA, 8 KV-голов                         320.0 КиБ/токен      327.7 ГБ на 1M
MLA (как в V3)                           68.6 КиБ/токен       70.3 ГБ на 1M
MLA + сжатие ×4 по оси токенов           17.2 КиБ/токен       17.6 ГБ на 1M
MLA + сжатие ×128                         0.5 КиБ/токен        0.5 ГБ на 1M
чередуем ×4 и ×128 (поровну слоёв)        8.8 КиБ/токен        9.1 ГБ на 1M

КиБ (кибибайт) — 1024 байта; программа делит байты на 1024, чтобы получить КиБ на токен. Без новых идей миллион токенов одного пользователя — это 330 ГБ кэша даже с GQA, больше всей видеопамяти ваших четырёх карт. MLA (урок 5.2.2) сокращает это до 70 ГБ — всё ещё много. Последние три строки — игрушечная оценка того, что даёт сжатие по оси токенов. Это не настоящая конфигурация V4 (в ней вместо MLA — внимание с одной общей головой K = V), но порядок величин правильный. По аннотации техотчёта, V4-Pro на контексте 1M использует 10% KV-кэша и 27% вычислений на токен по сравнению с V3.2. А у DeepSeek-V4.1-Flash (09.2026) глобальный кэш, по аннотации её отчёта, — 890 байт на токен, примерно четверть от V4-Flash: меньше 1 ГБ на миллион токенов.

Две школы

Разреженное и сжатое внимание (урок 5.5.2). Запрос смотрит не на все прошлые токены, а на избранные или на сжатые «конспекты» блоков:

• NSA (DeepSeek, 02.2025) — три ветви: сжатые блоки, отобранные top-k блоки и скользящее окно.
• DSA (DeepSeek-V3.2, 2025) — дешёвый lightning indexer оценивает все прошлые токены, полное внимание считается только по 2048 лучшим. В 2026 году DSA позаимствовал GLM-5.
• CSA + HCA (DeepSeek-V4, 04.2026) — разреженное вниманиеразреженное вниманиеEN sparse attention двух типов чередуется по слоям. По техотчёту (и его пересказу в документации Transformers): CSA сжимает KV в 4 раза по оси токенов и поверх выбирает top-k сжатых блоков индексатором, как в DSA; HCA сжимает в 128 раз, зато внимание по сжатому плотное. Ближайшие токены оба типа видят без сжатия — через отдельную ветвь скользящего окна.
• MiniMax Sparse Attention (M3, 06.2026) — индекс выбирает top-k блоков KV отдельно для каждой GQA-группы (16 блоков по 128 токенов). По аннотации статьи, на модели 109B при контексте 1M вычисления внимания на токен падают в 28.4 раза, а качество остаётся на уровне GQA.
• Qwen Sparse Attention (Qwen3.8-Next) — собственный вариант разреженного внимания Qwen: лёгкий индексатор выбирает контекст микроблоками. В модели он работает в паре с линейными слоями GDN (см. гибриды ниже).

Гибриды (урок 5.5.3, «Линейное внимание и гибриды»). Большинство слоёв — линейное вниманиелинейное вниманиеEN linear attention с состоянием фиксированного размера (KV-кэш не растёт) или внимание в коротком окне, и лишь каждый четвёртый–шестой слой — полное или разреженное внимание:

• Qwen3-Next, Qwen3.5 — Gated DeltaNet и внимание в пропорции 3:1.
• Kimi K3 (07.2026) — 69 слоёв Kimi Delta Attention и 24 слоя gated MLA, то есть примерно те же 3:1.
• MiMo-V2-Flash (Xiaomi) — не линейное внимание, а скользящее окно: пять слоёв с окном в 128 токенов на один глобальный. Кэш оконных слоёв тоже не растёт с длиной контекста.

flowchart TB
subgraph A["Гибрид 3:1 (Qwen3-Next, Qwen3.8-Next)"]
  direction TB
  a1["линейное (GDN)"] --> a2["линейное (GDN)"] --> a3["линейное (GDN)"] --> a4["полное / разреженное"]
end
subgraph B["Чередование сжатий (DeepSeek-V4)"]
  direction TB
  b1["CSA: сжатие ×4 + top-k"] --> b2["HCA: сжатие ×128, плотно"] --> b3["CSA"] --> b4["HCA"]
end

Два способа набрать контекст 1M: гибрид с линейным вниманием и чередование сжатого внимания (схема упрощена)

Честная оговорка из урока 5.5.3: MiniMax в M2 отказалась от гибрида линейного и полного внимания, потому что на агентных задачах он проигрывал, — и в M3 пришла к разреженному вниманию. Компромисс «дешевле, но не теряем ли мы точный поиск по контексту» не решён окончательно, и каждая лаборатория решает его по-своему.

Тренд 2. Новый остаточный поток

Что не так с x + f(x)

Остаточная связьостаточная связьEN residual connection (урок 3.4.2) — «шина», по которой сигнал проходит через всю сеть: $h_{l+1} = h_l + f_l(\mathrm{Norm}(h_l))$. Её главное свойство — тождественное отображение: если слой ничего не выучил ($f_l = 0$), сигнал проходит без изменений. Поэтому сети в сотню слоёв вообще учатся.

Но у PreNormPre-Norm (нормализация на входе подслоя)EN pre-normalization (Pre-LN)x + F(Norm(x)): нормализуется только вход ветки, остаточный путь чистый. Стандарт с GPT-2 (2019); требует финальной нормализации перед LM-головой.-шины (урок 4.5.1) есть болезнь, которую в 2026 году назвали размыванием (dilution). На выходе сети $h_L = h_0 + \sum_{l} f_l$ — сумма вкладов всех слоёв с весом 1. Если вклады примерно независимы, норма суммы растёт как $\sqrt{L}$ — как у случайного блуждания: $L$ независимых шагов длины 1 уводят от начала в среднем примерно на $\sqrt{L}$, а не на $L$. Поэтому относительный вклад каждого нового слоя падает как $1/\sqrt{L}$. В сети из 64 слоёв новый слой сдвигает направление шины лишь на ~1/8 — глубокие слои «кричат в шумной комнате».

Hyper-Connections и mHC

ГиперсвязигиперсвязиEN hyper-connections (HC)остаточный поток расширяется до n параллельных потоков с обучаемым смешиванием (ByteDance Seed, ICLR 2025) расширяют шину до $n$ параллельных потоков (например, $n = 4$) и учат матрицы, которые смешивают потоки между слоями. Это даёт сети гибкость: какие-то потоки могут хранить «давнюю» информацию, какие-то — свежую. Прирост качества в претрейне был заметным.

Проблема, которую нашла DeepSeek: матрица смешивания $H_l$ размера $n \times n$ свободна, а сигнал проходит через произведение $H_L \cdots H_2 H_1$. Произведение 60 матриц, каждая из которых чуть-чуть усиливает сигнал, усиливает его экспоненциально. Свойство тождественного отображения потеряно, обучение больших моделей становится нестабильным.

mHCmHC (гиперсвязи с ограничением на многообразие)EN manifold-constrained hyper-connections (mHC) (DeepSeek, 31.12.2025) решает это ограничением: каждая $H_l$ должна быть дважды стохастическойдважды стохастическая матрицаEN doubly stochastic matrixнеотрицательная матрица, у которой сумма каждой строки и каждого столбца равна 1 — все элементы неотрицательны, сумма каждой строки и каждого столбца равна 1. Три свойства делают её безопасной:

• она смешивает потоки, но не может усилить сигнал: её спектральная норма $\le 1$;
• произведение дважды стохастических матриц — снова дважды стохастическая (замкнутость), сколько бы слоёв ни было;
• среднее по потокам сохраняется точно (суммы столбцов равны 1) — это аналог тождественного отображения для $n$ потоков: смешивание переставляет и усредняет, но ничего не теряет и не раздувает.

Как сделать произвольную матрицу дважды стохастической? Алгоритмом Синкхорна–Кноппа: взять экспоненту (всё станет положительным) и попеременно нормировать строки и столбцы. Это несколько дифференцируемых делений прямо в прямом проходе.

import numpy as np

rng = np.random.default_rng(0)
n, L = 4, 60                      # 4 параллельных остаточных потока, 60 слоёв

def sinkhorn(M, iters=20):
    """Проекция на дважды стохастические матрицы (алгоритм Синкхорна–Кноппа)."""
    P = np.exp(M)                 # делаем все элементы положительными
    for _ in range(iters):
        P = P / P.sum(axis=1, keepdims=True)   # строки → сумма 1
        P = P / P.sum(axis=0, keepdims=True)   # столбцы → сумма 1
    return P

raw = [np.eye(n) + 0.3 * rng.normal(size=(n, n)) for _ in range(L)]  # «свободные» матрицы смешивания (HC)
ds = [sinkhorn(rng.normal(size=(n, n))) for _ in range(L)]            # ограниченные (mHC)

H = ds[0]
print("суммы строк:", np.round(H.sum(axis=1), 4), " суммы столбцов:", np.round(H.sum(axis=0), 4))

prod_raw, prod_ds = np.eye(n), np.eye(n)
for l in range(L):
    prod_raw = raw[l] @ prod_raw
    prod_ds = ds[l] @ prod_ds
    if l + 1 in (6, 12, 24, 48, 60):
        g1 = np.linalg.norm(prod_raw, 2)   # во сколько раз может вырасти сигнал
        g2 = np.linalg.norm(prod_ds, 2)
        print(f"после {l+1:2d} слоёв: HC усиление {g1:12.1f}   mHC усиление {g2:.3f}")

суммы строк: [1. 1. 1. 1.]  суммы столбцов: [1. 1. 1. 1.]
после  6 слоёв: HC усиление          3.1   mHC усиление 1.000
после 12 слоёв: HC усиление          3.8   mHC усиление 1.000
после 24 слоёв: HC усиление          4.9   mHC усиление 1.000
после 48 слоёв: HC усиление        423.1   mHC усиление 1.000
после 60 слоёв: HC усиление       1316.1   mHC усиление 1.000

np.linalg.norm(A, 2) — спектральная норма: максимальный коэффициент, в который матрица может растянуть вектор. Свободные матрицы, каждая из которых «почти единичная», за 60 слоёв дают усиление в 1300 раз. Дважды стохастические — ровно 1: вектор из одинаковых значений во всех потоках проходит сквозь любое их произведение без изменений. По аннотации техотчёта, mHC используется в DeepSeek-V4.

Attention Residuals: внимание по глубине

Kimi (03.2026) атаковала ту же проблему с другой стороны. Обычная шина складывает выходы всех прошлых слоёв с весом 1. Attention ResidualsAttention Residuals (внимание по глубине)EN Attention Residuals (AttnRes) разрешают каждому слою выбирать, чьи выходы ему важны:

$$h_l = \sum_{i=0}^{l-1} \alpha_{l,i}\, v_i, \qquad \alpha_{l,i} = \mathrm{softmax}_i\big(w_l^\top k_i\big)$$

Здесь $v_0$ — эмбеддинг токена, $v_i$ — выход слоя $i$, $k_i$ — ключ, построенный по этому выходу, а $w_l$ — один обучаемый «псевдо-запрос» на слой (формула упрощена). Это ровно attention из урока 4.4, только «последовательность» — не токены, а слои. Размывание исчезает: слой может дать большой вес одному конкретному предшественнику.

Хранить выходы всех слоёв дорого, поэтому на практике используют Block AttnRes: слои группируются в блоки, и внимание идёт по представлениям блоков — память $O(L/b)$ вместо $O(L)$. По аннотации, Block AttnRes догоняет базовую модель, обученную на в 1.25 раза большем бюджете вычислений. Attention Residuals вместе с KDA лежат в основе Kimi K3.

Gated Residual у Qwen

Qwen3.8-Next расширил шину до четырёх потоков, а смешивание между ними управляется обучаемыми гейтами (Gated Residual). Это ещё один вариант той же идеи: шина шире одного вектора, а смешивание — обучаемое, но ограниченное.

Схема	Что на шине	Как смешиваются слои	Где
Residual (PreNorm)	1 вектор	сумма с весом 1	GPT-2 … DeepSeek-V3
Hyper-Connections	$n$ потоков	свободные матрицы $n \times n$	ByteDance Seed, 2024
mHC	$n$ потоков	дважды стохастические матрицы (Синкхорн)	DeepSeek-V4
Attention Residuals	выходы всех слоёв (блоков)	softmax по глубине	Kimi K3
Gated Residual	4 потока	обучаемые гейты	Qwen3.8-Next

Тренд 3. Условная память: Engram

Вычисления против поиска

MoEсмесь экспертов (MoE)EN mixture of experts (MoE) (модуль 5.3) — это условные вычисления: роутер выбирает несколько экспертов из сотен. Но часть того, что модель «знает», — не вычисление, а поиск: после «столица Китая —» должно идти «Пекин». Чтобы вспомнить это, трансформер прогоняет токены через десятки слоёв матричных умножений — дорогой способ сделать то, что хеш-таблица делает за $O(1)$.

Условная памятьусловная памятьEN conditional memoryпоиск по хешированным n-граммам за O(1) (Engram, DeepSeek) — вторая ось разреженности рядом с MoE Engram (DeepSeek, 01.2026) возвращает старую идею n-граммных эмбеддингов на новом уровне. Последние $n$ токенов (до трёх) хешируются в номер строки огромной таблицы; оттуда достаётся вектор, и гейт решает, сколько его подмешать в остаточный поток. Умножений матриц на поиск — ноль.

import numpy as np

rng = np.random.default_rng(0)
text = "столица китая — пекин . столица россии — москва . столица китая — пекин".split()
vocab = {w: i for i, w in enumerate(dict.fromkeys(text))}
ids = [vocab[w] for w in text]

TABLE, D = 1 << 16, 8                        # 65 536 строк памяти по 8 чисел
memory = rng.normal(size=(TABLE, D)) * 0.02  # обучаемая таблица (здесь — случайная)

def ngram_slot(prev_ids):
    """Детерминированный хеш n-граммы → номер строки таблицы. O(1), без умножения матриц."""
    h = 0
    for t in prev_ids:
        h = (h * 1_000_003 + t + 1) % (1 << 61)
    return h % TABLE

for pos in range(2, len(ids)):
    tri = ids[pos - 2: pos + 1]                       # последние 3 токена
    slot = ngram_slot(tri)
    vec = memory[slot]                                # «вспомнили» вектор по адресу
    print(f"{' '.join(text[pos-2:pos+1]):28s} → строка {slot:5d}")

params = 51e9
print(f"\n51 млрд параметров n-граммных таблиц в BF16 = {params * 2 / 1e9:.0f} ГБ — это память хоста, а не VRAM")

столица китая —              → строка  8722
китая — пекин                → строка   479
— пекин .                    → строка 57772
пекин . столица              → строка 49524
. столица россии             → строка 22006
столица россии —             → строка 11038
россии — москва              → строка 30726
— москва .                   → строка 43125
москва . столица             → строка 39439
. столица китая              → строка 22002
столица китая —              → строка  8722
китая — пекин                → строка   479

51 млрд параметров n-граммных таблиц в BF16 = 102 ГБ — это память хоста, а не VRAM

Одна и та же триграмма всегда попадает в одну и ту же строку (8722, 479) — это и есть «память о факте». Мы не используем встроенный hash() Python: для строк он меняется от запуска к запуску. Разные n-граммы иногда попадают в одну строку (коллизия); в Engram с этим борются несколькими хеш-функциями и гейтом.

Что показала статья

• Вторая ось разреженности. У модели фиксированный бюджет параметров; сколько отдать экспертам MoE, а сколько — памяти? Авторы нашли U-образный закон: и «всё в MoE», и «всё в память» хуже, оптимум — посередине.
• При равном числе параметров и равных FLOPs модель с Engram на 27B параметров обходит чистую MoE: MMLU +3.4, CMMLU +4.0, BBH +5.0, ARC-Challenge +3.7 (бенчмарки знаний, знаний на китайском, многошаговых рассуждений и школьных научных вопросов; о бенчмарках — урок 7.3.1). Обратите внимание на честность сравнения: обе модели стоят одинаково.
• Неожиданность. Память, казалось бы, должна помогать знаниям (MMLU), а прирост в рассуждениях (BBH) оказался больше. Объяснение авторов: таблица снимает с ранних слоёв «зубрёжку» статичных шаблонов, и эти слои освобождаются для настоящих вычислений — сеть фактически становится глубже.
• Таблицы можно держать вне GPU. Адрес строки известен, как только известны токены, — задолго до того, как слой до него дойдёт. Значит, строки можно заранее подтянуть из обычной RAM. Qwen3.8-Next так и делает (модель выпущена 26.08.2026 как Qwen3.8-Flash-Next): 125B параметров MoE (6B активных) плюс ~51B параметров n-граммных таблиц, которые подгружаются из памяти хоста.

В самой DeepSeek-V4 Engram нет: по описанию архитектуры в Transformers, первые слои MoE там выбирают экспертов по фиксированной таблице «номер токена → эксперт», но n-граммной памяти нет. Зато в DeepSeek-V4.1-Flash (09.2026) таблицы Engram уже стоят — около 197 млрд элементов в FP8, больше трети чекпойнта (рецепт vLLM). А Meituan заложила в LongCat-2.0 (06.2026) 135B параметров n-граммных эмбеддингов (README).

Тренд 4. FP4 QAT и on-policy distillation

Обучение сразу в 4 битах

КвантованиеквантованиеEN quantization после обучения (урок 7.2.1) портит модель: она никогда не видела округлённых весов. QAT (quantization-aware training) вставляет округление в прямой проход во время обучения, и модель учится быть точной с учётом округления (обучение с учётом квантованияобучение с учётом квантования (QAT)EN quantization-aware training (QAT)В прямом проходе модель видит уже округлённые (например, 4-битные) веса и учится быть к этому устойчивой. Так получены INT4-веса Kimi K2 Thinking.). Хронология:

• Kimi K2 Thinking (11.2025) — INT4 QAT для весов MoE на этапе пост-трейнинга; по словам Moonshot, это примерно вдвое ускоряет генерацию без потери качества.
• DeepSeek-V4 (04.2026) — FP4 QAT для весов экспертов MoE. По техотчёту, мастер-веса экспертов хранятся в FP32, квантуются в FP4 и без потерь деквантуются в FP8 для вычислений (у FP8 E4M3 на два бита порядка больше, чем у FP4 E2M1); в FP4 переведён и путь QK индексатора CSA. В опубликованных весах эксперты лежат в FP4, остальное — в FP8 (о форматах — урок 5.4.1).
• Kimi K3 (07.2026) — MXFP4 QAT для весов экспертов, начиная с SFT; активации — в MXFP8. Веса выпущены сразу в MXFP4 (README и техотчёт K3).

Зачем это всё? Арифметика памяти для модели на 1.6T параметров, если бы все веса хранились в одном формате: BF16 — 3.2 ТБ, FP8 — 1.6 ТБ, FP4 — 0.8 ТБ. В формате MXFP4 на каждые 32 числа добавляется общий 8-битный масштаб, то есть $4 + 8/32 = 4.25$ бита на вес — около 0.85 ТБ. Половина памяти — это вдвое меньше GPU на одну копию модели и вдвое быстрее чтение весов на этапе decode (урок 7.1).

On-policy distillation: собрать одну модель из многих учителей

В уроке 6.4.4 вы видели on-policy дистилляциюon-policy дистилляция (OPD)EN on-policy distillation (OPD)Ученик сам генерирует ответы, учитель оценивает каждый токен; минимизируется обратная KL(π_ученика ‖ π_учителя). Qwen3, DeepSeek-V4. как приём. В 2026 году она стала хребтом пост-трейнинга. Схема V4 по техотчёту (смешанный RL-этап V3.2 она заменила целиком):

1. Для каждого домена — математика, код, агенты, следование инструкциям — отдельно обучают модель-эксперта (SFT + RL с проверяемыми наградами).
2. Одна модель-студент генерирует ответы сама (on-policyon-policy (обучение на данных текущей политики)EN on-policyПротивоположность — off-policy, обучение на данных другой политики.), а каждый учитель на тех же префиксах выдаёт своё распределение следующего токена. Студент минимизирует обратную KLобратная KL-дивергенция (reverse KL)EN reverse KL divergenceKL(q ‖ p), где q — модель, p — цель. «Ищет моду» — модель концентрируется на одном пике цели. Прямая KL(p ‖ q) «покрывает» все пики. (reverse KL, урок 6.4.4):

$$\mathcal{L}(\theta) = \mathbb{E}_{y \sim \pi_\theta(\cdot \mid x)} \sum_t \mathrm{KL}\Big(\pi_\theta(\cdot \mid x, y_{<t}) \;\Big\Vert\; \pi_{\text{учитель}}(\cdot \mid x, y_{<t})\Big)$$

Что здесь написано: «на своих собственных текстах студент на каждом токене подтягивает своё распределение к распределению учителя». Отличие от обычного SFT на трассах учителя — студент учится исправлять свои ошибки там, куда его заводит собственная генерация. При сборке V4 участвовали более десяти моделей-учителей; KL считали по всему словарю, а не по одному сэмплированному токену, — так оценка градиента стабильнее. Ту же схему (MOPD — multi-teacher on-policy distillation) описывает Xiaomi для MiMo-V2-Flash; ⚠️ вторично — и Meituan для LongCat-2.0.

Почему это тренд: раньше одна большая RL-гонка пыталась сразу улучшить всё и ломала одно, улучшая другое. Теперь домены развивают независимо и параллельно, а в одну модель их «сливает» дешёвая и стабильная дистилляция.

Сводная карта 2026 года

Модель	Внимание	Остаточный поток	Память	Точность / пост-трейнинг
DeepSeek-V4 (04.2026)	CSA + HCA, контекст 1M	mHC	—	FP4 QAT экспертов; OPD от 10+ учителей
DeepSeek-V4.1-Flash (09.2026)	скользящее окно + CSA2 (KV общий для нескольких слоёв, в FP4), 1M	mHC	Engram	эксперты в MXFP4
Kimi K3 (07.2026)	KDA + gated MLA, 1M	Attention Residuals	—	MXFP4 QAT
Qwen3.8-Next (08.2026)	GDN 3:1 + Qwen Sparse Attention	Gated Residual, 4 ветви	n-граммные таблицы ~51B в RAM	—
GLM-5 (02.2026)	DSA (взят у DeepSeek)	—	—	—
MiniMax M3 (06.2026)	MiniMax Sparse Attention, 1M	—	—	—
MiMo-V2-Flash (12.2025)	окно 128 : глобальное = 5 : 1	—	—	MOPD

Прочерк значит «в этой модели тренд не заявлен», а не «у лаборатории нет работ по теме».

Практика

Все три скрипта урока работают на CPU за секунды. Сохраните их в frontier/ и проведите мини-исследования:

1. KV-кэш. Добавьте строку для гибрида 3:1, где кэш есть только у каждого четвёртого слоя (GQA, 8 KV-голов). Сколько гигабайт на 1M токенов? Что выгоднее для одного пользователя — гибрид 3:1 или MLA? Подсказка: у линейных слоёв кэш не растёт с контекстом, поэтому в список rows достаточно добавить ("гибрид 3:1 (GQA)", gqa / 4).
2. mHC. Уменьшите число итераций Синкхорна до 1 и 3. Насколько суммы столбцов отличаются от 1? Что происходит с усилением через 60 слоёв? Отсюда видно, сколько итераций достаточно на практике. Подсказка: передайте iters в sinkhorn(...) при построении списка ds и напечатайте H.sum(axis=0).
3. Engram. Уменьшите таблицу до 64 строк и посчитайте, сколько разных триграмм попало в одну строку. Как коллизии зависят от размера таблицы? Подсказка: поставьте TABLE = 64 и соберите словарь {строка: множество триграмм} (setdefault(slot, set()).add(tuple(tri))); коллизия — строка, у которой в множестве больше одной триграммы. Для статистики возьмите текст подлиннее.

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

• HC против mHC на настоящем обучении. Возьмите nanoGPT из урока 4.6.2, сделайте 48 слоёв ширины 256, добавьте $n = 4$ потока с матрицами смешивания — свободными и через Синкхорна. Логируйте норму остаточного потока по слоям и максимальный градиент. На одной карте десятки миллионов параметров учатся за часы (на CPU — дни); запустите оба варианта параллельно на двух картах (CUDA_VISIBLE_DEVICES=0 и =1), а на двух оставшихся — тот же опыт с другим seed: разница, которая не повторяется между seed, — шум.
• Гибрид 3:1 вживую. Qwen3-Next-80B-A3B (Gated DeltaNet и внимание 3:1) в рецепте vLLM запускают с --tensor-parallel-size 4. При старте vLLM пишет в лог, сколько токенов помещается в KV-кэш (GPU KV cache size): сравните с плотной Qwen3-32B-AWQ на тех же картах — это ваш расчёт из задания 1, только на настоящем движке. Оговорка: FP8-версию рецепт рассчитывает на Hopper (поколение H100/H800) и новее, на Ada (поколение вашей RTX 4080) она может не запуститься; 80B в BF16 (~160 ГБ) в 128 ГБ не влезает, поэтому ищите 4-битную сборку, которую поддерживает ваша версия vLLM. На октябрь 2026 есть вариант проще: та же схема Gated DeltaNet и внимания 3:1 в плотной Qwen/Qwen3.6-27B — в BF16 по рецепту vLLM ей нужно около 65 ГБ с запасом, то есть все четыре карты (--tensor-parallel-size 4); команда та же, меняется имя модели.
• Engram на биграммах и триграммах. Добавьте в тот же nanoGPT гейтованную хеш-таблицу и сравните loss на задаче запоминания фактов («столица X — Y»). Таблицу на десятки миллионов строк можно держать в RAM (у вас 128 ГБ) и подтягивать нужные строки на GPU.
• Настоящий фронтир. DeepSeek-V4-Flash (284B / 13B активных) даже в 4 битах — это ~142 ГБ на одни веса. Это больше суммарной видеопамяти ваших карт, но в связке «GPU + 128 ГБ RAM» (гибридный инференс MoE в духе KTransformers: редко используемые эксперты лежат в оперативной памяти и считаются на процессоре, а внимание — на GPU) запуск становится реальным. Считайте память заранее; оценки — ориентировочные.

Подробнее о машине и о том, что запускать на каждой ступени, — на странице «Ваша лаборатория».

Китайский угол: фронтир, который во многом пишется в Китае

Посмотрите на авторов: разреженное внимание NSA/DSA/CSA — DeepSeek; KDA и Attention Residuals — Moonshot (Kimi); Gated DeltaNet в продакшене, gated attention и n-граммные таблицы на 51B — Qwen; Hyper-Connections — ByteDance Seed; mHC и Engram — DeepSeek; MSA — MiniMax. Фронтир архитектуры LLM в 2026 году в значительной мере пишется в Пекине, Ханчжоу и Шанхае.

Честности ради: корни у этих идей международные. Сам Gated DeltaNet придумали в NVIDIA и MIT, а Qwen вывела его в большие модели; QAT известен с конца 2010-х; on-policy дистилляцию для LLM подробно описала Google DeepMind в 2023 году (метод GKD). Китайский вклад двойной: собственные идеи (NSA и DSA, KDA, mHC, Engram, Attention Residuals) и смелость довести чужие до масштаба в триллион параметров — и выложить результат открыто, вместе с весами.

Вторая особенность — скорость заимствования. GLM-5 взял DSA у DeepSeek через несколько месяцев после публикации; n-граммная память появилась у DeepSeek в январе 2026 года, а в июне и августе похожие таблицы уже работали в LongCat-2.0 и Qwen3.8-Next. Это возможно, потому что лаборатории выкладывают не только статьи, но и код: deepseek-ai/Engram (Apache-2.0), MoonshotAI/Attention-Residuals. Китайское AI-сообщество называет такую гонку словом «цзюань» (букв. «закручиваться», «изматывающая конкуренция») — конкуренция, в которой никто не может остановиться.

Где следить: официальные анонсы DeepSeek выходят в разделе новостей их документации (есть китайская версия), разборы на китайском появляются на Чжиху (Zhihu, крупнейший китайский сайт вопросов и ответов с длинными техническими постами) и в «Цзици чжи синь» (Synced, ведущее китайское издание об ИИ) в первые дни после релиза. Как их читать и проверять — следующий урок.

Проверь себя

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

1 MLA как в DeepSeek-V3: 61 слой, на токен и слой кэшируется 576 чисел в BF16 (2 байта). Сколько гигабайт (10⁹ байт) займёт KV-кэш на 1 000 000 токенов? Округлите до целого.

2 Почему Hyper-Connections без ограничений нестабильны на большой глубине?

Потому что в них нет нормализацииСигнал проходит через произведение десятков свободных матриц смешивания; оно может экспоненциально усилить или погасить сигнал — теряется тождественное отображениеПотому что потоки не обмениваются информациейПотому что они требуют FP4

3 Какие утверждения о дважды стохастических матрицах верны?Можно выбрать несколько ответов

Сумма каждой строки и каждого столбца равна 1, элементы неотрицательныПроизведение двух дважды стохастических матриц — тоже дважды стохастическаяИх спектральная норма не больше 1Алгоритм Синкхорна делает матрицу дважды стохастической за один шаг нормировки строк

4 Чем Engram принципиально отличается от MoE?

Engram — тоже роутер, только по слоямMoE выбирает, какие вычисления сделать; Engram достаёт готовый вектор из таблицы по хешу последних токенов за O(1), без матричных умноженийEngram заменяет вниманиеEngram работает только на этапе инференса

5 Зачем в on-policy distillation студент учится на СВОИХ сгенерированных ответах, а не на трассах учителя?

Так дешевле хранить данныеСтудент попадает в состояния, куда его заводят собственные ошибки, и учится исправляться именно там; на чужих трассах он таких ситуаций не видитУчитель не умеет генерировать текстЧтобы не считать KL

6 Модель на 284 млрд параметров хранится в FP4 без учёта масштабов. Сколько это гигабайт (10⁹ байт)?

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

Итоги

• Контекст 1M делают дешёвым двумя путями: сжатое и разреженное внимание (NSA → DSA → CSA/HCA, MSA, QSA) и гибриды с линейным вниманием (GDN, KDA). Простая арифметика KV-кэша объясняет, почему без этого нельзя.
• Остаточный поток стал шире и умнее: mHC ограничивает смешивание потоков дважды стохастическими матрицами, Attention Residuals заменяют сумму слоёв вниманием по глубине, Qwen использует gated residual.
• Условная память (Engram) — вторая ось разреженности рядом с MoE: поиск по хешу n-граммы за O(1), таблицы — в RAM.
• FP4 QAT вдвое сокращает память по сравнению с FP8, а on-policy distillation собирает одну модель из доменных учителей.
• Свежие факты всегда делите на «прочитано в статье» и «пересказано в обзоре».

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