Attention &
Архитектура Трансформера

Трансформер предложен в статье «Attention Is All You Need» (Vaswani et al., Google, 2017). Основная идея: полностью отказаться от рекуррентности и свёрток, заменив их механизмом self-attention, который позволяет каждому токену напрямую «смотреть» на любой другой токен последовательности.

Self-Attention: механизм внимания

Self-attention — сердце трансформера. Для каждого токена в последовательности он вычисляет взвешенную сумму значений всех остальных токенов, где веса отражают «релевантность» каждого токена для текущего.

Из входного вектора каждого токена x создаются три вектора через три разные линейные проекции:

import torch.nn.functional as F

def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q: (batch, heads, seq_len, d_k)
    K: (batch, heads, seq_len, d_k)
    V: (batch, heads, seq_len, d_v)
    """
    d_k = Q.shape[-1]
    
    # Матрица оценок: насколько каждый токен внимателен к другим
    scores = Q @ K.transpose(-2, -1) / d_k ** 0.5  # (B, H, T, T)
    
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)  # Маскируем будущее
    
    weights = F.softmax(scores, dim=-1)
    
    return weights @ V, weights  # Взвешенная сумма + сами веса

Multi-Head Attention

Одна пара Q, K, V захватывает только один тип зависимостей. Multi-Head Attention запускает h независимых «голов» внимания параллельно, каждая с проекциями меньшей размерности dₖ = d_model / h. Результаты конкатенируются и проецируются обратно.

Зачем несколько голов? Разные головы специализируются на разных типах отношений:

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.d_k = d_model // n_heads
        self.n_heads = n_heads
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, Q, K, V, mask=None):
        B = Q.shape[0]
        # Проецируем и разбиваем по головам
        Q = self.W_q(Q).view(B, -1, self.n_heads, self.d_k).transpose(1,2)
        K = self.W_k(K).view(B, -1, self.n_heads, self.d_k).transpose(1,2)
        V = self.W_v(V).view(B, -1, self.n_heads, self.d_k).transpose(1,2)

        attn_out, _ = scaled_dot_product_attention(Q, K, V, mask)
        # Конкатенируем головы и проецируем обратно
        attn_out = attn_out.transpose(1,2).contiguous().view(B, -1, self.n_heads * self.d_k)
        return self.W_o(attn_out)

Positional Encoding

Self-attention не знает, в каком порядке стоят токены — операция симметрична. Чтобы передать позиционную информацию, к эмбеддингам прибавляют позиционное кодирование.

В оригинальной статье — детерминированные синусоиды разных частот:

Почему синусоиды? Модель может обобщаться на длины, которых не видела при обучении (например, обучалась на 512 токенах, а инференс на 1024). Современные модели (RoPE в LLaMA, ALiBi в MPT) используют обучаемые позиционные кодирования или относительные смещения — они лучше экстраполируют.

Residual-соединения и Layer Normalization

Каждый подблок трансформера (Attention и FFN) обёрнут в residual connection (остаточное соединение):

Зачем residual? Идея из ResNet (He et al., 2015): при обратном распространении градиент идёт по двум путям — через SubLayer (сложный) и напрямую через сложение (+). Прямой путь гарантирует, что градиент дойдёт до нижних слоёв без затухания, даже если SubLayer выдаёт малый градиент.

Layer Normalization нормирует активации по признакам (не по батчу как Batch Norm), что стабилизирует обучение независимо от размера батча:

Feed-Forward Sublayer и полная архитектура

После attention каждый токен проходит через позиционно-независимую FFN — одинаковую для всех позиций, но с разными активациями:

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

Transfer learning — обучение модели на одной задаче (обычно большой и дешёвой в получении данных), а затем перенос выученных представлений для решения другой задачи (часто маленькой и дорогостоящей в разметке).

Парадигма в NLP: Pretrain → Fine-tune

BERT vs GPT: два стиля предобучения

Практические стратегии Fine-tuning

# LoRA: добавляем обучаемые матрицы к заморозенным весам
from peft import get_peft_model, LoraConfig, TaskType

config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,           # ранг матриц A, B
    lora_alpha=32, # масштабирующий коэффициент
    lora_dropout=0.05,
    target_modules=["q_proj", "v_proj"]  # только Q и V attention
)
model = get_peft_model(base_model, config)
model.print_trainable_parameters()
# trainable params: 4,194,304 || all params: 6,742,609,920 || 0.06%

Zero-shot и Few-shot Learning

Мощные языковые модели (GPT-4, Claude, LLaMA 3) демонстрируют emergent-способности: