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"}, dondebefore_gbyafter_gbson las dos huellas yratioesfrom_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.
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.
Este navegador está bloqueando las cookies de learn.floati.life, así que las lecciones que terminaste aquí no se pueden abrir en orden. Permite las cookies de este sitio y recarga.