La Arquitectura Transformer (Transformer Architecture) es una arquitectura de aprendizaje profundo que procesa secuencias mediante mecanismos de atención, transformaciones Feed-Forward, conexiones residuales y operaciones de normalización.

Su diseño revolucionó el procesamiento del lenguaje natural y posteriormente influyó en la visión por computadora, los modelos multimodales, el reconocimiento de voz y la inteligencia artificial generativa.

El Transformer fue presentado en 2017 por Ashish Vaswani y colaboradores en el artículo científico Attention Is All You Need.

La investigación introdujo una arquitectura Encoder–Decoder que reemplazaba el procesamiento recurrente de los sistemas secuencia a secuencia tradicionales por mecanismos de atención.

Esta sustitución permitió procesar múltiples posiciones de una secuencia en paralelo durante el entrenamiento, aunque la generación autorregresiva continúa necesitando decisiones secuenciales cuando cada nuevo token depende de los anteriores.

El Transformer original combinaba:

• Token Embeddings.
• Positional Encoding.
• Multi-Head Self-Attention.
• Encoder–Decoder Cross-Attention.
• Position-Wise Feed-Forward Networks.
• Residual Connections.
• Layer Normalization.
• Masked Attention.
• Linear Projection.
• Softmax.

Una de las principales ventajas de esta arquitectura es su capacidad para construir representaciones contextualizadas.

Por ejemplo, en una frase como «El banco aprobó el préstamo», el significado de «banco» depende del contexto.

Los mecanismos de atención permiten incorporar información de otras posiciones al construir representaciones utilizadas por las capas posteriores.

Con el tiempo aparecieron diferentes familias de Transformers.

BERT popularizó una arquitectura basada en Encoder.

GPT es una familia asociada con Transformers de generación autorregresiva, generalmente de tipo Decoder-Only.

T5 adoptó una arquitectura Encoder–Decoder para tareas formuladas como transformaciones de texto a texto.

Vision Transformer (ViT) adaptó los bloques Transformer a secuencias de parches de imágenes.

Sin embargo, no todos los modelos actuales reproducen exactamente la arquitectura original de 2017.

Existen diferencias relacionadas con funciones de activación, normalización, mecanismos posicionales, atención eficiente, compartición de Keys y Values, entrenamientos y procedimientos de inferencia.

En esta entrada estudiaremos los principios fundamentales y construiremos modelos educativos con NumPy y PyTorch.

También analizaremos el uso de Transformers en aplicaciones empresariales, sistemas de búsqueda y AI Visibility.

1. ¿Qué es un Transformer?

Definición breve: Un Transformer es una arquitectura neuronal que utiliza mecanismos de atención y redes Feed-Forward para aprender representaciones de secuencias y, según su configuración, generar nuevas secuencias o realizar predicciones.

¿Qué recibe?

Normalmente recibe tensores que contienen representaciones de tokens.

¿Qué produce?

Depende de la arquitectura:

• Representaciones contextualizadas.
• Puntuaciones de clasificación.
• Predicciones del siguiente token.
• Traducciones.
• Resúmenes.
• Embeddings.
• Representaciones visuales.
• Otros resultados definidos por una cabeza de tarea.

¿Es sinónimo de Large Language Model?

No.

Un Transformer es una arquitectura. Un LLM es un modelo de lenguaje de gran escala que puede utilizar una arquitectura Transformer.

2. ¿Por qué surgieron los Transformers?

Antes de 2017, numerosos sistemas de procesamiento de secuencias utilizaban:

• Recurrent Neural Networks.
• LSTM.
• GRU.
• Convolutional Sequence Models.
• Encoder–Decoder con mecanismos de atención.

Estas arquitecturas demostraron resultados importantes, pero podían presentar limitaciones relacionadas con procesamiento secuencial o relaciones entre posiciones distantes.

El Transformer propuso una organización basada principalmente en atención.

¿Qué consiguió?

Permitir un mayor paralelismo en operaciones sobre secuencias conocidas durante entrenamiento.

¿Eliminó toda dependencia secuencial?

No.

Los decoders autorregresivos todavía generan tokens de forma condicionada por los anteriores.

3. ¿Qué significa Attention Is All You Need?

Es el título del artículo científico que presentó la arquitectura Transformer.

La idea central era construir un modelo de transducción de secuencias sin depender de recurrencia ni convoluciones como mecanismo principal.

¿Significa que un Transformer contiene únicamente Attention?

No.

El modelo original también utiliza proyecciones lineales, redes Feed-Forward, normalización, embeddings y conexiones residuales.

¿Por qué importa esta distinción?

Porque reducir toda la arquitectura a Self-Attention produce una explicación incompleta.

4. Los tres grandes tipos de arquitectura Transformer

La familia Transformer puede organizarse en tres configuraciones fundamentales.

¿Las tres estructuras utilizan exactamente las mismas máscaras?

No.

¿Son categorías completamente rígidas?

No.

Existen arquitecturas híbridas y variantes que incorporan características adicionales.

5. ¿Qué es el Encoder?

El Encoder transforma una secuencia de entrada en representaciones contextualizadas.

Por ejemplo:

Entrada: «La empresa necesita automatizar facturas».

El Encoder puede generar vectores que representan cada token considerando otros elementos de la secuencia.

¿Produce automáticamente texto nuevo?

Un Encoder estándar no está diseñado para generación autorregresiva mediante una cabeza de siguiente token.

¿Qué tareas puede realizar?

Clasificación, extracción de características y otras tareas mediante cabezas adecuadas.

6. ¿Qué es el Decoder?

El Decoder genera representaciones para una secuencia objetivo y puede utilizarse para predecir el siguiente token.

En el Transformer Encoder–Decoder original, el Decoder contiene:

1. Masked Self-Attention.
2. Encoder–Decoder Cross-Attention.
3. Feed-Forward Network.

¿Por qué utiliza una máscara causal?

Para evitar acceder a tokens futuros durante predicción autorregresiva.

¿Todos los modelos Decoder-Only tienen Cross-Attention?

No.

En una arquitectura Decoder-Only convencional no existe un Encoder independiente cuya salida deba consultarse.

7. ¿Qué es Encoder–Decoder?

Es una arquitectura que utiliza dos componentes complementarios.

Encoder

Procesa la secuencia fuente.

Decoder

Genera la secuencia destino utilizando los tokens anteriores y las representaciones del Encoder.

Ejemplo

Entrada:

«The product is available».

Salida deseada:

«El producto está disponible».

¿Cómo accede el Decoder al texto fuente?

Mediante Cross-Attention hacia la memoria producida por el Encoder.

8. El recorrido completo de una secuencia

El flujo del Transformer original puede dividirse en diez pasos.

1. Tokenizar el texto de entrada.
2. Convertir tokens en identificadores.
3. Transformar IDs en embeddings.
4. Incorporar información posicional.
5. Procesar la entrada mediante bloques Encoder.
6. Construir tokens previos del Decoder.
7. Aplicar Masked Self-Attention.
8. Consultar representaciones del Encoder mediante Cross-Attention.
9. Transformar las salidas con Feed-Forward Networks.
10. Calcular logits para predecir los tokens objetivo.

¿Por qué separar tokenización y embeddings?

Porque la tokenización convierte texto en unidades discretas, mientras que los embeddings convierten esas unidades en vectores.

9. ¿Qué es Tokenization?

Tokenization es el procedimiento que divide una entrada en unidades llamadas tokens.

Ejemplo ilustrativo

Texto:

«La inteligencia artificial aprende».

Tokens:

["La", "inteligencia", "artificial", "aprende"]

¿Todos los tokenizadores producen esos mismos tokens?

No.

Pueden utilizar fragmentos subpalabra, bytes y otras estrategias.

¿Por qué importa?

El tamaño del vocabulario y la longitud de las secuencias dependen del tokenizador.

10. ¿Qué es Token Embedding?

Un Token Embedding es una representación vectorial aprendida asociada a un identificador de token.

Si tenemos:

• Vocabulario V.
• Dimensión D.

La tabla de embeddings puede tener forma:

[V, D]

Ejemplo

V = 10.000.

D = 512.

Parámetros:

5.120.000

¿Cada vector es una definición lingüística explícita?

No.

Sus componentes se aprenden para contribuir a la tarea del modelo.

11. Ejemplo 1 — Crear Token Embeddings

import torch
from torch import nn
vocab_size = 1000
embedding_dim = 64
embedding = nn.Embedding(
    num_embeddings=vocab_size,
    embedding_dim=embedding_dim
)
token_ids = torch.tensor([
    [4, 17, 21, 8],
    [9, 30, 5, 2]
])
vectors = embedding(token_ids)
print("IDs:", token_ids.shape)
print("Embeddings:", vectors.shape)

Resultado esperado:

IDs: torch.Size([2, 4])
Embeddings: torch.Size([2, 4, 64])

¿Qué demuestra?

Cada ID de token se transforma en un vector de dimensión 64.

12. ¿Qué es Positional Encoding?

Positional Encoding incorpora información sobre el orden o posición de los tokens.

La autoatención básica no representa por sí misma el orden de una secuencia.

¿Qué utilizó el Transformer original?

Una codificación sinusoidal basada en funciones seno y coseno.

¿Todos los Transformers actuales utilizan esta técnica?

No.

Algunos utilizan posiciones aprendidas, RoPE, ALiBi o métodos relativos.

13. Fórmula de Positional Encoding sinusoidal

Para una posición pos y un índice de dimensión i:

PE(pos,2i) = sin(pos/10000^(2i/D))

PE(pos,2i+1) = cos(pos/10000^(2i/D))

¿Cómo se incorpora?

En la formulación original se suma a los embeddings.

Xpos = Xembedding + PE

¿Por qué usar diferentes frecuencias?

Para representar variaciones de posición a varias escalas.

14. Ejemplo 2 — Codificación Posicional con PyTorch

import math
import torch
def sinusoidal_positions(
    length,
    dimension
):
    if dimension % 2 != 0:
        raise ValueError(
            "La dimensión debe ser par"
        )
    positions = torch.arange(
        length,
        dtype=torch.float32
    ).unsqueeze(1)
    div_term = torch.exp(
        torch.arange(
            0,
            dimension,
            2,
            dtype=torch.float32
        ) * (
            -math.log(10000.0) / dimension
        )
    )
    pe = torch.zeros(
        length,
        dimension
    )
    pe[:, 0::2] = torch.sin(
        positions * div_term
    )
    pe[:, 1::2] = torch.cos(
        positions * div_term
    )
    return pe
pe = sinusoidal_positions(
    length=10,
    dimension=64
)
print(pe.shape)

Resultado esperado:

torch.Size([10, 64])

15. ¿Qué es Self-Attention?

Self-Attention permite que un token incorpore información de otras posiciones permitidas de la misma secuencia.

El mecanismo utiliza:

• Query.
• Key.
• Value.

¿Qué hace?

Calcula puntuaciones de compatibilidad y produce combinaciones ponderadas de Value.

Fórmula

Attention(Q,K,V) = softmax(QKᵀ/√dk)V

16. ¿Qué son Query, Key y Value?

Query: representación utilizada para consultar compatibilidades.

Key: representación frente a la que se compara una Query.

Value: representación agregada utilizando los pesos de atención.

¿Cómo se generan?

A partir de proyecciones lineales aprendidas.

Q = XWQ

K = XWK

V = XWV

¿Son las matrices WQ, WK y WV iguales?

No necesariamente.

17. Ejemplo 3 — Scaled Dot-Product Attention con NumPy

import numpy as np
def softmax_stable(x):
    shifted = x - np.max(
        x,
        axis=-1,
        keepdims=True
    )
    values = np.exp(shifted)
    return values / values.sum(
        axis=-1,
        keepdims=True
    )
def attention_numpy(Q, K, V):
    scores = (
        Q @ K.T
    ) / np.sqrt(Q.shape[-1])
    weights = softmax_stable(scores)
    return weights @ V, weights
rng = np.random.default_rng(42)
Q = rng.normal(size=(4, 8))
K = rng.normal(size=(4, 8))
V = rng.normal(size=(4, 8))
output, weights = attention_numpy(
    Q, K, V
)
print(output.shape)
print(weights.shape)

Resultado:

(4, 8)
(4, 4)

¿Qué demuestra?

Podemos calcular atención escalada mediante operaciones matriciales.

18. ¿Qué es Multi-Head Attention?

Multi-Head Attention utiliza varias cabezas de atención con proyecciones aprendidas diferentes.

¿Qué aporta?

Permite combinar información obtenida en distintos subespacios de representación.

Fórmula

MultiHead(Q,K,V) = Concat(head₁,…,headₕ)WO

¿Qué hace WO?

Proyecta el resultado concatenado a la dimensión del modelo.

19. Dimensiones de Multi-Head Attention

Supongamos:

D = 512

h = 8

La dimensión por cabeza es:

512 / 8 = 64

Para una secuencia de 20 tokens

Entrada:

[B,20,512]

Queries por cabeza:

[B,8,20,64]

Atención:

[B,8,20,20]

Salida final:

[B,20,512]

¿Cada cabeza genera un modelo independiente?

No.

Forman parte de un módulo entrenado conjuntamente.

20. Ejemplo 4 — Multi-Head Attention en PyTorch

import torch
from torch import nn
attention = nn.MultiheadAttention(
    embed_dim=512,
    num_heads=8,
    batch_first=True
)
tokens = torch.randn(
    2, 20, 512
)
output, weights = attention(
    tokens,
    tokens,
    tokens,
    need_weights=True,
    average_attn_weights=False
)
print("Output:", output.shape)
print("Weights:", weights.shape)

Resultado esperado:

Output: torch.Size([2, 20, 512])
Weights: torch.Size([2, 8, 20, 20])

21. ¿Qué es una Feed-Forward Network?

Cada bloque Transformer original contiene una red Feed-Forward aplicada a las posiciones de la secuencia.

Una formulación es:

FFN(x) = max(0, xW1+b1)W2+b2

¿Qué significa?

Una transformación lineal, seguida de ReLU y otra transformación lineal.

¿Se comparten parámetros entre posiciones?

Sí, en la subred Feed-Forward estándar de un mismo bloque.

¿Se comparten parámetros entre todos los bloques?

No necesariamente. El Transformer original utiliza parámetros específicos por bloque.

22. ¿Por qué existe una dimensión intermedia mayor?

El Transformer Base original utilizó:

d_model = 512

d_ff = 2048

¿Qué aporta?

Una transformación no lineal con mayor dimensión intermedia.

¿El tamaño siempre debe multiplicarse por cuatro?

No.

Es una configuración característica, pero existen otras.

23. Ejemplo 5 — Feed-Forward Network

import torch
from torch import nn
feed_forward = nn.Sequential(
    nn.Linear(512, 2048),
    nn.ReLU(),
    nn.Linear(2048, 512)
)
x = torch.randn(
    2, 20, 512
)
output = feed_forward(x)
print(output.shape)

Resultado esperado:

torch.Size([2, 20, 512])

¿Qué demuestra?

El FFN conserva la dimensión externa del modelo después de una transformación intermedia.

24. ¿Qué son las conexiones residuales?

Una Residual Connection suma la entrada de una subcapa a su salida.

y = x + F(x)

¿Para qué sirve?

Favorece el flujo de información y facilita el entrenamiento de redes profundas.

¿Qué requisito existe?

Las representaciones sumadas deben tener formas compatibles.

25. ¿Qué es Layer Normalization?

Layer Normalization normaliza las activaciones de una representación utilizando estadísticas de las dimensiones correspondientes.

¿Por qué se utiliza?

Para contribuir a la estabilidad del procesamiento y del entrenamiento.

¿Es igual que Batch Normalization?

No.

Las dimensiones sobre las que se calculan las estadísticas son distintas.

26. ¿Qué es Post-Norm?

En una configuración Post-Norm:

y = LN(x + Sublayer(x))

El Transformer original utilizó normalización después de la conexión residual.

¿Qué es Pre-Norm?

En Pre-Norm:

y = x + Sublayer(LN(x))

¿Son equivalentes?

No.

Cambiar la ubicación de la normalización altera el comportamiento del bloque.

¿Cuál utilizan los Transformers modernos?

Depende de la familia y de su implementación.

27. Ejemplo 6 — Encoder Block educativo

import torch
from torch import nn
class EncoderBlock(nn.Module):
    def __init__(
        self,
        dim=128,
        heads=4,
        ff_dim=512
    ):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attention = nn.MultiheadAttention(
            embed_dim=dim,
            num_heads=heads,
            batch_first=True
        )
        self.norm2 = nn.LayerNorm(dim)
        self.ffn = nn.Sequential(
            nn.Linear(dim, ff_dim),
            nn.GELU(),
            nn.Linear(ff_dim, dim)
        )
    def forward(
        self,
        x,
        padding_mask=None
    ):
        normalized = self.norm1(x)
        attended, _ = self.attention(
            normalized,
            normalized,
            normalized,
            key_padding_mask=padding_mask,
            need_weights=False
        )
        x = x + attended
        x = x + self.ffn(
            self.norm2(x)
        )
        return x
block = EncoderBlock()
x = torch.randn(
    2, 10, 128
)
output = block(x)
print(output.shape)

¿Qué demuestra?

Un bloque Encoder puede construirse combinando atención, LayerNorm, FFN y conexiones residuales.

Precaución

Este ejemplo utiliza Pre-Norm, mientras que el Transformer de 2017 utilizó Post-Norm.

28. ¿Qué es Masked Self-Attention?

Masked Self-Attention restringe determinadas conexiones de atención.

En el Decoder original se utiliza una máscara causal.

¿Qué impide?

Que una posición consulte tokens futuros.

Ejemplo

Para cuatro posiciones, la máscara de acceso permitido puede representarse como:

1 0 0 0
1 1 0 0
1 1 1 0
1 1 1 1

¿Por qué se necesita?

Para evitar filtración de información futura durante la predicción autorregresiva.

29. ¿Qué es Causal Mask?

Una Causal Mask representa qué posiciones deben bloquearse o permitirse durante atención.

¿Qué hace PyTorch?

nn.Transformer.generate_square_subsequent_mask produce una matriz triangular con valores cero y menos infinito.

¿Qué significa menos infinito?

Que una posición bloqueada obtiene peso cero después de Softmax, cuando existen claves válidas.

30. Ejemplo 7 — Generar una máscara causal

import torch
from torch import nn
mask = nn.Transformer.generate_square_subsequent_mask(
    5
)
print(mask)

Resultado esperado:

tensor([[0., -inf, -inf, -inf, -inf],
        [0., 0., -inf, -inf, -inf],
        [0., 0., 0., -inf, -inf],
        [0., 0., 0., 0., -inf],
        [0., 0., 0., 0., 0.]])

¿Qué demuestra?

Cada posición del Decoder puede atender solamente a sí misma y a las posiciones anteriores.

31. ¿Qué es Cross-Attention?

Cross-Attention permite que el Decoder consulte las representaciones producidas por el Encoder.

Queries

Proceden de las representaciones del Decoder.

Keys y Values

Proceden de la memoria del Encoder.

¿Para qué sirve?

Para condicionar la generación en la secuencia fuente.

32. ¿Qué dimensiones utiliza Cross-Attention?

Supongamos:

• Fuente: S = 12 tokens.
• Destino: T = 7 tokens.
• Dimensión: D = 128.

La matriz de atención por cabeza tiene forma:

[T,S] = [7,12]

¿Por qué no es cuadrada?

Porque las secuencias fuente y destino pueden tener diferentes longitudes.

33. Ejemplo 8 — Cross-Attention con PyTorch

import torch
from torch import nn
cross_attention = nn.MultiheadAttention(
    embed_dim=128,
    num_heads=4,
    batch_first=True
)
decoder_states = torch.randn(
    2, 7, 128
)
encoder_memory = torch.randn(
    2, 12, 128
)
output, weights = cross_attention(
    decoder_states,
    encoder_memory,
    encoder_memory,
    need_weights=True,
    average_attn_weights=False
)
print(output.shape)
print(weights.shape)

Resultado esperado:

torch.Size([2, 7, 128])
torch.Size([2, 4, 7, 12])

34. ¿Cómo funciona un Decoder Block?

El Decoder original contiene tres subcapas principales:

1. Masked Multi-Head Self-Attention.
2. Multi-Head Cross-Attention.
3. Feed-Forward Network.

Cada una incorpora conexión residual y normalización.

¿Por qué existen dos mecanismos de atención?

Uno procesa el contexto anterior del destino.

El otro incorpora información de la secuencia fuente.

35. Ejemplo 9 — Decoder Block educativo

import torch
from torch import nn
class DecoderBlock(nn.Module):
    def __init__(
        self,
        dim=128,
        heads=4,
        ff_dim=512
    ):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.norm2 = nn.LayerNorm(dim)
        self.norm3 = nn.LayerNorm(dim)
        self.self_attention = nn.MultiheadAttention(
            dim, heads, batch_first=True
        )
        self.cross_attention = nn.MultiheadAttention(
            dim, heads, batch_first=True
        )
        self.ffn = nn.Sequential(
            nn.Linear(dim, ff_dim),
            nn.GELU(),
            nn.Linear(ff_dim, dim)
        )
    def forward(
        self,
        target,
        memory,
        causal_mask=None,
        target_padding=None,
        source_padding=None
    ):
        q = self.norm1(target)
        self_out, _ = self.self_attention(
            q, q, q,
            attn_mask=causal_mask,
            key_padding_mask=target_padding,
            need_weights=False
        )
        target = target + self_out
        q = self.norm2(target)
        cross_out, _ = self.cross_attention(
            q,
            memory,
            memory,
            key_padding_mask=source_padding,
            need_weights=False
        )
        target = target + cross_out
        target = target + self.ffn(
            self.norm3(target)
        )
        return target

¿Qué demuestra?

Un Decoder Block puede combinar atención causal, Cross-Attention y FFN.

¿Es un Transformer completo?

No.

Todavía necesita embeddings, codificación posicional, un Encoder, proyección final y entrenamiento.

36. ¿Qué es Teacher Forcing?

Teacher Forcing es una estrategia de entrenamiento en la que el Decoder recibe los tokens reales anteriores en lugar de depender exclusivamente de los tokens que él mismo haya predicho.

Ejemplo

Destino esperado:

[BOS, hola, mundo, EOS]

Entrada del Decoder:

[BOS, hola, mundo]

Objetivo de predicción:

[hola, mundo, EOS]

¿Por qué desplazar la secuencia?

Porque cada posición debe predecir el token siguiente.

¿Se aplica una máscara causal?

Sí, para impedir que una posición consulte tokens objetivos posteriores.

37. ¿Qué es Exposure Bias?

Durante Teacher Forcing, el modelo utiliza tokens anteriores reales.

Durante inferencia autorregresiva, puede utilizar sus propias predicciones.

¿Qué problema aparece?

La distribución de los contextos durante entrenamiento e inferencia no es idéntica.

¿Cómo puede manifestarse?

Los errores generados en un paso pueden afectar las predicciones posteriores.

¿Teacher Forcing debe evitarse siempre?

No.

Es una estrategia habitual y útil, aunque debemos comprender sus limitaciones.

38. ¿Qué es la capa Linear + Softmax?

Después del Decoder se obtienen representaciones de dimensión D.

Una proyección lineal transforma cada representación en logits del vocabulario.

Forma

Entrada:

[B,T,D]

Proyección:

Linear(D,V)

Salida:

[B,T,V]

¿Qué hace Softmax?

Transforma logits en una distribución de probabilidades sobre el vocabulario.

¿CrossEntropyLoss necesita probabilidades?

No.

En PyTorch, nn.CrossEntropyLoss recibe logits directamente.

39. ¿Qué es la función de pérdida de un Transformer generativo?

Para predicción del siguiente token se utiliza frecuentemente Cross-Entropy.

Formulación

L = −Σ log P(yt | contexto permitido)

La suma suele agregarse o normalizarse según la implementación.

¿Por qué ignorar tokens PAD?

Porque no representan objetivos reales de contenido.

¿Cómo hacerlo en PyTorch?

Mediante ignore_index u otra estrategia equivalente.

40. ¿Qué es Label Smoothing?

Label Smoothing modifica la distribución objetivo para evitar asignar toda la masa de probabilidad a una única categoría.

El Transformer original utilizó Label Smoothing.

¿Por qué puede ser útil?

Como forma de regularización y control de confianza.

¿Siempre mejora el rendimiento?

No.

Depende de la tarea y de la métrica.

41. ¿Qué es Adam y Learning Rate Warmup?

El Transformer original utilizó Adam con un programa específico de tasa de aprendizaje.

Una formulación clásica es:

lr = d_model^(-0,5) × min(step^(-0,5), step × warmup^(-1,5))

¿Qué significa?

La tasa aumenta durante el Warmup y después disminuye siguiendo una regla de potencia inversa.

¿Todos los Transformers actuales utilizan esta fórmula?

No.

Las recetas modernas pueden utilizar AdamW, Cosine Decay y otras configuraciones.

42. Ejemplo 10 — Learning Rate Schedule del Transformer original

import math
def transformer_learning_rate(
    step,
    d_model=512,
    warmup=4000
):
    if step < 1:
        return 0.0
    return (
        d_model ** -0.5
        * min(
            step ** -0.5,
            step * warmup ** -1.5
        )
    )
for step in [
    1, 100, 1000, 4000, 8000
]:
    print(
        step,
        transformer_learning_rate(step)
    )

¿Qué demuestra?

Podemos reproducir la estructura del Learning Rate Schedule presentado en el artículo original, sin factores adicionales específicos de una implementación.

43. ¿Qué ofrece nn.Transformer de PyTorch?

PyTorch proporciona nn.Transformer, un módulo de referencia que implementa los componentes fundamentales de la arquitectura Encoder–Decoder original.

Parámetros principales

• d_model.
• nhead.
• num_encoder_layers.
• num_decoder_layers.
• dim_feedforward.
• dropout.
• batch_first.
• norm_first.

¿Es un LLM preentrenado?

No.

Es una arquitectura que necesita datos, embeddings, cabeza de salida y entrenamiento.

44. Ejemplo 11 — Transformer Encoder–Decoder mínimo

import torch
from torch import nn
transformer = nn.Transformer(
    d_model=64,
    nhead=4,
    num_encoder_layers=2,
    num_decoder_layers=2,
    dim_feedforward=128,
    dropout=0.0,
    batch_first=True
)
source = torch.randn(
    2, 7, 64
)
target = torch.randn(
    2, 5, 64
)
mask = nn.Transformer.generate_square_subsequent_mask(
    target.size(1)
)
output = transformer(
    source,
    target,
    tgt_mask=mask
)
print(output.shape)

Resultado esperado:

torch.Size([2, 5, 64])

¿Qué demuestra?

El Transformer produce una representación por posición del destino.

¿Por qué no produce directamente palabras?

Porque faltan el vocabulario, el tokenizador y la capa de clasificación de salida.

45. ¿Qué es Source Padding Mask?

Es una máscara que indica qué posiciones de la secuencia fuente corresponden a padding.

En nn.Transformer, una máscara booleana de padding utiliza:

True = ignorar esa posición como Key.

¿Por qué importa?

Porque los lotes pueden contener secuencias de distintas longitudes.

¿Qué ocurre si no se utiliza?

Los tokens reales pueden atender a posiciones de relleno artificial.

46. ¿Qué es Target Padding Mask?

Cumple una función equivalente para el Decoder.

¿Es igual que Causal Mask?

No.

La Causal Mask controla acceso a posiciones futuras.

La Padding Mask bloquea posiciones de relleno.

¿Pueden utilizarse ambas?

Sí.

47. Importante: máscaras booleanas en PyTorch

En nn.Transformer y nn.MultiheadAttention:

True = posición bloqueada.

En torch.nn.functional.scaled_dot_product_attention, una máscara booleana utiliza:

True = posición permitida.

¿Qué riesgo existe?

Invertir la convención puede permitir acceso a información futura o bloquear posiciones que deberían estar disponibles.

48. Ejemplo 12 — Transformer con máscaras de padding

import torch
from torch import nn
transformer = nn.Transformer(
    d_model=64,
    nhead=4,
    num_encoder_layers=2,
    num_decoder_layers=2,
    batch_first=True,
    dropout=0.0
)
src = torch.randn(
    2, 6, 64
)
tgt = torch.randn(
    2, 4, 64
)
src_padding = torch.tensor([
    [False, False, False, False, False, False],
    [False, False, False, False, True, True]
])
tgt_padding = torch.tensor([
    [False, False, False, False],
    [False, False, False, True]
])
tgt_mask = nn.Transformer.generate_square_subsequent_mask(
    tgt.size(1)
)
output = transformer(
    src,
    tgt,
    tgt_mask=tgt_mask,
    src_key_padding_mask=src_padding,
    tgt_key_padding_mask=tgt_padding,
    memory_key_padding_mask=src_padding
)
print(output.shape)

Resultado esperado:

torch.Size([2, 4, 64])

¿Por qué pasar memory_key_padding_mask?

Para evitar que la Cross-Attention del Decoder consulte posiciones de padding de la memoria del Encoder.

49. Construir un Transformer completo para traducción

A continuación construiremos un pequeño modelo educativo que recibe IDs de tokens y produce logits del vocabulario destino.

El ejemplo incluirá:

• Embeddings de fuente.
• Embeddings de destino.
• Codificación posicional.
• Transformer Encoder–Decoder.
• Máscara causal.
• Máscaras de padding.
• Capa de salida.

No se proporcionan datos reales de traducción. La finalidad es demostrar un pipeline funcional que pueda ampliarse.

50. Ejemplo 13 — Modelo Seq2Seq Transformer

import math
import torch
from torch import nn
class SinusoidalPE(nn.Module):
    def __init__(
        self,
        dim,
        max_len=512
    ):
        super().__init__()
        positions = torch.arange(
            max_len,
            dtype=torch.float32
        ).unsqueeze(1)
        div = torch.exp(
            torch.arange(
                0, dim, 2,
                dtype=torch.float32
            ) * (
                -math.log(10000.0) / dim
            )
        )
        pe = torch.zeros(
            1, max_len, dim
        )
        pe[0, :, 0::2] = torch.sin(
            positions * div
        )
        pe[0, :, 1::2] = torch.cos(
            positions * div
        )
        self.register_buffer(
            "pe",
            pe,
            persistent=False
        )
    def forward(self, x):
        return (
            x + self.pe[
                :, :x.size(1), :
            ].to(dtype=x.dtype)
        )
class Seq2SeqTransformer(nn.Module):
    def __init__(
        self,
        src_vocab,
        tgt_vocab,
        dim=64,
        heads=4,
        layers=2,
        pad_id=0
    ):
        super().__init__()
        self.dim = dim
        self.pad_id = pad_id
        self.src_embedding = nn.Embedding(
            src_vocab,
            dim,
            padding_idx=pad_id
        )
        self.tgt_embedding = nn.Embedding(
            tgt_vocab,
            dim,
            padding_idx=pad_id
        )
        self.position = SinusoidalPE(dim)
        self.transformer = nn.Transformer(
            d_model=dim,
            nhead=heads,
            num_encoder_layers=layers,
            num_decoder_layers=layers,
            dim_feedforward=dim * 4,
            dropout=0.1,
            batch_first=True
        )
        self.output_layer = nn.Linear(
            dim,
            tgt_vocab
        )
    def forward(self, src, tgt_input):
        src_padding = (
            src == self.pad_id
        )
        tgt_padding = (
            tgt_input == self.pad_id
        )
        src_vectors = self.position(
            self.src_embedding(src)
            * math.sqrt(self.dim)
        )
        tgt_vectors = self.position(
            self.tgt_embedding(tgt_input)
            * math.sqrt(self.dim)
        )
        causal_mask = (
            nn.Transformer
            .generate_square_subsequent_mask(
                tgt_input.size(1),
                device=tgt_input.device
            )
        )
        hidden = self.transformer(
            src_vectors,
            tgt_vectors,
            tgt_mask=causal_mask,
            src_key_padding_mask=src_padding,
            tgt_key_padding_mask=tgt_padding,
            memory_key_padding_mask=src_padding
        )
        return self.output_layer(
            hidden
        )

¿Qué demuestra?

Tenemos una arquitectura Encoder–Decoder que transforma tokens de fuente y destino en predicciones del vocabulario objetivo.

¿Es un traductor entrenado?

No.

Debemos proporcionar pares de traducción y optimizar el modelo.

51. Ejemplo 14 — Verificar las dimensiones del Seq2Seq

model = Seq2SeqTransformer(
    src_vocab=100,
    tgt_vocab=120,
    dim=64,
    heads=4,
    layers=2,
    pad_id=0
)
src = torch.tensor([
    [4, 7, 9, 2, 0],
    [5, 8, 3, 6, 2]
])
tgt_input = torch.tensor([
    [1, 20, 21, 22],
    [1, 35, 36, 37]
])
logits = model(
    src,
    tgt_input
)
print(logits.shape)

Resultado esperado:

torch.Size([2, 4, 120])

¿Qué significa?

Cada una de las cuatro posiciones de destino produce 120 logits, uno por token del vocabulario destino.

52. Ejemplo 15 — Preparar Teacher Forcing y calcular la pérdida

import torch
from torch import nn
# Secuencias:
# BOS=1, EOS=2, PAD=0
tgt = torch.tensor([
    [1, 20, 21, 22, 2],
    [1, 35, 36, 37, 2]
])
decoder_input = tgt[:, :-1]
targets = tgt[:, 1:]
logits = model(
    src,
    decoder_input
)
criterion = nn.CrossEntropyLoss(
    ignore_index=0
)
loss = criterion(
    logits.reshape(
        -1,
        logits.size(-1)
    ),
    targets.reshape(-1)
)
print(
    "Pérdida:",
    loss.item()
)

¿Qué demuestra?

Los tokens de destino se desplazan una posición para entrenar predicción autorregresiva.

¿La pérdida demuestra traducción correcta?

No.

El modelo todavía utiliza parámetros sin entrenamiento útil.

53. Ejemplo 16 — Un paso de optimización

import torch
optimizer = torch.optim.AdamW(
    model.parameters(),
    lr=3e-4
)
model.train()
optimizer.zero_grad()
logits = model(
    src,
    decoder_input
)
loss = criterion(
    logits.reshape(
        -1, logits.size(-1)
    ),
    targets.reshape(-1)
)
loss.backward()
torch.nn.utils.clip_grad_norm_(
    model.parameters(),
    max_norm=1.0
)
optimizer.step()
print(
    "Loss:",
    float(loss.detach())
)

¿Qué demuestra?

Podemos entrenar el Transformer mediante Cross-Entropy, Backpropagation y AdamW.

¿Por qué usar Gradient Clipping?

Puede limitar la magnitud global de los gradientes cuando sea necesario.

54. ¿Cómo genera texto un Transformer?

Durante inferencia autorregresiva, el Decoder puede generar un token por paso.

Procedimiento

1. Codificar la entrada.
2. Inicializar el destino con BOS.
3. Calcular logits.
4. Seleccionar el siguiente token.
5. Añadirlo a la secuencia.
6. Repetir hasta EOS o longitud máxima.

¿Puede utilizarse Greedy Decoding?

Sí.

¿Existen alternativas?

Beam Search, Sampling, Top-k, Top-p y otras estrategias.

55. Ejemplo 17 — Greedy Decoding educativo

import torch
@torch.inference_mode()
def greedy_decode(
    model,
    src,
    bos_id=1,
    eos_id=2,
    max_new_tokens=12
):
    model.eval()
    generated = torch.full(
        (src.size(0), 1),
        bos_id,
        dtype=torch.long,
        device=src.device
    )
    finished = torch.zeros(
        src.size(0),
        dtype=torch.bool,
        device=src.device
    )
    for _ in range(max_new_tokens):
        logits = model(
            src,
            generated
        )
        next_token = logits[
            :, -1, :
        ].argmax(dim=-1)
        next_token = torch.where(
            finished,
            torch.full_like(
                next_token,
                eos_id
            ),
            next_token
        )
        generated = torch.cat(
            [
                generated,
                next_token.unsqueeze(1)
            ],
            dim=1
        )
        finished |= (
            next_token == eos_id
        )
        if finished.all():
            break
    return generated
result = greedy_decode(
    model,
    src
)
print(result)

¿Qué demuestra?

Podemos generar una secuencia condicionada por el texto fuente.

Precaución

Este ejemplo recalcula el modelo en cada paso y no implementa KV Cache.

Además, los resultados serán esencialmente arbitrarios hasta que el modelo reciba entrenamiento significativo.

56. ¿Qué es Greedy Decoding?

Es seleccionar en cada paso el token con el logit más elevado.

¿Es siempre la mejor estrategia?

No.

Una elección local óptima no garantiza la mejor secuencia completa.

¿Qué alternativa conocida existe?

Beam Search.

57. ¿Qué es Beam Search?

Beam Search conserva varias secuencias candidatas durante generación.

¿Qué ventaja puede ofrecer?

Explora alternativas en lugar de conservar una única continuación.

¿Siempre supera Greedy Decoding?

No.

Depende de la tarea, de la calibración del modelo y de la configuración del algoritmo.

58. ¿Qué es un Encoder-Only Transformer?

Es una arquitectura que utiliza principalmente bloques Encoder.

¿Qué tipo de atención utiliza?

Generalmente atención bidireccional, condicionada por las máscaras disponibles.

¿Qué tareas favorece?

• Clasificación.
• Extracción de entidades.
• Extracción de características.
• Búsqueda semántica mediante modelos apropiados.
• Procesamiento de documentos.

Ejemplo representativo

BERT.

59. ¿Qué es BERT?

BERT (Bidirectional Encoder Representations from Transformers) es una arquitectura basada en Transformer Encoder.

Fue presentada por Jacob Devlin y colaboradores.

¿Qué característica destaca?

El aprendizaje de representaciones bidireccionales de texto.

¿Qué tareas puede abordar?

Clasificación, reconocimiento de entidades y otras tareas tras adaptar la cabeza del modelo.

¿BERT es un Decoder-Only LLM?

No.

60. Ejemplo 18 — Utilizar un Encoder para clasificación

import torch
from torch import nn
encoder_layer = nn.TransformerEncoderLayer(
    d_model=64,
    nhead=4,
    dim_feedforward=128,
    batch_first=True
)
encoder = nn.TransformerEncoder(
    encoder_layer,
    num_layers=2
)
classifier = nn.Linear(
    64, 3
)
tokens = torch.randn(
    2, 12, 64
)
encoded = encoder(tokens)
pooled = encoded.mean(dim=1)
logits = classifier(pooled)
print(logits.shape)

Resultado esperado:

torch.Size([2, 3])

¿Qué demuestra?

Podemos utilizar representaciones de Encoder para clasificación.

¿El Mean Pooling considera padding?

No en este ejemplo.

Si hay tokens PAD debemos utilizar un promedio enmascarado u otra estrategia compatible.

61. ¿Qué es Decoder-Only?

Un Decoder-Only Transformer utiliza una pila de bloques con atención causal para predecir continuaciones de una secuencia.

¿Qué tarea característica realiza?

Predicción del siguiente token.

¿Tiene que utilizar un Encoder independiente?

No.

¿Es el mismo bloque que el Decoder original?

No exactamente.

El Decoder original contiene Cross-Attention hacia un Encoder; una arquitectura Decoder-Only convencional omite esa subcapa porque no tiene memoria externa de Encoder.

62. ¿Qué es GPT?

GPT es una familia de modelos de lenguaje basada históricamente en preentrenamiento generativo y arquitecturas de tipo Transformer Decoder.

¿Qué significa Generative Pre-Training?

Entrenar un modelo para aprender patrones a partir de grandes cantidades de datos, frecuentemente mediante predicción de tokens.

¿Todos los modelos GPT utilizan exactamente la arquitectura de 2018?

No.

Las arquitecturas y procedimientos evolucionan.

63. ¿Qué es T5?

T5 (Text-to-Text Transfer Transformer) es una familia de modelos que trata numerosas tareas de lenguaje mediante un formato común de entrada y salida textual.

Su arquitectura representativa utiliza Encoder–Decoder.

Ejemplo

Entrada:

«translate English to Spanish: hello»

Salida:

«hola»

¿Por qué es importante?

Muestra cómo tareas distintas pueden formularse dentro de un mismo esquema secuencia a secuencia.

64. Comparación BERT, GPT y T5

¿Cuál es mejor?

Depende de la tarea.

No existe una arquitectura superior para todos los objetivos.

65. ¿Cómo se utilizan Transformers en visión artificial?

Vision Transformer adapta el procesamiento de secuencias a imágenes.

Procedimiento

1. Dividir la imagen en Patches.
2. Convertir Patches en embeddings.
3. Añadir información posicional.
4. Aplicar bloques Transformer.
5. Producir una salida para clasificación u otra tarea.

¿ViT original utiliza Encoder o Decoder?

Su formulación característica para clasificación utiliza una pila de bloques de tipo Encoder.

66. ¿Qué es un Transformer multimodal?

Es un sistema que combina representaciones de varias modalidades.

Modalidades posibles

• Texto.
• Imagen.
• Audio.
• Vídeo.
• Datos estructurados.

¿Cómo pueden integrarse?

Mediante encoders separados, Cross-Attention, secuencias conjuntas u otros mecanismos.

¿Todos los modelos multimodales comparten exactamente la misma arquitectura?

No.

67. ¿Qué es Context Window?

La Context Window define la cantidad de tokens que un modelo puede procesar bajo determinadas restricciones.

¿Por qué importa?

Porque influye en la información disponible y en los costes de cálculo.

¿Un Transformer puede atender a una secuencia infinita?

No.

Cada implementación tiene restricciones prácticas de memoria, cálculo y diseño.

68. ¿Cuál es el coste de Self-Attention?

En atención global convencional, la matriz de compatibilidad para N tokens contiene:

N² elementos por cabeza.

Ejemplo

N = 2048.

N² = 4.194.304.

¿Qué implica?

La atención puede consumir mucha memoria en secuencias largas si se materializan matrices completas.

¿Qué alternativas existen?

FlashAttention, atención local, atención dispersa y otras optimizaciones.

69. ¿Qué es KV Cache?

KV Cache almacena Keys y Values de posiciones anteriores durante inferencia autorregresiva.

¿Qué ventaja ofrece?

Evita recalcular repetidamente determinadas representaciones.

¿Convierte la generación de un Decoder en completamente paralela?

No.

Los nuevos tokens siguen dependiendo de los anteriores.

¿Se utiliza automáticamente en nn.Transformer?

La implementación educativa mostrada anteriormente no proporciona un sistema completo de KV Cache optimizada.

70. ¿Qué son MHA, MQA y GQA?

Multi-Head Attention

Utiliza múltiples cabezas de atención con proyecciones Key/Value asociadas.

Multi-Query Attention

Comparte una cabeza Key/Value entre múltiples cabezas Query.

Grouped-Query Attention

Agrupa cabezas Query alrededor de un número reducido de cabezas Key/Value.

¿Para qué sirven MQA y GQA?

Pueden reducir almacenamiento y tráfico de memoria durante inferencia autorregresiva.

71. ¿Qué es FlashAttention?

FlashAttention es una familia de algoritmos que optimiza el cálculo de atención y sus accesos a memoria.

¿Es una nueva arquitectura Encoder–Decoder?

No.

Es una estrategia de implementación de operaciones de atención.

¿Elimina universalmente el coste cuadrático?

No.

Reduce determinados costes de memoria y transferencia, pero no elimina todas las interacciones de atención global.

72. ¿Qué es Mixture of Experts?

Mixture of Experts (MoE) es una familia de arquitecturas que utiliza múltiples módulos expertos y un mecanismo que selecciona cuáles intervienen para procesar determinadas entradas.

¿Dónde puede incorporarse?

Por ejemplo, en sustitución o adaptación de determinadas redes Feed-Forward.

¿Es obligatorio en un Transformer?

No.

¿Todos los expertos se activan en cada token?

En modelos MoE dispersos, normalmente no.

73. ¿Cómo se entrena un Transformer moderno?

El procedimiento depende de su objetivo.

Puede incluir:

• Preentrenamiento autosupervisado.
• Fine-Tuning supervisado.
• Adaptación eficiente de parámetros.
• Distillation.
• Entrenamiento con preferencias.
• Evaluaciones específicas.

¿Qué diferencia existe entre arquitectura y entrenamiento?

La arquitectura define cómo se procesan representaciones.

El entrenamiento determina qué parámetros aprende el modelo.

¿Una arquitectura adecuada garantiza un modelo útil?

No.

La calidad de datos, el objetivo y la evaluación son fundamentales.

74. ¿Qué es Transfer Learning?

Transfer Learning consiste en reutilizar un modelo preentrenado para otra tarea.

Ejemplo

Podemos utilizar un Encoder preentrenado para clasificación documental.

¿Qué ventaja ofrece?

Reduce la necesidad de entrenar todos los parámetros desde cero.

¿Es siempre suficiente cambiar la última capa?

No.

Algunas tareas requieren Fine-Tuning adicional.

75. ¿Qué es LoRA?

Low-Rank Adaptation (LoRA) es una técnica de adaptación eficiente de parámetros.

¿Qué hace?

Introduce matrices entrenables de rango reducido en determinadas transformaciones del modelo.

¿Para qué sirve?

Para adaptar modelos sin actualizar necesariamente todos sus pesos originales.

¿LoRA forma parte del Transformer de 2017?

No.

Es un método de adaptación desarrollado posteriormente.

76. ¿Qué métricas se utilizan para evaluar Transformers?

Dependen de la tarea.

Clasificación

• Accuracy.
• Precision.
• Recall.
• F1-Score.

Modelos de lenguaje

• Cross-Entropy.
• Perplexity.
• Evaluaciones de calidad de generación.

Traducción

• BLEU.
• chrF.
• COMET u otras métricas apropiadas.

Recuperación

• Recall@k.
• MRR.
• nDCG.

¿Una sola métrica determina la calidad general?

No.

77. ¿Qué es Perplexity?

Perplexity es una métrica relacionada con la capacidad predictiva de un modelo de lenguaje.

En una formulación habitual:

PPL = exp(Cross-Entropy media por token)

¿Qué indica?

Valores menores corresponden a mayor probabilidad asignada a los tokens verdaderos bajo la evaluación especificada.

¿Podemos comparar Perplexity de modelos con tokenizadores diferentes sin precauciones?

No.

La unidad de tokenización y el protocolo pueden afectar la comparación.

78. ¿Qué es BLEU?

BLEU es una métrica utilizada históricamente para evaluar traducción automática comparando secuencias generadas con referencias.

¿Qué mide?

Solapamientos de n-gramas bajo reglas definidas.

¿Equivale a calidad humana?

No.

Puede no reflejar completamente adecuación semántica, fluidez o utilidad.

79. ¿Cómo medir la latencia de un Transformer?

Debemos especificar:

• Arquitectura.
• Número de capas.
• Dimensión del modelo.
• Cabezas de atención.
• Longitud de secuencia.
• Batch Size.
• Hardware.
• Tipo numérico.
• Backend.
• Modo de entrenamiento o inferencia.

¿Es lo mismo throughput que latencia?

No.

Throughput mide cantidad de procesamiento por unidad de tiempo.

Latencia mide tiempo transcurrido para completar una operación.

80. Ejemplo 19 — Benchmark de Transformer Encoder

import time
import torch
from torch import nn
device = torch.device(
    "cuda" if torch.cuda.is_available()
    else "cpu"
)
encoder_layer = nn.TransformerEncoderLayer(
    d_model=128,
    nhead=4,
    dim_feedforward=512,
    dropout=0.0,
    batch_first=True
)
encoder = nn.TransformerEncoder(
    encoder_layer,
    num_layers=3
).to(device).eval()
x = torch.randn(
    1, 256, 128,
    device=device
)
with torch.inference_mode():
    for _ in range(5):
        encoder(x)
    if device.type == "cuda":
        torch.cuda.synchronize()
    start = time.perf_counter()
    for _ in range(20):
        encoder(x)
    if device.type == "cuda":
        torch.cuda.synchronize()
elapsed = time.perf_counter() - start
print(
    f"Latencia media: {elapsed/20*1000:.2f} ms"
)

¿Qué demuestra?

Podemos obtener una medición básica de inferencia.

¿Es un benchmark definitivo?

No.

Deben evaluarse calentamiento, variabilidad, hardware, memoria y características de la carga real.

81. Aplicaciones empresariales de Transformers

Clasificación documental

Clasificar facturas, contratos, solicitudes y otros documentos.

Extracción de información

Identificar entidades y campos relevantes dentro de textos.

Atención al cliente

Procesar consultas mediante asistentes entrenados o configurados para tareas concretas.

Búsqueda semántica

Crear representaciones de documentos para recuperación.

Traducción

Transformar texto de un idioma a otro.

Resumen documental

Generar versiones condensadas de textos.

Análisis visual

Procesar imágenes mediante Vision Transformers y otras arquitecturas.

Sistemas multimodales

Combinar texto con información visual o acústica.

¿El Transformer realiza todas estas aplicaciones por sí mismo?

No.

Se necesitan modelos entrenados, datos, interfaces y controles adecuados.

82. Arquitectura Transformer y agentes de IA

Los agentes de IA pueden utilizar modelos basados en Transformers para interpretar instrucciones, planificar acciones o seleccionar herramientas.

¿El Transformer es un agente completo?

No.

Un agente suele necesitar componentes externos, como:

• Herramientas.
• Estado.
• Memoria operativa.
• Orquestación.
• Políticas.
• Validación de resultados.

¿Cuál es el papel del modelo?

Proporcionar capacidades de procesamiento, generación o toma de decisiones dentro del sistema.

83. Transformers y Retrieval-Augmented Generation

Retrieval-Augmented Generation (RAG) combina recuperación de información con generación de respuestas.

¿Qué componentes puede incluir?

1. Modelo de embeddings.
2. Índice de búsqueda.
3. Recuperador.
4. Modelo generativo.
5. Construcción de contexto.
6. Evaluación de respuestas.

¿RAG es un mecanismo interno obligatorio de los Transformers?

No.

Es una arquitectura de sistema que utiliza componentes adicionales.

84. Transformer y AI Visibility

La Arquitectura Transformer es importante para comprender cómo diferentes modelos procesan textos y otras representaciones.

Ejemplo

Un usuario pregunta:

«¿Qué software CRM es recomendable para una empresa de diez empleados?»

El sistema puede necesitar relacionar:

• Tipo de software.
• Tamaño de empresa.
• Necesidades.
• Criterios de recomendación.
• Información disponible.

Los mecanismos de atención participan en la construcción de representaciones contextuales dentro de modelos que los utilizan.

¿Esto garantiza una recomendación concreta?

No.

Las respuestas dependen de la arquitectura completa, del entrenamiento, de las fuentes disponibles y de otros mecanismos del sistema.

85. ¿Transformer mejora Recommendation Rate?

No directamente.

Recommendation Rate es una métrica que observa la frecuencia con la que una marca aparece recomendada bajo un protocolo.

La Arquitectura Transformer es una tecnología interna de procesamiento.

¿Qué podemos afirmar?

Los Transformers pueden participar en la interpretación de consultas y generación de respuestas.

¿Qué no podemos afirmar?

Que un cambio específico en el contenido de una web aumente recomendaciones mediante una fórmula de atención determinada.

86. ¿Transformer mejora Citation Coverage?

No directamente.

Citation Coverage depende de las referencias observadas en respuestas y de la metodología de medición.

El Transformer puede formar parte de un sistema que utiliza fuentes, pero las citas suelen depender también de recuperación, acceso a documentos y construcción de respuestas.

¿Una matriz de atención equivale a una cita?

No.

87. Errores frecuentes sobre Arquitectura Transformer

Error 1. Confundir Transformer con LLM

La arquitectura no equivale a un modelo de lenguaje específico.

Error 2. Suponer que Transformer contiene solamente Self-Attention

También utiliza FFN, normalización y otras operaciones.

Error 3. Confundir Encoder y Decoder

Cumplen funciones diferentes.

Error 4. Suponer que todos los Transformers tienen Encoder y Decoder

Existen arquitecturas Encoder-Only y Decoder-Only.

Error 5. Afirmar que el Decoder-Only siempre utiliza Cross-Attention

No en su estructura convencional.

Error 6. Confundir Tokenization con Embedding

Son operaciones diferentes.

Error 7. Ignorar Positional Encoding

El orden debe representarse mediante algún mecanismo apropiado.

Error 8. Confundir Self-Attention y Multi-Head Attention

Describen aspectos distintos del mecanismo.

Error 9. Confundir Query, Key y Value

Son proyecciones con funciones distintas.

Error 10. Aplicar Softmax sobre la dimensión equivocada

Puede producir distribuciones incorrectas.

Error 11. Confundir Post-Norm y Pre-Norm

No son formulaciones idénticas.

Error 12. Olvidar Residual Connections

Cambia la arquitectura del bloque.

Error 13. No desplazar el destino durante Teacher Forcing

Puede producir objetivos de entrenamiento incorrectos.

Error 14. No utilizar Causal Mask

Puede permitir filtración de tokens futuros.

Error 15. Confundir Padding Mask y Causal Mask

Bloquean posiciones por razones diferentes.

Error 16. Invertir convenciones booleanas de máscaras

Puede alterar la atención.

Error 17. No pasar Source Padding Mask a Cross-Attention

Puede hacer que el Decoder consulte posiciones PAD.

Error 18. Aplicar Softmax antes de CrossEntropyLoss de PyTorch

No es necesario y puede producir un entrenamiento incorrecto.

Error 19. Tratar logits como probabilidades

No son lo mismo.

Error 20. Suponer que un Transformer sin entrenamiento puede traducir

Necesita parámetros aprendidos.

Error 21. Confundir Teacher Forcing con generación autónoma

Son procedimientos distintos.

Error 22. Suponer que la generación autorregresiva es completamente paralela

Cada nuevo token depende del contexto anterior.

Error 23. Ignorar el coste de Context Window

Puede aumentar memoria y latencia.

Error 24. Considerar FlashAttention una arquitectura completa

Es una técnica de implementación de atención.

Error 25. Asociar una matriz de atención directamente con Citation Coverage

No existe esa equivalencia.

88. Buenas prácticas

1. Identificar la familia Transformer utilizada.
2. Diferenciar Encoder-Only, Decoder-Only y Encoder–Decoder.
3. Documentar el tokenizador.
4. Controlar el vocabulario.
5. Verificar las dimensiones de embeddings.
6. Seleccionar un mecanismo posicional apropiado.
7. Documentar número de capas.
8. Documentar número de cabezas.
9. Verificar dimensiones de Query, Key y Value.
10. Utilizar máscaras correctas.
11. Separar Causal Mask y Padding Mask.
12. Respetar las convenciones booleanas de cada API.
13. Utilizar conexiones residuales correctamente.
14. Documentar Pre-Norm o Post-Norm.
15. Seleccionar FFN y activaciones de forma coherente.
16. Preparar secuencias desplazadas para Teacher Forcing.
17. Ignorar los objetivos PAD durante entrenamiento.
18. Utilizar una función de pérdida compatible con logits.
19. Registrar optimizador y Learning Rate Schedule.
20. Aplicar Gradient Clipping cuando corresponda.
21. Separar Train, Validation y Test.
22. Evaluar con métricas propias de la tarea.
23. Medir latencia y memoria.
24. Comparar con modelos preentrenados y líneas base.
25. Documentar limitaciones de producción.

Preguntas frecuentes sobre Arquitectura Transformer

¿Qué es un Transformer?

Es una arquitectura neuronal que utiliza atención y transformaciones Feed-Forward para procesar secuencias.

¿Quién inventó el Transformer?

Fue presentado por Ashish Vaswani y colaboradores.

¿Cuándo se publicó?

En 2017.

¿Cuál es el artículo original?

Attention Is All You Need.

¿Qué significa Encoder?

Es el componente que transforma la entrada en representaciones contextualizadas.

¿Qué significa Decoder?

Es el componente que procesa el contexto de salida y puede generar predicciones de tokens.

¿Qué es Encoder–Decoder?

Es una arquitectura que combina ambos componentes mediante Cross-Attention.

¿Todos los Transformers tienen Encoder y Decoder?

No.

¿Qué es Encoder-Only?

Es una arquitectura basada principalmente en bloques Encoder.

¿Qué es Decoder-Only?

Es una arquitectura basada en bloques causales para generación autorregresiva.

¿Qué es Self-Attention?

Es un mecanismo que relaciona posiciones de una misma secuencia.

¿Qué es Multi-Head Attention?

Es calcular múltiples operaciones de atención en paralelo.

¿Qué es Cross-Attention?

Es un mecanismo que utiliza Queries de una secuencia y Keys/Values de otra.

¿Qué es Positional Encoding?

Es información que representa el orden o las posiciones de tokens.

¿Qué es Token Embedding?

Es una representación vectorial aprendida de un token.

¿Qué es Feed-Forward Network?

Es una red aplicada a las representaciones de tokens dentro de cada bloque.

¿Qué es Layer Normalization?

Es una técnica de normalización de activaciones.

¿Qué es Residual Connection?

Es una conexión que suma la entrada de una transformación a su salida.

¿Qué es Pre-Norm?

Es normalización antes de la subcapa.

¿Qué es Post-Norm?

Es normalización después de la conexión residual.

¿Qué utilizó el Transformer original?

Post-Norm en sus bloques.

¿Qué significa d_model?

Es la dimensión de representación del modelo.

¿Qué significa nhead?

Es el número de cabezas de atención.

¿Qué significa dim_feedforward?

Es la dimensión intermedia del FFN.

¿Cuántas capas tenía el Transformer Base original?

Seis Encoder y seis Decoder.

¿Qué dimensión utilizaba?

¿Cuántas cabezas tenía?

Ocho.

¿Qué es Masked Self-Attention?

Es atención con restricciones sobre determinadas posiciones.

¿Qué es Causal Mask?

Es una máscara que bloquea acceso a tokens futuros.

¿Qué es Padding Mask?

Es una máscara que ignora posiciones de relleno.

¿Qué es Teacher Forcing?

Es utilizar tokens objetivo anteriores reales durante entrenamiento.

¿Qué significa BOS?

Beginning of Sequence.

¿Qué significa EOS?

End of Sequence.

¿Qué significa PAD?

Padding.

¿Qué es Cross-Entropy?

Es una función de pérdida de clasificación.

¿Qué es Label Smoothing?

Es una técnica de suavizado de objetivos.

¿Qué es Warmup?

Es una fase inicial de aumento gradual de la tasa de aprendizaje.

¿Qué es AdamW?

Es un optimizador con Weight Decay desacoplado.

¿Qué es Greedy Decoding?

Es seleccionar el token de mayor puntuación en cada paso.

¿Qué es Beam Search?

Es un algoritmo que mantiene múltiples secuencias candidatas.

¿Qué es KV Cache?

Es almacenamiento de Keys y Values reutilizables durante generación incremental.

¿Qué es FlashAttention?

Es una familia de algoritmos eficientes para calcular atención.

¿Qué es MQA?

Multi-Query Attention.

¿Qué es GQA?

Grouped-Query Attention.

¿Qué es BERT?

Es una familia de modelos basada en representaciones bidireccionales de Encoder.

¿Qué es GPT?

Es una familia de modelos generativos basada históricamente en arquitecturas de tipo Decoder.

¿Qué es T5?

Es una familia Encoder–Decoder para tareas formuladas como texto a texto.

¿Qué es ViT?

Vision Transformer.

¿Transformers pueden procesar imágenes?

Sí.

¿Pueden procesar audio?

Sí, mediante arquitecturas apropiadas.

¿Pueden trabajar con varias modalidades?

Sí.

¿Qué es RAG?

Retrieval-Augmented Generation.

¿Qué es MoE?

Mixture of Experts.

¿Qué es LoRA?

Low-Rank Adaptation.

¿Qué es Transfer Learning?

Es reutilizar representaciones o pesos aprendidos anteriormente.

¿Qué es Fine-Tuning?

Es adaptar un modelo preentrenado a nuevos datos u objetivos.

¿Qué es Perplexity?

Es una métrica relacionada con la predicción de tokens.

¿Qué es BLEU?

Es una métrica utilizada en traducción automática.

¿Transformer es lo mismo que un agente de IA?

No.

¿Puedo crear un Transformer con PyTorch?

Sí.

¿Qué hace nn.Transformer?

Proporciona una implementación de referencia de la arquitectura Encoder–Decoder.

¿Es necesario usar GPU?

No obligatoriamente.

¿Por qué es costosa la atención global?

Porque determinadas operaciones crecen cuadráticamente con el número de tokens.

¿Un contexto más largo siempre produce mejores respuestas?

No.

¿Transformer mejora Recommendation Rate?

No directamente.

¿Transformer aumenta Citation Coverage?

No directamente.

¿Por qué es importante para AI Visibility?

Ayuda a comprender la arquitectura de numerosos modelos que procesan consultas y contenido.

Conceptos relacionados

• Inteligencia Artificial.
• Aprendizaje Profundo.
• Redes Neuronales.
• Procesamiento del Lenguaje Natural.
• Transformer.
• Encoder.
• Decoder.
• Encoder–Decoder.
• Encoder-Only.
• Decoder-Only.
• Tokenization.
• Token Embedding.
• Positional Encoding.
• Self-Attention.
• Multi-Head Attention.
• Cross-Attention.
• Query.
• Key.
• Value.
• Attention Mask.
• Causal Mask.
• Padding Mask.
• Feed-Forward Network.
• Layer Normalization.
• Residual Connections.
• Teacher Forcing.
• Cross-Entropy.
• Label Smoothing.
• AdamW.
• Warmup.
• Greedy Decoding.
• Beam Search.
• KV Cache.
• FlashAttention.
• MQA.
• GQA.
• Mixture of Experts.
• LoRA.
• BERT.
• GPT.
• T5.
• Vision Transformer.
• PyTorch.
• NumPy.
• AI Visibility.

Conclusión

La Arquitectura Transformer representa un cambio fundamental en el procesamiento de secuencias mediante aprendizaje profundo.

Su diseño combina mecanismos de atención, embeddings, codificación posicional, redes Feed-Forward, normalización y conexiones residuales.

El Transformer original utilizó una arquitectura Encoder–Decoder en la que el Encoder construye representaciones de la entrada y el Decoder genera una secuencia destino condicionada por esas representaciones.

Masked Self-Attention permite restringir el acceso a tokens futuros, mientras que Cross-Attention conecta el procesamiento del Decoder con la memoria del Encoder.

Posteriormente aparecieron arquitecturas Encoder-Only, como BERT, y Decoder-Only, utilizadas por familias de modelos generativos como GPT.

Vision Transformer demostró que los mismos principios podían aplicarse a representaciones visuales.

La arquitectura también evolucionó mediante optimizaciones como FlashAttention, KV Cache, Grouped-Query Attention y diferentes variantes de normalización y Feed-Forward Networks.

Sin embargo, comprender la arquitectura no es suficiente para construir un modelo útil.

Los resultados dependen de los datos, el entrenamiento, las funciones de pérdida, el procedimiento de generación y la evaluación.

PyTorch proporciona los componentes necesarios para implementar tanto el Transformer de referencia como arquitecturas personalizadas.

En aplicaciones empresariales, estos sistemas forman parte de soluciones de procesamiento documental, búsqueda semántica, traducción, clasificación, análisis visual y asistentes inteligentes.

En AI Visibility, conocer el Transformer ayuda a comprender los principios generales del procesamiento contextual de muchos modelos modernos, aunque no permite deducir directamente las recomendaciones ni las citas generadas por servicios externos.

La conclusión fundamental es que Transformer integra atención y transformaciones neuronales para construir representaciones contextualizadas y generar secuencias. Su arquitectura constituye una base conceptual esencial para estudiar los modelos de lenguaje, Vision Transformers y numerosos sistemas modernos de inteligencia artificial.