El mecanismo de atención, finalmente explicado (sin álgebra matricial)

En la Parte 6, Lina le dio una memoria a sus redes recurrentes. Las LSTM y GRU resolvieron el problema del gradiente desvanecido usando compuertas para proteger la información importante mientras fluye a través del tiempo. Incluso con una memoria perfecta, una red todavía tiene que procesar cada palabra en una oración para entenderla.

Imagina que Lina está revisando una sesión de cliente con 500 vistas de página. Su LSTM tiene una memoria perfecta de cada página. Cuando llega a la página 437 y ve “el cliente añadió una garantía premium”, no necesita releer las 436 páginas anteriores para entender por qué. Salta directamente a las partes que importan—tal vez el momento en que vieron el producto costoso que protege. Ella presta atención a las partes relevantes.

Eso es lo que hace la atención. Permite que una red neuronal omita lo irrelevante y se enfoque en lo que importa ahora mismo. De hecho, funciona tan bien que se ha convertido en la base de todos los modelos de lenguaje principales hoy en día, desde GPT hasta Claude. Construyámoslo desde cero—sin necesidad de álgebra matricial.

1. El problema de búsqueda en la biblioteca

Piensa en una red neuronal tradicional como una bibliotecaria con un pésimo sistema de archivos. Le pides un libro sobre “recetas de pastel de manzana”. En lugar de sacar solo los libros de pasteles, ella intenta recordar todo lo que hay en la biblioteca a la vez —libros de cocina, de historia, novelas— y luego, de alguna manera, averigua qué partes importan para tu pregunta.

Eso es agotador e ineficiente. ¿Y si la bibliotecaria tuviera un sistema de búsqueda inteligente en su lugar? Escribes “recetas de pastel de manzana” en una barra de búsqueda y el sistema encuentra únicamente los libros cuyos títulos y etiquetas coinciden. Ella saca esos. El resto lo ignora.

La atención es exactamente ese sistema de búsqueda. Le permite a la red preguntar qué palabras, de las que ha visto hasta ahora, son las más relevantes para lo que está haciendo en este momento.

Comienza con la versión más simple. Toma la oración “The manager approved the billing charge.” Cuando la red procesa la palabra “charge”, necesita averiguar si se trata de un cargo por facturación o de la carga de una batería. La respuesta depende de palabras cercanas como “manager” y “billing”.

La versión ideal de la atención es una simple tabla de búsqueda.

# Our sentence: "The manager approved the billing charge."
# Let's represent each word as a simple number (in reality, it's a vector)
sentence = {
    'The': 0.1,
    'charge': 0.5,
    'manager': 0.7,
    'approved': 0.6,
    'the': 0.1,
    'billing': 0.8
}

# When we're processing 'charge', we ask: which words are most relevant?
# In a perfect world, we'd have a lookup table that tells us
relevance_to_charge = {
    'The': 0.0,        # Not relevant
    'charge': 1.0,     # Very relevant (it's the word itself)
    'manager': 0.9,    # Very relevant (tells us what kind of charge)
    'approved': 0.6,   # Somewhat relevant
    'the': 0.0,        # Not relevant
    'billing': 0.8     # Very relevant (financial context)
}

# Now we take a weighted average of all the words
attended_representation = 0.0
for word, relevance in relevance_to_charge.items():
    attended_representation += sentence[word] * relevance

print(f"Attended representation of 'charge': {attended_representation:.2f}")

• sentence = {...} — Un diccionario que asigna a cada palabra de la oración un valor escalar. En un sistema real, cada palabra sería un vector de alta dimensión (p. ej., 512 números), no un solo número de coma flotante.
• relevance_to_charge = {...} — Una búsqueda predefinida de qué tan relevante es cada palabra para “charge”. En un mecanismo de atención real, estos pesos se aprenden de los datos utilizando interacciones de Query–Key, no se asignan manualmente.
• for word, relevance in relevance_to_charge.items() — Itera sobre cada par palabra–relevancia en el diccionario.
• attended_representation += sentence[word] * relevance — Multiplica el valor de cada palabra por su peso de relevancia y acumula la suma. Este es el “promedio ponderado” central que la atención calcula — la misma operación que un producto punto entre los pesos de relevancia y los valores de las palabras.

Lo que esto significa en realidad: Multiplicamos el valor de cada palabra por su relevancia y luego los sumamos todos. El resultado es una nueva representación de “cargo” enriquecida con información del contexto más relevante. Las palabras “gerente” y “facturación” desplazaron el significado hacia “cargo por facturación” en lugar de “carga de batería”.

Un problema: no existe una tabla de búsqueda mágica que nos indique la relevancia de cada palabra. Tenemos que aprenderla. Ahí es donde entran en juego las consultas, las claves y los valores.

2. Consultas, claves y valores: Los tres mosqueteros

Aquí es donde la mayoría de la gente se confunde. Olvida la terminología por un momento y piensa en lo que realmente está sucediendo.

Digamos que estás en YouTube. Escribes “videos de gatos” en la barra de búsqueda. El algoritmo necesita:

1. Entender lo que estás buscando (“videos de gatos”)
2. Comprobar el título y las etiquetas de cada video para ver si coinciden
3. Devolver los videos reales que coinciden

El mecanismo de atención funciona de la misma manera:

1. Consulta (Q): Lo que estás buscando (“videos de gatos”)
2. Clave (K): Los títulos y etiquetas de los videos (contra lo que el algoritmo compara)
3. Valor (V): El contenido real del video (lo que ves una vez que encuentras una coincidencia)

El truco: las tres provienen de la misma fuente: la oración de entrada. Simplemente la transformamos de tres maneras diferentes.

import numpy as np

# Let's say we have a word represented as a vector
# (In reality, this would be a 512-dimensional vector from a neural network,
# but we'll use 4 dimensions for simplicity)
word_embedding = np.array([0.5, 0.2, 0.8, 0.1])

# We create three different "views" of this word
# by multiplying it by three different learned weight matrices
# (These weights are trained by the network)

W_q = np.array([[0.1, 0.2, 0.3, 0.4],
                 [0.5, 0.6, 0.7, 0.8]])

W_k = np.array([[0.9, 0.8, 0.7, 0.6],
                 [0.5, 0.4, 0.3, 0.2]])

W_v = np.array([[0.1, 0.1, 0.1, 0.1],
                 [0.2, 0.2, 0.2, 0.2]])

# The Query: "What am I looking for?"
query = W_q @ word_embedding
print(f"Query: {query}")

# The Key: "What am I?"
key = W_k @ word_embedding
print(f"Key: {key}")

# The Value: "Here's my actual content"
value = W_v @ word_embedding
print(f"Value: {value}")

• word_embedding = np.array([0.5, 0.2, 0.8, 0.1]) — Un vector de 4 dimensiones que representa una palabra. Los sistemas reales usan 512+ dimensiones, pero 4 es suficiente para ver la mecánica.
• W_q, W_k, W_v — Tres matrices de peso aprendidas, cada una de forma (2, 4). Transforman el mismo embedding 4D en tres “vistas” 2D diferentes: Consulta, Clave y Valor. Estas matrices son lo que la red entrena.
• query = W_q @ word_embedding — Multiplicación de matrices: la matriz (2, 4) por el vector (4,) produce un vector (2,). Esta es la vista de “¿qué estoy buscando?”.
• key = W_k @ word_embedding — Misma operación con W_k, produciendo la vista de “¿qué soy?”.
• value = W_v @ word_embedding — Misma operación con W_v, produciendo la vista de “aquí está mi contenido real”.
• El operador @ es el operador de multiplicación de matrices de NumPy, equivalente a np.matmul().

Lo que esto significa en la práctica: Tomamos una palabra y creamos tres versiones diferentes de ella. La Consulta pregunta “¿Qué información necesito?”. La Clave dice “Esto es lo que contengo”. El Valor dice “Aquí están los datos reales”.

La parte difícil es internalizar que Q, K y V son solo diferentes perspectivas sobre los mismos datos. No son tres cosas separadas. La misma palabra llevando tres máscaras diferentes. La red aprende qué aspecto debería tener cada máscara para que la consulta pueda encontrar las claves más relevantes y extraer sus valores.

3. El puntaje de similitud: ¿Qué tan cerca estamos?

Ahora tenemos un Query (lo que estamos buscando) y un conjunto de Keys (lo que contiene cada palabra). Necesitamos una forma de medir: “¿Cuánto coincide este Key con este Query?”

La matemática aquí es directa. Multiplicamos el Query y el Key juntos. Si apuntan en la misma dirección —ambos tienen números positivos grandes en las mismas posiciones— el resultado es grande. Si apuntan en direcciones opuestas, el resultado es pequeño o negativo.

Veámoslo en acción.

import numpy as np

# Our Query: what we're looking for
query = np.array([1.0, 0.5])

# Keys from different words in the sentence
key_manager = np.array([0.9, 0.6])   # Similar to query
key_battery = np.array([0.1, 0.2])   # Different from query (the wrong meaning)
key_billing = np.array([0.95, 0.55]) # Very similar to query

# The similarity score is just the dot product (multiply and sum)
def similarity_score(query, key):
    return np.dot(query, key)

print(f"Similarity to 'manager': {similarity_score(query, key_manager):.2f}")
print(f"Similarity to 'battery': {similarity_score(query, key_battery):.2f}")
print(f"Similarity to 'billing': {similarity_score(query, key_billing):.2f}")

• query = np.array([1.0, 0.5]) — El vector de consulta para la palabra “charge”: lo que está “buscando” en el resto de la oración.
• key_manager, key_battery, key_billing — Vectores clave para tres palabras candidatas. Cada uno es un vector 2D; cuanto más cercano esté al query, mayor será su puntaje de similitud.
• def similarity_score(query, key): return np.dot(query, key) — El producto punto: multiplicar los elementos correspondientes y luego sumarlos. Esta es la forma estándar de medir cuánto dos vectores “apuntan en la misma dirección.”
• np.dot([1.0, 0.5], [0.9, 0.6]) = 1.0×0.9 + 0.5×0.6 = 0.9 + 0.3 = 1.2 — El puntaje de “manager” es alto porque el vector clave es similar al query.
• np.dot([1.0, 0.5], [0.1, 0.2]) = 0.1 + 0.1 = 0.2 — El puntaje de “battery” es bajo porque el vector clave apunta en una dirección muy diferente.

Qué significa esto en realidad: El puntaje para “manager” es 1.20. Para “battery” es 0.20. Para “billing” es 1.23. Estos números le indican al modelo dónde enfocarse —cuanto mayor sea el puntaje, más relevante es la palabra para el query.

Pero estos puntajes sin procesar vienen en tamaños muy diferentes, y compararlos directamente es difícil. ¿Qué pasaría si tuviéramos una oración con 100 palabras? Obtendríamos 100 números diferentes —algunos enormes, otros diminutos. Al modelo le costaría interpretarlos. Ahí es donde entra softmax.

4. El Softmax: De puntajes a porcentajes

Softmax toma cualquier lista de números y los convierte en porcentajes que suman 1.0 (o 100%). Piénsalo como una perilla de volumen: amplifica los números grandes y empuja los pequeños hacia el fondo.

El problema es este: las puntuaciones de similitud sin procesar pueden tener cualquier tamaño. Una palabra podría puntuar 0.2, otra 50. La red no tiene forma de interpretar ese rango. Pero al convertirlas a porcentajes —“Esta palabra recibe el 5% de mi atención, esa recibe el 60%”— la imagen se vuelve más nítida.

import numpy as np

# Our similarity scores from the previous section
scores = np.array([1.2, 0.2, 1.225])

# Softmax formula: for each score, calculate e^score, then divide by the sum
def softmax(scores):
    # First, exponentiate each score
    exp_scores = np.exp(scores)
    # Then divide each by the sum of all exponentials
    return exp_scores / np.sum(exp_scores)

attention_weights = softmax(scores)
print(f"Attention weights: {attention_weights}")
print(f"Sum of weights: {np.sum(attention_weights):.4f}")
print(f"As percentages: {attention_weights * 100}")

• scores = np.array([1.2, 0.2, 1.225]) — Puntuaciones de similitud sin procesar de los productos punto en la sección anterior. No están acotadas; podrían ser cualquier número positivo o negativo.
• np.exp(scores) — Eleva cada puntuación al exponente: $e^{1.2}$, $e^{0.2}$, $e^{1.225}$. Esto es lo que hace que el softmax sea “soft” (suave): las puntuaciones más grandes obtienen proporciones exponencialmente mayores, por lo que la brecha entre palabras relevantes e irrelevantes se amplía.
• exp_scores / np.sum(exp_scores) — Divide cada puntuación exponenciada entre el total para que todos los pesos sumen exactamente 1.0. Esto es lo que convierte las puntuaciones sin procesar en “porcentajes de atención”.
• np.sum(attention_weights) — Verifica que los pesos sumen 1.0 por construcción.
• attention_weights * 100 — Muestra los pesos como porcentajes para legibilidad humana (42% en lugar de 0.42).

Lo que esto significa en realidad: Las puntuaciones sin procesar eran [1.2, 0.2, 1.225]. Después de softmax, se convirtieron aproximadamente en [0.42, 0.15, 0.43]. Presta aproximadamente un 42% de atención a “gerente”, un 15% a “batería” y un 43% a “facturación”. Suman 100%.

Observa el patrón: “gerente” y “facturación” comenzaron cerca (1.2 frente a 1.225) y se mantuvieron cercanos como pesos (42% frente a 43%), mientras que “batería”—el evidente valor atípico en 0.2—se redujo al 15%. Softmax no reescala las cosas de forma lineal. Amplía la brecha entre el valor atípico y todo lo competitivo. Eso es lo que queremos aquí: el modelo debería ignorar en su mayoría a “batería” y dividir su atención entre las dos palabras que realmente explican a qué tipo de carga o cargo nos referimos.

5. Poniéndolo todo junto: La suma ponderada

Ahora tenemos los pesos de atención para cada palabra. Tomamos esos pesos, los multiplicamos por los valores reales de las palabras (las V de antes) y los sumamos. El resultado: una nueva representación de nuestra palabra original, enriquecida con contexto.

Ejecutemos el cálculo completo de extremo a extremo.

import numpy as np

# Step 1: Create Q, K, V for each word in our sentence
# (In reality, these come from a neural network. We'll use simple numbers.)

words = ['charge', 'manager', 'billing']

# Queries, Keys, and Values (simplified as 2D vectors)
queries = {
    'charge': np.array([1.0, 0.5]),
    'manager': np.array([0.8, 0.6]),
    'billing': np.array([0.9, 0.7])
}

keys = {
    'charge': np.array([0.95, 0.55]),
    'manager': np.array([0.9, 0.6]),
    'billing': np.array([0.92, 0.65])
}

values = {
    'charge': np.array([0.5, 0.2]),
    'manager': np.array([0.7, 0.4]),
    'billing': np.array([0.8, 0.5])
}

# Step 2: Calculate similarity scores
query_charge = queries['charge']
scores = []
for word in words:
    score = np.dot(query_charge, keys[word])
    scores.append(score)

scores = np.array(scores)
print(f"Raw similarity scores: {scores}")

# Step 3: Apply softmax to get attention weights
def softmax(x):
    return np.exp(x) / np.sum(np.exp(x))

attention_weights = softmax(scores)
print(f"Attention weights: {attention_weights}")

# Step 4: Weighted sum of values
attended_output = np.zeros(2)  # Same dimension as our values
for i, word in enumerate(words):
    attended_output += attention_weights[i] * values[word]

print(f"Original 'charge' value: {values['charge']}")
print(f"After attention: {attended_output}")
print(f"\nWhat happened: The word 'charge' got enriched with context from 'manager' and 'billing'.")
print(f"The output is closer to the meaning of 'billing charge' because those words dominated the attention.")

• words = ['charge', 'manager', 'billing'] — Las tres palabras en nuestra frase de juguete sobre las que aplicaremos la atención.
• queries, keys, values — Tres diccionarios, cada uno mapea una palabra a su vector Q, K o V (2D). En un transformer real, estos provienen de proyecciones lineales aprendidas de los embeddings de entrada.
• query_charge = queries['charge'] — La consulta para la palabra “charge”: lo que está “buscando” en el resto de la frase.
• for word in words: score = np.dot(query_charge, keys[word]) — Calcula la similitud de producto punto entre la consulta y cada clave, produciendo una puntuación bruta por palabra.
• scores = np.array(scores) — Convierte la lista de puntuaciones en un arreglo de NumPy para poder aplicar softmax de forma vectorizada.
• attention_weights = softmax(scores) — Convierte las puntuaciones brutas en porcentajes que suman 1.0.
• attended_output = np.zeros(2) — Inicializa la salida como un vector de ceros con la misma dimensionalidad que los vectores de valores (2D).
• for i, word in enumerate(words): attended_output += attention_weights[i] * values[word] — La suma ponderada: cada valor se multiplica por su peso de atención y se acumula. Esta es la representación “atendida” final.
• enumerate(words) — Produce pares (index, word) para poder indexar en attention_weights por posición y al mismo tiempo buscar en values por nombre.

Lo que esto significa realmente: Empezamos con “charge” como [0.5, 0.2]. Después de la atención, se convirtió aproximadamente en [0.67, 0.37]. Los números cambiaron porque mezclamos información de “manager” y “billing.” Los pesos de atención aquí —aproximadamente 33%, 33% y 34%— son todos bastante cercanos. En este ejemplo simplificado, los tres vectores clave resultan ser similares a la consulta. Una red entrenada generalmente produciría una división más marcada una vez que sus consultas y claves reflejen patrones reales aprendidos. Coloca “charge” en un contexto diferente —“la carga de la batería del teléfono estaba baja”— y la atención se desplazaría hacia “batería” en su lugar. La salida sería diferente.

Esta es la magia de la atención: la misma palabra obtiene una representación diferente según el contexto. La red no necesita memorizar cada significado de “charge.” Solo aprende a combinar los significados de las palabras cercanas en función de su relevancia.

El panorama completo

Aquí está lo que hemos construido, paso a paso:

1. Consulta: “¿Qué estoy buscando?” (derivada de la palabra actual)
2. Claves: “¿Qué contiene cada palabra?” (derivadas de todas las palabras en la oración)
3. Similitud: “¿Cuánto coincide cada clave con mi consulta?” (producto punto)
4. Softmax: “Convierte esos puntajes en porcentajes” (para que sumen 100%)
5. Suma ponderada: “Mezcla los valores según los porcentajes” (obtiene la salida final)

Todo el proceso se llama Scaled Dot-Product Attention. La parte de “escalado” se refiere a un detalle que omitimos: en la práctica, dividimos los puntajes de similitud por la raíz cuadrada de la dimensión antes de aplicar softmax. Esto evita que los números se vuelvan demasiado grandes, lo que reduciría los gradientes y estancaría el entrenamiento. La intuición sigue siendo la misma, sin embargo.

Atención por producto punto escalado

La operación completa de atención, en una línea:

$\text{Attention}(Q, K, V) = \text{softmax}\!\left(\frac{QK^T}{\sqrt{d_k}}\right)V$

Lenguaje sencillo	Símbolo estadístico	Equivalente en Python
Consulta (qué estoy buscando)	$Q$	query / queries
Clave (qué contiene cada palabra)	$K$	key / keys
Valor (el contenido real a mezclar)	$V$	value / values
Puntajes de similitud sin procesar (productos punto)	$QK^T$	np.dot(query, key)
Dimensión de la clave (número de características por vector)	$d_k$	len(key)
Factor de escala (mantiene los puntajes estables)	$\sqrt{d_k}$	np.sqrt(len(key))
Pesos de atención (porcentajes que suman 1)	$\text{softmax}(\cdot)$	softmax(scores)
Salida final atendida	$\text{Attention}(Q,K,V)$	attended_output

El escalado por $\sqrt{d_k}$ evita que los puntajes del producto punto crezcan demasiado cuando la dimensión de la clave es alta — sin él, el softmax se saturaría y los gradientes desaparecerían (el mismo problema que Lina vio en la Parte 5, reapareciendo en una nueva forma).

Atención vs. RNN/LSTM: ¿Qué enfoque para dependencias de largo alcance?

Enfoque	Qué hace	Mejor para	Compromiso
RNN / LSTM	Procesa los tokens uno a la vez, transportando un estado oculto (y un estado de celda para LSTM) a través de los pasos. La señal debe sobrevivir cada paso intermedio para llegar al final.	Secuencias de cortas a medianas; tareas donde el orden temporal es inherentemente secuencial; entornos de memoria limitada donde no puedes permitirte el cómputo de $O(n^2)$.	La señal se degrada en largas distancias incluso con las compuertas. No puede “saltar” pasos irrelevantes — el modelo debe procesar cada token entre la señal y el punto donde se necesita.
Atención	Calcula puntajes de relevancia entre cada par de tokens simultáneamente, y luego mezcla los valores basándose en esos puntajes. El modelo “salta directamente” al contexto relevante.	Secuencias largas donde importa un contexto distante específico; entrenamiento paralelizable (sin dependencia secuencial entre los pasos).	Memoria y cómputo de $O(n^2)$ — cada token atiende a los demás tokens. Sin conciencia inherente del orden de las palabras sin codificación posicional.

Regla general: Si la señal clave está 500 pasos atrás, un LSTM tiene que protegerla a través de 500 actualizaciones intermedias — son 500 oportunidades para que se degrade. La atención simplemente calcula un puntaje de relevancia entre el token actual y ese token distante directamente, en un solo paso. El costo es la escalabilidad cuadrática y no tener un sentido de orden incorporado. Lina recurriría a la atención cuando necesita encontrar una señal específica a lo largo de una sesión larga sin depender de que esta sobreviva a una cadena de compuertas.

A continuación en esta serie, Lina verá cómo ejecutar este mecanismo de atención múltiples veces en paralelo (llamado “atención multicabezal”) y cómo apilar estas capas para construir un Transformer completo. Por ahora, tienes la idea central: la atención es un sistema de búsqueda que permite a las redes neuronales enfocarse en lo que importa.

Lo que aprendiste:

• La atención se enfoca en las partes relevantes de la entrada
• Consulta, Clave y Valor son tres transformaciones aprendidas de los mismos datos
• Las puntuaciones de similitud miden cuánto coincide una Clave con una Consulta
• Softmax convierte las puntuaciones en porcentajes (pesos de atención)
• El resultado final es una suma ponderada de Valores, guiada por los pesos de atención
• La misma palabra obtiene representaciones diferentes según el contexto

Lina ya ha detectado una limitación, sin embargo. La atención básica trata la oración como una bolsa de palabras—no le importa en absoluto el orden de las palabras. “El gerente aprobó el cargo de facturación” y “El cargo de facturación aprobó al gerente” se verían casi idénticos para la atención simple. En la Parte 8, Lina solucionará esto con codificación posicional y dividirá esta única cabeza de atención en múltiples. La atención multicabezal permite a la red atender diferentes aspectos de los datos a la vez. Nos vemos allí.

Comprueba tu comprensión

Las preguntas a continuación avanzan desde el simple recuerdo hasta el diseño abierto, siguiendo aproximadamente la Taxonomía de Bloom.

Recordar ¿Qué representan Query, Key y Value cada uno en el mecanismo de atención?

Comprender Con tus propias palabras, explica por qué la palabra “charge” necesita una representación vectorial diferente dependiendo de si la oración trata sobre facturación o sobre la batería de un teléfono.

Aplicar Usando el método de puntuación de similitud del artículo (el producto escalar de Query y Key), calcula la similitud entre query = [0.5, 1.0] y key = [0.8, 0.3].

Analizar En el ejemplo completo y detallado del artículo, los tres pesos de atención (aproximadamente 33%, 33% y 34%) terminaron siendo casi iguales, a pesar de que las puntuaciones de similitud sin procesar no eran idénticas. Explica paso a paso cómo deberían verse los vectores Query y Key de un transformer real para que el modelo decida con confianza que “charge” significa “cargo de facturación”, en lugar de terminar en una división casi equitativa.

Evaluar Softmax siempre hace que los pesos de atención sumen 100%. Critica esta decisión de diseño: ¿qué sucede si ninguna de las palabras en una oración es realmente relevante para la palabra que se está procesando? ¿Forzar a que los pesos sumen 100% maneja esto de forma adecuada, o genera un problema?

Crear Diseña una oración de ejemplo de 3 palabras (diferente de “the manager approved the billing charge”) donde una palabra sea genuinamente ambigua entre dos significados muy diferentes, tal como lo es “charge” en este artículo. Nombra ambos significados y qué palabras cercanas desambiguarían cada uno.

---

Artículos relacionados

• LSTM y GRU: dándole memoria a las redes
• Atención de múltiples cabezas y codificación posicional: dándole a los Transformers un sentido de orden

Referencias y lecturas adicionales

• Bahdanau, D., Cho, K., & Bengio, Y. (2014). “Neural Machine Translation by Jointly Learning to Align and Translate.” Actas de ICLR 2015. — El artículo que introdujo la atención aditiva, el primer mecanismo de atención aplicado a la traducción automática neuronal, permitiendo al decodificador “mirar hacia atrás” a las palabras de origen relevantes en lugar de depender de un vector de contexto de longitud fija.
• Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). “Attention Is All You Need.” Avances en Sistemas de Procesamiento de Información Neuronal (NeurIPS 2017). — El artículo que introdujo la arquitectura Transformer, reemplazando la recurrencia por completo con atención de producto escalar escalada y atención multicabezal.

---