# Quanto

> [!WARNING]
> Backend Quanto telah ditinggalkan dan akan dihapus pada versi 1.0.0. Pertimbangkan untuk beralih ke salah satu [backend kuantisasi](./overview) lain yang didukung, seperti [bitsandbytes](./bitsandbytes) atau [torchao](./torchao).

[Quanto](https://github.com/huggingface/optimum-quanto) adalah backend kuantisasi PyTorch untuk [Optimum](https://huggingface.co/docs/optimum/en/index). Ia dirancang dengan mempertimbangkan fleksibilitas dan kesederhanaan:

- Semua fitur tersedia dalam mode eager (berfungsi dengan model yang tidak dapat dilacak)
- Mendukung pelatihan yang sadar kuantisasi
- Model terkuantisasi kompatibel dengan `torch.compile`
- Model terkuantisasi bersifat tidak bergantung pada perangkat (misalnya CUDA, XPU, MPS, CPU)

Untuk menggunakan backend Quanto, Anda perlu menginstal `optimum-quanto>=0.2.6` dan `accelerate` terlebih dahulu.

```shell
pip install optimum-quanto accelerate
```

Sekarang Anda dapat mengkuantisasi model dengan meneruskan objek `QuantoConfig` ke metode `from_pretrained()`. Meskipun pustaka Quanto mengizinkan pengkuantisasian modul `nn.Conv2d` dan `nn.LayerNorm`, saat ini Diffusers hanya mendukung pengkuantisasian bobot pada lapisan `nn.Linear` dari sebuah model. Cuplikan berikut menunjukkan cara menerapkan kuantisasi `float8` dengan Quanto.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)

pipe = FluxPipeline.from_pretrained(model_id, transformer=transformer, dtype=dtype)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")
```

## Mengabaikan Kuantisasi pada modul tertentu

Anda dapat melewati penerapan kuantisasi pada modul tertentu dengan menggunakan argumen `modules_to_not_convert` di `QuantoConfig`. Pastikan modul yang diteruskan ke argumen ini sesuai dengan kunci modul di `state_dict`

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8", modules_to_not_convert=["proj_out"])
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
```

## Menggunakan `from_single_file` dengan Backend Quanto

`QuantoConfig` kompatibel dengan `~FromOriginalModelMixin.from_single_file`.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

ckpt_path = "https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/flux1-dev.safetensors"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_single_file(ckpt_path, quantization_config=quantization_config, dtype=torch.bfloat16)
```

## Menyimpan model terkuantisasi

Diffusers mendukung serialisasi model Quanto menggunakan metode `~ModelMixin.save_pretrained`.

Persyaratan serialisasi dan pemuatan berbeda untuk model yang dikuantisasi langsung dengan pustaka Quanto dan model yang dikuantisasi dengan Diffusers menggunakan Quanto sebagai backend. Saat ini, tidak mungkin memuat model yang dikuantisasi langsung dengan Quanto ke dalam Diffusers menggunakan `~ModelMixin.from_pretrained`

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
# save quantized model to reuse
transformer.save_pretrained("<your quantized model save path>")

# you can reload your quantized model with
model = FluxTransformer2DModel.from_pretrained("<your quantized model save path>")
```

## Menggunakan `torch.compile` dengan Quanto

Saat ini backend Quanto mendukung `torch.compile` untuk tipe kuantisasi berikut:

- Bobot `int8`

```python
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="int8")
transformer = FluxTransformer2DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    quantization_config=quantization_config,
    dtype=torch.bfloat16,
)
transformer = torch.compile(transformer, mode="max-autotune", fullgraph=True)

pipe = FluxPipeline.from_pretrained(
    model_id, transformer=transformer, dtype=dtype
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"
images = pipe("A cat holding a sign that says hello").images[0]
images.save("flux-quanto-compile.png")
```

## Jenis Kuantisasi yang Didukung

### Bobot

- float8
- int8
- int4
- int2