Proyecto: el modelo hecho función

Las piezas del mini-GPT están repartidas por las celdas del bloque. codificar y decodificar salieron de la lección sobre BPEBloque 1 · Lección 2BPE de verdad: fusionar, no solo partirEl tokenizador del mini-GPT, escrito desde cero. BPE parte de los 256 bytes con los que se escribe cualquier texto y repite una sola operación: contar los pares de tokens vecinos y fusionar el más frecuente. Esta lección deriva lo que eso garantiza (ningún texto se queda sin tokens, y decodificar devuelve el original byte a byte) y lo que cuesta (cada fusión es una entrada más del vocabulario y ahorra menos tokens que la anterior), y lo comprueba entrenando sobre Marianela las mismas fusiones que usa el modelo. (byte-pair encoding); los pesos, de la del 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.; muestrear, de la del muestreoBloque 1 · Lección 4Muestreo: temperatura, top-k y top-pUna distribución no es un texto: para escribir hay que quedarse con un token en cada posición. La lección deriva la familia entera de reglas a partir de un solo mando, la temperatura, cuyos dos extremos son la favorita de siempre y el sorteo uniforme; demuestra por qué la generación voraz acaba en un ciclo del que no sale y por qué sortear sin más acaba sacando tokens de la cola; y presenta top-k y top-p como dos maneras de cortar esa cola antes de sortear. Todo medido sobre el mini-GPT.; llenar y avanzar, de la de la cachéBloque 1 · Lección 5La caché de claves y valores: cuánto cuesta cada tokenPara escribir cada token, el mini-GPT volvía a pasar el texto entero por la red. La lección demuestra que las claves y los valores de las posiciones ya leídas no cambian, los guarda en una caché y cuenta lo que cuesta cada token con ella y sin ella: sin ella, exactamente t veces más; con ella, una memoria que crece con el texto y que en un modelo grande llega a ocupar más que sus pesos. Todo medido sobre el mini-GPT, y contra el reloj.. Cada celda que ha querido texto las ha vuelto a cargar y a coser a mano. La lección sobre el aprendizaje en contextoBloque 1 · Lección 8Aprendizaje en contexto: el prompt como programaUn modelo grande hace, con unos cuantos ejemplos en el prompt y los pesos quietos, tareas que nadie le entrenó a hacer. La lección lo escribe en la notación del bloque, deriva por qué predecir el texto obliga a reconocer la tarea que siguen los ejemplos y mide por qué el mini-GPT no puede: su texto no tiene esas tareas, y lo que lee más allá de unos ocho tokens no le sirve. acabó dando la razón para coserlas de una vez: con $\theta$ quieto, todo lo que hace un modelo depende del texto que recibe, así que lo único que el resto del curso necesita del mini-GPT es una manera de dárselo y de recoger lo que escribe. Este proyecto la construye.

El curso anterior terminó en algo parecido. En el proyecto del Transformer del curso anteriorDeep Learning para NLP: del Perceptrón al TransformerBloque 5 · Lección 9Proyecto: un Transformer desde ceroEl artículo entero, montado y ejecutado: un vocabulario de doce entradas compartido por los dos idiomas, dos bloques por columna, dos cabezas y una frase de cinco tokens que sale por arriba convertida en seis distribuciones. Las seis funciones que hacen el trabajo son los desafíos de las lecciones anteriores sin tocar una letra, y lo que las une es que todo lo de en medio recibe T por d_model y devuelve T por d_model. Nadie ha entrenado estos pesos, así que la traducción que propone no significa nada; lo que sí se puede comprobar con pesos cualesquiera son tres cosas, y la segunda es la que este montaje añade: que ninguna posición del decoder ve lo que todavía no se ha escrito exige la máscara en cada uno de los bloques, no en el primero, y quitar una sola se mide., paso(entrada) era «el modelo hecho función»: recibía ids y devolvía una distribución, y quien lo llamaba tenía que saber qué es un id, dónde va <GO> y qué hacer con $\lvert V \rvert$ probabilidades. La función de esta lección recibe texto y devuelve texto, y quien la llama no maneja un solo id. Pero una firma sólo dice qué entra y qué sale. ¿Da dos veces lo mismo? ¿Cuándo para? ¿Qué hace con un texto que no cabe en las 64 posiciones del mini-GPT? Las respuestas son el contrato, y lo que el curso construya encima se apoyará en ellas, no en el código.

Mira una llamada entera, pieza a pieza, antes de ponerle nombre a nada: modelo("La Nela", max_tokens=4, semilla=0), que devuelve no traf.

Tres cosas de la traza. El texto acaba a mitad de palabra, porque max_tokens cuenta tokens y traf son tres. El último token, el 102, no entra en la caché: nadie va a pedir lo que viene detrás. Y lo que devuelve empieza por un espacio: es la continuación, y La Nela seguido de no traf es el texto entero. Los cuatro sorteos los decidió la semilla, y con otra habrían salido otros.

La firma y el contrato

La firma de una función es lo que cabe en su primera línea: el nombre, los parámetros con sus valores por defecto y lo que devuelve. La de modelo es ésta:

def modelo(
    prompt,
    max_tokens=32,
    temperatura=1.0,
    top_p=0.9,
    parar=None,
    semilla=None,
) -> str: ...

El contrato es lo que promete a quien la llama y lo que le pide. Son siete cláusulas, y cada una sale de una lección del bloque:

1. Continúa. Devuelve sólo lo que sigue al prompt: prompt + texto es el texto entero.
2. Sortea como en el muestreo. Cada token sale del softmax de los logits divididos entre temperatura, cortado al núcleo de masa top_p y renormalizado. temperatura=0 es la generación voraz, y top_p=None no corta.
3. Para tras max_tokens tokens, que son tokens y no palabras, o antes, en la primera aparición de parar en lo generado (el prompt no cuenta). Esa cadena de parada (stop sequence) no se devuelve.
4. Con semilla, es una función. Los mismos argumentos y la misma semilla dan el mismo texto; sin semilla, cada llamada es un sorteo nuevo.
5. No recuerda. Ninguna llamada cambia $\theta$ ni deja nada para la siguiente. Lo que el modelo tenga que saber va en el prompt, cada vez.
6. Lee como mucho los últimos $T_{\text{ctx}} = 64$ tokens, y más allá rellena la caché (la sección siguiente).
7. Pide un prompt no vacío, porque el primer token se da y no se predice, como estableció la lección sobre el modelo de lenguaje causalBloque 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., y que no acabe en espacio (la última sección de este apartado). Si no, falla en lugar de escribir.

La segunda cláusula dice de qué es muestra lo que devuelve. Llamemos $x$ a los tokens del prompt, todos (sin subíndice es la secuencia entera, como el caso de la lección anterior, no el token $x_t$), e $y_1, y_2, \dots$ a los que sortea. Cada $y_j$ sale de la distribución $\tilde{\mathbf{q}}$ de la lección sobre el muestreoBloque 1 · Lección 4Muestreo: temperatura, top-k y top-pUna distribución no es un texto: para escribir hay que quedarse con un token en cada posición. La lección deriva la familia entera de reglas a partir de un solo mando, la temperatura, cuyos dos extremos son la favorita de siempre y el sorteo uniforme; demuestra por qué la generación voraz acaba en un ciclo del que no sale y por qué sortear sin más acaba sacando tokens de la cola; y presenta top-k y top-p como dos maneras de cortar esa cola antes de sortear. Todo medido sobre el mini-GPT., calculada con los logits que la red da tras leer el prompt y lo sorteado antes; escribámosla $\tilde{q}(\cdot \mid x, y_{<j})$, con el texto leído a la vista, como hacía $\mathbf{z}_t(x_{\le t})$. Como cada sorteo sabe los anteriores, la probabilidad de que modelo escriba justo $y$ es el producto

Con temperatura=1 y top_p=None no hay nada entre los logits y el sorteo, y mientras el prompt y lo sorteado quepan en la ventana cada factor es la condicional del modelo. El producto es entonces la regla de la cadena de la primera lección del bloque, recorrida en el otro sentido:

Sortear token a token, cada uno sabiendo los anteriores, es sortear continuaciones enteras con la probabilidad que el modelo les da. No es una aproximación. Cualquier otra temperatura o núcleo da otra distribución, hecha con los mismos logits, y temperatura=0 la reduce a un solo texto, el de la voraz. La semilla no cambia la distribución: elige cuál de sus muestras sale.

Más allá de la ventana: rellenar la caché

La sexta cláusula obliga a decidir algo. La lección sobre la cachéBloque 1 · Lección 5La caché de claves y valores: cuánto cuesta cada tokenPara escribir cada token, el mini-GPT volvía a pasar el texto entero por la red. La lección demuestra que las claves y los valores de las posiciones ya leídas no cambian, los guarda en una caché y cuenta lo que cuesta cada token con ella y sin ella: sin ella, exactamente t veces más; con ella, una memoria que crece con el texto y que en un modelo grande llega a ocupar más que sus pesos. Todo medido sobre el mini-GPT, y contra el reloj. dejó dicho que la del mini-GPT no se desliza: sus posiciones son una tabla de $T_{\text{ctx}} = 64$ filas, y en cuanto se suelta el primer token cada uno cambia de posición y lo guardado deja de valer. generar, la función de minigpt.py, lo esquiva sin caché: en cada token pasa por la red los últimos 64 enteros. modelo usa la caché mientras cabe y, cuando está llena y hace falta otro token, la rellena: la tira y la vuelve a llenar, en un solo prefill, con los últimos $T_{\text{mín}}$ tokens del texto. En modelo, $T_{\text{mín}} = T_{\text{ctx}}/2 = 32$.

Contemos filas, cada una lo que aquella lección llamó $c_{\text{fila}}$ (el término de la atención, que crece con la posición, se queda fuera: en la posición 64 es un octavo de $c_{\text{fila}}$). Tras un relleno, la caché guarda $T_{\text{mín}}$ posiciones y crece de una en una hasta $T_{\text{ctx}}$: son $T_{\text{ctx}} - T_{\text{mín}}$ avances, de una fila cada uno. Cada avance deja sortear un token, y el relleno otro, así que un ciclo escribe $T_{\text{ctx}} - T_{\text{mín}} + 1$ tokens y calcula $T_{\text{mín}} + (T_{\text{ctx}} - T_{\text{mín}}) = T_{\text{ctx}}$ filas:

frente a las $T_{\text{ctx}} = 64$ de generar, una pasada entera por token. El precio es contexto: el token que se sortea justo después de un relleno lee $T_{\text{mín}}$ tokens y no 64, y cada uno de los siguientes, uno más. $T_{\text{mín}}$ es el mando entre los dos extremos. Con $T_{\text{mín}} = T_{\text{ctx}} - 1$ cada token lee al menos 63, y el ciclo da dos tokens por 64 filas; con $T_{\text{mín}} = 1$ sale a una fila por token, y el que sigue a un relleno lee uno solo.

Treinta y dos es generoso, y se puede decir por qué. La lección sobre el aprendizaje en contextoBloque 1 · Lección 8Aprendizaje en contexto: el prompt como programaUn modelo grande hace, con unos cuantos ejemplos en el prompt y los pesos quietos, tareas que nadie le entrenó a hacer. La lección lo escribe en la notación del bloque, deriva por qué predecir el texto obliga a reconocer la tarea que siguen los ejemplos y mide por qué el mini-GPT no puede: su texto no tiene esas tareas, y lo que lee más allá de unos ocho tokens no le sirve. midió que lo que el mini-GPT lee más allá de unos ocho tokens no le sirve para predecir: dejarle 32 no le quita nada que use. Con un modelo que sí aprovechara lo que lee, $T_{\text{mín}}$ dejaría de ser una cuestión de coste y pasaría a serlo de calidad.

Donde el texto deja ver los tokens

Quien llama a modelo no maneja ids, pero el tokenizador sigue dentro y asoma en dos cláusulas. La tercera ya ha salido en la traza: max_tokens cuenta tokens, y el texto puede quedarse a mitad de palabra. La séptima necesita un párrafo más.

El mini-GPT sólo ha leído su corpus tal como lo corta codificar, y un prompt se codifica solo, sin el texto que vendría detrás. Si su final no se corta como se cortaría dentro de un texto más largo, lo que el modelo lee al final no dice lo que quería decir quien escribió el prompt: dice lo que decía en el corpus. El caso que se da sin buscarlo es el espacio final. La lección sobre BPE cortó el texto en pre-tokens con el espacio pegado a la palabra que lo sigue, así que en la novela casi todas las palabras empiezan por un token que ya lleva su espacio. Un espacio suelto sólo aparece delante de los pocos comienzos de palabra que las fusiones no llegaron a pegar al espacio: Golfín empieza por un espacio suelto seguido de G.

Un prompt que acaba en espacio termina en ese token, y el mini-GPT entiende lo único que ha aprendido de él: que viene una de esas palabras. El arreglo de fondo es deshacer el último token del prompt y obligar al primero que se sortee a empezar por sus bytes (token healing), y no es de este bloque. El contrato hace lo honesto con lo que tiene, que es rechazar el prompt.

El mini-GPT, hecho función y congelado

Las tres celdas corren sobre el mini-GPT, el checkpoint del bloque, sin entrenarlo. Un cambio de nombre antes de empezar: en las celdas de las lecciones anteriores, modelo era el objeto MiniGPT; desde aquí modelo es la función, y el objeto se llama red, porque es lo que se ve cuando se mira dentro.

La primera reúne el motor: el tokenizador, la red, y llenar y avanzar tal como los dejó la lección sobre la caché, con la red como primer argumento en lugar de una variable global (una función que se va a congelar no puede depender de nada que no reciba). Después hace a mano la llamada de la traza.

Son los números de la traza, y es la última vez que los ves. La segunda celda escribe hacer_modelo(red, fusiones), que recibe la red y el tokenizador y devuelve modelo con los dos dentro. Lo que se congela es la firma: detrás puede haber otra red con la misma firma, que es lo que el bloque siguiente hará cuando cambie los pesos. El bucle es el de la traza con las cláusulas puestas: las dos comprobaciones de la séptima al entrar, el prefill con los últimos 64 tokens como mucho, el relleno cuando la caché está llena y la parada.

Las dos primeras líneas cambian cada vez que la ejecutas: sin semilla, cada llamada es un sorteo. Con la semilla 1 sale el mismo texto antes y después de otra llamada por medio, que no le ha dejado nada. La voraz vuelve al ciclo de no, de la lección sobre el muestreo, y con parar="." sale una frase sin su punto, no trafá como me dijo lo le jo, que empieza como la traza porque la semilla 0 sortea lo mismo. Doscientos tokens, tres veces la ventana y cinco rellenos, tardan menos de un segundo.

La tercera comprueba el contrato contra lo que no depende de él. Dentro de la ventana, modelo tiene que escribir lo mismo que generar con la misma semilla, porque la caché da los mismos logits y el sorteo es el mismo; fuera, tienen que separarse donde empieza el relleno. Después mira el espacio final y, al acabar, carga la copia congelada de modelo y la compara con la tuya.

Lo que dijo la derivación. Con dos semillas, 40 tokens de modelo y de generar son el mismo texto. Con 80 coinciden los 63 primeros: el 63 se sortea con la ventana justo llena (los 2 del prompt y 62 sorteados), y el 64 es el primero tras un relleno, que modelo sortea leyendo 32 tokens y generar leyendo 64. modelo tarda unas cinco veces menos, y no las casi treinta que dan las filas: en Pyodide cada pasada paga un coste fijo, sea de una fila o de 64, así que el reloj no sigue a la cuenta, y la cuenta es la que vale.

Y el espacio. Tras Dijo que, las favoritas son no, se, me, palabras con su espacio; tras Dijo que , u, j, é, trozos de los que sólo siguen a un espacio suelto. Un carácter de más ha cambiado la distribución entera, y modelo se niega a sortear de ella.

La última línea es la que congela el proyecto. /courses/llm-agents/modelo.py contiene la función de la segunda celda con el motor de la primera, y escribe lo mismo que la tuya. Desde el bloque siguiente, una celda que quiera el mini-GPT lo carga con una línea y lo llama sin abrirlo:

exec(open_url("/courses/llm-agents/modelo.py").read())

Comprueba tu intuición

Tres preguntas, sobre de qué es muestra lo que devuelve, sobre lo que cuesta rellenar y sobre lo que promete el contrato, y un reto: el bucle de la ventana, contra un motor de juguete.

modelo cumple su contrato, y el contrato no dice nada de responder. Promete continuar: devolver lo que, según $p_\theta$, suele venir después del prompt. Escríbele una pregunta y la tratará como Marianela trata las suyas, como la línea de un diálogo que sigue, sin contestarla. No es un defecto del tamaño. Un modelo grande entrenado sólo a predecir falla igual, con mejor ortografía, porque en su texto lo que sigue a una pregunta es lo que suele seguirla, y eso no siempre es la respuesta.

Hacer que un modelo haga lo que se le pide exige cambiarle algo más que el prompt, y ése es el bloque siguiente. Su primera lección, sobre por qué predecir no es obedecer, abre con esta misma función, cargada en una línea, y con una pregunta que se queda sin respuesta.