Диффузионные модели — кратко

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

LLM генерирует текст авторегрессионно: токен за токеном, слева направо. Картинки и видео в 2026 году почти всегда генерируют иначе — диффузионными моделямидиффузионная модельEN diffusion model. Они начинают с картинки из чистого шума и за десятки шагов «проявляют» её, как фотографию. Так работают Stable Diffusion, Sora, китайские Wan, Kling, HunyuanVideo, Qwen-Image.

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

Интуиция: снести дом и построить заново

Су Цзяньлинь (автор RoPE) объясняет DDPM метафорой «снос + стройка» — «снести здание и построить заново».

• Прямой процесс (снос): берём настоящую картинку и шаг за шагом добавляем немного гауссова шума. Через $T = 1000$ шагов от картинки не остаётся ничего — только шум. Этот процесс фиксирован, учить тут нечего.
• Обратный процесс (стройка): учим нейросеть делать один маленький шаг назад — убирать чуть-чуть шума. Повторив этот шаг 1000 раз, начиная с чистого шума, получаем новую картинку.

Почему не одним прыжком «шум → картинка»? Потому что это безнадёжно трудная задача: из шума можно получить что угодно. А убрать немного шума с почти чистой картинки — задача простая и почти однозначная. Диффузия разбивает невозможную задачу на тысячу простых — так же, как LLM разбивает генерацию текста на простые шаги «предскажи следующий токен».

flowchart LR
X0["x₀: картинка"] -->|"+ немного шума"| X1["x₁"] -->|"+ шум"| X2["…"] -->|"+ шум"| XT["x_T: чистый шум"]
XT -.->|"нейросеть убирает шум"| R2["…"] -.-> R1["x₁"] -.-> R0["x₀: новая картинка"]

Прямой процесс (сплошные стрелки) фиксирован; обратный (пунктир) выучивает нейросеть

Прямой процесс: формулы

Один шаг зашумления в DDPMDDPM (вероятностная диффузионная модель с шумоподавлением)EN Denoising Diffusion Probabilistic Model (DDPM) (Ho и соавторы, 2020):

$$x_t = \sqrt{1-\beta_t}\; x_{t-1} + \sqrt{\beta_t}\; \varepsilon_t, \qquad \varepsilon_t \sim \mathcal{N}(0, I)$$

Что здесь написано: немного «приглушаем» картинку (множитель чуть меньше 1) и добавляем немного шума. Запись $\varepsilon_t \sim \mathcal{N}(0, I)$ значит «стандартный нормальный шум» (урок 1.3.1): массив той же формы, что картинка, где каждое число независимо взято из нормального распределения со средним 0 и дисперсией 1 ($I$ — единичная матрица, то есть числа не связаны между собой). Числа $\beta_1, \dots, \beta_T$ — это расписание шумарасписание шумаEN noise scheduleсколько шума добавлять на каждом шаге прямого процесса (β₁…β_T); в статье они растут линейно от $10^{-4}$ до $0.02$. Зачем корень из $1-\beta_t$? Чтобы дисперсия оставалась равной 1. Два правила из теории вероятностей: при умножении величины на $a$ её дисперсия умножается на $a^2$, а дисперсии независимых слагаемых складываются. Поэтому если у $x_{t-1}$ дисперсия 1, то у $x_t$ она $(\sqrt{1-\beta_t})^2 \cdot 1 + (\sqrt{\beta_t})^2 \cdot 1 = (1-\beta_t) + \beta_t = 1$. Картинка не «взрывается» и не гаснет — она плавно заменяется шумом.

Главный трюк — не нужно делать $t$ шагов, чтобы получить $x_t$. Обозначим $\alpha_t = 1 - \beta_t$ и $\bar\alpha_t = \alpha_1 \alpha_2 \cdots \alpha_t$. Сумма гауссовых шумов — снова гауссов шум, и получается формула «прыжка»:

$$x_t = \sqrt{\bar\alpha_t}\; x_0 + \sqrt{1-\bar\alpha_t}\; \varepsilon, \qquad \varepsilon \sim \mathcal{N}(0, I)$$

$\sqrt{\bar\alpha_t}$ — сколько осталось от картинки, $\sqrt{1-\bar\alpha_t}$ — сколько в ней шума. Посчитаем для расписания из статьи:

import torch

T = 1000
betas = torch.linspace(1e-4, 0.02, T)          # линейное расписание из статьи DDPM
alphas = 1 - betas
alpha_bar = torch.cumprod(alphas, dim=0)         # ᾱ_t = α_1 · α_2 · … · α_t

print(" t     ᾱ_t     √ᾱ_t (сигнал)  √(1−ᾱ_t) (шум)")
for t in [1, 50, 100, 250, 500, 750, 1000]:
    a = alpha_bar[t - 1]
    print(f"{t:4d}  {a:.5f}   {a.sqrt():.4f}         {(1 - a).sqrt():.4f}")

 t     ᾱ_t     √ᾱ_t (сигнал)  √(1−ᾱ_t) (шум)
   1  0.99990   0.9999         0.0100
  50  0.97102   0.9854         0.1702
 100  0.89702   0.9471         0.3209
 250  0.52409   0.7239         0.6899
 500  0.07859   0.2803         0.9599
 750  0.00335   0.0579         0.9983
1000  0.00004   0.0064         1.0000

К шагу 250 коэффициенты сигнала и шума примерно равны, к шагу 500 картинку едва видно (коэффициент сигнала 0.28 против 0.96 у шума), к шагу 1000 остался чистый шум. torch.cumprod — накопленное произведение: та же идея, что cumsum, только с умножением.

Обратный процесс и обучение

Что учит нейросеть

Нейросеть $\varepsilon_\theta(x_t, t)$ получает зашумлённую картинку и номер шага, а предсказывает шум, который был добавлен. Зная шум, легко получить и картинку: из формулы прыжка $x_0 = (x_t - \sqrt{1-\bar\alpha_t}\,\varepsilon)/\sqrt{\bar\alpha_t}$. Предсказывать именно шум удобно: это всегда стандартная гауссова величина одного масштаба, на любом шаге.

Обучение (Algorithm 1 из статьи) — до смешного короткое:

1. Берём настоящий пример $x_0$ из данных.
2. Выбираем случайный шаг $t$ от 1 до $T$ и случайный шум $\varepsilon \sim \mathcal{N}(0, I)$.
3. Прыгаем: $x_t = \sqrt{\bar\alpha_t}\,x_0 + \sqrt{1-\bar\alpha_t}\,\varepsilon$.
4. Минимизируем $\lVert \varepsilon - \varepsilon_\theta(x_t, t) \rVert^2$ — обычную MSE из урока 2.2.1.

Сравните с LLM: там тоже «испортили» вход (спрятали следующий токен) и учим восстановить. Это самообучениесамообучение, самоконтролируемое обучениеEN self-supervised learningМетки берутся из самих данных (например, следующий токен текста). Так идёт предобучение LLM.: разметка не нужна, данные сами себе учитель.

Генерация

Сэмплирование (Algorithm 2) идёт от $x_T \sim \mathcal{N}(0, I)$ к $x_0$:

$$x_{t-1} = \frac{1}{\sqrt{\alpha_t}}\left(x_t - \frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\,\varepsilon_\theta(x_t, t)\right) + \sigma_t z, \qquad z \sim \mathcal{N}(0, I)$$

Словами: вычитаем предсказанный шум (с нужным весом), немного масштабируем и добавляем свежий маленький шум $\sigma_t z$ (в простейшем варианте $\sigma_t = \sqrt{\beta_t}$; на последнем шаге шум не добавляют). Свежий шум делает генерацию случайной: из одного и того же $x_T$ получаются разные картинки — как сэмплирование с температурой в LLM.

Почему это работает: взгляд через «направление к данным»

Предсказанный шум, взятый с минусом, указывает, в какую сторону сдвинуть $x_t$, чтобы он стал больше похож на настоящие данные. Ян Сун, Стефано Эрмон и соавторы (2020) показали, что DDPM — частный случай более общей картины: модель учит поле направлений к данным (score), а генерация — это движение по этому полю. Тогда же появились и быстрые сэмплеры: DDIM (Цзямин Сун и соавторы, 2020) берёт ту же обученную сеть и генерирует за 50 шагов вместо 1000 почти без потери качества.

Практика: DDPM на PyTorch за полминуты

Возьмём данные попроще картинок: точки на окружности радиуса 1. «Картинка» здесь — всего 2 числа $(x, y)$, зато весь алгоритм ровно тот же. Модель должна научиться из гауссова шума делать точки на кольце.

import math
import torch
import torch.nn as nn

torch.manual_seed(0)

# ── Данные: точки на окружности радиуса 1 (наша «картинка» — всего 2 числа) ──
def sample_data(n):
    angle = torch.rand(n) * 2 * math.pi
    r = 1 + 0.05 * torch.randn(n)
    return torch.stack([r * torch.cos(angle), r * torch.sin(angle)], dim=1)

# ── Расписание шума (как в DDPM, но T = 200 шагов, чтобы всё шло быстро) ──
T = 200
betas = torch.linspace(1e-4, 0.05, T)
alphas = 1 - betas
alpha_bar = torch.cumprod(alphas, dim=0)

# ── Модель: MLP, который по (x_t, t) предсказывает шум ε ──
class EpsModel(nn.Module):
    def __init__(self, h=128):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(2 + 16, h), nn.SiLU(),
            nn.Linear(h, h), nn.SiLU(),
            nn.Linear(h, 2),
        )

    def forward(self, x, t):
        # синусоидальное кодирование шага t — тот же приём, что позиции в трансформере
        freqs = torch.exp(-math.log(1000) * torch.arange(8) / 8)
        ang = t[:, None].float() * freqs[None, :]
        t_emb = torch.cat([ang.sin(), ang.cos()], dim=1)
        return self.net(torch.cat([x, t_emb], dim=1))

model = EpsModel()
opt = torch.optim.Adam(model.parameters(), lr=2e-3)

# ── Обучение: зашумили → предсказали шум → MSE ──
for step in range(3001):
    x0 = sample_data(512)
    t = torch.randint(0, T, (512,))
    eps = torch.randn_like(x0)
    ab = alpha_bar[t][:, None]
    xt = ab.sqrt() * x0 + (1 - ab).sqrt() * eps          # прыжок сразу на шаг t
    loss = ((model(xt, t) - eps) ** 2).mean()
    opt.zero_grad(); loss.backward(); opt.step()
    if step % 1000 == 0:
        print(f"шаг {step:4d}  loss {loss.item():.3f}")

# ── Генерация: от чистого шума назад, шаг за шагом ──
@torch.no_grad()
def sample(n):
    x = torch.randn(n, 2)
    for t in reversed(range(T)):
        tt = torch.full((n,), t)
        eps = model(x, tt)
        x = (x - betas[t] / (1 - alpha_bar[t]).sqrt() * eps) / alphas[t].sqrt()
        if t > 0:
            x = x + betas[t].sqrt() * torch.randn_like(x)   # σ_t = √β_t
    return x

noise = torch.randn(2000, 2)
gen = sample(2000)
for name, pts in [("чистый шум", noise), ("сгенерировано", gen), ("настоящие данные", sample_data(2000))]:
    r = pts.norm(dim=1)
    print(f"{name:17s} радиус: среднее {r.mean():.3f}, разброс {r.std():.3f}")

шаг    0  loss 0.951
шаг 1000  loss 0.293
шаг 2000  loss 0.277
шаг 3000  loss 0.267
чистый шум        радиус: среднее 1.252, разброс 0.659
сгенерировано     радиус: среднее 0.989, разброс 0.095
настоящие данные  радиус: среднее 0.998, разброс 0.049

На свободном 4-ядерном CPU это занимает около полуминуты (на загруженной машине — несколько минут). Как читать результат:

• Loss не стремится к нулю — и не должен. На сильно зашумлённых шагах шум принципиально невозможно угадать точно. Важно, что loss упал с ≈1 (модель отвечает «ноль», MSE с гауссовым шумом равна 1) до ≈0.27.
• Радиус сгенерированных точек ≈0.99 при радиусе данных 1.0, хотя начинали с шума со средним радиусом 1.25 и огромным разбросом. Модель выучила кольцо. Разброс 0.095 вдвое больше настоящего — маленькой сети и 3000 шагов не хватает на точную «толщину» кольца.
• Нарисуйте точки (plt.scatter(gen[:, 0], gen[:, 1], s=2), урок 0.3.3) и сохраните x каждые 50 шагов генерации — увидите, как облако шума «стягивается» в кольцо.

Ваши числа могут немного отличаться на другой версии PyTorch. Типичные ошибки в шаге генерации ведут себя по-разному — мы проверили их на этой же обученной модели:

• перепутан знак перед предсказанным шумом — видно сразу: радиус «улетает» в тысячи и больше;
• забыто деление на alphas[t].sqrt() — радиус ≈0.97 вместо 0.99, почти незаметно. Такие ошибки числами не ловятся, поэтому сверяйте код с формулой построчно;
• убран свежий шум $\sigma_t z$ — точки сжимаются внутрь кольца (средний радиус ≈0.89): без шума генерация «усредняет» и теряет разброс.

Обратите внимание и на расписание: у нас $\bar\alpha_{200} \approx 0.006$, то есть в $x_T$ осталось лишь ≈8% амплитуды данных — почти чистый шум, с которого и стартует генерация. Если уменьшить последний $\beta$ до $0.01$, получится $\bar\alpha_{200} \approx 0.36$: в $x_T$ останется 60% сигнала. Генерация же стартует с чистого $\mathcal{N}(0, I)$, то есть модель получит на вход не то, на чём училась, — и кольцо выйдет хуже.

От игрушки к Stable Diffusion: латентная диффузия

Картинка 512×512 — это $512 \cdot 512 \cdot 3 = 786\,432$ числа, и тысяча шагов денойзера по такому массиву стоит дорого. При этом большая часть пикселей — мелкая текстура, которую нет смысла «придумывать» диффузией.

Латентная диффузиялатентная диффузияEN latent diffusionдиффузия идёт не по пикселям, а в сжатом пространстве VAE (Stable Diffusion) (Ромбах и соавторы, 2021 — это Stable Diffusion) делит работу на две части:

1. Вариационный автокодировщик (VAE)вариационный автокодировщик (VAE)EN variational autoencoder (VAE) учится сжимать картинку в латент и разжимать обратно. В Stable Diffusion 512×512×3 → 64×64×4: $16\,384$ чисел, в 48 раз меньше. Как устроен VAE и почему его латент удобен для диффузии — в уроке 9.1.3.
2. Диффузия работает в латенте. В конце декодер VAE превращает латент в пиксели.

Текстовый промпт подаётся в денойзер через перекрёстное вниманиеперекрёстное внимание (cross-attention)EN cross-attentionЗапросы из одной последовательности, ключи и значения — из другой (декодер смотрит на выход энкодера). Ср. self-attention, где все три из одной последовательности. (урок 4.5.1): запросы — из латента, ключи и значения — из эмбеддингов текстового энкодера. В первых версиях Stable Diffusion это был текстовый энкодер CLIP из прошлого урока — вот где он пригодился.

Classifier-free guidance: «сильнее слушай промпт»

Если просто учить модель с условием, картинки получаются «вялыми» — промпт учитывается слабо. Classifier-free guidanceguidance без классификатора (CFG)EN classifier-free guidance (CFG) (Хо и Салиманс, 2022) решает это простым трюком:

• при обучении в части примеров (обычно 10–20%) условие выбрасывают — модель учится и без промпта;
• при генерации делают два прогона и экстраполируют:

$$\tilde\varepsilon = \varepsilon_\theta(x_t, \varnothing) + w \cdot \big(\varepsilon_\theta(x_t, c) - \varepsilon_\theta(x_t, \varnothing)\big)$$

Разность $\varepsilon_c - \varepsilon_\varnothing$ — это «что промпт добавляет к картинке». При $w = 1$ получаем обычную условную модель, при $w > 1$ усиливаем влияние промпта. Пример на одном числе: $\varepsilon_\varnothing = 0.2$, $\varepsilon_c = 0.5$, $w = 6$ → $\tilde\varepsilon = 0.2 + 6 \cdot 0.3 = 2.0$. Цена — два прогона денойзера на шаг и риск пересвеченных, «пластиковых» картинок при слишком большом $w$. В README Wan2.1 пример команды использует --sample_guide_scale 6.

DiT: трансформер вместо U-Net

Долгое время денойзером служила U-NetU-NetEN U-Netсвёрточная сеть «сжать — разжать» с обходными связями; классический денойзер диффузии до DiT — свёрточная сеть «сжать — разжать» со skip-связями (её устройство и код — в уроке 3.5.2). В 2022 году Уильям Пиблс и Се Сайнин показали, что её можно заменить трансформером, — так появился DiT (Diffusion Transformer)диффузионный трансформер (DiT)EN Diffusion Transformer (DiT). Устройство вам уже знакомо по ViT:

1. Латент 32×32×4 (картинка 256×256 после VAE) режется на патчи 2×2 → $16 \cdot 16 = 256$ токенов.
2. Токены идут через блоки трансформера.
3. Номер шага $t$ и класс (или текст) подмешиваются через adaLN-Zero: LayerNorm, у которого масштаб и сдвиг предсказываются из условия, а выход блока в начале обучения умножается на ноль — блок стартует как тождественное отображение (вспомните остаточные связи, урок 3.4.2).

Главный результат статьи — DiT масштабируется, как языковые модели: больше вычислений на шаг → стабильно лучше качество. Лучшая модель DiT-XL/2 достигла FID 2.27 на ImageNet 256×256 — рекорд на тот момент (FID — Fréchet Inception Distance — мера того, насколько распределение сгенерированных картинок отличается от распределения настоящих; чем меньше, тем лучше). С тех пор большие генераторы картинок и видео почти все строятся на DiT и его вариантах (MMDiT у Stable Diffusion 3 и Qwen-Image: токены текста и картинки обрабатываются разными весами, но «смотрят» друг на друга в общем внимании). Вместо классической DDPM их всё чаще учат через flow matchingflow matching (сопоставление потоков)EN flow matching: модель предсказывает не шум, а скорость движения по прямой от шума к данным. Идея та же — много простых шагов от шума к картинке; подробно — в уроке 9.1.4.

Видео: сколько токенов в пяти секундах

Видео — это картинка плюс ось времени. 3D-VAE сжимает и пространство, и время: у HunyuanVideo коэффициенты 4 по времени, 8×8 по пространству и 16 каналов латента. Посчитаем для 5 секунд 720p:

# Сколько чисел и токенов в видео до и после 3D-VAE (сжатие 4 по времени, 8×8 по пространству, 16 каналов)
frames, H, W = 121, 720, 1280                 # 5 секунд при 24 к/с (+1 первый кадр)
pixels = frames * 3 * H * W
lat_t, lat_h, lat_w = (frames - 1) // 4 + 1, H // 8, W // 8
latent = lat_t * 16 * lat_h * lat_w
tokens = lat_t * (lat_h // 2) * (lat_w // 2)   # DiT режет латент на кубики 1×2×2
print(f"пикселей: {pixels:,}")
print(f"латент:   {lat_t}×16×{lat_h}×{lat_w} = {latent:,} чисел (сжатие в {pixels / latent:.0f} раз)")
print(f"токенов для DiT: {tokens:,}")
print(f"пар в матрице внимания: {tokens**2:.2e}")
img_px, img_lat = 512 * 512 * 3, 64 * 64 * 4
print(f"Stable Diffusion: {img_px:,} → {img_lat:,} (в {img_px // img_lat} раз)")

пикселей: 334,540,800
латент:   31×16×90×160 = 7,142,400 чисел (сжатие в 47 раз)
токенов для DiT: 111,600
пар в матрице внимания: 1.25e+10
Stable Diffusion: 786,432 → 16,384 (в 48 раз)

Пять секунд видео — это ≈112 тысяч токенов, и каждый из десятков шагов денойзера гоняет по ним полное внимание. Поэтому видео-генерация — один из главных потребителей разреженного внимания (урок 5.5.2) и параллелизма по последовательности: длинную последовательность токенов делят между несколькими GPU, а для внимания карты обмениваются нужными кусками данных (родственник видов параллелизма из урока 5.4.3). Кубик 1×2×2 — типичный выбор, но точная нарезка у разных моделей своя.

Китайские image- и video-модели (обзорно)

Модель	Кто	Когда	Что важно
U-ViT → Vidu	Университет Цинхуа, затем ShengShu Technology	2022 → 04.2024	U-ViT — один из первых ViT-денойзеров (одновременно с DiT): все входы, включая время и условие, — токены, плюс длинные обходные связи. По словам разработчиков, на этой архитектуре построена видеомодель Vidu
Kling	Kuaishou	06.2024	одна из первых сильных видеомоделей после Sora; закрытая, доступна через сервис
CogVideoX	Zhipu и Цинхуа	08.2024	3D-VAE + «экспертный» трансформер; 10-секундные ролики 768×1360 при 16 к/с; открытые веса
HunyuanVideo	Tencent	12.2024	более 13 млрд параметров — на момент выхода крупнейшая открытая видеомодель
Wan 2.1	Alibaba	02.2025	14B и 1.3B; младшей нужно 8.19 ГБ видеопамяти; Apache-2.0
Qwen-Image	Alibaba	08.2025	20B MMDiT, Apache-2.0; сильная сторона — рендеринг текста в картинке, особенно китайских иероглифов
Janus-Pro	DeepSeek	01.2025	не диффузия: одна авторегрессионная модель и понимает, и генерирует картинки
Seedream, Seedance	ByteDance Seed	2025–2026	закрытые модели картинок и видео; доступны через продукты и API ByteDance

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

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

• Wan2.1-T2V-1.3B на одной карте. По README модель генерирует 5-секундное видео 480p примерно за 4 минуты на RTX 4090 без оптимизаций; RTX 4080 медленнее 4090, так что закладывайте немного больше. Команда по образцу README: python generate.py --task t2v-1.3B --size 832*480 --ckpt_dir ./Wan2.1-T2V-1.3B --sample_shift 8 --sample_guide_scale 6 --prompt "Панда катается на велосипеде по улице Пекина". Поменяйте --sample_guide_scale на 1, 3 и 12 и посмотрите, как меняется следование промпту — это ваш CFG.
• Wan2.1-T2V-14B на 4 картах: в README есть пример torchrun --nproc_per_node=8 generate.py --task t2v-14B ... --dit_fsdp --t5_fsdp --ulysses_size 8 для 8 GPU; для ваших 4 замените оба числа на 4 (команда адаптирована, в README её нет — если упадёт, сверьтесь с разделом о multi-GPU). --dit_fsdp и --t5_fsdp делят веса между картами (FSDP, урок 5.4.3) — у денойзера DiT и у текстового энкодера T5 соответственно, а --ulysses_size включает параллелизм по последовательности DeepSpeed-Ulysses: десятки тысяч токенов видео делятся между картами, а на время внимания каждая карта берёт свою часть голов. README требует, чтобы число голов делилось на ulysses_size: у 14B их 40, так что 4 подходит (у 1.3B голов 12: на 8 картах не делится, поэтому для 8 GPU README советует другую стратегию, Ring; а на ваших 4 картах 12 делится на 4).
• Одна карта против четырёх. По README 14B запускается и на одной карте с --offload_model True (модели, которые сейчас не работают, выгружаются в RAM). Сравните время генерации одного и того же ролика: одна карта с выгрузкой против четырёх с FSDP и Ulysses. Ускорение будет меньше 4×: Ulysses дважды за слой пересылает активации между картами (all-to-all), а у вас это PCIe без NVLink — та же беда, что у DeepSeek на H800 (урок 5.4.3).
• Игрушка из урока на GPU: замените кольцо на MNIST (28×28 = 784 числа), MLP — на маленькую U-Net (как в уроке 3.5.2) или DiT по патчам 4×4. Обучение на одной карте займёт десятки минут.

На CPU видео-диффузия практически недоступна: каждый шаг денойзинга — проход DiT по десяткам тысяч токенов, а шагов десятки. Следите за пиком памяти в nvidia-smi и за временем на шаг в логе. Время и память здесь — ориентиры: они зависят от разрешения, числа кадров и версии кода. Подробнее о машине — на странице «Ваша лаборатория».

Китайский угол: Су Цзяньлинь, диффузия и диффузионные LLM

Лучшее объяснение диффузии на китайском — серия Су Цзяньлиня «Беседы о генеративных диффузионных моделях» в блоге «Научное пространство». Первая часть «DDPM = снос + стройка» строит теорию из метафоры сноса и стройки, почти не опираясь на теорию вероятностей; следующие части показывают DDPM как «авторегрессионный VAE», как байесовское шумоподавление и как SDE (стохастическое дифференциальное уравнение — непрерывная версия процесса зашумления; это продвинутое чтение, к нему можно вернуться позже). Это тот же автор, что придумал RoPE (урок 4.5.2). Читать — с подстрочником из урока «Как читать китайские технические источники».

Курсы Ли Хунъи (NTU) включают отдельное домашнее задание по диффузии (например, HW10 в ML 2025 Spring) — видео лекций есть на YouTube.

Диффузия для текста. LLaDA (группа Ли Чунсюаня, Народный университет Китая, arXiv:2502.09992) — языковая модель на 8B, обученная с нуля без авторегрессии: прямой процесс случайно закрывает токены маской, обратный — трансформер угадывает закрытые токены, весь ответ «проявляется» одновременно. По заявлению авторов, модель сопоставима с LLaMA3 8B, а на «проклятии обратимости» (reversal curse) — восстановить предыдущую строку стихотворения по следующей — обошла GPT-4o. Претрейн — 2.3T токенов за 0.13 млн GPU-часов H800. Диффузионные LLM — живая исследовательская ветка, за которой стоит следить (урок 9.2.2).

Проверь себя

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

1 В DDPM при $t = 500$ имеем $\bar\alpha_t \approx 0.0786$. Какой коэффициент стоит перед $x_0$ в формуле прыжка? Округлите до двух знаков.

2 Что предсказывает нейросеть в DDPM и с каким loss её учат?

Чистую картинку $x_0$, loss — cross-entropy по пикселямШум $\varepsilon$, добавленный к $x_0$; loss — MSE между настоящим и предсказанным шумомНомер шага $t$; loss — cross-entropyСледующий пиксель слева направо, как в LLM

3 Почему в прямом процессе $x_{t-1}$ умножают на $\sqrt{1-\beta_t}$, а не оставляют как есть?

Чтобы дисперсия $x_t$ оставалась равной 1 и картинка плавно заменялась шумом, а не «взрывалась»Чтобы ускорить обучениеЭто нужно только для латентной диффузии

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

Латентная диффузия Stable Diffusion работает с массивом 64×64×4 вместо 512×512×3 — в 48 раз меньше чиселClassifier-free guidance требует отдельно обученного классификатора картинокВ DiT латент режется на патчи, а условие подаётся через adaLNГенерация с CFG делает два прогона денойзера на шаг: с условием и без

5 CFG: $\varepsilon_\varnothing = 0.1$, $\varepsilon_c = 0.3$, $w = 5$. Чему равно $\tilde\varepsilon$?

6 Видео-DiT получает латент 31×90×160 (время × высота × ширина) и режет его на кубики 1×2×2. Сколько это токенов?

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

Итоги

• Диффузия разбивает генерацию на много простых шагов: прямой процесс постепенно превращает данные в шум, нейросеть учится убирать шум по шагу. Формула прыжка позволяет учиться на любом шаге сразу.
• Обучение DDPM — это MSE между настоящим и предсказанным шумом; генерация — тысяча (или, с DDIM, полсотни) шагов от чистого шума.
• Латентная диффузия экономит вычисления в десятки раз, CFG усиливает следование промпту, DiT заменил U-Net трансформером и сделал генераторы масштабируемыми, как LLM.
• Китайские лаборатории — среди лидеров открытой генерации: Wan и Qwen-Image (Alibaba), HunyuanVideo (Tencent), CogVideoX (Zhipu), Vidu (ShengShu и Цинхуа); а LLaDA переносит диффузию в языковые модели.

Дальше: автоэнкодеры, VAE и дискретные токены изображений — как устроен латент, в котором работает диффузия, и как картинка превращается в токены для LLM. А следом, в уроке 9.1.4, — flow matching, на котором учат многие современные генераторы.