¿Por qué tarda más la primera palabra?
La inferencia de un LLM es el trabajo que hace un modelo de lenguaje ya entrenado para responderte. Ocurre en dos fases: el prefill lee todo tu prompt y la decodificación escribe la respuesta token a token.
Las dos fases usan el ordenador de forma muy distinta. Saber cuál es lenta, y por qué, es el punto de partida de cada mejora de este módulo.
Al final de esta lección
Nota
Puedo explicar por qué la decodificación está limitada por la lectura de memoria y el prefill no.
Palabras clave
| Palabra | Qué significa |
|---|---|
| Inferencia | ejecutar un modelo ya entrenado para obtener una salida |
| Pasada | una ejecución del modelo sobre algunos tokens |
| Prefill | la primera pasada, que lee el prompt entero |
| Decodificación | las pasadas siguientes, un token nuevo en cada una (decode en inglés) |
| Multiplicación-suma | una multiplicación y una suma, la unidad de trabajo de un modelo |
| Limitado por memoria | frenado por la lectura de memoria y no por las cuentas (memory-bound) |
Las celdas que rellenan los estudiantes quedan en blanco en esta vista previa.
Generar es un bucle de pasadas
Un modelo solo sabe responder a una pregunta: ¿qué viene ahora? Para escribir una respuesta, trabaja en bucle. La primera pasada lee el prompt y da el primer token nuevo. Eso es el prefill.
Cada pasada siguiente lee el token recién hecho y da uno más. Eso es la decodificación. Una respuesta de 100 tokens necesita una pasada de prefill y 99 de decodificación.
Mira el prefill y la decodificación
docker exec jupyter python3 steps/generate.pySe muestra aquí y no se ejecuta. Pulsa Iniciar laboratorio para escribirlo en el terminal de tu propio laboratorio.
Lo que imprimió la Ejecución
| Línea | Lo que muestra |
|---|---|
| prefill: read 12 tokens of the prompt in one pass | Todo "the cat sat " de una vez |
| decode step 1 chose 'o' | El primer carácter nuevo |
| decode step 10 chose 't' | El texto ya dice "the cat sat on the mat" |
Las celdas que rellenan los estudiantes quedan en blanco en esta vista previa.
Pruébalo: cuenta las pasadas
# Un modelo de mentira: una tabla de qué palabra sigue a cuál.
NEXT = {"el": "gato", "gato": "come", "come": "en", "en": "el"}
prompt = ["el", "perro", "come"]
passes = 1 # el prefill lee todo el prompt en una sola pasada
words = [NEXT[prompt[-1]]]
while len(words) < 5:
passes = passes + 1 # cada pasada de decodificación lee una palabra nueva
words.append(NEXT[words[-1]])
print("palabras nuevas:", words)
print("pasadas:", passes)
# Cambia 5 por 10. ¿Cuántas pasadas hay ahora?
Cada pasada lee todos los pesos
Un modelo es sobre todo un conjunto de grandes tablas de números, los pesos. Una pasada tiene que leerlos todos de la memoria. Hace más o menos una multiplicación-suma por peso para cada token que lee.
El prefill lee los pesos una vez para todo el prompt. Así, un prompt de 24 tokens hace el trabajo de 24 tokens con una sola lectura. La decodificación vuelve a leer todos los pesos para el trabajo de un único token.
Cuenta el trabajo de cada fase
docker exec jupyter python3 steps/phases.pySe muestra aquí y no se ejecuta. Pulsa Iniciar laboratorio para escribirlo en el terminal de tu propio laboratorio.
Ejemplo resuelto: las dos fases en el laboratorio
| Fase | Pasadas | Multiplicaciones-suma | Bytes leídos | Trabajo por byte |
|---|---|---|---|---|
| Prefill, 24 tokens | 1 | 30291 | 50508 | 0,6 |
| Decodificación, 24 tokens | 24 | 100680 | 402720 | 0,2 |
Las celdas que rellenan los estudiantes quedan en blanco en esta vista previa.
Un error frecuente
Advertencia
Mucha gente cree que la decodificación es lenta porque hace más cuentas. Cada pasada de decodificación hace menos cuentas que el prefill. Es lenta porque cada pasada lee todos los pesos para hacer un solo token. Pregúntate cuántos bytes lee una pasada, no solo cuántas sumas hace.
La velocidad de la memoria manda
Un modelo grande tiene miles de millones de pesos. Un modelo 7B tiene 7000 millones. A 2 bytes cada uno, son 14 GB que leer en cada pasada de decodificación.
Si la memoria entrega 50 GB por segundo, lo mejor posible son unas 3,6 pasadas por segundo, por rápidas que sean las cuentas. Eso significa limitado por memoria. El modelo de este laboratorio solo ocupa 12 KB, así que sus cuentas muestran la forma, no velocidades reales.
Pruébalo: la mejor velocidad de decodificación
# Cada pasada de decodificación lee todos los pesos una vez,
# así que la memoria marca la velocidad máxima.
READ_GB_PER_SECOND = 50
models = [["7B a 2 bytes", 7, 2], ["7B a 1 byte", 7, 1], ["1B a 2 bytes", 1, 2]]
for name, billions, bytes_each in models:
gb_per_pass = billions * bytes_each
best = READ_GB_PER_SECOND / gb_per_pass
print(name, "lee", gb_per_pass, "GB por pasada, como mucho", round(best, 1), "tokens por segundo")
# Cambia READ_GB_PER_SECOND a 100. ¿Qué les pasa a todas las velocidades?