Por qué dividir por sqrt(d_k)

Una Matriz de Puntuación

Una vez que Q & K existen (cada una con forma (T, d_k)), la atención calcula una matriz de puntuación:

scores = Q · K^T     # shape: (T, T)

scores[i, j] = qué tan fuertemente se alinea la consulta de la posición i con la clave de la posición j. Cada par (i, j) obtiene una puntuación: 1024 × 1024 = 1,048,576 puntuaciones por cabeza de atención por pasada hacia adelante.

Por qué dividir

Los productos punto de dos vectores unitarios aleatorios de dimensión d tienen una magnitud del orden de sqrt(d). Sin escalado, las puntuaciones crecen con d_k:

- d_k = 64: productos punto típicos del orden de 8.

- d_k = 256: productos punto típicos del orden de 16.

- d_k = 4096: productos punto típicos del orden de 64.

Puntuaciones grandes producen un softmax picudo (una posición domina, los gradientes desaparecen en otros lugares). El entrenamiento se estanca. La escalada corrige una magnitud:

scaled_scores = (Q · K^T) / sqrt(d_k)

Para ANDREA-120M, sqrt(d_k) = sqrt(64) = 8. Cada puntaje se divide por 8. Las magnitudes se mantienen aproximadamente a escala unitaria independientemente de d_k. Softmax se mantiene bien comportado. Los gradientes fluyen.

Justificación Original de Vaswani

De Attention Is All You Need (2017): 'Para grandes valores de d_k, los productos punto crecen en magnitud, empujando la función softmax a regiones donde tiene gradientes extremadamente pequeños.' Un divisor sqrt(d_k) contrarresta ese crecimiento.

Una Vista de Código

Dentro de microgpt_cuda.cu, este escalado aparece como una división literal:

scores[i][j] = dot(Q[i], K[j]) * (1.0f / sqrtf(d_k));

Una multiplicación de float por puntuación. Barato. Crítico.

Escala en d_model = 4096

Por qué la Posición i No Puede Ver la Posición j > i

Una Restricción Nacida de la Generación

ANDREA genera un token a la vez. Durante la inferencia, la posición 0 produce un primer token, luego la posición 1 ve la salida de la posición 0 & produce un segundo token, & así sucesivamente. Un modelo nunca tiene acceso a tokens futuros durante la generación.

El entrenamiento debe reflejar esto. Si durante el entrenamiento la posición 5 pudiera atender a la posición 6, un modelo aprendería un atajo: 'predecir el token 6 leyendo el token 6'. Durante la inferencia, ese atajo desaparece (el token 6 aún no existe). El comportamiento de entrenamiento-versus-inferencia de un modelo divergiría catastróficamente.

Una Máscara

Una máscara causal bloquea la atención desde cualquier posición i hacia cualquier posición j > i. Implementación: establecer scaled_scores[i][j] = -infinity dondequiera que j > i. Después del softmax, esas entradas se convierten en exp(-inf) = 0. La máscara anula la atención a posiciones futuras de manera limpia.

for i in range(T):
for j in range(T):
if j > i:
scaled_scores[i][j] = -1e9   # efectivamente -inf

Después del softmax (por fila), cada fila suma 1, pero solo las entradas [0, i] llevan masa de probabilidad. La posición i mezcla información solo de posiciones pasadas.

Visualizando una Máscara

Una matriz de puntuaciones de forma (T, T) con máscara aplicada se ve como una estructura triangular inferior:

scaled_scores después de la máscara, softmax fila por fila:

fila 0:  [1.0, 0,   0,   0,   ...]   # solo se ve a sí misma
fila 1:  [0.4, 0.6, 0,   0,   ...]   # ve las posiciones 0, 1
fila 2:  [0.2, 0.3, 0.5, 0,   ...]   # ve 0, 1, 2
fila 3:  [0.1, 0.2, 0.3, 0.4, ...]   # ve 0, 1, 2, 3
...

Distribución de probabilidad estrictamente triangular inferior por fila. El futuro permanece invisible.

Por qué un Transformer solo de Decoder necesita esto

Los modelos solo-decodificador como ANDREA, GPT y LLaMA comparten un objetivo: predecir el siguiente token a partir de los anteriores. Una máscara causal hace que ese objetivo sea entrenable en paralelo: cada posición calcula su propia predicción del siguiente token al mismo tiempo, y ninguna posición hace trampa mirando hacia adelante.

Máscara y Sabor

De Puntuaciones a Salida

Softmax: De puntuaciones a probabilidades

Las puntuaciones escaladas enmascaradas aún varían sobre números reales. Softmax convierte cada fila en una distribución de probabilidades:

A[i][j] = exp(scaled_scores[i][j]) / sum_k exp(scaled_scores[i][k])

Tres propiedades resultan:

- A[i][j] >= 0 para todo (i, j).

- sum_j A[i][j] = 1 para cada fila i.

- Puntuaciones crudas más grandes producen probabilidades más grandes (monótona).

El vector de probabilidades de la fila i le dice al modelo: ¿cuánto debe atender la posición i a cada posición previa al calcular su salida?

Suma ponderada de V

Una salida final de atención para la posición i:

output[i] = sum_j A[i][j] · V[j]

Cada vector de valor V[j] se pondera por la probabilidad de atención A[i][j], luego se suman. La salida de la posición i combina vectores de valor de cada posición previa, ponderados por relevancia.

En forma matricial, todas las posiciones a la vez:

Attention(Q, K, V) = softmax(mask(Q · K^T / sqrt(d_k))) · V

Una línea. Todo un mecanismo de atención. Vaswani et al. escribieron esa línea en 2017; los transformadores no han cambiado fundamentalmente desde entonces.

Forma de Salida por Cabeza

Salida de una cabeza de atención: forma (T, d_k). Para ANDREA-120M: (1024, 64). Todas las 12 cabezas computan en paralelo; sus salidas se concatenan a (1024, 768) & se alimentan a una proyección lineal final (W_O), luego a un bloque transformer MLP.

La Actividad 6 (grow_a_language_model_multi_head) cubre una división multi-cabeza. La Actividad 7 (grow_a_language_model_transformer_block) cubre todo lo que rodea la atención: conexiones residuales, normalización de capa, MLP.

Sintetiza un Pipeline