Lección 20 · 06 Tu mini modelo de lenguaje

La atención, la pieza clave del Transformer

Un Transformer decide qué palabras anteriores importan para predecir la siguiente. Ese mecanismo se llama atención y cabe en tres funciones que vas a escribir tú.

El problema que resuelve

En la sección anterior convertiste texto en números. Ahora el modelo tiene que predecir el siguiente token. Para eso no le basta con mirar el último: en «el gato de mi vecina come», para acertar «come» importa «gato», que está lejos.

La atención deja que cada posición mire a todas las anteriores y decida cuánto le importa cada una. Cada token tiene tres vectores:

  • una consulta (q): qué estoy buscando;
  • una clave (k): qué ofrezco;
  • un valor (v): qué aporto si me eligen.

Lo que importa una posición a otra es el producto escalar de la consulta de una con la clave de la otra: cuanto más se parecen, más alto.

q = [1, 0]
claves = [[1, 0], [0, 1], [1, 1]]
for k in claves:
    print(k, "→", sum(a * b for a, b in zip(q, k)))

Softmax: de puntuaciones a porcentajes

Las puntuaciones pueden ser cualquier número. Softmax las convierte en pesos positivos que suman 1: aplica la exponencial a cada una y divide entre el total. Restar antes el máximo no cambia el resultado y evita que math.exp se desborde con números grandes.

// reto 01

Escribe softmax

Define softmax(xs) que reste el máximo, aplique math.exp a cada valor y divida cada uno entre la suma.

main.py
Ctrl/⌘ + Enter
¿Atascado? Ver pista
maximo = max(xs)
exps = [math.exp(x - maximo) for x in xs]
total = sum(exps)
return [e / total for e in exps]
$ python main.py

    La máscara causal: prohibido mirar el futuro

    Al entrenar, el modelo ve la frase entera, pero cuando genera texto el futuro todavía no existe. Para que aprenda en las mismas condiciones, cada posición solo puede mirar las anteriores y a sí misma. El truco: poner -inf en las puntuaciones del futuro. Como exp(-inf) es 0, softmax les da peso cero.

    // reto 02

    La máscara

    Define enmascarar(fila, i) que devuelva una copia de fila en la que los elementos de las posiciones mayores que i valgan float("-inf").

    main.py
    Ctrl/⌘ + Enter
    ¿Atascado? Ver pista

    return [x if j <= i else float("-inf") for j, x in enumerate(fila)]

    $ python main.py

      Atención completa

      Para cada posición i: puntuaciones con todas las claves (divididas entre la raíz de la dimensión, para que no crezcan con vectores largos), máscara, softmax y, al final, la media ponderada de los valores.

      // reto 03

      Atención causal

      Define atencion(qs, ks, vs) que devuelva una lista con un vector por posición, siguiendo los cuatro pasos.

      main.py
      Ctrl/⌘ + Enter
      ¿Atascado? Ver pista
      d = len(qs[0])
      salida = []
      for i, q in enumerate(qs):
          puntos = [sum(a * b for a, b in zip(q, k)) / math.sqrt(d) for k in ks]
          pesos = softmax(enmascarar(puntos, i))
          salida.append([sum(pesos[j] * vs[j][c] for j in range(len(vs))) for c in range(len(vs[0]))])
      return salida
      $ python main.py

        Lo que hace un Transformer de verdad

        Un Transformer repite esta pieza muchas veces: varias «cabezas» de atención en paralelo, cada una con sus propios vectores, y decenas de capas apiladas. Las consultas, claves y valores no se escriben a mano: salen de multiplicar cada token por matrices que el modelo aprende. Cómo se aprende un modelo es justo lo que viene en la lección siguiente.