Cuantización

Qué cubre este artículo sobre cuantización

• Qué es la cuantización y por qué resulta imprescindible para la IA local
• Cómo ejecutar modelos grandes en tarjetas gráficas con recursos limitados mediante cuantización
• Qué formatos y métodos existen, desde GGUF pasando por AWQ hasta EXL2
• Cómo encontrar el nivel de cuantización adecuado para tu hardware
• Qué limitaciones y compromisos debes conocer

Introducción: cuantización explicada de forma clara

Si te interesa la IA local, hay un término que no puedes evadir: cuantización. Los modelos de lenguaje modernos cuentan con miles de millones de parámetros, y cada uno ocupa espacio en memoria. Un modelo sin cuantizar con 13 mil millones de parámetros requiere alrededor de 26 GB de memoria. Sin embargo, la mayoría de tarjetas gráficas de consumo solo ofrecen entre 8 y 12 GB de VRAM. Sin cuantización, ejecutar estos modelos en casa simplemente no sería viable.

La cuantización es el paso que hace que la IA local sea práctica en el día a día. Reduce el tamaño de almacenamiento de un modelo sin necesidad de reentrenarlo completamente. De esta forma, modelos grandes caben en tarjetas gráficas más pequeñas, se cargan más rápido y consumen menos energía. En este artículo aprenderás cómo funciona, qué métodos existen y qué nivel elegir según tu caso de uso.

Para más contexto sobre cómo ejecutar modelos localmente, consulta el artículo LLM ejecutado localmente.

¿Por qué necesito cuantización?

Un ejemplo concreto aclara el problema de inmediato. Imagina que quieres ejecutar localmente un modelo como Llama 2 13B. En su estado original, este modelo se almacena en FP16, es decir, con 16 bits por parámetro. Con 13 mil millones de parámetros, esto resulta en aproximadamente 26 GB de requisito de memoria.

Ahora miras tu tarjeta gráfica. Una GPU de consumo típica como la RTX 3060 tiene 12 GB de VRAM. El modelo sin cuantizar no entra en absoluto. Podrías descargarlo a la memoria del sistema, pero la ejecución se vuelve extremadamente lenta porque la RAM del sistema ofrece mucho menos ancho de banda que la VRAM de la tarjeta gráfica. Encontrarás más detalles en el artículo RAM vs. VRAM.

Con cuantización a Q4, es decir, 4 bits por parámetro, el modelo se reduce a unos 8 GB. Eso cabe perfectamente en una tarjeta de 12 GB, dejando espacio para el contexto y los resultados intermedios durante la generación de texto. El modelo se ejecuta rápido, sin interrupciones y completamente en la GPU, sin descarga a memoria.

Este es el punto clave: la cuantización no es un detalle de optimización opcional, sino el requisito previo para que modelos grandes funcionen en hardware normal.

Cuantización en pocas palabras

Cuantización significa representar los valores numéricos de un modelo con menos bits que en el original. Un modelo almacenado originalmente en números de punto flotante de 16 bits (FP16) se reduce a 8, 5 o 4 bits. Menos bits implican menor requisito de memoria y cálculos más rápidos.

Una buena comparación es la compresión de imágenes. Una imagen PNG guarda cada píxel sin pérdidas y es correspondientemente grande. Una imagen JPG comprime los datos, es decir, descarta información, pero se ve casi igual de bien para el ojo humano. La cuantización funciona de manera similar: reduces la precisión de los valores almacenados, pero el modelo sigue produciendo resultados útiles y frecuentemente casi indistinguibles.

Un modelo de 7B en FP16 requiere unos 14 GB. En Q4 necesita solo entre 4 y 5 GB. En una tarjeta gráfica con 8 GB de VRAM funciona sin problemas. El precio de este ahorro es una posible pérdida de calidad, generalmente pequeña, especialmente en niveles muy bajos como Q4 o Q3.

¿Para quién está pensada la cuantización?

La cuantización va dirigida a todos los que deseen ejecutar modelos de lenguaje localmente sin invertir miles de euros en hardware de servidor. Concretamente esto abarca a:

• Usuarios domésticos con una tarjeta gráfica de consumo que quieren ejecutar un modelo potente
• Desarrolladores que prueban modelos en estaciones de trabajo antes de pasarlos a producción
• Personas preocupadas por la privacidad que quieren usar modelos sin conexión para no enviar datos a servicios en la nube
• Investigadores y estudiantes que experimentan con presupuesto limitado
• Usuarios de Apple Silicon que desean aprovechar eficientemente la memoria unificada de sus Macs

En resumen: si quieres ejecutar IA local, necesitas cuantización. Prácticamente no hay forma de evitarlo.

Términos clave sobre cuantización

Término	Significado
FP16	Representación de punto flotante de 16 bits, formato estándar para modelos entrenados
INT8	Representación de entero de 8 bits, reduce el requisito de memoria a la mitad respecto a FP16
INT4	Representación de entero de 4 bits, reduce la memoria a una cuarta parte de FP16
Q4	Nivel de cuantización con 4 bits por peso
Q5	Nivel de cuantización con 5 bits por peso
Q6	Nivel de cuantización con 6 bits por peso
Q8	Nivel de cuantización con 8 bits por peso, cercano al original
GGUF	Formato de archivo para modelos cuantizados, utilizado por llama.cpp y Ollama
K-Quantisierung	Técnica de cuantización mixta que almacena los pesos sensibles con más bits
Bits	Número de bits de almacenamiento por valor de parámetro, determina precisión y requisito de memoria
Pesos	Los parámetros aprendidos del modelo, ajustados durante el entrenamiento
Activaciones	Los valores intermedios calculados durante la ejecución del modelo

¿Cómo funciona la cuantización?

Para entender la cuantización, necesitas saber cómo un modelo almacena números. Cada parámetro, es decir, cada peso en el modelo, es un número. Sin cuantizar, este número se almacena como un número de punto flotante de 16 bits, en formato FP16. Con 16 bits puedes representar aproximadamente 65.500 valores diferentes, lo que permite alta precisión.

En cuantización, tomas estos números de 16 bits y los conviertes en números con menos bits. Con 8 bits quedan 256 valores posibles, con 4 bits solo 16. Esto significa que agrupas valores cercanos y les asignas un valor común más burdo. Un número como 0,123456 se convierte, por ejemplo, en 0,125, porque ese es el nivel más cercano representable con 4 bits.

¿Por qué eso ahorra memoria? Es simple: menos bits por valor significa menos bytes en total. Un modelo de 13B tiene 13 mil millones de valores. Con 16 bits, es decir, 2 bytes por valor, necesitas 26 GB. Con 4 bits, es decir, 0,5 bytes por valor, necesitas solo 6,5 GB. El requisito de memoria disminuye proporcionalmente con el número de bits.

Hay dos enfoques fundamentales:

1. Cuantización posterior al entrenamiento (PTQ): El modelo se entrena normalmente y luego se cuantiza. Este es el caso más común en el ámbito local. Descargas un modelo FP16 terminado y lo conviertes a una versión Q4 o Q8. El proceso tarda desde minutos hasta horas, dependiendo del tamaño del modelo.

2. Entrenamiento consciente de cuantización (QAT): El modelo se prepara durante el entrenamiento para ser cuantizado posteriormente. Esto produce mejores resultados pero es más costoso y generalmente lo realizan los desarrolladores del modelo, no los usuarios finales.

Para uso local, casi siempre es relevante PTQ. Descargas un modelo ya cuantizado o lo cuantizas tú mismo con herramientas como llama.cpp.

Una distinción importante es qué se cuantiza exactamente. En la mayoría de procedimientos locales, solo se cuantizaban los pesos, no las activaciones. Esto simplifica el proceso y es suficiente para la mayoría de casos de uso. Durante la ejecución, los pesos cuantizados se convierten brevemente a mayor precisión para el cálculo, lo que se conoce como descuantización.

Tipos de cuantización

Existen varios métodos y formatos que juegan un papel importante en el ámbito de la IA local. Se diferencian en técnica de compresión, velocidad y compatibilidad.

GGUF (GPT-Generated Unified Format): El formato estándar para modelos locales, utilizado por llama.cpp, Ollama y LM Studio. GGUF almacena el modelo en un único archivo, incluyendo metadatos y tokenizador. Soporta muchos niveles de cuantización desde Q2 hasta Q8 y las variantes de K-cuantización. GGUF es la opción más segura si quieres ejecutar un modelo localmente, porque funciona en CPU, GPU y Apple Silicon.

AWQ (Activation-aware Weight Quantization): Un método que identifica los pesos particularmente importantes y los almacena con mayor precisión. AWQ a menudo proporciona mejor calidad en 4 bits que procedimientos simples, pero está diseñado principalmente para ejecución en GPU con vLLM o Text-Generation-Inference. Para usuarios puros de llama.cpp, GGUF es la mejor opción.

GPTQ: Un procedimiento más antiguo que cuantiza pesos basándose en su influencia en la salida del modelo. GPTQ proporciona buenos resultados en 4 bits, pero está siendo desplazado progresivamente por AWQ y métodos más nuevos. Funciona bien con ciertos frameworks, pero es menos flexible que GGUF.

EXL2 (ExLlamaV2): Un formato que permite tasas de bits flexibles, por ejemplo 4,5 bits o 6,25 bits. EXL2 está optimizado para velocidad con ExLlamaV2 y es adecuado para usuarios que buscan velocidad máxima de inferencia en GPUs Nvidia. Es menos difundido que GGUF, pero popular entre entusiastas de la velocidad.

bitsandbytes: Una biblioteca que integra cuantización de 8 bits y 4 bits directamente en PyTorch. Se utiliza frecuentemente para entrenamiento y ajuste fino, por ejemplo en QLoRA. Para ejecución pura, bitsandbytes es menos típico, pero relevante para desarrolladores que quieren adaptar modelos.

Qué método es el mejor depende de tu configuración. Para la mayoría de usuarios: GGUF a través de Ollama o llama.cpp es el camino más simple y compatible. Quien quiere velocidad máxima en GPU y utiliza ExLlamaV2, elige EXL2. Quien ajusta modelos no puede evitar bitsandbytes.

K-cuantización explicada

Cuando exploras modelos cuantizados, te encuentras con designaciones como Q4_0 y Q4_K_M. La diferencia es importante.

Q4_0 es la variante simple: todos los pesos del modelo se cuantizan uniformemente a 4 bits. Es rápido, sencillo y ahorra máximo almacenamiento, pero ignora que no todos los pesos son igualmente importantes.

Q4_K_M es una variante de K-cuantización. La “K” representa un método que almacena diferentes partes del modelo con precisión variable. Las capas sensibles que tienen fuerte influencia en la salida se almacenan con más bits, por ejemplo 6 bits. Las capas menos críticas obtienen 4 bits o menos. La “M” significa “Medium” y es un compromiso entre tamaño y calidad.

¿Por qué es mejor? Un modelo consta de muchas capas, y no cada capa es igualmente importante para el resultado final. Si cuantizas todas uniformemente de forma cruda, pierdes demasiada información en las capas importantes. La K-cuantización preserva la calidad de las partes importantes y ahorra solo en las partes no críticas consistentemente. El resultado es un modelo apenas más grande que una versión Q4_0, pero que proporciona respuestas notablemente mejores.

Existen varias variantes de K:

• Q4_K_S (Small): Compresión algo más agresiva, más pequeño que Q4_K_M
• Q4_K_M (Medium): El compromiso más popular, recomendado para la mayoría de usuarios
• Q5_K_M: Base de 5 bits con cuantización mixta, calidad superior a Q4
• Q6_K: Base de 6 bits, muy cerca del original, pero más grande

Como regla general: si usas Q4, elige Q4_K_M, no Q4_0. La diferencia de calidad es perceptible, la diferencia de almacenamiento mínima.

Comparación de niveles de cuantización comunes

Nivel	Bits	Requisitos de almacenamiento (modelo 13B)	Calidad	Velocidad	Adecuado para
FP16	16	aprox. 26 GB	Original	Base	Servidores, workstations de alto rendimiento
Q8_0	8	aprox. 13 GB	Casi idéntico	Muy rápido	GPUs con 16+ GB VRAM
Q6_K	6	aprox. 10 GB	Excelente	Rápido	La calidad es prioritaria
Q5_K_M	5	aprox. 9 GB	Muy bueno	Rápido	Compromiso sólido
Q4_K_M	4	aprox. 8 GB	Bueno	Muy rápido	Opción estándar para GPUs consumer
Q4_0	4	aprox. 7 GB	Algo más débil que Q4_K_M	Muy rápido	Cuando cada GB cuenta
Q3_K_M	3	aprox. 6 GB	Notablemente más débil	Muy rápido	Solución de emergencia con muy poco VRAM
Q2_K	2	aprox. 5 GB	Significativamente limitado	Muy rápido	Solo para experimentos

Los valores de almacenamiento son orientativos y varían ligeramente según la arquitectura del modelo y el tamaño del tokenizador.

Ejemplo: ahorro de almacenamiento en un modelo 13B

Aquí hay un cálculo concreto que muestra cuánto ahorras con cuantización. Tomamos un modelo 13B con 13 mil millones de parámetros.

FP16 (Original): 13 mil millones de parámetros por 2 bytes (16 bits) resulta en 26 GB de almacenamiento requerido. Esto no cabe en ninguna tarjeta gráfica consumer típica.

Q8_0: 13 mil millones de parámetros por 1 byte (8 bits) resulta en 13 GB. Esto cabe en una RTX 4080 con 16 GB VRAM, pero ajustadamente, porque aún necesitas espacio para el contexto.

Q5_K_M: 13 mil millones de parámetros por 0,625 bytes (5 bits, más algo de overhead por cuantización mixta) resulta en aproximadamente 9 GB. Esto cabe en una RTX 3080 con 10 GB o una RTX 4070 con 12 GB.

Q4_K_M: 13 mil millones de parámetros por 0,5 bytes (4 bits, más overhead) resulta en aproximadamente 8 GB. Esto cabe en una RTX 3060 con 12 GB, con espacio suficiente para un contexto adecuado.

El ahorro de FP16 a Q4_K_M es enorme: necesitas solo aproximadamente un tercio del almacenamiento. En lugar de una costosa GPU de workstation, una tarjeta gráfica de gama media es suficiente.

Encontrarás más información sobre los requisitos de almacenamiento de diferentes modelos en el artículo Requisitos de RAM y VRAM.

¿Qué nivel de cuantización debo elegir?

La elección depende principalmente del VRAM disponible. Aquí hay una guía de decisión:

Tienes 8 GB VRAM o menos: Elige Q4_K_M para modelos de hasta 7B parámetros. Para modelos de 13B se vuelve ajustado, Q3_K_M o Q2_K son posibles, pero espera pérdidas de calidad. Lo mejor es usar un modelo más pequeño en mayor calidad.

Tienes 12 GB VRAM: Q4_K_M para modelos de 13B es ideal. Aún tienes espacio para un contexto generoso. Alternativamente, Q5_K_M para modelos de 7B, si la calidad es más importante que el tamaño del modelo.

Tienes 16 GB VRAM: Q5_K_M o Q6_K para modelos de 13B son una buena opción. Obtienes calidad alta y contexto suficiente. Para modelos de 7B puedes usar Q8_0 y estar cerca del original.

Tienes 24 GB VRAM o más: Q6_K o Q8_0 para modelos de 13B proporciona calidad casi original. También puedes ejecutar modelos de 30B o 34B en Q4_K_M.

Usas Apple Silicon: Apple Silicon comparte memoria entre CPU y GPU. Un Mac con 16 GB RAM puede ejecutar bien un modelo 7B en Q4_K_M. Con 32 GB RAM, los modelos de 13B en Q4_K_M son realistas. Con 64 GB o más, también puedes usar modelos de 30B en Q5 o Q6.

Como recomendación general: Q4_K_M es la opción estándar con la que rara vez te equivocas. Si tienes más VRAM, sube a Q5_K_M o Q6_K. Usas Q8_0 cuando la calidad máxima es más importante que el ahorro de almacenamiento. Q3 y Q2 debes elegirlos solo en caso de emergencia, las pérdidas de calidad se notan allí.

Cómo obtener modelos cuantizados

No necesitas cuantizar modelos por tu cuenta. Hay varios caminos simples para conseguir versiones cuantizadas ya listas.

Ollama: La opción más directa. Ollama descarga automáticamente una versión cuantizada apropiada cuando instalas un modelo. Escribes ollama run llama3 y Ollama se encarga del resto. Por defecto utiliza Q4_K_M, ideal para la mayoría de usuarios.

Hugging Face: La plataforma más grande para modelos. Allí encuentras archivos GGUF cuantizados que puedes descargar manualmente y usar con llama.cpp, LM Studio u otras herramientas. Busca el nombre del modelo más “GGUF”, por ejemplo “Llama-3-8B-Instruct-GGUF”.

TheBloke: Uno de los proveedores más conocidos de modelos cuantizados en Hugging Face. TheBloke ha puesto a disposición cientos de modelos en diferentes niveles de cuantización, desde Q2 hasta Q8. Busca “TheBloke” más el nombre del modelo en Hugging Face.

bartowski: Otro proveedor activo de modelos GGUF cuantizados. Si TheBloke no tiene un modelo específico, revisa bartowski. La calidad de las cuantizaciones es comparable.

LM Studio: Una aplicación de escritorio con interfaz gráfica que descarga modelos directamente desde Hugging Face. Buscas un modelo, seleccionas el nivel de cuantización de una lista y LM Studio descarga el archivo GGUF correspondiente. Ideal para usuarios que prefieren evitar la línea de comandos.

Si quieres cuantizar un modelo tú mismo, necesitas el modelo original en FP16 y una herramienta como llama.cpp. El proceso está bien documentado, pero para la mayoría de usuarios es más sencillo descargar archivos GGUF ya preparados.

Errores comunes al cuantizar

1. Cuantización demasiado baja para tareas complejas: Q4 funciona bien para chat y textos generales. En tareas que requieren razonamiento lógico preciso o formateo exacto, como generación de código o cálculos matemáticos, los niveles bajos pueden introducir errores. Aquí deberías usar al menos Q5_K_M o Q6_K.

2. No contabilizar el contexto: El consumo de memoria de un modelo no es solo el modelo en sí. También necesitas espacio para el contexto, es decir, la conversación en curso, y para resultados intermedios del cálculo. Planifica unos 1 o 2 GB adicionales para el contexto, más si utilizas contextos largos. Los detalles están en el artículo Contextlänge.

3. Formato incorrecto para el software: GGUF funciona con llama.cpp y Ollama. Pero si usas vLLM o ExLlamaV2, necesitas AWQ o EXL2. Verifica qué formato soporta tu software antes de descargar un modelo.

4. Cuantización en CPU vs. en GPU: Algunos formatos están optimizados para CPU, otros para GPU. GGUF funciona en ambos, pero no siempre es el más rápido en GPU. EXL2 es rápido en GPUs Nvidia, pero no funciona en CPU. Elige el formato según tu hardware.

5. Usar variantes antiguas de cuantización: Q4_0 es más antiguo y simple que Q4_K_M. Si puedes elegir, siempre opta por la variante K. La diferencia de calidad es notable, la diferencia de memoria es mínima.

6. Calcular VRAM demasiado ajustado: Si un modelo “apenas cabe” en VRAM, puede causar problemas en conversaciones más largas porque el contexto crece. Deja margen, especialmente si trabajas con textos largos o ventanas de contexto grandes.

7. En Apple Silicon se comparte memoria entre sistema y GPU: En Macs con Apple Silicon, CPU y GPU usan la misma memoria. Un Mac de 16 GB no tiene 16 GB de VRAM, sino que comparte 16 GB entre el sistema operativo, aplicaciones y modelo. Planifica en consecuencia.

Hardware, costos y seguridad con cuantización

Hardware: Los modelos cuantizados reducen los requisitos de hardware considerablemente. En lugar de una cara GPU profesional con 24 GB de VRAM, a menudo basta una tarjeta gráfica de rango medio con 8 a 12 GB. Esto abre la IA local a un público mucho más amplio. Más información sobre fundamentos de hardware en KI-Hardware Grundlagen.

Costos: El ahorro de costos es significativo. Una RTX 3060 con 12 GB cuesta una fracción de lo que cuesta una A100 con 80 GB. Con cuantización puedes ejecutar un modelo de 13B en una RTX 3060, algo que sin cuantización requeriría una GPU de precio de cuatro dígitos.

Seguridad: La cuantización no cambia la seguridad de tus datos. El modelo cuantizado es una versión comprimida del mismo modelo, no un modelo nuevo. Si lo ejecutas localmente, todos los datos permanecen en tu máquina. No se envía información a servicios en la nube. Este es uno de los grandes beneficios de la IA local, algo que la cuantización no afecta.

Un aspecto a considerar: en raros casos los modelos cuantizados pueden comportarse ligeramente diferente al original, especialmente con niveles muy bajos. Si utilizas un modelo para aplicaciones críticas de seguridad, prueba exhaustivamente la versión cuantizada antes de usarla en producción.

Enlaces adicionales e información sobre cuantización

• Was ist lokale KI? - Fundamentos de operación de IA local
• LLM lokal betreiben - Guía práctica para empezar
• RAM und VRAM Anforderungen - Cuánta memoria necesitas
• Kontextlänge - Por qué el contexto consume memoria
• Ollama - La forma más simple de ejecutar modelos locales
• RAM vs. VRAM - Diferencias entre tipos de memoria
• KI-Hardware Grundlagen - Resumen de hardware apropiado

FAQ - Preguntas típicas sobre cuantización

¿Pierdo mucha calidad con la cuantización?

Con Q4 la diferencia es notable para muchas tareas, pero a menudo todavía aceptable. Con Q5 o Q6 la pérdida de calidad disminuye significativamente. Q8 es prácticamente indistinguible del original para la mayoría de aplicaciones.

¿Cuál es la diferencia entre Q4_0 y Q4_K_M?

Q4_0 cuantiza todos los pesos uniformemente. Q4_K_M usa cuantización mixta, almacenando las partes más sensibles del modelo con más bits, y generalmente ofrece mejores resultados con casi el mismo consumo de memoria.

¿Puedo cuantizar un modelo yo mismo?

Sí, con herramientas como llama.cpp y los scripts de conversión correspondientes. Normalmente usas archivos GGUF ya cuantizados de Hugging Face o a través de Ollama, porque es más rápido y sencillo.

¿Cuánta memoria ahorro con Q4?

Aproximadamente tres a cuatro veces menos que un modelo FP16. Un modelo de 13B se reduce de alrededor de 26 GB a unos 7 u 8 GB, dependiendo de la variante.

¿Necesito cuantización también en Apple Silicon?

Sí. Apple Silicon también se beneficia mucho de modelos cuantizados, porque la memoria unificada es limitada y se logran tiempos de carga más rápidos. Un Mac con 16 GB de RAM puede ejecutar bien un modelo de 7B en Q4.

¿Cuál es el nivel de cuantización mejor para principiantes?

Q4_K_M es la recomendación estándar. Ofrece un buen balance entre ahorro de memoria y calidad, y funciona en la mayoría de tarjetas gráficas consumer. Si tienes dudas, comienza con Q4_K_M.

¿Qué significa la “K” en Q4_K_M?

La “K” representa el método de cuantización K, que almacena diferentes capas del modelo con precisión variable. La “M” significa “Medium”, un compromiso entre tamaño y calidad. También existen “S” para Small y “L” para Large.

¿Es GGUF mejor que AWQ o GPTQ?

Depende de tu software. GGUF es más flexible y funciona en CPU, GPU y Apple Silicon. AWQ y GPTQ están pensados más bien para ejecución en GPU con frameworks específicos como vLLM. Para la mayoría de usuarios locales, GGUF es la mejor opción.

¿Puedo seguir entrenando un modelo cuantizado?

No directamente, pero puedes usar QLoRA, una técnica que permite fine-tuning en modelos cuantizados. El modelo base permanece cuantizado y solo pequeños módulos adicionales se entrenan en mayor precisión.

¿Qué pasa si el modelo no cabe en VRAM?

El software descarga partes del modelo a RAM del sistema. Funciona, pero es considerablemente más lento porque la RAM del sistema tiene menor ancho de banda que VRAM. Con descarga intensiva, la generación de texto se ralentiza notablemente.

¿Son seguros los modelos cuantizados?

Sí. La cuantización es una técnica pura de compresión. El modelo sigue siendo el mismo, solo cambia la representación en memoria. Si lo ejecutas localmente, tus datos permanecen en tu máquina.

¿Afecta la cuantización a la velocidad?

Sí, usualmente positivamente. Los modelos cuantizados requieren menos ancho de banda de memoria, lo que puede acelerar la ejecución. En GPU, los modelos de 4 bits y 8 bits a menudo son más rápidos que FP16, porque se deben mover menos datos.

¿Puedo cambiar entre niveles de cuantización sin recargar el modelo?

No. Cada nivel de cuantización es un archivo separado. Si quieres cambiar el nivel, debes cargar el modelo correspondiente. Con Ollama puedes instalar diferentes niveles del mismo modelo y alternar entre ellos.

¿Cuál es la diferencia entre cuantización de pesos y de activaciones?

La cuantización de pesos reduce solo los parámetros almacenados del modelo. La cuantización de activaciones también cuantiza los valores intermedios durante la ejecución. La última es más complicada y menos común en el ámbito local, pero puede proporcionar beneficios de velocidad adicionales.

Fuentes y lecturas complementarias

• Documentación de cuantización de llama.cpp en GitHub
• Catálogo de modelos y documentación de Hugging Face
• Colección de modelos GGUF de TheBloke en Hugging Face
• Modelos GGUF de bartowski en Hugging Face
• Documentación de gestión de modelos de Ollama
• Documentación de ExLlamaV2 sobre el formato EXL2