Transformers

¿Qué es un Transformer?

Un Transformer es una arquitectura de red neuronal basada enteramente en mecanismos de atención, sin recurrencia ni convoluciones. Fue propuesta en 2017 por Vaswani et al. en el paper "Attention Is All You Need" y ha revolucionado prácticamente todos los campos del deep learning: procesamiento de lenguaje natural, visión por computador, generación de audio, series temporales, y más.

Pero para entender por qué el Transformer fue tan revolucionario, necesitamos entender lo que había antes: las RNNs, sus limitaciones, y cómo surgió la idea de la atención.

El camino hacia la atención: de las RNNs al Transformer

La historia del Transformer es la historia de cómo el deep learning aprendió a prestar atención. Antes de 2017, el paradigma dominante para procesar secuencias (texto, audio, series temporales) eran las Redes Neuronales Recurrentes (RNNs).

El problema de las RNNs

Las RNNs procesan la secuencia paso a paso, manteniendo un estado oculto \(h_t\) que se actualiza en cada timestep. Esto tiene dos problemas fundamentales:

El modelo seq2seq clásico (Sutskever et al., 2014; arXiv:1409.3215) tenía una limitación crítica: toda la información de la secuencia de entrada se comprimía en un único vector de contexto \(c\) — el último estado oculto del encoder. Para secuencias largas, esto provocaba una pérdida masiva de información.

Las LSTMs y GRUs mitigaron parcialmente el problema de vanishing gradients con gates, pero el cuello de botella y la falta de paralelismo seguían siendo fundamentales.

El nacimiento de la atención (Bahdanau, 2014)

La idea que cambió todo fue simple pero brillante: en lugar de comprimir toda la secuencia en un único vector, permitir que el decoder mire directamente a cada posición del encoder en cada paso de generación.

Bahdanau, Cho & Bengio (2014) propusieron un mecanismo de atención aditiva para modelos seq2seq de traducción automática. En cada paso del decoder \(t\), se calcula un score de atención \(e_{t,i}\) entre el estado del decoder \(s_t\) y cada estado del encoder \(h_i\):

Los pesos \(\alpha_{t,i}\) indican cuánta atención presta el decoder al token \(i\) cuando genera el token \(t\). El vector de contexto \(c_t\) es ahora diferente en cada paso: ya no hay cuello de botella.

Este paper fue un punto de inflexión. De repente, los modelos de traducción mejoraron drásticamente, y la idea de «atención» se convirtió en una herramienta fundamental en el toolkit del deep learning. La atención permitía resolver el problema del cuello de botella: el decoder ya no dependía de un único vector \(c\), sino que podía consultar directamente cada posición del encoder en cada paso de generación. Los pesos de atención \(\alpha_{t,i}\) además proporcionaban interpretabilidad: se podía visualizar exactamente a qué partes de la entrada prestaba atención el modelo.

Atención multiplicativa (Luong, 2015)

Poco después, Luong et al. (2015) propusieron una variante más simple y eficiente: la atención multiplicativa (dot-product attention), que calcula la similitud directamente con un producto escalar:

La atención multiplicativa de Luong tiene la misma capacidad que la aditiva de Bahdanau, pero es más eficiente computacionalmente. La scaled dot-product attention del Transformer es una evolución directa de esta idea.

Self-Attention: el salto conceptual

Hasta 2016, la atención siempre era cross-attention: el decoder mira al encoder. Pero la pregunta clave que llevó al Transformer fue:

Esta idea — la self-attention o autoatención — fue la revolución. En lugar de procesar la secuencia paso a paso (RNN) o con filtros locales (CNN), cada token computa una representación que depende de toda la secuencia, ponderada por relevancia.

El paper "Attention Is All You Need" demostró que con self-attention apilada en varias capas, más normalización y conexiones residuales, se podía superar a las RNNs en traducción automática, y entrenar órdenes de magnitud más rápido gracias a la paralelización.

Historia del Transformer

El paper: "Attention Is All You Need"

El paper de Vaswani et al. (2017) es uno de los más citados en la historia de la IA (>130.000 citas). Propone una arquitectura radicalmente simple que prescinde de toda recurrencia y convolución:

Visión general de la arquitectura

El Transformer original es un modelo encoder-decoder. El encoder procesa la secuencia de entrada completa y genera representaciones contextuales. El decoder genera la secuencia de salida token a token, usando tanto su propia secuencia parcial (self-attention con máscara) como la salida del encoder (cross-attention).

Input Embeddings

El primer paso es convertir cada token (palabra, subpalabra, o carácter) en un vector denso de dimensión \(d_{\text{model}}\). Esto se hace con una capa de embedding aprendida:

En el paper original, \(d_{\text{model}} = 512\). Los embeddings se multiplican por \(\sqrt{d_{\text{model}}}\) para escalar su magnitud relativa al positional encoding:

Positional Encoding: ¿dónde está cada token?

Como el Transformer procesa toda la secuencia en paralelo (sin recurrencia), no tiene noción inherente de orden. Para que sepa que «El gato» es diferente de «gato El», se añade un positional encoding a cada embedding.

El paper original usa funciones sinusoidales con frecuencias diferentes para cada dimensión:

donde \(pos\) es la posición del token en la secuencia e \(i\) es la dimensión. Las dimensiones bajas varían rápidamente (alta frecuencia), las altas varían lentamente (baja frecuencia), creando un patrón único para cada posición.

El Encoder: apilar autoatención

El encoder consiste en \(N\) capas idénticas apiladas (N=6 en el original). Cada capa tiene exactamente dos subcapas:

Cada subcapa tiene una conexión residual y layer normalization:

El Decoder: generar token a token

El decoder también tiene \(N\) capas, pero cada capa tiene tres subcapas:

Capa de salida: Linear + Softmax

La salida del decoder pasa por una capa lineal que proyecta de \(d_{\text{model}}\) al tamaño del vocabulario \(V\), seguida de un softmax para obtener probabilidades:

Hiperparámetros del Transformer original

Comparado con los modelos actuales (GPT-4 tiene ~1.7T parámetros estimados, LLaMA 3 tiene hasta 405B), el Transformer original era sorprendentemente pequeño. La arquitectura ha escalado verticalmente, pero los principios fundamentales son exactamente los mismos.

Widget: explorador de Positional Encoding

Visualiza cómo varían las funciones sinusoidales del positional encoding según la posición y la dimensión. Observa cómo las frecuencias bajas (dimensiones altas) varían lentamente, creando patrones únicos para cada posición.

Scaled Dot-Product Attention

El bloque fundamental del Transformer es la Scaled Dot-Product Attention. Cada token genera tres vectores: una query (\(Q\)), una key (\(K\)) y un value (\(V\)), obtenidos multiplicando la entrada por matrices de pesos aprendidas:

La atención se calcula como:

¿Por qué dividir entre \(\sqrt{d_k}\)?

Cuando \(d_k\) es grande, los dot products \(q \cdot k\) crecen en magnitud, lo que empuja al softmax a regiones de gradientes muy pequeños (saturación). Dividir entre \(\sqrt{d_k}\) normaliza la varianza de los scores a 1, manteniendo los gradientes saludables:

Multi-Head Attention

En lugar de calcular una única función de atención, el Transformer usa múltiples cabezas (heads) que operan en paralelo. Cada head aprende a prestar atención a un tipo diferente de relación:

Con \(h = 8\) cabezas y \(d_{\text{model}} = 512\), cada head trabaja con vectores de dimensión \(d_k = d_v = 512 / 8 = 64\). Los resultados de las 8 heads se concatenan y se proyectan con \(W^O \in \mathbb{R}^{hd_v \times d_{\text{model}}}\).

Self-Attention: paso a paso con ejemplo

Veamos el cálculo completo de self-attention para la frase «El gato duerme» con \(d_k = 4\) (simplificado para visualización):

Cross-Attention: el puente encoder-decoder

En el decoder, además de la self-attention (masked), hay una capa de cross-attention donde:

• Queries (\(Q\)) vienen de la capa anterior del decoder.
• Keys (\(K\)) y Values (\(V\)) vienen de la salida del encoder.

Esto permite al decoder consultar la secuencia de entrada completa en cada paso de generación. Es el equivalente moderno del mecanismo de atención de Bahdanau, pero integrado en la arquitectura del Transformer sin RNNs.

La cross-attention es fundamental en cualquier tarea condicionada: traducción (decoder condicionado al texto fuente), generación de imágenes con texto (modelos de difusión como Stable Diffusion usan cross-attention para inyectar el prompt de texto), y modelos multimodales. En cambio, los modelos decoder-only (GPT, LLaMA) prescinden de cross-attention: solo usan masked self-attention, y toda la información de entrada se proporciona como parte del prompt concatenado.

Masked Self-Attention: no mirar al futuro

En el decoder, la self-attention debe ser causal: el token en la posición \(t\) solo puede atender a las posiciones \(1, 2, \ldots, t\). Esto se implementa sumando una máscara al score antes del softmax:

donde \(M_{ij} = 0\) si \(j \leq i\), y \(M_{ij} = -\infty\) si \(j > i\). Tras el softmax, \(e^{-\infty} = 0\), así que los tokens futuros tienen peso cero.

Complejidad computacional

La self-attention tiene complejidad \(O(n^2 \cdot d)\) donde \(n\) es la longitud de la secuencia y \(d\) es la dimensión. Esto es cuadrático en la longitud, lo que se vuelve problemático para secuencias muy largas.

La tabla anterior revela una tensión fundamental: self-attention ofrece el camino más corto entre cualquier par de tokens (\(O(1)\) vs \(O(n)\) en RNNs), lo que facilita capturar dependencias a larga distancia. Pero su complejidad cuadrática en la longitud de secuencia limita su aplicación a secuencias largas. Esto ha motivado una línea de investigación muy activa en efficient attention, que busca mantener las ventajas de la atención reduciendo su coste computacional.

Widget: explorador de Self-Attention

Escribe una frase y visualiza cómo la self-attention asigna pesos entre tokens. Ajusta la temperatura (escala del softmax) para ver su efecto: valores bajos → atención más uniforme, valores altos → atención más concentrada.

Función de pérdida: Cross-Entropy

El Transformer para traducción/generación se entrena con cross-entropy loss sobre el vocabulario de salida. En cada posición del decoder, el modelo predice una distribución de probabilidad sobre \(V\) tokens y la comparamos con el token correcto:

Optimizador: Adam con warmup

El Transformer usa Adam con un esquema de learning rate especial que combina un warmup lineal con un decay proporcional a la raíz cuadrada inversa del paso:

Con \(\text{warmup\_steps} = 4000\), el learning rate crece linealmente durante los primeros 4000 pasos y luego decrece proporcionalmente a \(1/\sqrt{\text{step}}\).

Teacher Forcing

Durante el entrenamiento, el decoder recibe como entrada la secuencia objetivo desplazada una posición a la derecha (shifted right), en lugar de sus propias predicciones anteriores. Esto se llama teacher forcing:

Implementación: Transformer simplificado

Veamos una implementación limpia del Transformer en PyTorch y TensorFlow. Incluye self-attention, multi-head attention, positional encoding, y el encoder completo.

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

# ─── Positional Encoding (sinusoidal) ───
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(
            torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
        )
        pe[:, 0::2] = torch.sin(position * div_term)   # dimensiones pares
        pe[:, 1::2] = torch.cos(position * div_term)    # dimensiones impares
        pe = pe.unsqueeze(0)  # (1, max_len, d_model)
        self.register_buffer('pe', pe)

    def forward(self, x):
        # x: (batch, seq_len, d_model)
        x = x + self.pe[:, :x.size(1)]
        return self.dropout(x)

# ─── Scaled Dot-Product Attention ───
def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q, K, V: (batch, heads, seq_len, d_k)
    mask: (batch, 1, 1, seq_len) or (1, 1, seq_len, seq_len) for causal
    """
    d_k = Q.size(-1)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))

    attn_weights = F.softmax(scores, dim=-1)
    output = torch.matmul(attn_weights, V)
    return output, attn_weights

# ─── Multi-Head Attention ───
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.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):
        batch_size = Q.size(0)

        # Linear projections + reshape to (batch, heads, seq, d_k)
        Q = self.W_q(Q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

        # Attention
        attn_output, attn_weights = scaled_dot_product_attention(Q, K, V, mask)

        # Concat heads + linear
        attn_output = attn_output.transpose(1, 2).contiguous().view(
            batch_size, -1, self.num_heads * self.d_k
        )
        return self.W_o(attn_output), attn_weights

# ─── Feed-Forward Network ───
class FeedForward(nn.Module):
    def __init__(self, d_model, d_ff, dropout=0.1):
        super().__init__()
        self.linear1 = nn.Linear(d_model, d_ff)
        self.linear2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.linear2(self.dropout(F.relu(self.linear1(x))))

# ─── Encoder Layer ───
class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ffn = FeedForward(d_model, d_ff, dropout)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        # Self-attention + residual + norm
        attn_out, _ = self.self_attn(x, x, x, mask)
        x = self.norm1(x + self.dropout1(attn_out))
        # FFN + residual + norm
        ffn_out = self.ffn(x)
        x = self.norm2(x + self.dropout2(ffn_out))
        return x

# ─── Encoder completo ───
class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model=512, num_heads=8,
                 d_ff=2048, num_layers=6, dropout=0.1, max_len=5000):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = PositionalEncoding(d_model, max_len, dropout)
        self.layers = nn.ModuleList([
            EncoderLayer(d_model, num_heads, d_ff, dropout)
            for _ in range(num_layers)
        ])
        self.d_model = d_model

    def forward(self, x, mask=None):
        # x: (batch, seq_len) of token ids
        x = self.embedding(x) * math.sqrt(self.d_model)
        x = self.pos_encoding(x)
        for layer in self.layers:
            x = layer(x, mask)
        return x

# ─── Uso ───
encoder = TransformerEncoder(vocab_size=32000)
tokens = torch.randint(0, 32000, (2, 50))  # batch=2, seq=50
output = encoder(tokens)
print(output.shape)  # torch.Size([2, 50, 512])

import tensorflow as tf
import numpy as np

# ─── Positional Encoding ───
def positional_encoding(max_len, d_model):
    positions = np.arange(max_len)[:, np.newaxis]
    dims = np.arange(d_model)[np.newaxis, :]
    angles = positions / np.power(10000, (2 * (dims // 2)) / d_model)
    angles[:, 0::2] = np.sin(angles[:, 0::2])
    angles[:, 1::2] = np.cos(angles[:, 1::2])
    return tf.cast(angles[np.newaxis, :, :], dtype=tf.float32)

# ─── Scaled Dot-Product Attention ───
def scaled_dot_product_attention(Q, K, V, mask=None):
    d_k = tf.cast(tf.shape(K)[-1], tf.float32)
    scores = tf.matmul(Q, K, transpose_b=True) / tf.math.sqrt(d_k)
    if mask is not None:
        scores += (mask * -1e9)
    weights = tf.nn.softmax(scores, axis=-1)
    return tf.matmul(weights, V), weights

# ─── Multi-Head Attention ───
class MultiHeadAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        self.wq = tf.keras.layers.Dense(d_model)
        self.wk = tf.keras.layers.Dense(d_model)
        self.wv = tf.keras.layers.Dense(d_model)
        self.wo = tf.keras.layers.Dense(d_model)

    def split_heads(self, x, batch_size):
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.d_k))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, Q, K, V, mask=None):
        batch_size = tf.shape(Q)[0]
        Q = self.split_heads(self.wq(Q), batch_size)
        K = self.split_heads(self.wk(K), batch_size)
        V = self.split_heads(self.wv(V), batch_size)
        attn_out, attn_weights = scaled_dot_product_attention(Q, K, V, mask)
        attn_out = tf.transpose(attn_out, perm=[0, 2, 1, 3])
        attn_out = tf.reshape(attn_out, (batch_size, -1, self.num_heads * self.d_k))
        return self.wo(attn_out), attn_weights

# ─── Encoder Layer ───
class EncoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, d_ff, dropout_rate=0.1):
        super().__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(d_ff, activation='relu'),
            tf.keras.layers.Dense(d_model)
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(dropout_rate)
        self.dropout2 = tf.keras.layers.Dropout(dropout_rate)

    def call(self, x, mask=None, training=False):
        attn_out, _ = self.mha(x, x, x, mask)
        x = self.norm1(x + self.dropout1(attn_out, training=training))
        ffn_out = self.ffn(x)
        x = self.norm2(x + self.dropout2(ffn_out, training=training))
        return x

# ─── Uso ───
encoder_layer = EncoderLayer(d_model=512, num_heads=8, d_ff=2048)
sample = tf.random.uniform((2, 50, 512))
output = encoder_layer(sample)
print(output.shape)  # (2, 50, 512)

Trucos de entrenamiento

Inferencia: generación autoregresiva

En inferencia, el decoder genera un token a la vez. En cada paso, toma toda la secuencia generada hasta el momento, pasa por el decoder, y predice el siguiente token:

La combinación de KV-cache con Flash Attention (Dao et al., 2022) permite una inferencia eficiente incluso para secuencias con cientos de miles de tokens. Flash Attention optimiza los accesos a memoria GPU sin cambiar la complejidad algorítmica, logrando speedups de 2–4× en la práctica. Esto, junto con técnicas como speculative decoding y quantization (INT8, INT4), hace viable servir modelos con miles de millones de parámetros en tiempo real.

El éxito del Transformer en NLP

La arquitectura Transformer transformó (literalmente) el procesamiento de lenguaje natural. La idea clave fue el pre-training a gran escala: entrenar un Transformer enorme con cantidades masivas de texto, y luego fine-tunear para tareas específicas. Esto dio lugar a dos paradigmas fundamentales:

Y existe un tercer paradigma que combina ambos:

BERT: Bidirectional Encoder Representations from Transformers

BERT (Devlin et al., 2018) fue el primer modelo que demostró el poder del pre-training bidireccional. Solo usa el encoder del Transformer.

BERT estableció el paradigma de pre-training + fine-tuning que dominaría el NLP durante años. La idea de enmascarar tokens y predecirlos (MLM) fuerza al modelo a construir representaciones contextuales ricas — cada token codifica información sobre todos los demás. Tras BERT, surgieron variantes mejoradas como RoBERTa (Liu et al., 2019), que eliminó el objetivo NSP y usó más datos y batch sizes mayores, y DeBERTa (He et al., 2020), que introdujo atención con codificación de posición relativa (disentangled attention).

GPT: Generative Pre-trained Transformer

GPT (Radford et al., 2018) toma el camino opuesto a BERT: usa solo el decoder del Transformer con masked self-attention (causal), entrenado para predecir el siguiente token.

La familia GPT demostró que el enfoque decoder-only con pre-training autoregresivo escala extraordinariamente bien. Cada generación multiplicó los parámetros y los datos, y con GPT-3 emergió la capacidad de in-context learning: resolver tareas nuevas simplemente proporcionando ejemplos en el prompt, sin reentrenamiento (few-shot). Esta propiedad emergente transformó la forma de usar modelos de lenguaje.

BERT vs GPT: dos filosofías

T5: Text-to-Text Transfer Transformer

T5 (Raffel et al., 2019) unifica todas las tareas NLP bajo un mismo formato: text-to-text. Usa el Transformer completo (encoder-decoder) y trata cada tarea como una traducción entre textos:

LLMs: Large Language Models

Un Large Language Model (LLM) es un Transformer (generalmente decoder-only) entrenado con cantidades masivas de texto. A partir de cierta escala (~10B+ parámetros), emergen capacidades que no existían en modelos más pequeños:

Widget: visualizador de atención en traducción

Explora cómo funciona la cross-attention en un modelo de traducción. La matriz muestra cuánta atención presta cada token de salida (decoder) a cada token de entrada (encoder). Selecciona un par de frases y ajusta los parámetros.

Transformers más allá del NLP

Lo que empezó como una arquitectura para traducción de texto se ha convertido en la columna vertebral de toda la IA moderna. La idea clave —procesar secuencias con self-attention en paralelo— funciona igual de bien con píxeles, ondas de audio, series temporales o combinaciones multimodales.

Vision Transformers (ViT)

ViT (Dosovitskiy et al., 2020) fue la primera demostración contundente de que los Transformers pueden competir con las CNNs en visión. La idea es radical por su simplicidad:

La línea de investigación de Vision Transformers ha convergido con los modelos generativos: los foundation models visuales como DINOv2 y SAM producen representaciones que sirven para casi cualquier tarea visual (clasificación, segmentación, detección) sin entrenamiento específico — el equivalente visual de BERT. También puedes ver cómo se aplican los Transformers en el submódulo de difusión, donde DiT ha reemplazado a la U-Net como backbone de referencia.

Transformers para audio: Whisper

Whisper (Radford et al., 2022, OpenAI) es un Transformer encoder-decoder entrenado con 680.000 horas de audio (weakly supervised) que puede:

Transformers para series temporales

Las series temporales son secuencias — el dominio natural del Transformer. Varios modelos adaptan self-attention para capturar dependencias temporales complejas:

Las series temporales representan un campo donde la tensión entre la complejidad cuadrática de self-attention y la longitud de las secuencias es especialmente crítica. Modelos como PatchTST (Nie et al., 2023) mitigan esto agrupando timestamps en parches (como ViT con píxeles), reduciendo la longitud de secuencia efectiva. iTransformer (Liu et al., 2023) va más allá: invierte la dimensión de atención, aplicando self-attention sobre las variables (canales) en lugar de sobre los timestamps, lo que captura mejor las correlaciones entre sensores o indicadores.

DiT: Diffusion Transformer

DiT (Peebles & Xie, 2023) reemplaza la U-Net de los modelos de difusión por un Transformer. La idea: en lugar de aplicar convoluciones para predecir el ruido, usar self-attention sobre parches del latent space.

Transformers multimodales

La misma arquitectura puede procesar múltiples modalidades simultáneamente: tokenizar cada modalidad, concatenar o intercalar, y dejar que self-attention aprenda las relaciones cross-modal.

Papers y recursos fundamentales