# Memulai

Quantization berfokus pada representasi data dengan jumlah bit yang lebih sedikit sambil tetap berusaha mempertahankan presisi data asli. Hal ini sering berarti mengonversi tipe data untuk merepresentasikan informasi yang sama dengan bit yang lebih sedikit. Misalnya, jika bobot model Anda disimpan sebagai floating point 32-bit dan dikuantisasi menjadi floating point 16-bit, ukuran model akan berkurang setengahnya sehingga lebih mudah disimpan dan penggunaan memori berkurang. Presisi yang lebih rendah juga dapat mempercepat inferensi karena waktu yang dibutuhkan untuk melakukan perhitungan dengan bit yang lebih sedikit lebih singkat.

Diffusers mendukung beberapa backend kuantisasi untuk membuat model difusi besar seperti [Flux](../api/pipelines/flux) lebih mudah diakses. Panduan ini menunjukkan cara menggunakan kelas [PipelineQuantizationConfig](/docs/diffusers/main/id/api/quantization#diffusers.PipelineQuantizationConfig) untuk mengkuantisasi pipeline selama inisialisasinya dari checkpoint pretrained atau non-kuantisasi.

## Kuantisasi tingkat pipeline

Ada dua cara untuk menggunakan [PipelineQuantizationConfig](/docs/diffusers/main/id/api/quantization#diffusers.PipelineQuantizationConfig) tergantung pada seberapa banyak kustomisasi yang ingin Anda terapkan pada konfigurasi kuantisasi.

- untuk kasus penggunaan dasar, definisikan argumen `quant_backend`, `quant_kwargs`, dan `components_to_quantize`
- untuk kontrol kuantisasi yang lebih granular, definisikan `quant_mapping` yang menyediakan konfigurasi kuantisasi untuk komponen model individual

### Kuantisasi dasar

Inisialisasi [PipelineQuantizationConfig](/docs/diffusers/main/id/api/quantization#diffusers.PipelineQuantizationConfig) dengan parameter berikut.

- `quant_backend` menentukan backend kuantisasi yang akan digunakan. Backend yang saat ini didukung meliputi: `bitsandbytes_4bit`, `bitsandbytes_8bit`, `gguf`, `quanto`, dan `torchao`.
- `quant_kwargs` menentukan argumen kuantisasi yang akan digunakan.

> [!TIP]
> Argumen `quant_kwargs` ini berbeda untuk setiap backend. Lihat dokumentasi [Quantization API](../api/quantization) untuk melihat argumen untuk setiap backend.

- `components_to_quantize` menentukan komponen mana dari pipeline yang akan dikuantisasi. Biasanya, Anda sebaiknya menguantisasi komponen yang paling intensif secara komputasi, seperti transformer. Text encoder adalah komponen lain yang perlu dipertimbangkan untuk dikuantisasi jika pipeline memiliki lebih dari satu, seperti pada [FluxPipeline](/docs/diffusers/main/id/api/pipelines/flux#diffusers.FluxPipeline). Contoh di bawah ini menguantisasi T5 text encoder di [FluxPipeline](/docs/diffusers/main/id/api/pipelines/flux#diffusers.FluxPipeline) sambil mempertahankan model CLIP tetap utuh.

   `components_to_quantize` menerima daftar untuk beberapa model atau string untuk satu model.

Contoh di bawah ini memuat backend bitsandbytes dengan argumen berikut dari [BitsAndBytesConfig](/docs/diffusers/main/id/api/quantization#diffusers.BitsAndBytesConfig), `load_in_4bit`, `bnb_4bit_quant_type`, dan `bnb_4bit_compute_dtype`.

```py
import torch
from diffusers import DiffusionPipeline
from diffusers.quantizers import PipelineQuantizationConfig

pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={"load_in_4bit": True, "bnb_4bit_quant_type": "nf4", "bnb_4bit_compute_dtype": torch.bfloat16},
    components_to_quantize=["transformer", "text_encoder_2"],
)
```

Lewatkan `pipeline_quant_config` ke [from_pretrained()](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) untuk mengkuantisasi pipeline.

```py
pipe = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"

image = pipe("photo of a cute dog").images[0]
```

### Kuantisasi lanjutan

Argumen `quant_mapping` menyediakan lebih banyak opsi untuk cara mengkuantisasi setiap komponen individual dalam pipeline, seperti menggabungkan backend kuantisasi yang berbeda.

Inisialisasi [PipelineQuantizationConfig](/docs/diffusers/main/id/api/quantization#diffusers.PipelineQuantizationConfig) dan berikan `quant_mapping` ke dalamnya. `quant_mapping` memungkinkan Anda untuk menentukan opsi kuantisasi untuk setiap komponen dalam pipeline, seperti transformer dan text encoder.

Contoh di bawah ini menggunakan dua backend kuantisasi, [QuantoConfig](/docs/diffusers/main/id/api/quantization#diffusers.QuantoConfig) dan [transformers.BitsAndBytesConfig](https://huggingface.co/docs/transformers/main/en/main_classes/quantization#transformers.BitsAndBytesConfig), untuk transformer dan text encoder.

```py
import torch
from diffusers import DiffusionPipeline
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig
from diffusers.quantizers.quantization_config import QuantoConfig
from diffusers.quantizers import PipelineQuantizationConfig
from transformers import BitsAndBytesConfig as TransformersBitsAndBytesConfig

pipeline_quant_config = PipelineQuantizationConfig(
    quant_mapping={
        "transformer": QuantoConfig(weights_dtype="int8"),
        "text_encoder_2": TransformersBitsAndBytesConfig(
            load_in_4bit=True, compute_dtype=torch.bfloat16
        ),
    }
)
```

Ada backend bitsandbytes terpisah di [Transformers](https://huggingface.co/docs/transformers/main_classes/quantization#transformers.BitsAndBytesConfig). Anda perlu mengimpor dan menggunakan [transformers.BitsAndBytesConfig](https://huggingface.co/docs/transformers/main/en/main_classes/quantization#transformers.BitsAndBytesConfig) untuk komponen yang berasal dari Transformers. Misalnya, `text_encoder_2` di [FluxPipeline](/docs/diffusers/main/id/api/pipelines/flux#diffusers.FluxPipeline) adalah [T5EncoderModel](https://huggingface.co/docs/transformers/main/en/model_doc/t5#transformers.T5EncoderModel) dari Transformers, jadi Anda perlu menggunakan [transformers.BitsAndBytesConfig](https://huggingface.co/docs/transformers/main/en/main_classes/quantization#transformers.BitsAndBytesConfig) alih-alih [diffusers.BitsAndBytesConfig](/docs/diffusers/main/id/api/quantization#diffusers.BitsAndBytesConfig).

> [!TIP]
> Gunakan metode [basic quantization](#basic-quantization) di atas jika Anda tidak ingin mengelola impor yang berbeda-beda ini atau tidak yakin dari mana masing-masing komponen pipeline berasal.

```py
import torch
from diffusers import DiffusionPipeline
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig
from diffusers.quantizers import PipelineQuantizationConfig
from transformers import BitsAndBytesConfig as TransformersBitsAndBytesConfig

pipeline_quant_config = PipelineQuantizationConfig(
    quant_mapping={
        "transformer": DiffusersBitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16),
        "text_encoder_2": TransformersBitsAndBytesConfig(
            load_in_4bit=True, compute_dtype=torch.bfloat16
        ),
    }
)
```

Lewatkan `pipeline_quant_config` ke [from_pretrained()](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) untuk mengkuantisasi pipeline.

```py
pipe = DiffusionPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"

image = pipe("photo of a cute dog").images[0]
```

## Memuat checkpoint prequantized

Beberapa backend kuantisasi mendukung pemuatan checkpoint yang sudah dikuantisasi dan diunggah ke Hub. Dalam kasus ini, konfigurasi kuantisasi disimpan di `config.json` model dan dibaca secara otomatis — Anda tidak perlu membuat [PipelineQuantizationConfig](/docs/diffusers/main/id/api/quantization#diffusers.PipelineQuantizationConfig) atau meneruskan argumen `quantization_config`.

```py
import torch
from diffusers import DiffusionPipeline

pipe = DiffusionPipeline.from_pretrained(
    "rootonchair/ERNIE-Image-Turbo-nunchaku-lite-nvfp4",
    dtype=torch.bfloat16,
).to("cuda")  # or "mps", "xpu", "cpu"
```

Backend berikut mendukung pemuatan checkpoint prequantized secara bawaan.

| Backend | Catatan |
|---|---|
| [bitsandbytes](./bitsandbytes) | Config disimpan di `config.json`; tidak perlu argumen tambahan. Mendukung kuantisasi secara langsung serta memuat checkpoint yang sudah dikuantisasi. |
| [torchao](./torchao) | Sama seperti di atas. |
| [GGUF](./gguf) | Menggunakan `from_single_file` dengan kelas Model; pemuatan pada tingkat pipeline tidak didukung. |
| [BFL](./bfl) | Memuat checkpoint single-file Black Forest Labs `fp8r` dan `nvfp4` dengan `from_single_file`; pemuatan pada tingkat pipeline tidak didukung. |
| [AutoRound](./autoround) | Hanya pemuatan yang didukung; kuantisasi terlebih dahulu dengan CLI AutoRound atau API Python. |
| [Nunchaku Lite](./nunchaku) | Config disimpan di `config.json`; memerlukan paket `kernels`. Hanya pemuatan yang didukung. |
| [ModelOpt](./modelopt) | Hanya pemuatan model prequantized yang didukung. |
| [SDNQ](./sdnq) | Mendukung kuantisasi secara langsung dan pemuatan model yang sudah dikuantisasi; memerlukan paket `sdnq`. |

## Sumber daya

Lihat sumber daya di bawah ini untuk mempelajari lebih lanjut tentang kuantisasi.

- Jika Anda baru dalam kuantisasi, kami merekomendasikan untuk melihat kursus-kursus berikut yang ramah pemula, yang dibuat bekerja sama dengan DeepLearning.AI.

    - [Dasar-Dasar Kuantisasi dengan Hugging Face](https://www.deeplearning.ai/short-courses/quantization-fundamentals-with-hugging-face/)
    - [Kuantifikasi Secara Mendalam](https://www.deeplearning.ai/short-courses/quantization-in-depth/)

- Lihat [Panduan berkontribusi metode kuantisasi baru](https://huggingface.co/docs/transformers/main/en/quantization/contribute) jika Anda tertarik untuk menambahkan metode kuantisasi baru.

- [Ikhtisar](https://huggingface.co/docs/transformers/quantization/overview#when-to-use-what) kuantisasi Transformers memberikan gambaran tentang kelebihan dan kekurangan berbagai backend kuantisasi.

- Baca artikel blog [Exploring Quantization Backends in Diffusers](https://huggingface.co/blog/diffusers-quantization) untuk pengantar singkat tentang masing-masing backend kuantisasi, cara memilih backend, serta menggabungkan kuantisasi dengan optimasi memori lainnya.