дорожка · 23.10.2026 · смесь экспертов

Почему у модели сотни миллиардов параметров, а работает малая часть: смесь экспертов

В описаниях новых моделей всё чаще стоят две цифры: «всего 671 миллиард параметров, активных 37 миллиардов» или название вроде Qwen3-235B-A22B. Это модели со смесью экспертов (Mixture of Experts, MoE): вместо одного большого блока вычислений в каждом слое стоит много маленьких, и для каждого токена работают только несколько из них. Разберём, где именно сидят эти эксперты, как модель решает, кого позвать, почему эксперты норовят перегрузиться, что это даёт по скорости и чего стоит по памяти, и чему они на самом деле учатся. Весь код на странице мы запускали, выводы взяты из этих запусков; цифры о настоящих моделях подписаны источником.

Все дорожки — /put. Прошлая — спекулятивное декодирование.

1 Где в модели живут параметры и что такое эксперт

Зачем это в работе. Когда ты выбираешь модель для своего сервиса или читаешь новость о релизе, от двух цифр — всех параметров и активных — зависят три разные вещи: сколько видеопамяти нужно, чтобы модель вообще загрузить, сколько вычислений уходит на каждый токен и насколько модель «знает много». У обычной (плотной) модели эти три вещи растут вместе, у модели со смесью экспертов они расходятся. Если не понимать, где именно возникает разница, легко купить сервер, на который модель не влезет, или ждать от «маленькой по активным параметрам» модели скорости маленькой модели там, где её не будет.

Напомним устройство слоя трансформера из дорожки про внимание. Каждый слой состоит из двух частей. Сначала блок внимания: каждый токен смотрит на предыдущие и собирает из них нужное. Потом блок прямого прохода (feed-forward network, FFN): каждый токен по отдельности пропускается через две-три большие матрицы, которые сначала расширяют его вектор в несколько раз, а потом сжимают обратно. Внимание смешивает информацию между токенами, а блок прямого прохода перерабатывает её внутри одного токена, и именно в нём хранится большая часть того, что модель «знает».

Смесь экспертов заменяет этот один блок прямого прохода на несколько копий с независимыми весами. Каждая копия называется экспертом (expert), хотя никакой заранее заданной специальности у неё нет — это просто отдельный набор матриц того же устройства. Рядом ставится маленький маршрутизатор (router, иногда gate): одна матрица, которая по вектору токена оценивает, каким экспертам его отдать. Токен проходит только через выбранных, обычно одного, двух или восьми, а остальные эксперты для него не считаются вовсе. Блок внимания при этом остаётся общим и обычным.

Отсюда две цифры. Все параметры (total parameters) — это сумма весов всех экспертов во всех слоях плюс внимание и словарь; столько чисел должно лежать в памяти. Активные параметры (active parameters) — только те веса, через которые проходит один токен; от них зависит объём вычислений на токен. Сама идея старая: разреженно включаемые эксперты в нейросетях описали Shazeer и соавторы в статье «Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer» (2017), а в трансформеры её перенесли работы GShard (2020) и Switch Transformer (2021) из Google.

Ограничение заложено в определение: модель со смесью экспертов экономит вычисления, но не память. Этим она отличается от сжатия весов из дорожки о квантовании, которое уменьшает именно объём в памяти, и от спекулятивного декодирования из вчерашней дорожки, которое ничего не меняет в модели и лишь выжимает больше токенов из каждого прохода. Смесь экспертов — это решение об архитектуре, его принимают до обучения, и включить его потом в готовую плотную модель настройкой нельзя.

Подробный пример. Посчитаем обе цифры для открытой модели Mixtral 8x7B от Mistral AI по её опубликованной конфигурации: 32 слоя, ширина 4096, в каждом слое 8 экспертов, на токен работают 2. Эксперт устроен как блок SwiGLU — это вариант блока прямого прохода с тремя матрицами вместо двух.

# Считаем параметры по открытой конфигурации Mixtral 8x7B (config.json на Hugging Face)
dim, layers, vocab = 4096, 32, 32000
heads, kv_heads, head_dim = 32, 8, 128
hidden = 14336            # ширина внутреннего слоя одного эксперта
E, k = 8, 2               # экспертов в слое и сколько из них работает на токен

attn = dim*heads*head_dim + 2*dim*kv_heads*head_dim + heads*head_dim*dim
expert = 3*dim*hidden     # три матрицы: gate, up, down (SwiGLU)
router = dim*E
norms = 2*dim
embed = 2*vocab*dim + dim # вход, выход и финальная нормировка

total  = layers*(attn + E*expert + router + norms) + embed
active = layers*(attn + k*expert + router + norms) + embed
print(f"внимание на слой:        {attn/1e6:8.1f} млн")
print(f"один эксперт на слой:    {expert/1e6:8.1f} млн")
print(f"все параметры:           {total/1e9:8.2f} млрд")
print(f"работают на один токен:  {active/1e9:8.2f} млрд  ({active/total:.0%})")
print(f"доля экспертов в общем:  {layers*E*expert/total:.0%}")

У нас этот код напечатал:

внимание на слой:            41.9 млн
один эксперт на слой:       176.2 млн
все параметры:              46.70 млрд
работают на один токен:     12.88 млрд  (28%)
доля экспертов в общем:  97%

Получилось 46,7 миллиарда всех параметров и 12,9 миллиарда активных — это совпадает с цифрами, которые Mistral AI приводит в статье «Mixtral of Experts» (2024): 47 миллиардов всего и 13 миллиардов активных на токен. Обрати внимание на название: «8x7B» — это не 56 миллиардов, потому что внимание и словарь у восьми экспертов общие, размножен только блок прямого прохода. И вторая строчка, которая объясняет весь подход: эксперты составляют 97% всех весов. Значит, разреживая именно их, мы почти не трогаем остальную модель, но в четыре раза сокращаем работу на токен.

Где обычно ошибаются.

  • Читают «8x7B» как восемь отдельных моделей по 7 миллиардов. На деле это одна модель, у которой размножен только блок прямого прохода, а внимание общее.
  • Оценивают нужную видеопамять по активным параметрам. Загрузить нужно все веса, иначе маршрутизатору будет некуда отправить токен.
  • Думают, что эксперт заранее назначен на тему вроде «математика» или «код». Специализация не задаётся, она возникает при обучении и, как покажет пятая ступень, обычно совсем не тематическая.

Смесь экспертов (Mixture of Experts, MoE). архитектура, в которой блок прямого прохода заменён несколькими независимыми копиями, и каждый токен проходит только через некоторые из них.

Эксперт (expert). одна такая копия блока прямого прохода со своими весами, без заранее заданной специальности.

Маршрутизатор (router, gate). маленькая матрица, которая для каждого токена решает, каким экспертам его отдать.

Блок прямого прохода (feed-forward network, FFN). часть слоя, которая обрабатывает каждый токен по отдельности через расширяющую и сжимающую матрицы.

Плотная модель (dense model). обычная модель, где каждый токен проходит через все её веса.

Все параметры (total parameters). сколько чисел у модели всего; определяет нужную память.

Активные параметры (active parameters). сколько чисел участвует в обработке одного токена; определяет вычисления на токен.

SwiGLU. распространённое устройство блока прямого прохода с тремя матрицами, где одна из них работает как «вентиль» для другой.

2 Маршрутизатор: как для каждого токена выбирают экспертов

Зачем это в работе. Маршрутизатор — единственное место, где модель со смесью экспертов принимает дискретное решение «этот эксперт да, этот нет». От того, как он устроен, зависят и качество модели, и все инженерные сложности следующих ступеней: перекосы нагрузки, нестабильность обучения, различия в ответах при разных размерах пакета. Когда в описании модели пишут «128 экспертов, 8 активных» или «один общий эксперт плюс маршрутизируемые», это всё про маршрутизатор, и понять такую строку можно только зная его механику.

Шаги для одного токена в одном слое такие. Первый: вектор токена умножается на матрицу маршрутизатора размером «ширина модели на число экспертов», и получается по одному числу-оценке на каждого эксперта. Второй: оценки превращаются в вероятности функцией softmax — та же операция, что в дорожке о выборе слова превращала оценки слов в вероятности. Третий: берутся k экспертов с наибольшими вероятностями (top-k), остальные отбрасываются. Четвёртый: токен прогоняется через каждого выбранного эксперта, а их выходы складываются с весами, равными их вероятностям, обычно перенормированными так, чтобы сумма весов выбранных была единицей.

Веса в последнем шаге важны не меньше, чем выбор. Именно через них маршрутизатор учится: выбор «топ-k» — ступенька, через которую градиент (сигнал «в какую сторону поправить веса» при обучении) не проходит, а через вес, с которым смешиваются выходы, проходит. Если эксперт с весом 0,8 сильно помог уменьшить ошибку, градиент поднимет его оценку для похожих токенов. Варианты различаются деталями: в Switch Transformer k равно 1, в Mixtral 2 из 8, в DeepSeek-V3, по техническому отчёту DeepSeek (декабрь 2024), 8 из 256 маршрутизируемых экспертов плюс один общий эксперт, через который проходит каждый токен, а вместо softmax оценки считаются сигмоидой.

Маршрутизация происходит отдельно в каждом слое и для каждого токена. Один и тот же токен в пятом слое может пойти к экспертам 3 и 7, а в шестом — к 1 и 4; соседние токены одного предложения тоже расходятся по разным экспертам. Поэтому «эксперт номер 3» — это не модуль модели, которому можно поручить тему, а 32 разных, ничем не связанных блока, по одному в каждом слое, у которых совпадает только номер.

Ограничение: выбор top-k жёсткий, и маленькое изменение вектора токена может перебросить его к другому эксперту, резко изменив выход слоя. Этим маршрутизация отличается от внимания: внимание смотрит на все предыдущие токены с плавными весами, а маршрутизатор полностью выключает большинство экспертов. Отсюда известная особенность серверов с такими моделями: если сервер ограничивает, сколько токенов может принять эксперт (третья ступень), ответ на один и тот же запрос может зависеть от того, с какими чужими запросами он попал в пакет.

Подробный пример. Маленький слой со смесью экспертов на numpy: 8 экспертов, выбираем 2, пять токенов. В конце проверяем, что «разреженный» расчёт, где считаются только выбранные эксперты, даёт тот же результат, что расчёт всех восьми, умноженных на маску из нулей.

import numpy as np
rng = np.random.default_rng(0)
d, h, E, k, T = 16, 32, 8, 2, 5           # ширина, ширина эксперта, экспертов, top-k, токенов
W_router = rng.normal(size=(d, E)) * 0.5
W_in  = rng.normal(size=(E, d, h)) * 0.2  # у каждого эксперта свои веса
W_out = rng.normal(size=(E, h, d)) * 0.2
x = rng.normal(size=(T, d))

def expert(e, v): return np.maximum(v @ W_in[e], 0) @ W_out[e]

logits = x @ W_router
probs = np.exp(logits - logits.max(1, keepdims=True)); probs /= probs.sum(1, keepdims=True)
top = np.argsort(-probs, 1)[:, :k]
y = np.zeros_like(x)
for t in range(T):
    w = probs[t, top[t]]; w = w / w.sum()          # перенормируем веса двух выбранных
    y[t] = sum(wi * expert(e, x[t]) for wi, e in zip(w, top[t]))
    print(f"токен {t}: эксперты {top[t].tolist()}  веса {np.round(w, 2).tolist()}")

# Проверка: то же самое через «плотный» расчёт всех экспертов с маской из нулей
mask = np.zeros((T, E))
for t in range(T):
    mask[t, top[t]] = probs[t, top[t]] / probs[t, top[t]].sum()
dense = sum(mask[:, [e]] * np.stack([expert(e, x[t]) for t in range(T)]) for e in range(E))
print("совпадает с плотным расчётом:", np.allclose(y, dense))
print(f"посчитано экспертов: {T*k} из {T*E} возможных")

У нас этот код напечатал:

токен 0: эксперты [3, 4]  веса [0.56, 0.44]
токен 1: эксперты [6, 5]  веса [0.79, 0.21]
токен 2: эксперты [3, 5]  веса [0.8, 0.2]
токен 3: эксперты [5, 6]  веса [0.85, 0.15]
токен 4: эксперты [2, 4]  веса [0.72, 0.28]
совпадает с плотным расчётом: True
посчитано экспертов: 10 из 40 возможных

Видно три вещи. Каждый токен получил свою пару экспертов: эксперт 5 нужен трём токенам из пяти, а экспертов 0, 1 и 7 не позвал никто. Веса внутри пары разные: токен 3 почти целиком отдан эксперту 5 (0,85), а токен 0 разделён почти поровну. И разреженный расчёт совпал с плотным, хотя посчитано 10 прогонов эксперта вместо 40 — в этом и вся экономия: выключенный эксперт даёт ноль, и считать его незачем.

Где обычно ошибаются.

  • Забывают перенормировать веса выбранных экспертов. Тогда выход слоя становится меньше обычного на долю отброшенных вероятностей, и масштаб плывёт от токена к токену.
  • Считают, что эксперт с одним номером в разных слоях — одно и то же. Это независимые блоки, и выводы о «специализации эксперта 3» надо делать для конкретного слоя.
  • Ждут, что ответ при температуре 0 будет одинаковым на любом сервере. Если сервер ограничивает ёмкость экспертов, состав пакета может повлиять на маршрутизацию и на текст.

Top-k маршрутизация. выбор k экспертов с наибольшими оценками для каждого токена.

Softmax. функция, которая превращает набор оценок в вероятности, дающие в сумме единицу.

Сигмоида (sigmoid). функция, которая превращает каждую оценку в число от 0 до 1 независимо от остальных.

Вес эксперта (gate weight). число, с которым выход выбранного эксперта входит в сумму.

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

Общий эксперт (shared expert). эксперт, через которого проходит каждый токен, в дополнение к выбранным маршрутизатором.

Маршрутизируемый эксперт (routed expert). эксперт, которого включают только по решению маршрутизатора.

3 Перекос нагрузки: почему экспертов приходится выравнивать

Зачем это в работе. Главная болезнь моделей со смесью экспертов — маршрутизатор начинает отправлять почти всё нескольким любимым экспертам. Тогда остальные простаивают, их веса почти не учатся, и модель с сотней миллиардов параметров работает как модель поменьше. На сервере перекос бьёт ещё и по скорости: перегруженный эксперт задерживает весь слой. Когда в отчётах о моделях пишут про «вспомогательную потерю», «коэффициент ёмкости» или «балансировку без вспомогательной потери», речь об этой проблеме, и без неё половину технического отчёта о любой такой модели не прочитать.

Перекос возникает сам собой из-за обратной связи. В начале обучения какой-то эксперт случайно оказывается чуть лучше, маршрутизатор начинает чаще отправлять к нему токены, эксперт получает больше обучающего сигнала и становится ещё лучше, а остальные отстают. Без вмешательства это заканчивается коллапсом маршрутизации (routing collapse): несколько экспертов делают всю работу. Shazeer и соавторы описали это ещё в 2017 году и добавили к обучению штраф за неравномерность.

Первый способ лечения — вспомогательная потеря (auxiliary loss): к обычной ошибке модели прибавляется небольшой штраф за неравномерность. В Switch Transformer он считается так: для каждого эксперта берётся доля токенов, которые к нему реально попали, и средняя вероятность, которую маршрутизатор ему давал; их произведения суммируются и умножаются на число экспертов. При идеально ровной нагрузке штраф равен единице, при перекосе больше. Авторы Switch Transformer умножали его на коэффициент 0,01, чтобы он подталкивал к равенству, но не перебивал основную задачу. Минус в том, что этот штраф тянет модель в сторону от главной цели, и слишком сильный штраф ухудшает качество.

Второй механизм — ёмкость эксперта (expert capacity). Чтобы вычисления на видеокарте шли блоками фиксированного размера, каждому эксперту в пакете дают ограниченное число мест: среднюю нагрузку, умноженную на коэффициент ёмкости (capacity factor), например 1,25. Токены сверх лимита выбрасываются (token dropping): для них этот блок экспертов просто пропускается, и вектор идёт дальше по обходному соединению слоя без изменений. Это защищает от перегрузки, но означает, что часть токенов обрабатывается хуже.

Третий способ предложен в техническом отчёте DeepSeek-V3: балансировка без вспомогательной потери (auxiliary-loss-free balancing). У каждого эксперта есть поправка, которая прибавляется к его оценке только при выборе top-k, но не участвует в весах смешивания. После каждого шага обучения поправку перегруженных экспертов немного уменьшают, а недогруженных увеличивают. Так нагрузка выравнивается без штрафа в основной ошибке; в отчёте сказано, что дополнительно оставлен очень маленький штраф на уровне отдельной последовательности.

Подробный пример. Смоделируем маршрутизатор, который уже «полюбил» первых двух экспертов из восьми, и 4096 токенов, каждому нужны 2 эксперта. Посчитаем штраф в духе Switch Transformer, сколько назначений будет выброшено при разных коэффициентах ёмкости, и как выравнивает нагрузку поправка в духе DeepSeek-V3. Это игрушка: оценки не обучаются, меняется только поправка.

import numpy as np
rng = np.random.default_rng(1)
E, k, T = 8, 2, 4096
pref = np.array([1.5, 1.2, 0.3, 0.0, 0.0, -0.3, -0.5, -1.0])   # маршрутизатор «полюбил» первых
logits = pref + rng.normal(size=(T, E))

def route(lg):
    top = np.argsort(-lg, 1)[:, :k]
    load = np.bincount(top.ravel(), minlength=E) / (T*k)
    return top, load

top, load = route(logits)
p = np.exp(logits); p /= p.sum(1, keepdims=True)
P = p.mean(0)
aux = E * np.sum(load * P)                       # штраф в духе Switch Transformer
print("доля токенов по экспертам:", np.round(load, 3).tolist())
print(f"штраф за дисбаланс: {aux:.3f}  (при идеальном равенстве 1.000)")

for cf in (1.0, 1.25, 2.0):
    cap = int(cf * T * k / E)
    dropped = np.maximum(np.bincount(top.ravel(), minlength=E) - cap, 0).sum()
    print(f"запас ёмкости {cf}: мест у эксперта {cap}, выброшено {dropped} из {T*k} назначений ({dropped/(T*k):.1%})")

# Балансировка без штрафа: добавка к оценкам влияет только на выбор, не на веса
b, gamma = np.zeros(E), 0.05
for step in range(201):
    _, load = route(logits + b)
    if step in (0, 10, 50, 200):
        print(f"шаг {step:3d}: макс. доля {load.max():.3f}, мин. доля {load.min():.3f}")
    b -= gamma * np.sign(load - 1/E)

У нас этот код напечатал:

доля токенов по экспертам: [0.356, 0.298, 0.113, 0.072, 0.071, 0.046, 0.031, 0.013]
штраф за дисбаланс: 1.722  (при идеальном равенстве 1.000)
запас ёмкости 1.0: мест у эксперта 1024, выброшено 3314 из 8192 назначений (40.5%)
запас ёмкости 1.25: мест у эксперта 1280, выброшено 2802 из 8192 назначений (34.2%)
запас ёмкости 2.0: мест у эксперта 2048, выброшено 1266 из 8192 назначений (15.5%)
шаг   0: макс. доля 0.356, мин. доля 0.013
шаг  10: макс. доля 0.248, мин. доля 0.031
шаг  50: макс. доля 0.133, мин. доля 0.116
шаг 200: макс. доля 0.133, мин. доля 0.116

При ровной нагрузке каждому эксперту досталось бы 12,5% назначений, а здесь первому 35,6%, последнему 1,3%, и штраф равен 1,72 вместо 1. Ограничение ёмкости в таком состоянии разрушительно: при коэффициенте 1,25 выброшена треть всех назначений, и даже двойной запас теряет 15,5%. Поправка за 50 шагов свела разброс к диапазону от 11,6% до 13,3%, после чего доли колеблются на месте: мы меняем поправку на фиксированный шаг, и точнее она не сходится. Вывод практический: ограничение ёмкости — только страховка, а выравнивать нагрузку надо до того, как дело дойдёт до выброса токенов.

Где обычно ошибаются.

  • Ставят большой коэффициент вспомогательной потери «для надёжности». Нагрузка становится ровной, но модель учится хуже, потому что штраф спорит с основной задачей.
  • Не следят за долей выброшенных токенов при обучении. Средняя ошибка может выглядеть нормально, пока заметная часть токенов тихо проходит слой без экспертов.
  • Путают равную загрузку с хорошей специализацией. Ровная нагрузка нужна для железа и обучения, но сама по себе не означает, что эксперты выучили что-то разное.

Коллапс маршрутизации (routing collapse). состояние, при котором маршрутизатор отправляет почти все токены нескольким экспертам, а остальные не учатся.

Вспомогательная потеря (auxiliary loss). добавочный штраф к ошибке модели за неравномерную нагрузку экспертов.

Ёмкость эксперта (expert capacity). сколько токенов из пакета эксперт может принять за один шаг.

Коэффициент ёмкости (capacity factor). во сколько раз ёмкость эксперта больше средней ожидаемой нагрузки.

Выброс токенов (token dropping). пропуск блока экспертов для токенов, которым не хватило мест.

Обходное соединение (residual connection). путь, по которому вектор токена проходит мимо блока и складывается с его выходом; через него идут и выброшенные токены.

Балансировка без вспомогательной потери. выравнивание нагрузки поправками к оценкам маршрутизатора вместо штрафа в ошибке.

4 Память и скорость: что смесь экспертов даёт на сервере и что отнимает

Зачем это в работе. Модели со смесью экспертов продают как «качество большой модели по цене маленькой». Это правда про вычисления, но не про всё остальное. Если ты запускаешь модель сам, на своём сервере или ноутбуке, нужно понимать, где выигрыш реальный, а где его съедает память или связь между видеокартами. Иначе можно выбрать модель «с 3 миллиардами активных параметров» для слабого компьютера и обнаружить, что она не помещается, или ждать ускорения на нагруженном сервере, где его нет.

Начнём с памяти. Все веса всех экспертов должны лежать в быстрой памяти, потому что любой следующий токен может понадобиться любому эксперту. Для Mixtral из первой ступени это 46,7 миллиарда чисел; в формате по два байта на число — около 93 ГБ, больше, чем в одной видеокарте на 80 ГБ. Плотная модель с теми же 13 миллиардами параметров заняла бы около 26 ГБ. Поэтому большие модели со смесью экспертов почти всегда запускают на нескольких видеокартах сразу или в сжатом виде.

Теперь скорость генерации. Из вчерашней дорожки мы знаем, что при выводе одного ответа время уходит в основном на чтение весов из памяти. Здесь смесь экспертов выигрывает по-настоящему: для одного токена надо прочитать только веса выбранных экспертов, то есть примерно активные параметры. Но сервер обычно обрабатывает много токенов разом — пакеты разговоров из дорожки про кэш. Каждый токен в пакете выбирает своих экспертов, и чем больше пакет, тем больше разных экспертов задето в слое. Когда задеты почти все, читать приходится почти все веса, и выигрыш по памяти исчезает; остаётся выигрыш по вычислениям, который важен уже тогда, когда железо упирается в вычисления.

Третья статья расходов — связь. Когда эксперты разложены по разным видеокартам (параллелизм экспертов, expert parallelism), в каждом слое токены надо разослать туда, где живут их эксперты, и собрать результаты обратно. Такая пересылка «все со всеми» (all-to-all) повторяется дважды в каждом слое, и при медленной связи между машинами она может занимать заметную часть времени. В техническом отчёте DeepSeek-V3 этому посвящён отдельный раздел: маршрутизация там ограничена так, чтобы каждый токен уходил не более чем на 4 машины, а пересылку совмещают по времени с вычислениями.

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

Подробный пример. Посчитаем, какая доля экспертов слоя задета, если в пакете B токенов и каждый выбирает k экспертов из E случайно и равномерно. Для одного токена эксперт не выбран с вероятностью 1 − k/E, для B независимых токенов — (1 − k/E) в степени B. Сравним формулу с прямым моделированием для схемы Mixtral (2 из 8) и схемы DeepSeek-V3 (8 из 256 маршрутизируемых).

import numpy as np
rng = np.random.default_rng(2)
def touched(E, k, B, trials=2000):
    hits = 0
    for _ in range(trials):
        used = set()
        for _ in range(B):
            used.update(rng.choice(E, k, replace=False))
        hits += len(used)
    return hits / trials / E
for E, k in ((8, 2), (256, 8)):
    print(f"экспертов {E}, на токен {k}:")
    for B in (1, 4, 16, 64, 256):
        sim = touched(E, k, B, 300 if E > 8 else 2000)
        formula = 1 - (1 - k/E)**B
        print(f"  токенов в пакете {B:4d}: задеты {sim:6.1%} экспертов (формула {formula:6.1%})")

У нас этот код напечатал:

экспертов 8, на токен 2:
  токенов в пакете    1: задеты  25.0% экспертов (формула  25.0%)
  токенов в пакете    4: задеты  68.5% экспертов (формула  68.4%)
  токенов в пакете   16: задеты  99.1% экспертов (формула  99.0%)
  токенов в пакете   64: задеты 100.0% экспертов (формула 100.0%)
  токенов в пакете  256: задеты 100.0% экспертов (формула 100.0%)
экспертов 256, на токен 8:
  токенов в пакете    1: задеты   3.1% экспертов (формула   3.1%)
  токенов в пакете    4: задеты  11.9% экспертов (формула  11.9%)
  токенов в пакете   16: задеты  39.8% экспертов (формула  39.8%)
  токенов в пакете   64: задеты  86.7% экспертов (формула  86.9%)
  токенов в пакете  256: задеты 100.0% экспертов (формула 100.0%)

Для схемы «2 из 8» уже при 16 токенах в пакете задеты 99% экспертов, то есть сервер читает почти все веса слоя, как у плотной модели такого же полного размера. Мелкое дробление экспертов растягивает выигрыш: при 256 экспертах и 16 токенах задеты 40%, и только к 256 токенам — все. Оговорка: в настоящей модели выбор не равномерный и токены одного текста часто идут к похожим экспертам, поэтому реальная доля может быть ниже; мы этого не мерили. Но порядок величин понятен: на одиночных запросах смесь экспертов читает лишь малую часть весов, на больших пакетах — почти все.

Где обычно ошибаются.

  • Рассчитывают видеопамять по активным параметрам. Считать надо по всем, плюс кэш ключей и значений.
  • Переносят скорость одиночного запроса на нагруженный сервер. При больших пакетах задеты почти все эксперты, и упор в память возвращается.
  • Раскладывают экспертов по машинам без быстрой связи. Пересылки «все со всеми» в каждом слое съедают выигрыш от разреженности.

Параллелизм экспертов (expert parallelism). способ разложить экспертов одного слоя по разным видеокартам.

Пересылка «все со всеми» (all-to-all). обмен, при котором каждая видеокарта отправляет часть токенов каждой другой и получает результаты обратно.

Пропускная способность памяти (memory bandwidth). сколько байт в секунду можно прочитать из памяти; при генерации одного ответа она обычно главный ограничитель.

Пакет (batch). набор токенов из разных запросов, которые сервер обрабатывает за один проход.

Задетые эксперты. эксперты слоя, которых выбрал хотя бы один токен пакета; их веса приходится читать.

Упор в вычисления (compute-bound). режим, когда время определяется числом умножений, а не чтением памяти; здесь экономия вычислений смесью экспертов окупается.

5 Чему учатся эксперты и как читать названия моделей

Зачем это в работе. Вокруг смеси экспертов много красивых, но неверных объяснений: «в модели есть эксперт по медицине и эксперт по коду». От этого зависят практические решения — можно ли выбросить «ненужных» экспертов для своей задачи, почему дообучение таких моделей капризнее, как сравнивать модели по описанию. Здесь разберём, что известно об экспертах из опубликованных измерений, зачем современные модели дробят экспертов на мелкие и как читать строки вроде «A22B» в названиях.

Что выучивают эксперты, проверяли напрямую. Авторы статьи «Mixtral of Experts» смотрели, каким экспертам маршрутизатор отдаёт токены текстов из разных областей — статей arXiv, биологии, философии, математики, кода. Они пишут, что явных закономерностей по темам не обнаружили, а распределение по экспертам у разных тем похоже. Зато заметна связь с формой текста: в коде на Python одни и те же эксперты часто получают слово self и отступы, а соседние токены нередко уходят к тем же экспертам. То есть специализация есть, но она про синтаксис и частые конструкции, а не про предметные области в человеческом смысле.

Отсюда интерес к дроблению экспертов. В статье DeepSeekMoE (2024) предложено делать экспертов мельче и больше: вместо 16 экспертов полной ширины с выбором двух взять 64 эксперта в четыре раза уже с выбором восьми. Объём вычислений на токен тот же, но число возможных наборов экспертов растёт с 120 до миллиардов, и каждый токен может получить более точную комбинацию. Вторая идея той же работы — общие эксперты, через которых идёт каждый токен: они берут на себя общие знания, нужные всем, чтобы маршрутизируемые не дублировали их. Обе идеи вошли в DeepSeek-V3.

Теперь про названия. Две цифры в описании — всё и активные — сегодня часто пишут прямо в имени модели. В названии Qwen3-235B-A22B от Alibaba «235B» означает 235 миллиардов всех параметров, а «A22B» — 22 миллиарда активных. В Mixtral 8x7B запись «8x7B» говорит о числе экспертов и размере исходной плотной модели того же устройства, но, как мы посчитали на первой ступени, не равна их произведению. DeepSeek-V3 по отчёту — 671 миллиард всех и 37 миллиардов активных; Llama 4 Maverick по объявлению Meta (апрель 2025) — 400 миллиардов всех, 17 миллиардов активных, 128 экспертов.

Отличие от ансамбля моделей (ensemble), с которым смесь экспертов часто путают: ансамбль — это несколько полностью обученных моделей, чьи готовые ответы потом усредняют или выбирают голосованием. Эксперты же обучаются вместе, внутри одной модели, делят внимание и словарь и смешиваются в каждом слое, а не на выходе. Поэтому выбросить «лишнего» эксперта — это не убрать одну модель из ансамбля, а вырезать кусок из каждого слоя, на который могли опираться токены любых тем.

Подробный пример. Посчитаем, сколько разных наборов экспертов доступно токену при одинаковом объёме вычислений: 16 экспертов полной ширины с выбором двух против 64 экспертов в четыре раза уже с выбором восьми. Это та же пара схем, которую приводят авторы DeepSeekMoE.

from math import comb
# Одинаковый объём работы на токен: 2 эксперта ширины h или 8 экспертов ширины h/4
for E, k, width in ((16, 2, "h"), (64, 8, "h/4")):
    print(f"{E:3d} экспертов ширины {width:>3}, выбираем {k}: {comb(E, k):>15,} вариантов набора".replace(",", " "))

У нас этот код напечатал:

 16 экспертов ширины   h  выбираем 2:             120 вариантов набора
 64 экспертов ширины h/4  выбираем 8:   4 426 165 368 вариантов набора

Активных весов на токен в обеих схемах одинаково: два эксперта ширины h или восемь ширины h/4. Но вариантов набора 120 против 4,4 миллиарда. Число вариантов само по себе не гарантирует качества — это лишь гибкость, которую обучение может использовать. Авторы DeepSeekMoE пишут, что в их экспериментах мелкое дробление и общие эксперты улучшали результат при том же объёме вычислений; это их измерения, мы их не повторяли. Цена тоже понятна из прошлой ступени: больше экспертов — больше мелких пересылок и сложнее балансировка.

Где обычно ошибаются.

  • Пытаются вырезать «эксперта по ненужной теме», чтобы сэкономить память. Эксперты не разделены по темам, и такая обрезка ломает модель в неожиданных местах.
  • Сравнивают модели только по активным параметрам. Знаний помещается больше в модели с большим числом всех параметров, а скорость и память зависят от разных цифр.
  • Называют смесь экспертов ансамблем. Эксперты обучаются вместе внутри одной модели и смешиваются в каждом слое, а не на выходе.

Мелкое дробление экспертов (fine-grained experts). замена небольшого числа широких экспертов большим числом узких при том же объёме работы на токен.

DeepSeekMoE. архитектура из работы DeepSeek 2024 года, которая ввела мелкое дробление и общих экспертов.

Запись «A22B» в названии. число активных параметров: 22 миллиарда участвуют в обработке одного токена.

Ансамбль моделей (ensemble). несколько отдельно обученных моделей, чьи готовые ответы объединяют.

Специализация экспертов. склонность эксперта получать определённые токены; по опубликованным измерениям она больше про синтаксис, чем про темы.

Mixtral 8x7B. открытая модель Mistral AI с 8 экспертами в слое и двумя активными на токен.

DeepSeek-V3. открытая модель DeepSeek с 256 маршрутизируемыми и одним общим экспертом в слое, 8 активных на токен.

Словарь целиком — /slovar, новости — /novosti. Все дорожки — /put.