> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monostate.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Cuantización

> Reduce memoria con entrenamiento cuantizado

# Cuantización

La cuantización reduce el uso de memoria usando menor precisión para pesos del modelo.

## Inicio Rápido

```bash theme={null}
aitraining llm --train \
  --model meta-llama/Llama-3.2-8B \
  --data-path ./data.jsonl \
  --project-name quantized-model \
  --peft \
  --quantization int4
```

## Python API

```python theme={null}
from autotrain.trainers.clm.params import LLMTrainingParams

params = LLMTrainingParams(
    model="meta-llama/Llama-3.2-8B",
    data_path="./data.jsonl",
    project_name="quantized-model",

    peft=True,
    quantization="int4",  # or "int8"
    lora_r=16,
)
```

## Opciones de Cuantización

| Opción | Reducción de Memoria | Calidad   |
| ------ | -------------------- | --------- |
| None   | 0%                   | Mejor     |
| int8   | \~50%                | Muy Buena |
| int4   | \~75%                | Buena     |

## Tareas Soportadas

La cuantización está disponible para:

| Tarea   | Clase Params        | Notas            |
| ------- | ------------------- | ---------------- |
| LLM     | `LLMTrainingParams` | Soporte completo |
| VLM     | `VLMTrainingParams` | Soporte completo |
| Seq2Seq | `Seq2SeqParams`     | Soporte completo |

### 4-bit (QLoRA)

Máximo ahorro de memoria:

```python theme={null}
params = LLMTrainingParams(
    ...
    quantization="int4",
)
```

### 8-bit

Mejor calidad, menos ahorro:

```python theme={null}
params = LLMTrainingParams(
    ...
    quantization="int8",
)
```

## Requisitos de Memoria

### Llama 3.2 8B

| Config             | VRAM Requerido |
| ------------------ | -------------- |
| Precisión completa | \~64 GB        |
| LoRA (fp16)        | \~18 GB        |
| LoRA + 8bit        | \~12 GB        |
| LoRA + 4bit        | \~8 GB         |

### Gemma 2 27B

| Config             | VRAM Requerido |
| ------------------ | -------------- |
| Precisión completa | \~108 GB       |
| LoRA + 4bit        | \~20 GB        |

## Mejores Prácticas

### Usa con LoRA

La cuantización **requiere** que PEFT/LoRA esté habilitado:

```python theme={null}
params = LLMTrainingParams(
    ...
    peft=True,  # Required for quantized training
    quantization="int4",
)
```

<Warning>
  La cuantización solo funciona cuando `peft=True`. Sin PEFT habilitado, la configuración de cuantización será ignorada.
</Warning>

### Ajusta la Tasa de Aprendizaje

El entrenamiento cuantizado a menudo se beneficia de una tasa de aprendizaje mayor que la por defecto (`3e-5`):

```python theme={null}
params = LLMTrainingParams(
    ...
    peft=True,
    quantization="int4",
    lr=2e-4,  # Higher LR works well with QLoRA
)
```

### Usa Flash Attention

Combina con [Flash Attention](/advanced/flash-attention) para velocidad:

```python theme={null}
params = LLMTrainingParams(
    ...
    quantization="int4",
    use_flash_attention_2=True,  # Requires Linux + CUDA + flash-attn package
)
```

## Inferencia con Modelos Cuantizados

Carga modelos cuantizados para inferencia:

```python theme={null}
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

# 4-bit config (matches AITraining defaults)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=False,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B",
    quantization_config=bnb_config,
)
```

## Requisitos de Plataforma

<Warning>
  **La cuantización solo funciona en Linux.** La biblioteca `bitsandbytes` requerida para cuantización int4/int8 está disponible solo en sistemas Linux.
</Warning>

## Nota sobre Apple Silicon (MPS)

La cuantización **no es compatible con Apple Silicon MPS**. Cuando usas cuantización en un Mac con M1/M2/M3:

* El entrenamiento automáticamente vuelve a CPU
* Verás un mensaje de advertencia explicando esto
* Para entrenamiento más rápido en Mac, omite la cuantización y usa solo LoRA

```bash theme={null}
# En Apple Silicon - usa LoRA sin cuantización para aceleración MPS
aitraining llm --train \
  --model google/gemma-3-270m \
  --data-path ./data.jsonl \
  --project-name mac-training \
  --peft \
  --lora-r 16
```

Variables de entorno para control manual:

* `AUTOTRAIN_DISABLE_MPS=1` - Forzar entrenamiento en CPU
* `AUTOTRAIN_ENABLE_MPS=1` - Forzar MPS incluso con cuantización (puede fallar)

## Consideraciones de Calidad

La cuantización reduce ligeramente la calidad. Para aplicaciones críticas:

1. Prueba en tu tarea específica
2. Compara con línea base de precisión completa
3. Considera 8-bit si la calidad importa más

## Próximos Pasos

<CardGroup cols={2}>
  <Card title="LoRA/PEFT" href="/advanced/lora-peft">
    Fine-tuning eficiente
  </Card>

  <Card title="Flash Attention" href="/advanced/flash-attention">
    Optimizaciones de velocidad
  </Card>
</CardGroup>