# GGUF

El formato de archivo GGUF se utiliza típicamente para almacenar modelos para inferencia con [GGML](https://github.com/ggerganov/ggml) y admite una variedad de opciones de cuantización por bloques. Diffusers admite la carga de puntos de control precuantizados y guardados en el formato GGUF mediante la carga con `from_single_file` en las clases de Modelo. La carga de puntos de control GGUF a través de Pipelines no está soportada actualmente.

El siguiente ejemplo cargará el modelo transformer [FLUX.1 DEV](https://huggingface.co/black-forest-labs/FLUX.1-dev) utilizando la variante de cuantización GGUF Q2_K.

Antes de comenzar, instale gguf en su entorno

```shell
pip install -U gguf
```

Dado que GGUF es un formato de archivo único, use `~FromSingleFileMixin.from_single_file` para cargar el modelo y pase [GGUFQuantizationConfig](/docs/diffusers/main/es/api/quantization#diffusers.GGUFQuantizationConfig).

Al usar puntos de control GGUF, los pesos cuantizados permanecen en un `dtype` de baja memoria (típicamente `torch.uint8`) y se descuantizan dinámicamente y se convierten al `compute_dtype` configurado durante el paso hacia adelante de cada módulo a través del modelo. `GGUFQuantizationConfig` permite establecer el `compute_dtype`.

Las funciones utilizadas para la descuantización dinámica se basan en el gran trabajo realizado por [city96](https://github.com/city96/ComfyUI-GGUF), quien creó las portadas a Pytorch de la implementación original en [`numpy`](https://github.com/ggerganov/llama.cpp/blob/master/gguf-py/gguf/quants.py) de [compilade](https://github.com/compilade).

```python
import torch

from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

ckpt_path = (
    "https://huggingface.co/city96/FLUX.1-dev-gguf/blob/main/flux1-dev-Q2_K.gguf"
)
transformer = FluxTransformer2DModel.from_single_file(
    ckpt_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16,
)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, generator=torch.manual_seed(0)).images[0]
image.save("flux-gguf.png")
```

## Uso de núcleos CUDA optimizados con GGUF

Los kernels de CUDA optimizados pueden acelerar la inferencia de modelos cuantizados en formato GGUF en aproximadamente un 10%. Esta funcionalidad requiere una GPU compatible con `torch.cuda.get_device_capability` mayor que 7 y la biblioteca de kernels:

```shell
pip install -U kernels
```

Una vez instalado, establece `DIFFUSERS_GGUF_CUDA_KERNELS=true` para usar kernels optimizados cuando estén disponibles. Ten en cuenta que los kernels de CUDA pueden introducir pequeñas diferencias numéricas en comparación con la implementación original de GGUF, lo que podría causar variaciones visuales sutiles en las imágenes generadas. Para deshabilitar el uso de kernels de CUDA, establece la variable de entorno `DIFFUSERS_GGUF_CUDA_KERNELS=false`.

Los kernels GGUF se descargan del repositorio [`Isotr0py/ggml`](https://huggingface.co/Isotr0py/ggml), cuyo editor no es un editor de kernels de confianza en el Hub. Al cargarlo, se descarga y ejecuta código desde el Hub, por lo que Diffusers requiere que aceptes explícitamente esta acción estableciendo `DIFFUSERS_TRUST_REMOTE_KERNELS=true`. Consulta [Confianza en kernels remotos](../optimization/attention_backends#trusting-remote-kernels) para más detalles.

## Tipos de cuantización admitidos

- BF16
- Q4_0
- Q4_1
- Q5_0
- Q5_1
- Q8_0
- Q2_K
- Q3_K
- Q4_K
- Q5_K
- Q6_K

## Convertir a GGUF

Utilice el Space de abajo para convertir un checkpoint de Diffusers al formato GGUF para inferencia. Ejecutar la conversión:

<iframe src="https://diffusers-internal-dev-diffusers-to-gguf.hf.space" frameborder="0" width="850" height="450"
>

```py
import torch

from diffusers import FluxPipeline, FluxTransformer2DModel, GGUFQuantizationConfig

ckpt_path = (
    "https://huggingface.co/sayakpaul/different-lora-from-civitai/blob/main/flux_dev_diffusers-q4_0.gguf"
)
transformer = FluxTransformer2DModel.from_single_file(
    ckpt_path,
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    config="black-forest-labs/FLUX.1-dev",
    subfolder="transformer",
    dtype=torch.bfloat16,
)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    transformer=transformer,
    dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
prompt = "A cat holding a sign that says hello world"
image = pipe(prompt, generator=torch.manual_seed(0)).images[0]
image.save("flux-gguf.png")
```

Al usar puntos de control GGUF en formato Diffusers, es obligatorio proporcionar la ruta de la `config` del modelo. Si la configuración del modelo se encuentra en una `subfolder`, también se debe especificar.