Módulo transformersParte 2 de 3

Self-Attention y GPT

Construyendo la arquitectura de los LLMs modernos

🔩 Self-Attention y GPT

Ahora damos el salto: de la atención a GPT. Si el Transformer completo es una orquesta, GPT se queda con la sección más potente: el Decoder. Y con eso le basta para modelar lenguaje.

1. Self-Attention Head

Una "cabeza" de atención transforma la entrada en Query, Key y Value para entender el contexto.

self_attention.py

1import torch.nn as nn
2import torch.nn.functional as F
3
4class SelfAttentionHead(nn.Module):
5  def __init__(self, d_model, d_head):
6      super().__init__()
7      self.w_q = nn.Linear(d_model, d_head, bias=False)
8      self.w_k = nn.Linear(d_model, d_head, bias=False)
9      self.w_v = nn.Linear(d_model, d_head, bias=False)
10      
11  def forward(self, x):
12      # x: (batch, seq_len, d_model)
13      q = self.w_q(x)
14      k = self.w_k(x)
15      v = self.w_v(x)
16      
17      # Similitud (Attention Matrix)
18      scores = (q @ k.transpose(-2, -1)) / (q.size(-1)**0.5)
19      weights = F.softmax(scores, dim=-1)
20      
21      return weights @ v

2. Multi-Head Attention

Combinar múltiples cabezas para que el modelo aprenda diferentes tipos de relaciones simultáneamente.

Cabeza 1

Sintaxis

Cabeza 2

Semántica

Cabeza 3

Entidades

3. Bloque Transformer (Estilo GPT)

Un bloque de GPT combina Multi-Head Attention con una red Feed-Forward y conexiones residuales.

gpt_block.py

1class TransformerBlock(nn.Module):
2  def __init__(self, d_model, n_heads):
3      super().__init__()
4      self.attention = nn.MultiheadAttention(d_model, n_heads)
5      self.norm1 = nn.LayerNorm(d_model)
6      self.ffn = nn.Sequential(
7          nn.Linear(d_model, 4 * d_model),
8          nn.ReLU(),
9          nn.Linear(4 * d_model, d_model)
10      )
11      self.norm2 = nn.LayerNorm(d_model)
12
13  def forward(self, x):
14      # x = x + Attn(Norm(x))
15      x = x + self.attention(self.norm1(x), self.norm1(x), self.norm1(x))[0]
16      # x = x + FFN(Norm(x))
17      x = x + self.ffn(self.norm2(x))
18      return x

4. ¿Por qué Decoder-Only?

Porque para predecir la siguiente palabra solo necesitas contexto pasado. El Masked Self-Attention obliga al modelo a no mirar al futuro, y eso lo convierte en un generador puro: aprende a continuar, no a rellenar.

Resumen en una frase: GPT es un Transformer que aprendió a escribir sin hacer trampa.

5. Referencias Clave

Vaswani et al. Attention Is All You Need (2017).
Radford et al. Language Models are Unsupervised Multitask Learners (GPT-2, 2019).