Aprendizaje en contexto: el prompt como programa

Hasta aquí, en este bloque, aprender ha querido decir una sola cosa: mover $\theta$. La lección sobre el entrenamientoBloque 1 · Lección 3Entrenar un mini-GPT en NumPyEl checkpoint del bloque es el resultado de 2 000 pasos de un bucle que esta lección escribe entero. Cada paso sigue la pérdida media de unas pocas ventanas del corpus sacadas al azar, y la lección deriva por qué eso apunta, de media, adonde apuntaría el corpus entero, y cuánto ruido cuesta ahorrarse el resto. El paso es AdamW, con una tasa de aprendizaje que se calienta y luego decae. Con todo ello el mini-GPT sigue entrenando en el navegador, sobre las últimas páginas de Marianela, que no había visto. lo hacía un paso de gradiente cada vez, y la de las leyes de escalaBloque 1 · Lección 7Leyes de escala: Kaplan y ChinchillaLa pérdida de un modelo de lenguaje baja como una potencia de sus parámetros, de los tokens que lee y del cálculo que gasta: una recta en ejes logarítmicos. La lección cuenta lo que cuesta entrenar, C ≈ 6ND, deriva el reparto óptimo de un presupuesto entre modelo y datos, lee en las cifras de Chinchilla sus 20 tokens por parámetro y hace las cuentas del mini-GPT: su tamaño es el que Chinchilla le daría a su cálculo, y lo que le falta es texto. le puso precio al recorrido entero y concluyó que, para lo que costó, al mini-GPT no le sobra tamaño: le falta texto. Los modelos grandes hacen otra cosa que también parece aprender, y en la que $\theta$ no se mueve. Escribe en el prompt unos cuantos casos resueltos de algo que nunca se les enseñó, añade uno sin resolver, y lo resuelven. La primera lección del bloqueBloque 1 · Lección 1Una sola columna: el modelo de lenguaje causalEl curso anterior eligió una columna del Transformer, le puso la máscara en todos los bloques y le pidió el token siguiente, posición a posición. Esta lección hace la pregunta que aquél no hizo, qué probabilidad le da ese modelo a un texto entero, y de la respuesta sale todo lo demás: la regla de la cadena convierte esa probabilidad, sin perder nada, en un producto de condicionales; la máscara causal es lo que permite calcular las T de una ventana en una sola pasada; y la pérdida es el logaritmo de ese producto, cambiado de signo y repartido por token. Sin código a propósito: la cuenta se hace a mano sobre una ventana de cuatro palabras, y sale un dieciseisavo por los dos caminos. prometió explicar cómo llega a eso un modelo que sólo aprendió a continuar texto, y esta lección cumple la promesa.

Escribe dos listas con las mismas cuatro palabras a la izquierda de los dos puntos y dos tareas distintas a la derecha, y termina las dos con el mismo caso sin resolver:

Tú has completado la primera con hermanos y la segunda con hermana antes de terminar de leer, y un modelo grande hace lo mismo. Nada en su entrenamiento le pidió poner palabras en plural ni en femenino, y el caso es idéntico en las dos columnas. Sólo cambia lo que hay a la derecha de los dos puntos en las líneas de arriba, y con eso cambia la función que el modelo calcula sobre hermano.

Mira el modelo como una función de un solo argumento, el texto que le das, con $\theta$ fijo dentro. Los ejemplos forman parte de ese argumento y hacen de programa: dicen qué hay que hacer con el caso que viene detrás. Ningún peso guarda el plural en un sitio y el femenino en otro. Lo que el modelo tiene es lo que aprendió al predecir su texto, y en el texto hay listas, glosarios, ejercicios resueltos: documentos que repiten una misma operación caso tras caso. Continuar bien uno de ellos exige averiguar qué operación sigue.

Una tarea es una condición, no un peso

Llamemos ejemplo $e_i$ a un caso resuelto escrito en el prompt, una secuencia de tokens como hijo: hijos con su salto de línea detrás; $e_{1:K}$ son los $K$ ejemplos en orden, $x$ es el caso sin resolver con el que acaba el prompt (hermano:) e $y$ la respuesta que se le pide ( hermanos, con su espacio). Los tres son secuencias de tokens: este $x$ sin subíndice es un caso entero, no el token $x_t$ de las lecciones anteriores, y $K$ es la letra del artículo de GPT-3, no la $k$ de top-k. Lo que el modelo le da a una respuesta sale de la regla de la cadena de la primera lección, con el prompt delante:

un término por cada token $y_j$ de la respuesta, y todos salen, gracias a la máscara, de una sola pasada por el prompt seguido de $y$.

Un modelo hace aprendizaje en contexto (in-context learning, ICL) con una tarea cuando, con $\theta$ fijo, los ejemplos le suben la probabilidad de la respuesta que esa tarea pide hasta que es la más probable, sin que nadie lo haya entrenado para esa tarea. El artículo de GPT-3 lo midió sin ejemplos, con uno y con cuantos cupieran en su ventana de 2 048 tokens (entre 10 y 100, según la tarea), y los llamó zero-shot, one-shot y few-shot. Aprender, aquí, es cambiar el argumento de $p_\theta$, no sus parámetros.

Con dos tareas que reciben los mismos casos, como las dos columnas, la prueba es la diferencia entre los logaritmos de sus dos respuestas: si el modelo lee la tarea en los ejemplos, sube con $K$ en una lista y baja en la otra. Dos filas que se separan.

Predecir el texto obliga a reconocer la tarea

Para ver por qué pasa, dejemos la red un momento y preguntemos qué haría el texto. Llamemos $p_{\text{texto}}$ a la distribución de la que sale el texto de entrenamiento: lo que el texto es, frente a lo que el modelo cree, $p_\theta$. Supongamos que el texto está hecho de documentos y que cada uno sigue una tarea $\omega$: se elige una con probabilidad $p_{\text{texto}}(\omega)$, y después se escriben sus casos resueltos uno tras otro, independientes entre sí una vez fijada la tarea. Una lista de plurales es un documento; un capítulo de Marianela, otro, con su propia tarea. Ningún texto real se escribe así, y lo que sigue vale en la medida en que el texto se le parezca. (Es una versión reducida del modelo de Xie y sus coautores; ellos llaman $\theta$ a la tarea, y aquí $\theta$ tiene dueño.)

Con ese modelo, la probabilidad de la respuesta, leídos los ejemplos y el caso, se reparte entre las tareas:

Es la regla de la cadena aplicada al par $(\omega, y)$ y sumada sobre $\omega$, y en el primer factor los ejemplos desaparecen porque, fijada la tarea, no dicen nada más sobre la respuesta. Así que lo único que hacen es mover el segundo factor: cuánto cree el texto, a la vista del prompt, en cada tarea. La regla de Bayes lo da, con una constante que es la misma para todas:

La constante se va al comparar dos tareas, $\omega_1$ y $\omega_2$. Tomando logaritmos,

que se lee término a término, y cada término dice una cosa.

Cada ejemplo suma uno. Si los ejemplos son de verdad de $\omega_1$, cada término vale, en promedio, cero o más: es la desigualdad de la lección sobre la perplejidadBloque 1 · Lección 6Perplejidad: medir un modelo de lenguajeUn modelo que sólo cuenta bytes paga, sobre las páginas de Marianela que el mini-GPT no vio, la misma pérdida por token que el mini-GPT. La lección explica por qué eso no dice nada: convierte la pérdida en perplejidad, el número de candidatas entre las que duda el modelo, y en bits por byte, la medida que no depende del tokenizador; le pone al lado dos varas de medir, el modelo uniforme y el de unigramas; y demuestra por qué la pérdida sobre el texto de entrenamiento engaña y la del texto reservado no., según la cual ninguna distribución paga menos por un texto que aquella de la que sale. La suma crece con $K$, y el cociente, como su exponencial: unos pocos ejemplos que distingan bien dejan a una sola tarea con casi toda la probabilidad, y la respuesta es la suya.

Lo que distingue es lo que difiere. En las dos columnas del principio, las palabras de la izquierda son las mismas, y las dos tareas las reciben igual, así que su parte de cada término se cancela y el término del caso vale cero. Queda la derecha de los dos puntos, y ahí cada ejemplo pesa mucho: hijo: hija es casi imposible en una lista de plurales. El programa entero está en las respuestas.

Y una tarea que el texto no tiene no aparece. El primer término no depende de $K$: si $p_{\text{texto}}(\omega_1) = 0$, vale $-\infty$, y ninguna suma finita lo levanta. Los ejemplos no crean tareas. Eligen entre las que el texto ya traía, y una tarea rara cuesta más ejemplos que una frecuente.

Lo que la red necesita para imitarlo

Falta la red. Entrenar es bajar la pérdida sobre el texto, y en cualquier contexto la pérdida media más baja posible es la que paga el propio texto. Para la respuesta de un documento,

con las dos esperanzas sobre los documentos del texto, y con igualdad sólo cuando $p_\theta$ y $p_{\text{texto}}$ coinciden en esos contextos: es otra vez la desigualdad de la perplejidad. Una red que se acercara a ese mínimo calcularía la suma sobre tareas sin que nadie la hubiera escrito: reconocería la tarea en los ejemplos y la aplicaría al caso. La pérdida no menciona tareas en ningún sitio. El aprendizaje en contexto sale de predecir bien un texto que las contiene.

La desigualdad dice también qué le hace falta a la red para acercarse a ese mínimo, y son tres cosas. Que su texto tenga las tareas, para que $p_{\text{texto}}(\omega)$ no sea cero en lo que leyó: GPT-3 leyó 300 000 millones de tokens de páginas web y de libros, con sus listas y sus glosarios, y el mini-GPT, una novela. Parámetros para guardar muchas tareas y distinguirlas: en el artículo de GPT-3, lo que aportan los ejemplos crece con el tamaño, del modelo de 1 300 millones de parámetros al de 175 000 millones. Y leer lo bastante atrás, porque los ejemplos quedan decenas de tokens antes del caso. Son los ejes $D$ y $N$ de las leyes de escalaBloque 1 · Lección 7Leyes de escala: Kaplan y ChinchillaLa pérdida de un modelo de lenguaje baja como una potencia de sus parámetros, de los tokens que lee y del cálculo que gasta: una recta en ejes logarítmicos. La lección cuenta lo que cuesta entrenar, C ≈ 6ND, deriva el reparto óptimo de un presupuesto entre modelo y datos, lee en las cifras de Chinchilla sus 20 tokens por parámetro y hace las cuentas del mini-GPT: su tamaño es el que Chinchilla le daría a su cálculo, y lo que le falta es texto., más la ventana, y en los tres el mini-GPT está lejos.

La derivación da el mecanismo mínimo, no el techo. Min y sus coautores cambiaron al azar las respuestas de los ejemplos en tareas de clasificación, y los modelos grandes apenas empeoraron: los ejemplos servían sobre todo para mostrar el formato y el tipo de caso, que es lo que predice un modelo que reconoce. Pero Wei y los suyos encontraron que los más grandes sí siguen ejemplos que contradicen lo que traen aprendido, y eso ya no es elegir entre tareas conocidas.

Lo que el mini-GPT hace con las dos listas

Las dos celdas corren sobre el mini-GPT, el checkpoint de la lección sobre el entrenamiento, y no lo entrenan: sólo lo leen. La primera escribe las dos columnas del principio con $K$ de 0 a 4 y pregunta, con la regla de la cadena de arriba, cuánto da el modelo a hermanos y a hermana detrás de hermano:. Después mira qué escribe él, eligiendo siempre la favorita.

Con $K = 0$ las dos listas son el mismo prompt, y hermana gana por $3.01$ nats: la novela la usa mucho más. Con ejemplos, la diferencia sube en las dos listas, también en la del femenino, donde tendría que bajar, y nunca pasa de cero. Lo que distingue una tarea de otra es la separación entre las dos filas, y es de $1.37$ nats con un ejemplo y de $0.59$ con cuatro: los ejemplos no se acumulan, que era lo primero que pedía la derivación. Las dos respuestas, además, son casi imposibles para el modelo, entre $-15$ y $-20$ nats. Lo que espera está en las dos últimas líneas: un salto de línea, con la mitad de la probabilidad, y después un diálogo.

La segunda celda busca dos de las tres cosas que la red necesita: qué tarea tiene el texto del mini-GPT para unos dos puntos, y hasta dónde lee él. Para lo segundo toma 64 tramos de 32 tokens del texto reservado y le da cada uno dos veces seguidas. La primera vez, la pérdida del token $j$ dice cuánto le sirve tener $j - 1$ tokens delante; la segunda, cuánto le sirve haber leído ya, 32 posiciones atrás, el tramo entero.

De los 204 dos puntos de la novela, 95 abren un párrafo nuevo, que en Marianela es un diálogo, y 40 unas comillas; ninguna de sus líneas tiene la forma palabra: palabra. En el texto del mini-GPT, una lista de plurales tiene probabilidad cero, y la tarea que hay detrás de unos dos puntos es que alguien hable. Eso es lo que hizo en la primera celda: reconocer la única tarea que conoce.

La tabla dice lo otro. La primera vez, la pérdida baja de $3.69$ a $3.22$ mientras el token tiene hasta siete delante, y de ahí en adelante se queda en $3.14$ y $3.17$: lo que el mini-GPT lee más allá de unos ocho tokens no le sirve para predecir, y los ejemplos de la primera celda quedan, casi todos, más atrás. Kaplan midió la misma curva en ventanas de 1 024 tokens, y en sus modelos bajaba como una ley de potencia hasta el final. La segunda vez, el mini-GPT paga lo mismo, $3.17$ y $3.16$ nats, por tokens que tiene escritos 32 posiciones atrás. Copiar lo que acaba de leer es el aprendizaje en contexto más elemental que hay, un solo ejemplo de la tarea «repite», y no lo hace. Olsson y sus coautores encontraron el mecanismo que lo hace, dos cabezas de atención en capas distintas que completan A B … A con B, y el mini-GPT tiene las dos capas que hacen falta. No lo aprendió, y su texto apenas se lo pedía: en ventanas de 64 tokens de una novela, lo que acaba de pasar casi nunca vuelve a pasar igual.

Comprueba tu intuición

Cuatro preguntas: una cuenta con el cociente de la derivación, una tarea que el texto no tiene, lo que miden las celdas y lo que le falta al mini-GPT.

El mini-GPT no lee tareas en su prompt, pero su forma es la de GPT-3: texto que entra, texto que sale y $\theta$ fijo dentro. Lo que esta lección le ha añadido es para qué sirve esa forma: con los pesos quietos, el prompt es el único sitio por el que se le puede decir algo a un modelo, y buena parte de lo que queda de curso se escribe ahí.

Antes de envolver ese modelo en nada, falta escribirlo una vez como función y congelarlo: el checkpoint, el tokenizador y lo que las lecciones del bloque le han ido añadiendo, detrás de una sola firma, modelo(prompt) -> texto, que los bloques siguientes puedan llamar sin abrirla. Es la lección siguiente, el proyecto del bloque: el modelo hecho función.