Por qué cada palabra siguiente sigue siendo barata de generar. · Source

Para añadir una palabra, debería releer todo el chat. No lo hace.

Un chatbot suelta palabras casi tan rápido como puedes leerlas. Pero para elegir cada palabra siguiente, un modelo está hecho para mirar atrás todo lo dicho hasta ahora. Hazlo desde cero en cada palabra y una conversación larga iría a paso de tortuga. No va lento: fluye. El truco que la mantiene fluyendo es toda la historia de aquí.

Cada palabra nueva relee todas las anteriores. Se acumula.

\sum_{t=1}^{n} t = \frac{n(n+1)}{2} \approx \frac{n^2}{2}

Un modelo escribe palabra por palabra, y para elegir cada una mira atrás todo el prefijo. La palabra 2 relee la 1, la 100 relee la 99, la 1000 relee la 999. Como una centralita reconectada a mano en cada llamada: el mismo cableado tendido una y otra vez. Suma todo ese retrabajo y el coste sube con el cuadrado de la longitud: el doble de chat, el cuádruple de trabajo.

Pero el pasado nunca cambia. ¿Por qué recalcularlo?

k_j = x_j W_K, \qquad v_j = x_j W_V

Cuando el modelo convierte una palabra anterior en las dos cosas que la atención necesita —una Key y un Value— estas dependen solo de esa palabra. Las palabras que llegan después no pueden volver atrás y cambiarlas. Como una huella de mano estampada en cemento fresco: en cuanto fragua, queda fija para siempre. Se calcula una vez y listo.

Entonces, guárdalas. Lleva una tabla viva de Keys y Values.

\mathrm{Attn} = \mathrm{softmax}\!\left(\frac{q_t\,K_{1:t}^{\top}}{\sqrt{d}}\right) V_{1:t}

No rehagas el pasado: guárdalo. Cada Key y Value que el modelo calcula cae en una tabla que crece. Para escribir la siguiente palabra, forma una Query nueva y la consulta contra toda esa tabla guardada. Como el mise en place de un chef: prepara cada ingrediente una vez y luego solo alcanzas lo que necesitas. Esa tabla es la KV cache.

Ahora cada palabra nueva es barata: codifica una, ojea el resto.

\underbrace{O(d^2)}_{\text{one new word}} + \underbrace{O(t\,d)}_{\text{the glance}} \;\ll\; \underbrace{O(t\,d^2)}_{\text{re-encode all } t}

Con la tabla guardada, añadir una palabra no cuesta casi nada. El modelo codifica solo esa única palabra —un coste fijo, por larga que sea la charla— y luego echa un vistazo rápido a las filas en caché. Como asfaltar una carretera: no repavimentas los kilómetros que dejas atrás, solo añades asfalto fresco en el borde de avance. La costosa recodificación de todo el prefijo simplemente desaparece.

La trampa: esa tabla solo crece. La memoria es la nueva factura.

\text{cache bytes} = 2 \cdot L \cdot n \cdot d_{\text{model}} \cdot b

Compraste velocidad con espacio. La caché guarda dos vectores por cada capa, por cada palabra hasta ahora, y solo se hincha a medida que avanza la charla. En contextos largos se dispara a gigabytes, y eso, no el cómputo, se vuelve el muro. Como un excursionista que nunca suelta nada: las notas que te mantienen rápido también se amontonan en tu espalda, paso a paso.

Lee el prompt una vez. Luego fluye: una palabra barata cada vez.

Eso es la KV cache: cambiar memoria por tiempo, para que el pasado nunca se recalcule. Divide el trabajo en dos: lee todo tu prompt en una pasada paralela para llenar la tabla, y luego suelta cada palabra añadiendo una sola fila y mirando atrás. Como un tren de carga: no lo reconstruyes para ir más lejos; enganchas un vagón más y sigues rodando.

Puede sumar a su memoria. Nunca puede revisarla.

🌱 La caché es de solo añadir. Cada palabra que el modelo ha visto queda fija en el instante en que cae —guardada a la perfección, nunca reescrita, como un disco grabado una vez y solo reproducido—. Y cada pensamiento nuevo aún debe mirar atrás todo ello. Entonces, una memoria a la que solo puedes sumar —nunca editar, nunca acortar— ¿es una forma de libertad, o un peso que solo puede crecer?