Image for post Introducción a la Arquitectura Transformer: Fundamentos y Funcionamiento Interno

Introducción a la Arquitectura Transformer: Fundamentos y Funcionamiento Interno

Escrito por Sergio Márquez

La arquitectura Transformer ha revolucionado el campo de la inteligencia artificial, especialmente en el procesamiento de lenguaje natural (PLN), pero su aplicación se extiende a múltiples dominios como visión, audio y biología computacional. A pesar de su popularidad, comprender cómo funciona internamente puede resultar un reto para muchos desarrolladores e investigadores. Este artículo presenta una explicación técnica, detallada y clara, destinada a un público intermedio que busca profundizar en el diseño y los mecanismos que hacen tan poderosa a esta arquitectura.

¿Qué es un Transformer?

Un Transformer es un tipo de modelo de redes neuronales diseñado para manejar secuencias de datos sin necesidad de procesarlas de manera secuencial, a diferencia de las redes recurrentes (RNN) y LSTM. Fue introducido en el paper "Attention is All You Need" en 2017 por Vaswani et al., marcando un antes y un después en cómo se abordan tareas como la traducción automática, la generación de texto y más.

Estructura Básica de un Transformer

La arquitectura se compone fundamentalmente de dos bloques principales:

  • Encoder (Codificador): Procesa la entrada para generar representaciones contextuales.
  • Decoder (Decodificador): Genera la salida basada en la información del encoder y el propio contexto del decodificador.

Ambos bloques están formados por capas repetidas que incluyen mecanismos de atención y redes feed-forward. A continuación, desglosamos cada componente.

Mecanismo de Atención

El mecanismo de self-attention es el núcleo del Transformer y permite que el modelo evalúe la relevancia relativa de distintos tokens (palabras, subpalabras, etc.) entre sí dentro de la secuencia. Esto permite capturar dependencias a largo plazo de manera eficiente.

¿Cómo funciona la atención en el Transformer?

Para cada token en la entrada se calculan tres vectores: Query (Q), Key (K) y Value (V) mediante multiplicaciones matriciales con matrices aprendibles. La atención se obtiene con la fórmula:

Attention(Q, K, V) = softmax( (QK^T) / \sqrt{d_k} ) V

donde d_k es la dimensión de las keys, y el softmax normaliza los pesos para que sumen 1. Los valores V se combinan según la importancia relativa dada por las similitudes Q y K.

Multi-Head Attention

En lugar de una única atención, el Transformer aplica múltiples cabezas paralelas que permiten al modelo enfocarse en distintos tipos de relaciones simultáneamente. Cada cabeza realiza la operación de atención con diferentes matrices Q, K y V.

La salida de estas múltiples cabezas se concatena y se proyecta a una dimensión final para seguir el flujo en la red.


import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        assert d_model % num_heads == 0
        self.d_k = d_model // num_heads
        self.num_heads = num_heads

        self.linear_q = nn.Linear(d_model, d_model)
        self.linear_k = nn.Linear(d_model, d_model)
        self.linear_v = nn.Linear(d_model, d_model)
        self.linear_out = nn.Linear(d_model, d_model)

        self.softmax = nn.Softmax(dim=-1)

    def forward(self, x):
        batch_size = x.size(0)

        # Lineal projections
        Q = self.linear_q(x).
        reshape(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.linear_k(x).
        reshape(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.linear_v(x).
        reshape(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

        # Attention scores
        scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5)
        attn = self.softmax(scores)

        # Weighted sum
        context = torch.matmul(attn, V)

        context = context.transpose(1, 2).contiguous().reshape(batch_size, -1, self.num_heads * self.d_k)
        out = self.linear_out(context)
        return out

Capa Feed-Forward Posicional

Después de la atención, cada token pasa por una red neuronal feed-forward aplicada a cada posición por separado. Esta consta de dos capas lineales con una función de activación no lineal entre ellas (generalmente ReLU o GELU).


ff_layer = nn.Sequential(
    nn.Linear(d_model, d_ff),
    nn.ReLU(),
    nn.Linear(d_ff, d_model)
)

Positional Encoding

Los Transformers no tienen por sí mismos información sobre el orden de los tokens, ya que procesan la secuencia en paralelo. Para que el modelo capture la posición de cada token, se suman vectores de positional encoding a la entrada antes del primer encoder.

Estos vectores se calculan con funciones trigonométricas sinusoidales que varían con la posición y la dimensión del embedding:


def get_positional_encoding(seq_len, d_model):
    pos_enc = torch.zeros(seq_len, d_model)
    position = torch.arange(0, seq_len).unsqueeze(1)
    div_term = torch.exp(torch.arange(0, d_model, 2) * -(math.log(10000.0) / d_model))
    pos_enc[:, 0::2] = torch.sin(position * div_term)
    pos_enc[:, 1::2] = torch.cos(position * div_term)
    return pos_enc

Ventajas Clave del Transformer

  • Procesamiento paralelo: permite un entrenamiento mucho más rápido que modelos secuenciales.
  • Manejo eficiente de dependencias a largo plazo: no sufre problemas clásicos de RNN con secuencias largas.
  • Capacidad de atención múltiple: puede extraer diferentes relaciones y patrones simultáneamente.

Conclusión

La arquitectura Transformer ha cambiado radicalmente las reglas del juego en IA, ofreciendo un modelo flexible, eficiente y poderoso para trabajar con secuencias. Su núcleo, el mecanismo de atención, es una innovadora forma de entender relaciones de contexto que supera los modelos clásicos.

Este artículo ha explorado los componentes técnicos esenciales, ayudando a entender cómo se combinan para formar modelos altamente sofisticados. Profundizar en estos conceptos es fundamental para cualquier profesional que desee diseñar, adaptar o mejorar soluciones basadas en Transformers.

Volver al blog