Temario Lección 204 de 250 · El ajuste fino, en concepto
El ajuste fino, en concepto

Huella de memoria: 4 bits frente a 16 bits

Esta es la aritmética que decide si un modelo cabe siquiera en tu hardware, y por qué los modelos "cuantizados" están por todas partes. Los pesos de un modelo no son más que números, y cada número ocupa unos bytes según su precisión. La huella es sencilla:

bytes = params * bits_per_param / 8
# (8 bits per byte)

El entrenamiento y la inferencia a precisión completa suelen usar floats de 16 bits (2 bytes cada uno). Para ejecutar un modelo en un portátil o un teléfono lo cuantizas: guardas cada peso en menos bits. La cuantización a 4 bits usa la cuarta parte de los bytes, porque 4 bits son la cuarta parte de 16 bits. El mismo número de parámetros, la cuarta parte de la memoria.

Haz las cuentas con un modelo de 7.000 millones de parámetros:

16-bit: 7e9 * 16 / 8 = 1.4e10 bytes  ~= 13.04 GiB
 4-bit: 7e9 *  4 / 8 = 3.5e9  bytes  ~=  3.26 GiB   (exactly 1/4)

Esa es la diferencia entre un modelo que necesita una GPU grande y uno que funciona en un portátil. Es exactamente la razón por la que un asistente en el dispositivo (como el que mueve el tutor de IA de este curso) lleva un modelo de 4 bits: el coste en calidad es pequeño, y la ganancia en memoria y ancho de banda es enorme. También es la razón por la que el ajuste fino eficiente en parámetros (LoRA) resulta atractivo: solo guardas y distribuyes unos pocos pesos de adaptador pequeños encima de una base congelada y quizá cuantizada.

Lo que la fórmula sencilla deja fuera. Solo cuenta los pesos, así que tómala como un mínimo. Los formatos reales de 4 bits también guardan una escala por cada pequeño grupo de pesos, lo que los lleva a unos 4.5 a 5 bits por peso (un modelo de 7B se acerca más a 4 GiB que a 3.26). Ejecutar el modelo necesita espacio para la caché KV, que crece con la longitud del contexto. Y el entrenamiento necesita mucho más que los pesos: el ajuste fino completo con el optimizador Adam guarda gradientes y dos estados del optimizador por peso, unos 16 bytes por parámetro en precisión mixta, así que aproximadamente 100 GiB para un modelo de 7B antes de las activaciones. Esa diferencia es la verdadera razón de que existan LoRA y el ajuste fino cuantizado.

Damos la huella en GiB (gibibytes), dividiendo los bytes por 1024 ** 3. Mantenla como un float exacto, no redondees, para que las relaciones de abajo se cumplan con precisión.

Construye dos funciones.

  • model_memory(params, bits_per_param) -> la huella en GiB como float: params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, donde before_gb y after_gb son las dos huellas y ratio es from_bits / to_bits (cuántas veces más pequeño es el modelo cuantizado).

Las matemáticas son reales y se pueden evaluar; el entrenamiento en GPU que hacen posible no es algo que este entorno pueda ejecutar. Pulsa Ejecutar para imprimir la huella de un modelo de 7B con unas cuantas precisiones.

Tu turno

Escribe model_memory(params, bits_per_param), que devuelva la huella en GiB como float (params * bits_per_param / 8 / (1024 ** 3)), y quantization_savings(params, from_bits, to_bits), que devuelva {"before_gb", "after_gb", "ratio"}, donde las dos huellas salen de model_memory y ratio es from_bits / to_bits. No redondees; mantén floats exactos para que 4 bits salga exactamente como la cuarta parte de 16 bits.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.