Основы MoE

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

Принято считать, что фактические знания модели хранятся в основном в её FFN-блоках. В стандартном блоке трансформера внимание занимает около $4d^2$ параметров, а FFN — около $8d^2$, то есть две трети (это верно и для классического FFN с $4d$, и для SwiGLU с $\tfrac{8}{3}d$). Хотим, чтобы модель знала больше, — увеличиваем FFN. Но тогда каждый токен проходит через все эти параметры, и вычисления растут так же быстро.

Смесь экспертов (MoE)смесь экспертов (MoE)EN mixture of experts (MoE) разрывает эту связь. Вместо одного большого FFN ставим много FFN поменьше — экспертовэксперт (в MoE)EN expertОдин из параллельных FFN-блоков MoE-слоя. Каждый токен обрабатывают лишь несколько экспертов, выбранных роутером., и для каждого токена включаем лишь несколько из них. Это разреженная активацияразреженная активацияEN sparse activationНа каждый токен работает лишь малая часть параметров модели. У DeepSeek-V3 — около 5.5% (37B активных из 671B).: параметров много, а работает на каждом токене малая часть.

Цифры DeepSeek-V3: 671 миллиард параметров всего, из них 37 миллиардов активныхактивные параметрыEN activated (active) parametersСколько параметров MoE-модели реально участвует в обработке одного токена. «A22B» в названии Qwen3-235B-A22B — 22 млрд активных из 235 млрд. на токен, около 5.5%. По закону 6ND из урока 5.1.1 стоимость обучения считается по активным параметрам: $6 \cdot 37 \cdot 10^9 \cdot 14.8 \cdot 10^{12} \approx 3.3 \cdot 10^{24}$ FLOPs. Плотная модель того же размера стоила бы в 18 раз дороже. Именно MoE, вместе с MLA и FP8, объясняет знаменитые 2.788 млн GPU-часов H800 на обучение V3. Для грубого сравнения: плотная Llama 3.1 405B потребовала 30.84 млн GPU-часов H100.

Как устроен MoE-слой

MoE-слой заменяет FFN в блоке трансформера. Внимание остаётся обычным, и residual-связи тоже.

flowchart LR
X["токен x"] --> R["роутер: softmax(x·W_g)"]
R -->|"вес 0.73"| E1["эксперт 1 (FFN)"]
R -->|"вес 0.27"| E2["эксперт 2 (FFN)"]
R -.->|"не выбран"| E3["эксперт 3"]
R -.->|"не выбран"| E4["эксперт 4"]
X --> E1
X --> E2
E1 --> S["взвешенная сумма"]
E2 --> S
S --> Y["выход y"]

MoE-слой с 4 экспертами и top-2 роутингом. Невыбранные эксперты на этом токене ничего не считают.

Роутермаршрутизатор (роутер), гейтEN router / gating network — это одна линейная матрица $W_g$ размера $d \times N$, где $N$ — число экспертов. Для токена $x$:

1. Логиты $z = x W_g$, вероятности $p = \mathrm{softmax}(z)$.
2. top-k маршрутизацияtop-k маршрутизацияEN top-k routingРоутер оценивает всех экспертов и отправляет токен к k лучшим; их выходы складываются с весами роутера.: выбираем $k$ экспертов с наибольшими $p_i$, их множество обозначим $\mathcal{T}$.
3. Веса выбранных перенормируем: $g_i = p_i / \sum_{j \in \mathcal{T}} p_j$.
4. Выход: $y = \sum_{i \in \mathcal{T}} g_i \, \mathrm{FFN}_i(x)$.

Пример с числами. Четыре эксперта, логиты роутера $[2.0,\ 1.0,\ 0.5,\ -1.0]$. Softmax даёт $[0.609,\ 0.224,\ 0.136,\ 0.030]$. При top-2 выбраны эксперты 1 и 2 (в нумерации с единицы), их веса после перенормировки $0.609 / 0.833 = 0.731$ и $0.269$. Эксперты 3 и 4 на этом токене не тратят ни одного FLOP.

Варианты в разных моделях отличаются деталями. В Switch Transformer $k = 1$, и весом служит сама $p_i$ без перенормировки, иначе вес всегда был бы равен 1 и роутер не получал бы градиент от основного лосса. В Mixtral $k = 2$ из 8. В DeepSeek-V3 вместо softmax используется сигмоида, и экспертов 256 (об этом — в следующем уроке).

И ещё одна деталь из практики: самые первые слои часто оставляют плотными, с обычным FFN. В официальном config_671B.json DeepSeek-V3 за это отвечает поле n_dense_layers = 3 (в конфиге на Hugging Face оно называется first_k_dense_replace): MoE стоит в 58 слоях из 61.

Немного истории

Год	Работа	Что нового
1991	Jacobs, Jordan, Nowlan, Hinton — Adaptive Mixtures of Local Experts	сама идея: «сеть-распорядитель» делит задачу между экспертами
2017	Shazeer и др. — Sparsely-Gated MoE	разреженный top-k с шумом, до 137B параметров (на LSTM)
2020	GShard (Google)	MoE в трансформере, top-2, 600B, машинный перевод
2021	Switch Transformer	top-1, до 1.6T параметров, aux loss и коэффициент ёмкости
2023	Mixtral 8x7B (Mistral AI)	открытые веса: 46.7B всего, 12.9B активных
2024	DeepSeekMoE, DeepSeek-V2/V3, Qwen-MoE	мелкие и общие эксперты, сотни экспертов — следующий урок

Всего параметров и активных параметров

Посчитаем DeepSeek-V3 сами по официальному config_671B.json. Коротко вы это уже делали в уроке 4.5.3; теперь разложим подсчёт по частям, чтобы увидеть, где живут параметры. В конфиге 61 слой (первые 3 — плотные), $d = 7168$, 256 маршрутизируемых экспертов и 1 общий, на токен выбираются 8. Каждый эксперт — SwiGLU с промежуточной размерностью 2048.

# Считаем параметры DeepSeek-V3 по config_671B.json из официального репозитория
dim, layers, dense_layers = 7168, 61, 3
inter, moe_inter = 18432, 2048
n_routed, n_shared, k = 256, 1, 8
vocab, H = 129280, 128
q_lora, kv_lora, nope, rope_d, v_d = 1536, 512, 128, 64, 128

attn = (dim * q_lora + q_lora + q_lora * H * (nope + rope_d)       # сжатие и восстановление Q
        + dim * (kv_lora + rope_d) + kv_lora                          # W_DKV и W_KR
        + kv_lora * H * (nope + v_d)                                  # W_UK и W_UV
        + H * v_d * dim + 2 * dim)                                    # W_O и две нормы слоя
expert = 3 * dim * moe_inter                                          # SwiGLU: w1, w2, w3
dense_ffn = 3 * dim * inter
moe_layers = layers - dense_layers
embed = 2 * vocab * dim                                               # вход и выход не связаны

total = layers * attn + dense_layers * dense_ffn + moe_layers * ((n_routed + n_shared) * expert + n_routed * dim) + embed
active = layers * attn + dense_layers * dense_ffn + moe_layers * ((k + n_shared) * expert + n_routed * dim) + embed
print(f"внимание (MLA) на слой: {attn / 1e6:.0f} M; один эксперт: {expert / 1e6:.0f} M")
print(f"всего: {total / 1e9:.0f} B, активных на токен: {active / 1e9:.1f} B ({active / total:.1%})")

внимание (MLA) на слой: 187 M; один эксперт: 44 M
всего: 671 B, активных на токен: 37.6 B (5.6%)

Сошлось с техотчётом. Видно, где живут параметры: 58 MoE-слоёв по 257 экспертов по 44M — это около 656B из 671B.

Отсюда главный компромисс MoE: вычисления — как у маленькой модели, память — как у большой. Все 671B параметров должны лежать в памяти, ведь следующий токен может выбрать любых экспертов. Для облачного сервиса с тысячами запросов это выгодно. Дома всё иначе: Qwen3-30B-A3B генерирует быстро, как модель на 3B, но требует памяти как модель на 30B (в 4-битном квантовании это 15–19 ГБ в зависимости от формата: ровно 4 бита на вес дают $30.5 \cdot 10^9 \cdot 0.5$ байта ≈ 15 ГБ, а популярный формат llama.cpp Q4_K_M хранит около 4.9 бита на вес — около 19 ГБ, см. урок 7.1.1; плюс KV-кэш).

Проблема балансировки

Роутер обучается вместе с моделью, и у этого процесса есть неприятная положительная обратная связь:

1. Эксперт A случайно получил чуть больше токенов в начале обучения.
2. Он получил больше градиентов и стал лучше остальных.
3. Роутер замечает, что A снижает loss, и отправляет к нему ещё больше токенов.

Итог — коллапс маршрутизацииколлапс маршрутизацииEN routing collapseРоутер отправляет почти все токены к нескольким экспертам, остальные не обучаются. Механизм «богатые богатеют» — выбранный эксперт учится лучше и выбирается ещё чаще.: несколько экспертов перегружены, остальные почти не обучаются. Последствий три.

• Бесполезные параметры. Мёртвый эксперт занимает память, но ничего не делает.
• Медленное обучение. При параллелизме экспертов (следующий урок) эксперты живут на разных GPU. Шаг длится столько, сколько работает самая загруженная GPU, остальные ждут.
• Потерянные токены. Чтобы перегруженная GPU не тормозила всех, эксперту ставят лимит ёмкости. Его задаёт коэффициент ёмкостикоэффициент ёмкостиEN capacity factorСколько токенов может принять эксперт относительно идеально ровной раскладки. Лишние токены отбрасываются (token dropping) и проходят только по residual-связи. CF: эксперт принимает не больше $\mathrm{CF} \cdot T k / N$ токенов, где $T k / N$ — его доля при идеальном балансе. В Switch Transformer изучали CF от 1.0 до 2.0. Лишние токены отбрасываются (token dropping) и проходят слой только по residual-связи.

Вспомогательный лосс Switch Transformer

Самое распространённое лекарство — добавить к основному лоссу вспомогательный лосс балансировкивспомогательный лосс балансировки (aux loss)EN auxiliary load-balancing lossДобавка к основному лоссу, штрафующая неравномерную загрузку экспертов. Классическая форма из Switch Transformer — α·N·Σ f_i·P_i., штраф за неравномерность. В Switch Transformer он выглядит так:

$$L_{aux} = \alpha \cdot N \cdot \sum_{i=1}^{N} f_i \, P_i$$

• $f_i$ — доля токенов батча, отправленных к эксперту $i$ (после top-k).
• $P_i$ — средняя по батчу вероятность, которую роутер даёт эксперту $i$.
• $\alpha = 0.01$ — коэффициент из статьи Switch Transformer.

Почему именно произведение. Самый очевидный штраф, $\sum_i f_i^2$, был бы бесполезен: $f_i$ получается подсчётом после top-k, и градиент через него не течёт. $P_i$ — гладкая функция весов роутера. Градиент $\partial L_{aux} / \partial P_i = \alpha N f_i$: чем больше эксперт перегружен, тем сильнее лосс давит вниз его вероятность. Получается «налог на популярность».

Шкала значений. Если загрузка и вероятности равномерны ($f_i = P_i = 1/N$), то $N \sum f_i P_i = N \cdot N \cdot \tfrac{1}{N^2} = 1$. При полном коллапсе на одного эксперта ($f_1 = 1$, $P_1 \approx 1$) значение приближается к $N$. Пример для $N = 4$: при загрузке $[0.4, 0.3, 0.2, 0.1]$ и вероятностях $[0.35, 0.3, 0.2, 0.15]$ получаем $4 \cdot (0.14 + 0.09 + 0.04 + 0.015) = 1.14$.

Есть и другие приёмы. Shazeer в 2017 году добавлял к логитам роутера перед top-k шум с обучаемой амплитудой, чтобы токены «пробовали» разных экспертов. В ST-MoE (Google, 2022) появился router z-loss, который штрафует слишком большие логиты роутера ради численной стабильности.

У aux loss есть цена

Вспомогательный лосс тянет роутер к равномерности, а основной — к качеству. Маленький $\alpha$ не спасает от перекоса, большой мешает модели учиться: градиенты балансировки «спорят» с градиентами языкового моделирования. DeepSeek нашла способ обойтись без этого компромисса — об этом следующий урок.

Практика

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

Реализуйте top-k роутинг, подсчёт загрузки экспертов, aux loss и сам MoE-слой с линейными экспертами. Тесты проверят пример из урока, крайние случаи (равномерный роутер и полный коллапс) и то, что при $k = N$ MoE превращается в плотную смесь всех экспертов.

Top-k роутинг и загрузка экспертовnumpy · нужен интернет7 тестов

import numpy as np


def softmax(x):
    """Готовый помощник: устойчивый softmax по последней оси."""
    e = np.exp(x - x.max(axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)


def topk_route(logits, k):
    """Top-k роутинг.

    logits: (T, E) — логиты роутера для T токенов и E экспертов.
    Возвращает (idx, weights):
      idx     — (T, k) int: номера выбранных экспертов по убыванию вероятности
                (при равенстве — меньший номер раньше: np.argsort(-p, kind='stable'));
      weights — (T, k): вероятности softmax выбранных экспертов, перенормированные к сумме 1.
    """
    # TODO
    ...


def expert_load(idx, n_experts):
    """Доля назначений, пришедшихся на каждого эксперта: f_i = count_i / (T * k). Сумма = 1."""
    # TODO (подсказка: np.bincount(..., minlength=n_experts))
    ...


def aux_loss(logits, idx, n_experts):
    """Вспомогательный лосс балансировки в стиле Switch Transformer (без множителя alpha):

        L = N * sum_i f_i * P_i,
    где f_i — expert_load, P_i — средняя по токенам вероятность роутера для эксперта i.
    При идеальном балансе L = 1, при полном коллапсе на одного эксперта L -> N.
    """
    # TODO
    ...


def moe_layer(x, W_g, experts, k):
    """MoE-слой: y_t = sum_j weights[t, j] * experts[idx[t, j]](x_t).

    x: (T, d); W_g: (d, E) — матрица роутера; experts — список из E матриц (d, d),
    эксперт e — линейное отображение x -> x @ experts[e]. Возвращает (T, d).
    """
    # TODO: логиты = x @ W_g; topk_route; сложите взвешенные выходы выбранных экспертов
    ...


# Проверьте себя кнопкой «Запустить»:
logits = np.array([[2.0, 1.0, 0.5, -1.0]])
res = topk_route(logits, 2)
print(res)  # ожидается idx [[0 1]] и веса ≈ [[0.731 0.269]]
rng = np.random.default_rng(0)
L = rng.normal(size=(1000, 8))
res = topk_route(L, 2)
if res is not None:
    load = expert_load(res[0], 8)
    print("загрузка:", None if load is None else np.round(load, 3))
    print("aux loss:", aux_loss(L, res[0], 8))

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

Эксперимент на PyTorch: коллапс и его лечение

Маленький MoE-слой учится на игрушечной задаче: 8 кластеров входов, у каждого своё линейное отображение. У всех токенов есть общая компонента, как у настоящих скрытых состояний LLM, и из-за неё роутеру легко «слипнуться» на нескольких экспертах. Обучаем с разными $\alpha$ и смотрим на загрузку.

import torch
import torch.nn as nn
import torch.nn.functional as F

torch.set_num_threads(1)  # маленькие тензоры: один поток быстрее


class MoE(nn.Module):
    """Классический MoE-слой: softmax-роутер, top-k, aux loss в стиле Switch."""

    def __init__(self, d, d_ff, n_experts=8, k=2):
        super().__init__()
        self.k, self.E = k, n_experts
        self.router = nn.Linear(d, n_experts, bias=False)
        self.experts = nn.ModuleList(
            nn.Sequential(nn.Linear(d, d_ff), nn.GELU(), nn.Linear(d_ff, d)) for _ in range(n_experts)
        )

    def forward(self, x):                                    # x: (T, d) — токены уже «расплющены»
        probs = self.router(x).softmax(dim=-1)               # (T, E)
        w, idx = probs.topk(self.k, dim=-1)                  # (T, k)
        if self.k > 1:                                       # при k=1 (Switch) вес — сама p_i,
            w = w / w.sum(dim=-1, keepdim=True)              # иначе роутер не получит градиент
        y = torch.zeros_like(x)
        for e, expert in enumerate(self.experts):
            rows, slot = torch.where(idx == e)               # кто пришёл к эксперту e
            if rows.numel():                                 # эксперт считает только свои токены x[rows]
                # index_add_(0, rows, src): прибавить строки src к строкам y с номерами rows (взвешенная сумма)
                y.index_add_(0, rows, w[rows, slot, None] * expert(x[rows]))
        f = torch.bincount(idx.flatten(), minlength=self.E).float() / idx.numel()  # доля назначений
        P = probs.mean(dim=0)                                # средняя вероятность (дифференцируема)
        self.aux = self.E * (f * P).sum()
        self.load = f
        return y


def run(alpha, steps=200, seed=0):
    """Игрушечная задача: 8 кластеров, у каждого своё линейное отображение. Возвращает MSE, aux, загрузку."""
    torch.manual_seed(seed)
    d, n_clusters = 16, 8
    centers = torch.randn(n_clusters, d)
    common = 2.0 * torch.randn(d)              # общая компонента у всех токенов, как в реальных скрытых состояниях
    maps = torch.randn(n_clusters, d, d) / d ** 0.5
    moe = MoE(d, 32, n_experts=8, k=2)
    opt = torch.optim.Adam(moe.parameters(), lr=3e-3)
    for _ in range(steps):
        c = torch.randint(0, n_clusters, (256,))
        x = centers[c] + common + 0.3 * torch.randn(256, d)
        x = x / x.pow(2).mean(-1, keepdim=True).sqrt()      # RMSNorm, как перед FFN в трансформере
        target = torch.einsum("td,tde->te", x, maps[c])     # каждый токен × матрица своего кластера
        loss = F.mse_loss(moe(x), target) + alpha * moe.aux
        opt.zero_grad()
        loss.backward()
        opt.step()
    return F.mse_loss(moe(x), target).item(), moe.aux.item(), moe.load


for alpha in (0.0, 0.01, 0.1):
    mse, aux, load = run(alpha)
    print(f"alpha={alpha:<4} MSE={mse:.3f} aux={aux:.2f} загрузка={[round(v, 2) for v in load.tolist()]}")

Вывод на CPU (PyTorch 2.x, от нескольких секунд до полуминуты на три прогона в зависимости от процессора; на другой версии PyTorch числа могут немного отличаться):

alpha=0.0  MSE=0.032 aux=1.62 загрузка=[0.0, 0.26, 0.0, 0.0, 0.22, 0.05, 0.41, 0.07]
alpha=0.01 MSE=0.028 aux=1.03 загрузка=[0.18, 0.14, 0.07, 0.09, 0.14, 0.06, 0.19, 0.12]
alpha=0.1  MSE=0.027 aux=1.01 загрузка=[0.15, 0.08, 0.1, 0.13, 0.14, 0.12, 0.13, 0.14]

Без балансировки три эксперта из восьми мертвы, а один забирает 41% назначений. С $\alpha = 0.01$ работают все, и качество даже немного лучше: живых экспертов больше, значит, больше параметров реально используется. Попробуйте top-1: замените k=2 на k=1 в строке moe = MoE(...). При $\alpha = 0$ коллапс в этой задаче становится полным при любом seed: вся нагрузка уходит одному эксперту, а aux подбирается к $N = 8$.

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

Почувствуйте разреженность руками. Возьмите Qwen3-30B-A3B в 4-битном квантовании (15–19 ГБ весов в зависимости от формата, в Q4_K_M около 19 ГБ — одна карта) и плотную Qwen3-14B в тех же битах, дайте обеим один промпт и сравните токены в секунду при batch 1. У MoE активны 3B параметров из 30B, и при генерации по одному токену она читает из памяти только выбранных экспертов — скорость должна быть заметно выше, хотя памяти модель занимает вдвое больше. Потом повторите замер при batch 16 и подумайте, почему разрыв меняется (подсказка: с ростом батча в слое задействуется всё больше экспертов; расчёт доли экспертов — задача 5 в уроке 11.3.3). Ваших 128 ГБ VRAM хватает и на MoE-модели покрупнее, но DeepSeek-V3 даже в 4 битах занимает больше 300 ГБ и не помещается ни в VRAM, ни в 128 ГБ оперативной памяти. Такие модели дома запускают на машинах с большим объёмом RAM через KTransformers из «Китайского угла» ниже.

Чем мерить: для batch 1 удобен llama-bench из llama.cpp (колонка tg128 — токены в секунду на генерации), для batch 16 — llama-batched-bench или vLLM. Запускайте обе модели на одной и той же карте (CUDA_VISIBLE_DEVICES=0), иначе llama.cpp разложит слои по всем четырём, и вы будете мерить ещё и PCIe. Коротко о llama.cpp и vLLM — в уроке 4.6.5, подробно про квантование и llama.cpp — в модуле 7.2, настройка карт — на странице «Ваша лаборатория (4×GPU)».

Китайский угол: MoE стала стандартом китайских флагманов

К 2025 году почти все флагманские открытые модели китайских лабораторий стали MoE:

Модель	Всего / активных	Экспертов на слой (выбрано)
DeepSeek-V3 / R1	671B / 37B	256 + 1 общий (8)
Qwen3-235B-A22B	235B / 22B	128 (8), без общих экспертов
Qwen3-30B-A3B	30B / 3B	128 (8)
Kimi K2	1T / 32B	384 + 1 общий (8)
GLM-4.5	355B / 32B	—
MiniMax-M2	230B / 10B	256 (8)

Прочерк значит, что проверенных данных о числе экспертов GLM-4.5 у нас нет: общее и активное число параметров указано в README модели, а разбивку по экспертам смотрите в её конфиге на Hugging Face или ModelScope. Число экспертов MiniMax-M2 взято из описания её архитектуры в библиотеке transformers (класс MiniMaxM2Config). Буква «A» в названиях Qwen означает activated: Qwen3-235B-A22B — 22 млрд активных параметров.

Qwen и балансировка. Команда Qwen в статье «Demons in the Detail» (2025) показала тонкость, которую легко пропустить. Если считать $f_i$ и $P_i$ по каждому маленькому микро-батчу, лосс заставляет экспертов быть равномерно загруженными даже внутри одной узкой последовательности (например, только код). Это мешает специализации. Решение — считать статистику по глобальному батчу, синхронизируя $f_i$ между устройствами. В Qwen3-MoE применена именно такая балансировка, а от общих экспертов, которые были в Qwen2.5-MoE, Qwen3 отказалась.

MoE дома. Проект KTransformers держит экспертов в обычной оперативной памяти и считает их на CPU, а внимание — на GPU. Это работает именно благодаря разреженности: на токен нужны лишь несколько экспертов.

Что почитать. Самый компактный MoE-код на китайском — класс MOEFeedForward в MiniMind: на октябрь 2026 там 4 эксперта, top-1 и aux loss в стиле Switch с коэффициентом $5 \cdot 10^{-4}$. Проблему градиента при top-1 автор решает иначе, чем Switch: вес выбранного эксперта в прямом проходе равен ровно 1, а к роутеру градиент проходит «насквозь» (straight-through«прямой» оценщик градиента (STE)EN straight-through estimator (STE)Приём QAT — в прямом проходе веса округляются, а в обратном округление считается тождественной функцией, и градиент проходит «насквозь».: при обратном проходе операцию делают вид, что её нет) — полезно сравнить с рассуждением выше. Теорию изложил Су Цзяньлинь в цикле «Путешествие по MoE»: часть 1 выводит MoE из приближения плотного FFN, а часть 2 с названием-пословицей «Беда не в бедности, а в неравенстве» выводит лосс балансировки.

Проверь себя

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

1 Какая доля параметров DeepSeek-V3 активна на одном токене? Ответ в процентах, округлите до десятых (37B из 671B).

2 Логиты роутера для 4 экспертов: $[2.0, 1.0, 0.5, -1.0]$, top-2 с перенормировкой. Чему равен вес первого эксперта? Округлите до сотых.

3 Что определяет стоимость обучения MoE-модели по закону $C \approx 6ND$, а что — требования к памяти?

И то и другое — общее число параметровВычисления — активные параметры, память — общее число параметровВычисления — общее число параметров, память — активныеИ то и другое — активные параметры

4 Какие утверждения о вспомогательном лоссе $\alpha N \sum f_i P_i$ верны?Можно выбрать несколько ответов

Градиент идёт через $P_i$, а не через $f_i$При равномерной загрузке и равномерных вероятностях $N \sum f_i P_i = 1$Чем больше $\alpha$, тем лучше качество моделиОн сильнее всего снижает вероятность перегруженных экспертов

5 MoE с 8 экспертами и top-1 полностью «схлопнулся»: все токены идут к одному эксперту, и роутер даёт ему вероятность ≈ 1. Чему примерно равно $N \sum f_i P_i$?

6 Что происходит с токенами, которые не поместились в ёмкость эксперта (capacity factor)?

Ждут следующего шага обученияОтправляются случайному экспертуОтбрасываются: проходят слой только по residual-связиВызывают ошибку переполнения

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

Итоги

• MoE заменяет FFN набором экспертов. Роутер выбирает top-k из них для каждого токена, выход — взвешенная сумма.
• Активные параметры определяют вычисления, общие — память. DeepSeek-V3: 671B всего и 37B активных.
• Без балансировки роутер склонен к коллапсу: часть экспертов умирает, обучение тормозит, токены отбрасываются.
• Классическое лекарство — aux loss $\alpha N \sum f_i P_i$ из Switch Transformer, но он конфликтует с основной целью обучения.

Дальше: как DeepSeek переизобрела MoE — мелкие и общие эксперты и балансировка без вспомогательного лосса. Урок про DeepSeekMoE.