Шпаргалка: глубокое обучение¶

~10 минут чтения

Предварительно: Архитектура трансформера | Функции активации

Справочная карточка по фундаментальным компонентам глубокого обучения за пределами базового трансформера. Покрывает 9 ключевых направлений: нормализация (RMSNorm заменил LayerNorm в 100% современных LLM), активации (SwiGLU -- стандарт с 2024), диффузионные модели (от 1000 шагов DDPM до 1 шага Consistency Models), Knowledge Distillation (сжатие моделей в 2-10 раз), SSM/Mamba (линейная сложность O(T) vs O(T^2)), xLSTM (2.16x throughput на AMD MI300X), эффективные трансформеры, NAS и GNN. На интервью эти темы появляются в 60%+ вопросов по архитектуре моделей.

Тип: synthesis / interview cheat sheet Дата: Февраль 2026 Synthesis of: Diffusion, NAS, KD, Normalization, Continual Learning, SSM, xLSTM, Efficient Transformers, GNN

Quick Reference: Key Numbers¶

Metric	Value	Context
Diffusion steps (traditional)	50-1000	DDPM, Stable Diffusion
Flow Matching steps	1-10	SD3, FLUX
Consistency Model steps	1	Single-step generation
LoRA rank (typical)	8-64	Memory: 0.5-2% of full params
QLoRA memory	15-25%	4-bit quantization + LoRA
RMSNorm vs LayerNorm	~15-25% faster	Standard in all LLMs
SSM inference speedup	5×	vs Transformer at 2K+ tokens

1. Normalization Methods¶

Comparison Table¶

Method	Formula	Batch Dependency	Best For
BatchNorm	$\frac{x-\mu_B}{\sigma_B} \cdot \gamma + \beta$	Yes	CNNs, fixed batch
LayerNorm	$\frac{x-\mu_L}{\sigma_L} \cdot \gamma + \beta$	No	Transformers, RNNs
RMSNorm	$\frac{x}{\sqrt{\text{mean}(x^2)}} \cdot \gamma$	No	LLMs (Llama, Qwen)
GroupNorm	Per-group normalize	No	Small batches, CNNs

Why RMSNorm Won (2025-2026)¶

LayerNorm:  μ, σ computation per token (expensive)
RMSNorm:    Only √(mean(x²)) needed (simpler, faster)

Performance: ~15-25% faster
Quality:     Identical or better
Adoption:    LLaMA, Mistral, Qwen, Gemma, all modern LLMs

Pre-Norm vs Post-Norm¶

Architecture	Gradient Flow	Training Stability
Post-Norm	Vanishing in deep nets	Unstable
Pre-Norm	Residual path preserved	Stable

Standard pattern (all modern LLMs):

class TransformerBlock(nn.Module):
    def forward(self, x):
        # Pre-Norm pattern
        x = x + self.attention(self.norm1(x))
        x = x + self.mlp(self.norm2(x))
        return x

2025-2026 Developments¶

Method	Description	Status
DynamicTanh	Replace normalization with learnable tanh	Experimental
HybridNorm	Combine LayerNorm + RMSNorm	Research
SeeDNorm	Seed-driven normalization	Very new

2. Activation Functions¶

Modern LLM Standard¶

SwiGLU (Swish-Gated Linear Unit):

\[\text{SwiGLU}(x) = \text{Swish}(xW_1) \otimes (xW_2)\]

Where $\text{Swish}(x) = x \cdot \sigma(x)$

class SwiGLU(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.w1 = nn.Linear(d_model, d_ff, bias=False)
        self.w2 = nn.Linear(d_model, d_ff, bias=False)
        self.w3 = nn.Linear(d_ff, d_model, bias=False)

    def forward(self, x):
        return self.w3(F.silu(self.w1(x)) * self.w2(x))

Comparison¶

Function	Formula	Best For
ReLU	$\max(0, x)$	Classic, simple
GELU	$x \cdot \Phi(x)$	BERT, GPT-⅔
Swish/SiLU	$x \cdot \sigma(x)$	Modern LLMs
SwiGLU	Swish + gating	LLaMA, Mistral, Gemma
GeGLU	GELU + gating	T5, PaLM

Why SwiGLU?¶

Gating mechanism — dynamic feature selection
Smooth gradients — no dead neurons like ReLU
Empirical SOTA — best performance in large models

3. Diffusion Models (2025-2026)¶

Evolution¶

DDPM (2020)     → Score-based generative models
Stable Diffusion → Latent diffusion (compress to latent space)
DiT (2023)      → Diffusion Transformers (replace U-Net)
SD3 (2024)      → MMDiT + Rectified Flow
FLUX (2024)     → 12B params, Flow Matching
Consistency     → 1-step generation

Key Methods¶

Method	Steps	Quality	Speed
DDPM	1000	High	Very slow
DDIM	50-100	High	Slow
Flow Matching	1-10	High	Fast
Consistency Models	1	Good	Fastest

Flow Matching Formula¶

\[\frac{dx}{dt} = v_t(x)\]

Where $v_t$ is learned velocity field from $x_0$ (noise) to $x_1$ (data).

DiT (Diffusion Transformer)¶

Input (latent + noise) → Patch Embedding → Transformer Blocks → Output
                                    ↓
                         Diagonal Gaussian → Sample → Denoise

MMDiT (SD3): Multimodal DiT with separate text/image streams + joint attention.

Code: Simple Diffusion¶

def forward_diffusion(x_0, t, noise):
    """Add noise at timestep t"""
    sqrt_alpha_t = extract(sqrt_alphas_cumprod, t)
    sqrt_one_minus_alpha = extract(sqrt_one_minus_alphas_cumprod, t)
    return sqrt_alpha_t * x_0 + sqrt_one_minus_alpha * noise

def reverse_diffusion(model, x_t, t):
    """Denoise one step"""
    predicted_noise = model(x_t, t)
    return denoise_step(x_t, predicted_noise, t)

4. Knowledge Distillation¶

Methods¶

Method	Description	Compression
Logit matching	Match soft labels	2-4×
Feature matching	Match intermediate features	4-10×
Self-distillation	Model teaches itself	1.5-2×

Distillation Loss¶

\[\mathcal{L} = \alpha \cdot \mathcal{L}_{CE}(y, y_s) + (1-\alpha) \cdot T^2 \cdot KL(p_t \| p_s)\]

Where $T$ is temperature, $p_t, p_s$ are teacher/student probabilities.

TinyLlama Approach¶

Initialize from Llama 2 weights (1.1B)
Pre-train for 3T tokens
Distill from larger model
Result: 1.1B model competitive with 7B

Pruning + Distillation Pipeline¶

graph LR
    A["Full Model<br/>100% params"] --> B["Prune<br/>50-70% params"]
    B --> C["Fine-tune<br/>70-80% качества"]
    C --> D["Distill<br/>30-50% размера"]
    D --> E["Compact Model"]

    style A fill:#e8eaf6,stroke:#3f51b5
    style B fill:#fff3e0,stroke:#ef6c00
    style C fill:#f3e5f5,stroke:#9c27b0
    style D fill:#fff3e0,stroke:#ef6c00
    style E fill:#e8f5e9,stroke:#4caf50

5. State Space Models (SSM)¶

Why SSMs?¶

Aspect	Transformer	SSM (Mamba)
Complexity	$O(T^2)$	$O(T)$
Memory	Grows with T	Fixed state
Inference	Slow for long	Fast, constant
Quality	SOTA	Near-SOTA

Mamba Architecture¶

Selective SSM: $$h_t = \bar{A}_t h_{t-1} + \bar{B}_t x_t$$

\[y_t = C_t h_t\]

Where $\bar{A}_t, \bar{B}_t, C_t$ are input-dependent (selective mechanism).

Evolution¶

S4 (2022)      → Structured State Spaces
H3 (2022)      → Hybrid architecture
Mamba (2023)   → Selective SSM
Mamba-2 (2024) → Optimization, 2-8× faster
Mamba-3 (2026) → ICLR Oral, SOTA quality

Hybrid Architectures¶

Jamba (1:7 ratio):

Block 0: Transformer (1/8)
Block 1: Mamba      (1/8)
Block 2: Mamba      (1/8)
...
Block 7: Mamba      (1/8)

Result: Near-Transformer quality + SSM efficiency.

Code: Mamba Block¶

class MambaBlock(nn.Module):
    def __init__(self, d_model, d_state=16, d_conv=4):
        self.proj = nn.Linear(d_model, d_model * 2)
        self.conv = nn.Conv1d(d_model, d_model, d_conv)
        self.ssm = SelectiveSSM(d_model, d_state)
        self.out = nn.Linear(d_model, d_model)

    def forward(self, x):
        x_proj = self.proj(x)
        x_conv = self.conv(x_proj.transpose(-1, -2)).transpose(-1, -2)
        x_ssm = self.ssm(x_conv)
        return self.out(x_ssm)

6. xLSTM (Extended LSTM)¶

Building Blocks¶

Block	Memory Type	Use Case
sLSTM	Scalar memory	Simple sequences
mLSTM	Matrix memory	Complex dependencies

mLSTM Formula¶

\[C_t = f_t \odot C_{t-1} + i_t \odot (V_t K_t^T)\]

\[h_t = o_t \odot \tanh(C_t q_t)\]

Where $V_t, K_t, q_t$ are value, key, query (like attention).

xLSTM-7B (March 2025)¶

Fastest 7B model inference
2.16× throughput on AMD MI300X
Pareto-dominates Transformers (ICLR 2026 scaling laws)

xLSTM vs Mamba vs Transformer¶

Architecture	Quality	Inference	Memory
Transformer	100%	Baseline	$O(T)$
Mamba	95-98%	5× faster	Fixed
xLSTM	98-100%	3× faster	Fixed

7. Efficient Transformers¶

2025-2026 Advances¶

Method	Focus	Speedup	Date
ZeroS	Linear Attention	$O(N)$	Feb 2026
FAL	Training Communication	44%	Oct 2025
EcoSpa	Structured Sparsity	50% memory	Nov 2025
AGFT	GPU Power	44.3% energy	Aug 2025

ZeroS (Zero-Sum Linear Attention)¶

\[w_i^{ZeroS} = \frac{\exp(q_i \cdot k_i) - \bar{w}}{\sum_j (\exp(q_j \cdot k_j) - \bar{w})}\]

Enables positive AND negative weights
Maintains $O(N)$ complexity
Better expressiveness than standard linear attention

FlashAttention Evolution¶

Version	Key Feature	Speedup
FlashAttention-1	Memory-efficient	2-4×
FlashAttention-2	Better parallelization	2×
FlashAttention-3	Hopper (H100) optimized	1.5-2×

8. Neural Architecture Search (NAS)¶

Methods¶

Method	Search Cost	Quality
DARTS	GPU-days	Good
Once-for-All	One-time	Good
LLM-NAS	Minutes-hours	Excellent

LLM-NAS (2025)¶

Prompt LLM with architecture requirements
Generate candidate architectures
Evaluate small subset
Iterate with feedback

Result: Minutes to hours vs GPU-days for traditional NAS.

Hardware-Aware NAS (HW-NAS)¶

\[\text{Score} = \alpha \cdot \text{Accuracy} + \beta \cdot \frac{1}{\text{Latency}} + \gamma \cdot \frac{1}{\text{Energy}}\]

9. Continual Learning¶

Problem: Catastrophic Forgetting¶

\[\text{Forgetting} = \text{Accuracy}_{\text{old}} - \text{Accuracy}_{\text{after new task}}\]

Mitigation Strategies¶

Strategy	Description	Effectiveness
Replay	Store old examples	High
Regularization	EWC, LwF	Medium
Architecture	Progressive nets	High
Mixed training	Interleave old data	Very High

Key Finding (2025)¶

Even 6.2% interleaved old data = zero catastrophic forgetting

# Mixed training pattern
for batch in dataloader:
    new_data = batch['new_task']
    old_data = batch['old_tasks']  # 6.2% of batch

    loss = model.loss(new_data) + 0.062 * model.loss(old_data)

10. Graph Neural Networks (GNN)¶

Key Insight (June 2025)¶

Transformers = GNN on fully connected graphs

GNN	Transformer
Sparse neighbors	All tokens (fully connected)
Fixed adjacency	Learned attention weights
Graph topology	Positional encodings

Attention as Message Passing¶

\[\text{Attention}(Q, K, V)_i = \sum_j \alpha_{ij} V_j\]

This IS message passing where: - $\alpha_{ij}$ = edge weight from attention - $V_j$ = message from neighbor

ADMP-GNN (Sep 2025)¶

Adaptive Depth Message Passing: - Fixed depth inefficient - Different nodes need different depths - Dynamic depth adjustment per node - Early stopping for converged nodes

11. Типичные заблуждения¶

Заблуждение: BatchNorm и LayerNorm взаимозаменяемы

BatchNorm зависит от размера батча и ведет себя по-разному в train/eval (running mean/std vs batch statistics). В трансформерах с переменной длиной последовательности и маленькими батчами BatchNorm нестабилен. LayerNorm нормализует по feature-dimension и не зависит от батча. Именно поэтому ни один современный LLM не использует BatchNorm.

Заблуждение: Mamba/SSM полностью заменят трансформеры

SSM дают O(T) вместо O(T^2) и фиксированную память при инференсе, но проигрывают 2-5% качества на задачах, требующих точного retrieval из контекста (in-context learning, few-shot). Лучший подход 2025-2026 -- гибриды (Jamba: 1 Transformer : 7 Mamba), дающие 95-98% качества трансформера при 3-5x ускорении.

Заблуждение: Knowledge Distillation всегда сохраняет качество учителя

При сжатии в 4-10x через feature matching студент теряет 5-15% качества на out-of-distribution данных, даже если на тестовом сете разница < 2%. Критично проверять KD-модели на edge cases. TinyLlama (1.1B из Llama 2 7B) конкурентоспособна только на benchmark-ах, но уступает на сложном reasoning.

12. Интервью-вопросы¶

Базовые¶

В: Сравните BatchNorm и LayerNorm

"BatchNorm нормализует по батчу, LayerNorm -- по слою. Оба работают одинаково"

"BatchNorm вычисляет статистики (mean, std) по батчу -- это создает зависимость от batch size и различное поведение train/eval. LayerNorm вычисляет статистики по feature-dimension каждого образца независимо. Для трансформеров LayerNorm обязателен: переменная длина последовательности и малые батчи. В 2025-2026 RMSNorm заменил LayerNorm во всех LLM -- на 15-25% быстрее без потери качества за счет отказа от вычисления mean"

В: Что такое SwiGLU и почему это стандарт?

"Это улучшенная функция активации"

"SwiGLU = Swish(xW1) * xW2 -- gated activation с тремя проекциями (W1, W2, W3). Три преимущества: (1) gating обеспечивает динамическую селекцию признаков, (2) Swish/SiLU дает гладкие градиенты без dead neurons как у ReLU, (3) эмпирически лучшее качество на больших моделях. Используется в LLaMA, Mistral, Gemma, Qwen -- фактически во всех LLM с 2023 года"

В: Почему RMSNorm вместо LayerNorm для LLM?

"RMSNorm быстрее"

"RMSNorm убирает вычисление среднего (mean subtraction) из LayerNorm, оставляя только нормализацию на RMS = sqrt(mean(x^2)). Это дает 15-25% ускорения при идентичном или лучшем качестве. Используется во всех LLM 2024-2026: LLaMA, Mistral, Qwen, Gemma. Комбинация Pre-Norm + RMSNorm -- стандартный паттерн, обеспечивающий стабильный градиентный поток через residual connections"

Продвинутые¶

В: Чем Mamba отличается от трансформеров?

"Mamba -- это RNN с линейной сложностью"

"Mamba использует selective state space model с input-dependent параметрами A, B, C. Сложность O(T) vs O(T^2) у attention, фиксированная память при инференсе (state вместо KV cache). Ключевое отличие от классических SSM -- селективный механизм: параметры зависят от входа, что позволяет модели решать, какую информацию запоминать. Mamba-3 (2026) достиг SOTA качества. Гибрид Jamba (1:7 ratio) -- лучший компромисс для production"

В: Объясните Flow Matching в диффузионных моделях

"Это улучшенный DDPM с меньшим числом шагов"

"Flow Matching обучает velocity field v_t, переводящее noise distribution в data distribution по прямой траектории (ODE: dx/dt = v_t(x)). В отличие от DDPM (1000 шагов через стохастический процесс), FM дает прямые пути от шума к данным за 1-10 шагов. Используется в SD3 (MMDiT + Rectified Flow) и FLUX (12B params). Consistency Models идут дальше -- одношаговая генерация через distillation из диффузионной модели"

В: Как работает Knowledge Distillation?

"Маленькая модель учится копировать большую"

"KD обучает студента через комбинированный loss: alpha * CE(y, y_student) + (1-alpha) * T^2 * KL(p_teacher || p_student), где T (temperature) сглаживает softmax учителя для передачи dark knowledge -- информации о соотношении вероятностей неправильных классов. Feature matching дополнительно выравнивает промежуточные представления. TinyLlama (1.1B) через 3T токенов pre-training + distillation достигает уровня 7B модели. Порядок сжатия: Pruning -> KD -> Quantization"

System Design¶

В: Спроектируйте пайплайн сжатия модели

Простое перечисление техник без порядка

"Последовательность P-KD-Q: (1) Structured pruning -- удаление неважных голов/слоев (50-70% параметров), (2) Fine-tune на целевых данных для восстановления качества, (3) Knowledge Distillation из оригинальной модели для компенсации потерь, (4) Quantization (AWQ/GPTQ 4-bit) для финального сжатия. Каждый этап требует валидации на holdout set. Итог: 10-20x сжатие с потерей < 5% качества на benchmarks"

В: Когда выбрать SSM вместо трансформера?

"Когда нужно быстрее"

"SSM оптимален при: (1) длинных последовательностях > 16K токенов (фиксированная память vs O(T) KV cache), (2) ограниченной GPU-памяти на inference (state size фиксирован ~16-64 dims), (3) потоковой обработке (constant-time per token). Для quality-critical задач -- гибрид Jamba (1 Transformer : 7 Mamba). xLSTM -- альтернатива с 98-100% качества трансформера при 3x ускорении (matrix memory вместо scalar)"

12. Formulas Quick Reference¶

RMSNorm¶

\[\text{RMSNorm}(x) = \frac{x}{\sqrt{\text{mean}(x^2) + \epsilon}} \cdot \gamma\]

SwiGLU¶

\[\text{SwiGLU}(x) = \text{SiLU}(xW_1) \otimes (xW_2)\]

Distillation Loss¶

\[\mathcal{L} = \alpha \cdot \mathcal{L}_{CE} + (1-\alpha) \cdot T^2 \cdot KL(p_t \| p_s)\]

Selective SSM¶

\[h_t = \bar{A}_t h_{t-1} + \bar{B}_t x_t, \quad y_t = C_t h_t\]

Diffusion Forward¶

\[x_t = \sqrt{\bar{\alpha}_t} x_0 + \sqrt{1-\bar{\alpha}_t} \epsilon\]

Flow Matching¶

\[\frac{dx}{dt} = v_t(x), \quad x_1 = x_0 + \int_0^1 v_t(x) dt\]

13. Sources Synthesized¶

diffusion-models-2025-2026.md — Flow Matching, Consistency Models
neural-architecture-search-2025-2026.md — DARTS, LLM-NAS
knowledge-distillation-llm-2025-2026.md — TinyLlama, Pruning+KD
normalization-comparison-2025-2026.md — RMSNorm vs LayerNorm
continual-learning-llm-2025-2026.md — Catastrophic forgetting
state-space-models-2025-2026.md — Mamba, RWKV, Hybrids
xlstm-architecture-2025-2026.md — sLSTM, mLSTM
efficient-transformers-2025-2026.md — ZeroS, FlashAttention
gnn-advances-2025.md — GNN-Transformer connection
deep-learning-advances-2025.md — SSL, Normalization
vision-language-models-2026.md — VLM architecture, CLIP, LLaVA (ФАЗА 5)
llm-compression-distillation-2026.md — P-KD-Q sequence, pruning (ФАЗА 5)
llm-watermarking-detection-2026.md — V-JEPA 2, self-supervised video (ФАЗА 5)

Method	Formula	Batch Dependency	Best For
BatchNorm	\(\frac{x-\mu_B}{\sigma_B} \cdot \gamma + \beta\)	Yes	CNNs, fixed batch
LayerNorm	\(\frac{x-\mu_L}{\sigma_L} \cdot \gamma + \beta\)	No	Transformers, RNNs
RMSNorm	\(\frac{x}{\sqrt{\text{mean}(x^2)}} \cdot \gamma\)	No	LLMs (Llama, Qwen)
GroupNorm	Per-group normalize	No	Small batches, CNNs

Function	Formula	Best For
ReLU	\(\max(0, x)\)	Classic, simple
GELU	\(x \cdot \Phi(x)\)	BERT, GPT-⅔
Swish/SiLU	\(x \cdot \sigma(x)\)	Modern LLMs
SwiGLU	Swish + gating	LLaMA, Mistral, Gemma
GeGLU	GELU + gating	T5, PaLM

Aspect	Transformer	SSM (Mamba)
Complexity	\(O(T^2)\)	\(O(T)\)
Memory	Grows with T	Fixed state
Inference	Slow for long	Fast, constant
Quality	SOTA	Near-SOTA

Method	Focus	Speedup	Date
ZeroS	Linear Attention	\(O(N)\)	Feb 2026
FAL	Training Communication	44%	Oct 2025
EcoSpa	Structured Sparsity	50% memory	Nov 2025
AGFT	GPU Power	44.3% energy	Aug 2025