# FP8 de gran granularidad

La cuantización FP8 de gran granularidad cuantiza los pesos y las activaciones a fp8.

- Los pesos se cuantizan a 8 bits para cada bloque 2D (`weight_block_size=(128, 128)`).
- Las activaciones se cuantizan a 8 bits para cada grupo por token. El valor del grupo coincide con los pesos en el canal de entrada (128 por defecto).

La cuantización FP8 permite el soporte para [DeepSeek-V3](https://hf.co/papers/2412.19437) y DeepSeek-R1.

    

> [!TIP]
> Se necesita una GPU con Compute Capability>=9 (H100) y una versión de PyTorch compatible con la versión de CUDA de la GPU.

Instala Accelerate y actualiza a la última versión de PyTorch.

```bash
pip install --upgrade accelerate torch
```

Cree una clase [FineGrainedFP8Config](/docs/transformers/main/es/main_classes/quantization#transformers.FineGrainedFP8Config) y pásela a [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cuantizarla. Por defecto, los pesos se cargan en precisión completa (`torch.float32`) sin importar el tipo de datos real en el que se almacenan. Establezca `dtype="auto"` para cargar los pesos en el tipo de datos definido en el archivo `config.json` del modelo, de modo que se cargue automáticamente el tipo de datos más óptimo en memoria.

```py
from transformers import FineGrainedFP8Config, AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Meta-Llama-3-8B"
quantization_config = FineGrainedFP8Config()
quantized_model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto", device_map="auto", quantization_config=quantization_config)

tokenizer = AutoTokenizer.from_pretrained(model_name)
input_text = "What are we having for dinner?"
input_ids = tokenizer(input_text, return_tensors="pt").to(quantized_model.device.type)

output = quantized_model.generate(**input_ids, max_new_tokens=10)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

Use [save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained) para guardar el modelo cuantizado y recárguelo con [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained).

```py
quant_path = "/path/to/save/quantized/model"
quantized_model.save_pretrained(quant_path)
model = AutoModelForCausalLM.from_pretrained(quant_path, device_map="auto")
```

## Ruta rápida de DeepGEMM

En las GPU Hopper (SM90+) y Blackwell (SM100+), cada lineal FP8 se despacha automáticamente a los kernels de [DeepGEMM](https://github.com/deepseek-ai/DeepGEMM) de [kernels-community/deep-gemm](https://huggingface.co/kernels-community/deep-gemm) cuando `weight_block_size=(128, 128)` y `activation_scheme="dynamic"`. DeepGEMM es de 3 a 6 veces más rápido que la alternativa de Triton. Instala o actualiza el paquete [kernels](https://github.com/huggingface/kernels) para habilitarlo.

```bash
pip install -U kernels
```

DeepGEMM compila sus kernels mediante JIT con el `nvcc` del sistema, por lo que debe estar instalado un kit de herramientas CUDA completo. Una instalación solo de tiempo de ejecución (bibliotecas de CUDA sin `nvcc`) no funcionará. La versión mínima del kit de herramientas depende del hardware: 12.3 o posterior en Hopper (SM90) y 12.9 o posterior en Blackwell (SM100).

Transformers localiza el kit de herramientas comprobando `CUDA_HOME`, luego `CUDA_PATH`, luego `nvcc` en tu `PATH` y luego `/usr/local/cuda`. Establece `CUDA_HOME` en la raíz del kit de herramientas si `nvcc` no se detecta.

Si el kernel no se puede cargar (faltan `kernels`, GPU no compatible, ausencia del toolkit de CUDA o una versión de `nvcc` anterior a la requerida), Transformers registra una advertencia una sola vez y recurre al kernel finegrained-fp8 de Triton. La cuantización estática de activaciones siempre se mantiene en la ruta de Triton.

Para forzar el uso de la alternativa de Triton incluso cuando DeepGEMM está disponible, establezca `TRANSFORMERS_DISABLE_DEEPGEMM_LINEAR=1`. Esto solo afecta la asignación lineal de FP8 y deja intacto el backend de expertos `"deepgemm"`, que se cambia con [set_experts_implementation()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.set_experts_implementation).

Para los expertos de MoE, la ruta de DeepGEMM es opcional. Pasa `experts_implementation="deepgemm"` (o `"deepgemm_megamoe"` en Blackwell) en el momento de la carga para enrutar las multiplicaciones de matrices de los expertos a través de DeepGEMM. Consulta la guía [Backends de expertos](../experts_interface) para ver el conjunto completo de opciones.

## Formato de escala UE8M0

Los puntos de control de estilo DeepSeek V4 almacenan las escalas de pesos FP8 en el formato empaquetado `float8_e8m0fnu` en lugar de `float32`. Estos puntos de control están pre-cuantizados y establecen `scale_fmt="ue8m0"` en su configuración de cuantización. Tanto los núcleos de DeepGEMM como los de Triton leen las escalas UE8M0, por lo que estos puntos de control se ejecutan en cualquiera de las dos rutas.

En Blackwell (SM100+), los kernels de expertos de DeepGEMM solo admiten escalas UE8M0. Un checkpoint con escalas `float32` simples (`scale_fmt="float"`) genera un `ValueError`. Utilice un checkpoint con `scale_fmt="ue8m0"`, o ejecute los expertos con `grouped_mm` o `batched_mm`, que admiten escalas `float32` directamente. Hopper (SM90+) admite escalas `float32` en la ruta de DeepGEMM sin conversión. Consulte la guía de [backends de expertos](../experts_interface) para conocer las opciones de backend de expertos.