# Kuantisasi

Teknik kuantisasi mengurangi biaya memori dan komputasi dengan merepresentasikan bobot dan aktivasi menggunakan tipe data presisi rendah seperti bilangan bulat 8-bit (int8). Hal ini memungkinkan pemuatan model yang lebih besar yang biasanya tidak muat di memori, serta mempercepat inferensi.

> [!TIP]
> Pelajari cara mengkuantisasi model dalam panduan [Kuantisasi](../quantization/overview).

## PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

#### diffusers.PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

```python
diffusers.PipelineQuantizationConfig(quant_backend: str = None, quant_kwargs: dict[str, str | float | int | dict] = None, components_to_quantize: list[str] | str | None = None, quant_mapping: dict[str, DiffQuantConfigMixin | 'TransformersQuantConfigMixin'] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/pipe_quant_config.py#L34)

**Parameter:**

quant_backend (`str`) : Backend kuantisasi yang akan digunakan. Saat menggunakan opsi ini, kami mengasumsikan bahwa backend tersebut tersedia untuk `diffusers` dan `transformers`.

quant_kwargs (`dict`) : Parameter untuk menginisialisasi kelas backend kuantisasi.

components_to_quantize (`list`) : Komponen dari pipeline yang akan dikuantisasi.

quant_mapping (`dict`) : Pemetaan yang mendefinisikan spesifikasi kuantisasi yang akan digunakan untuk komponen pipeline. Saat menggunakan argumen ini, pengguna tidak diharapkan untuk menyediakan `quant_backend`, `quant_kawargs`, dan `components_to_quantize`.

Kelas konfigurasi yang digunakan saat menerapkan kuantisasi secara langsung pada [from_pretrained()](/docs/diffusers/v0.43.0/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

## BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

#### diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

```python
diffusers.BFLQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L427)

**Parameter:**

compute_dtype (`torch.dtype`, defaultnya `torch.bfloat16`) : dtype dari aktivasi dan lapisan yang tidak dikuantisasi. Perangkat tanpa kernel FP8 atau NVFP4 yang terintegrasi akan mendekuantisasi bobot ke dtype ini pada setiap langkah maju (forward pass).

Konfigurasi untuk memuat checkpoint yang dikuantisasi dengan skema `fp8r` dan `nvfp4` dari Black Forest Labs.

Kedua skema dibaca dari checkpoint melalui `~FromSingleFileMixin.from_single_file`; kuantisasi model secara langsung tidak didukung. Lapisan linear dikuantisasi ketika bobotnya disertai tensor skala:

- `fp8r`: `weight` adalah `float8_e4m3fn` dengan bentuk `[N, K]` dan `weight_scale` adalah skala fp32 per baris `[N]`.
- `nvfp4`: `weight` adalah `uint8` dengan bentuk `[N, K/2]` (dua nilai E2M1 per byte), `weight_scale` adalah skala blok `float8_e4m3fn` `[N, K/16]`, dan `weight_scale_2` serta `input_scale` adalah skalar fp32 yang menyimpan skala bobot global dan skala aktivasi yang dikalibrasi (layout ModelOpt NVFP4).

## BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]

#### diffusers.BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]

```python
diffusers.BitsAndBytesConfig(load_in_8bit = False, load_in_4bit = False, llm_int8_threshold = 6.0, llm_int8_skip_modules = None, llm_int8_enable_fp32_cpu_offload = False, llm_int8_has_fp16_weight = False, bnb_4bit_compute_dtype = None, bnb_4bit_quant_type = 'fp4', bnb_4bit_use_double_quant = False, bnb_4bit_quant_storage = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L171)

**Parameter:**

load_in_8bit (`bool`, *opsional*, defaultnya `False`) : Flag ini digunakan untuk mengaktifkan kuantisasi 8-bit dengan LLM.int8().

load_in_4bit (`bool`, *opsional*, defaultnya `False`) : Flag ini digunakan untuk mengaktifkan kuantisasi 4-bit dengan mengganti lapisan Linear dengan lapisan FP4/NF4 dari `bitsandbytes`.

llm_int8_threshold (`float`, *opsional*, default 6.0) : Ini sesuai dengan ambang batas outlier untuk deteksi outlier seperti yang dijelaskan dalam paper `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale`: https://huggingface.co/papers/2208.07339 Nilai hidden states mana pun yang berada di atas ambang batas ini akan dianggap sebagai outlier dan operasi pada nilai-nilai tersebut akan dilakukan dalam fp16. Nilai biasanya terdistribusi secara normal, artinya sebagian besar nilai berada dalam rentang [-3.5, 3.5], tetapi ada beberapa outlier sistematis yang sangat berbeda distribusinya pada model besar. Outlier ini sering berada dalam interval [-60, -6] atau [6, 60]. Kuantisasi Int8 bekerja dengan baik untuk nilai dengan magnitudo ~5, tetapi melampaui itu, terdapat penalti kinerja yang signifikan. Ambang batas default yang baik adalah 6, tetapi ambang batas yang lebih rendah mungkin diperlukan untuk model yang lebih tidak stabil (model kecil, fine-tuning).

llm_int8_skip_modules (`list[str]`, *opsional*) : Daftar eksplisit modul yang tidak ingin dikonversi ke 8-bit. Ini berguna untuk model seperti Jukebox yang memiliki beberapa head di berbagai tempat dan tidak selalu di posisi terakhir. Misalnya, untuk model `CausalLM`, `lm_head` terakhir biasanya tetap dipertahankan dalam `dtype` aslinya.

llm_int8_enable_fp32_cpu_offload (`bool`, *opsional*, defaultnya `False`) : Flag ini digunakan untuk kasus penggunaan lanjutan dan pengguna yang memahami fitur ini. Jika Anda ingin membagi model Anda ke dalam bagian-bagian berbeda dan menjalankan beberapa bagian dalam int8 di GPU serta beberapa bagian dalam fp32 di CPU, Anda dapat menggunakan flag ini. Hal ini berguna untuk offloading model besar seperti `google/flan-t5-xxl`. Perhatikan bahwa operasi int8 tidak akan dijalankan di CPU.

llm_int8_has_fp16_weight (`bool`, *opsional*, defaultnya `False`) : Flag ini menjalankan LLM.int8() dengan bobot utama 16-bit. Hal ini berguna untuk fine-tuning karena bobot tidak perlu dikonversi bolak-balik untuk backward pass.

bnb_4bit_compute_dtype (`torch.dtype` atau str, *opsional*, defaultnya `torch.float32`) : Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input mungkin fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan.

bnb_4bit_quant_type (`str`,  *opsional*, defaultnya `"fp4"`) : Ini mengatur tipe data kuantisasi di lapisan bnb.nn.Linear4Bit. Opsi yang tersedia adalah tipe data FP4 dan NF4 yang ditentukan oleh `fp4` atau `nf4`.

bnb_4bit_use_double_quant (`bool`, *opsional*, defaultnya `False`) : Flag ini digunakan untuk kuantisasi bersarang, di mana konstanta kuantisasi dari kuantisasi pertama dikuantisasi lagi.

bnb_4bit_quant_storage (`torch.dtype` atau str, *opsional*, defaultnya `torch.uint8`) : Ini mengatur tipe penyimpanan untuk mengemas parameter 4-bit yang dikuantisasi.

kwargs (`dict[str, Any]`, *opsional*) : Parameter tambahan untuk menginisialisasi objek konfigurasi.

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan `bitsandbytes`.

Ini menggantikan `load_in_8bit` atau `load_in_4bit`, sehingga kedua opsi tersebut saling eksklusif.

Saat ini hanya mendukung kuantisasi `LLM.int8()`, `FP4`, dan `NF4`. Jika metode lain ditambahkan ke `bitsandbytes`, maka argumen tambahan akan ditambahkan ke kelas ini.

#### is_quantizable[[diffusers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L343)

Mengembalikan `True` jika model dapat dikuantisasi, `False` jika tidak.

#### post_init[[diffusers.BitsAndBytesConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L313)

Pemeriksa keselamatan yang memastikan argumen benar - juga mengganti beberapa argumen NoneType dengan nilai default-nya.

#### quantization_method[[diffusers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L349)

Metode ini mengembalikan metode kuantisasi yang digunakan untuk model. Jika model tidak dapat dikuantisasi, metode ini mengembalikan `None`.

#### to_diff_dict[[diffusers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L380)

**Mengembalikan:** `dict[str, Any]`

Kamus dari semua atribut yang membentuk instance konfigurasi ini,

Menghapus semua atribut dari config yang sesuai dengan atribut config default untuk keterbacaan yang lebih baik dan melakukan serialisasi ke kamus Python.

## GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

#### diffusers.GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

```python
diffusers.GGUFQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L404)

**Parameter:**

compute_dtype : (`torch.dtype`, defaultnya `torch.float32`): Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input mungkin fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan.

Ini adalah kelas konfigurasi untuk teknik kuantisasi GGUF.

## NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]

#### diffusers.NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]

```python
diffusers.NunchakuLiteQuantizationConfig(compute_dtype: 'torch.dtype' | str | None = None, svdq_w4a4: dict[str, Any] | None = None, awq_w4a16: dict[str, Any] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L451)

**Parameter:**

compute_dtype (`torch.dtype`, defaultnya `torch.bfloat16`) : dtype runtime yang digunakan oleh buffer floating-point di dalam modul terkuantisasi.

svdq_w4a4 (`dict`, *opsional*) : Konfigurasi target SVDQ W4A4 eksplisit dengan `precision`, `group_size`, `rank`, dan `targets`.

awq_w4a16 (`dict`, *opsional*) : Konfigurasi target AWQ W4A16 eksplisit dengan `precision`, `group_size`, dan `targets`.

Konfigurasi untuk memuat checkpoint Nunchaku Lite.

Dukungan Nunchaku Lite di Diffusers memuat checkpoint prequantized. Untuk membuat checkpoint yang kompatibel, gunakan [`diffuse-compressor`](https://github.com/rootonchair/diffuse-compressor) untuk memilih atau menyesuaikan konfigurasi target untuk arsitektur model, melakukan kuantisasi dan mengekspor transformer, serta mengemasnya sebagai pipeline Diffusers dengan `quantization_config` ringkas yang disimpan di `config.json`.

State dict yang diekspor harus cocok persis dengan arsitektur model Diffusers target. Checkpoint yang dikuantisasi dengan proyeksi QKV yang digabungkan tidak akan dapat dimuat ke dalam konfigurasi model yang mengharapkan modul proyeksi Q, K, dan V yang terpisah.

Contoh konfigurasi `config.json` ringkas:

```json
{
  "_class_name": "ErnieImageTransformer2DModel",
  "quantization_config": {
    "quant_method": "nunchaku_lite",
    "compute_dtype": "bfloat16",
    "svdq_w4a4": {
      "precision": "nvfp4",
      "group_size": 16,
      "rank": 32,
      "targets": ["layers.0.self_attention.to_q"]
    },
    "awq_w4a16": {
      "precision": "int4",
      "group_size": 64,
      "targets": ["final_linear"]
    }
  }
}
```

## QuantoConfig[[diffusers.QuantoConfig]]

#### diffusers.QuantoConfig[[diffusers.QuantoConfig]]

```python
diffusers.QuantoConfig(weights_dtype: str = 'int8', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L669)

**Parameter:**

weights_dtype (`str`, *opsional*, defaultnya `"int8"`) : dtype target untuk bobot setelah kuantisasi. Nilai yang didukung adalah ("float8","int8","int4","int2")

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan `quanto`.

`QuantoConfig` tidak lagi didukung dan akan dihapus pada versi 1.0.0. Pertimbangkan untuk beralih ke salah satu backend kuantisasi lain yang didukung, seperti [BitsAndBytesConfig](/docs/diffusers/v0.43.0/id/api/quantization#diffusers.BitsAndBytesConfig) atau [TorchAoConfig](/docs/diffusers/v0.43.0/id/api/quantization#diffusers.TorchAoConfig).

modules_to_not_convert (`list`, *opsional*, default ke `None`): Daftar modul yang tidak akan dikuantisasi, berguna untuk menguantisasi model yang secara eksplisit membutuhkan beberapa modul tetap berada pada presisi aslinya (misalnya encoder Whisper, encoder Llava, lapisan gate Mixtral).

#### post_init[[diffusers.QuantoConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L703)

Pemeriksa keselamatan yang memastikan argumen benar

## SDNQConfig[[diffusers.SDNQConfig]]

#### diffusers.SDNQConfig[[diffusers.SDNQConfig]]

```python
diffusers.SDNQConfig(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L981)

**Parameter:**

weights_dtype (`str`, *opsional*, defaultnya `"int8"`) : dtype target untuk bobot setelah kuantisasi, misalnya `"int8"`, `"uint4"`, `"float8_e4m3fn"`. Lihat `sdnq.common.accepted_weight_dtypes` untuk semua nilai yang didukung.

group_size (`int`, *opsional*, defaultnya `0`) : Berapa banyak elemen tensor yang berbagi grup kuantisasi yang sama. `0` memilih secara otomatis berdasarkan `weights_dtype`, `-1` menonaktifkan pengelompokan dan menggunakan kuantisasi per baris.

use_svd (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan algoritma SVDQuant di atas kuantisasi SDNQ.

use_quantized_matmul (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan matmul INT8 / FP8 / FP16 yang dikuantisasi pada forward pass alih-alih BF16 / FP16.

modules_to_not_convert (`list`, *opsional*, defaultnya `None`) : Daftar modul yang akan dilewati selama kuantisasi.

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke `sdnq.SDNQConfig` (mis. `quantized_matmul_dtype`, `svd_rank`, `use_hadamard`, `quant_conv`, `quant_embedding`, `modules_dtype_dict`).

Kelas konfigurasi untuk SDNQ (SD.Next Quantization).

Perpustakaan `sdnq` menyediakan konfigurasi dan kuantizer yang kompatibel dengan diffusers; kelas ini adalah pabrik tipis yang mendelegasikan ke mereka sehingga checkpoint dengan `quant_method="sdnq"` dapat dimuat secara native dengan diffusers. Semua argumen diteruskan ke `sdnq.SDNQConfig`. Memerlukan perpustakaan `sdnq`: `pip install sdnq`.

Referensi: https://github.com/Disty0/sdnq

## TorchAoConfig[[diffusers.TorchAoConfig]]

#### diffusers.TorchAoConfig[[diffusers.TorchAoConfig]]

```python
diffusers.TorchAoConfig(quant_type: 'AOBaseConfig', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L572)

**Parameter:**

quant_type (`AOBaseConfig`) : Instans subclass `AOBaseConfig` yang menentukan tipe kuantisasi. Lihat [dokumentasi torchao](https://docs.pytorch.org/ao/main/api_ref_quantization.html#inference-apis-for-quantize) untuk kelas konfigurasi yang tersedia (misalnya `Int4WeightOnlyConfig`, `Int8WeightOnlyConfig`, `Float8WeightOnlyConfig`, `Float8DynamicActivationFloat8WeightConfig`, dll.).

modules_to_not_convert (`list[str]`, *opsional*, default ke `None`) : Daftar modul yang tidak akan dikuantisasi, berguna untuk mengkuantisasi model yang secara eksplisit membutuhkan beberapa modul tetap berada pada presisi aslinya.

Ini adalah kelas konfigurasi untuk teknik kuantisasi/keroposan torchao.

Contoh:
```python
from diffusers import FluxTransformer2DModel, TorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig

quantization_config = TorchAoConfig(Int8WeightOnlyConfig())
transformer = FluxTransformer2DModel.from_pretrained(
    "black-forest-labs/Flux.1-Dev",
    subfolder="transformer",
    quantization_config=quantization_config,
    torch_dtype=torch.bfloat16,
)
```

#### from_dict[[diffusers.TorchAoConfig.from_dict]]

```python
from_dict(config_dict, return_unused_kwargs = False, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L637)

Buat konfigurasi dari kamus.

#### get_apply_tensor_subclass[[diffusers.TorchAoConfig.get_apply_tensor_subclass]]

```python
get_apply_tensor_subclass()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L659)

Buat metode kuantisasi yang sesuai berdasarkan konfigurasi.

#### to_dict[[diffusers.TorchAoConfig.to_dict]]

```python
to_dict()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L623)

Mengonversi konfigurasi menjadi kamus.

## DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

#### diffusers.DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

```python
diffusers.DiffusersQuantizer(quantization_config: QuantizationConfigMixin, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L34)

Kelas abstrak dari kuantizer HuggingFace. Saat ini mendukung kuantisasi model HF diffusers untuk inferensi dan/atau kuantisasi. Kelas ini hanya digunakan untuk diffusers.models.modeling_utils.ModelMixin.from_pretrained dan belum dapat dengan mudah digunakan di luar cakupan metode tersebut.

Attributes quantization_config (`diffusers.quantizers.quantization_config.QuantizationConfigMixin`): Konfigurasi kuantisasi yang mendefinisikan parameter kuantisasi dari model Anda yang ingin dikuantisasi. modules_to_not_convert (`list[str]`, *opsional*): Daftar nama modul yang tidak akan dikonversi saat mengkuantisasi model. required_packages (`list[str]`, *opsional*): Daftar paket pip yang wajib diinstal sebelum menggunakan kuantizer. requires_calibration (`bool`): Apakah metode kuantisasi memerlukan kalibrasi model sebelum digunakan.

#### adjust_max_memory[[diffusers.DiffusersQuantizer.adjust_max_memory]]

```python
adjust_max_memory(max_memory: dict[str, int | str])
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L133)

sesuaikan argumen max_memory untuk infer_auto_device_map() jika memori tambahan diperlukan untuk kuantisasi

#### adjust_target_dtype[[diffusers.DiffusersQuantizer.adjust_target_dtype]]

```python
adjust_target_dtype(torch_dtype: torch.dtype)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L91)

**Parameter:**

torch_dtype (`torch.dtype`, *opsional*) : torch_dtype yang digunakan untuk menghitung device_map.

Override metode ini jika Anda ingin menyesuaikan variabel `target_dtype` yang digunakan dalam `from_pretrained` untuk menghitung device_map dalam kasus device_map berupa `str`. Misalnya, untuk bitsandbytes kami memaksa `target_dtype` menjadi `torch.int8` dan untuk 4-bit kami meneruskan enum kustom `accelerate.CustomDtype.int4`.

#### check_if_quantized_param[[diffusers.DiffusersQuantizer.check_if_quantized_param]]

```python
check_if_quantized_param(model: ModelMixin, param_value: torch.Tensor, param_name: str, state_dict: dict[str, typing.Any], **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L137)

memeriksa apakah komponen state_dict yang dimuat merupakan bagian dari param kuantisasi + beberapa validasi; hanya didefinisikan untuk metode kuantisasi yang memerlukan pembuatan parameter baru untuk kuantisasi.

#### check_quantized_param_shape[[diffusers.DiffusersQuantizer.check_quantized_param_shape]]

```python
check_quantized_param_shape(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L157)

memeriksa apakah parameter terkuantisasi memiliki bentuk yang diharapkan.

#### create_quantized_param[[diffusers.DiffusersQuantizer.create_quantized_param]]

```python
create_quantized_param(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L151)

mengambil komponen yang diperlukan dari state_dict dan membuat param yang dikuantisasi.

#### dequantize[[diffusers.DiffusersQuantizer.dequantize]]

```python
dequantize(model)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L219)

Potensi untuk mendekuantisasi model guna mengambil model asli, dengan sedikit penurunan akurasi / kinerja. Perhatikan bahwa tidak semua skema kuantisasi mendukung ini.

#### get_cuda_warm_up_factor[[diffusers.DiffusersQuantizer.get_cuda_warm_up_factor]]

```python
get_cuda_warm_up_factor()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L232)

Faktor yang digunakan dalam `caching_allocator_warmup` untuk mendapatkan jumlah byte yang akan dialokasikan sebelumnya guna pemanasan cuda. Faktor 2 berarti kita mengalokasikan semua byte dalam model kosong (karena kita mengalokasikan dalam fp16), faktor 4 berarti kita mengalokasikan setengah memori dari bobot yang berada dalam model kosong, dan seterusnya...

#### get_special_dtypes_update[[diffusers.DiffusersQuantizer.get_special_dtypes_update]]

```python
get_special_dtypes_update(model, torch_dtype: torch.dtype)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L113)

**Parameter:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Model yang akan dikuantisasi

torch_dtype (`torch.dtype`) : dtype yang diteruskan ke metode `from_pretrained`.

mengembalikan dtypes untuk modul yang tidak dikuantisasi - digunakan untuk perhitungan device_map dalam kasus di mana str dilewatkan sebagai device_map. Metode ini akan menggunakan `modules_to_not_convert` yang dimodifikasi di `_process_model_before_weight_loading`. Model `diffusers` belum memiliki atribut `modules_to_not_convert` tetapi ini bisa berubah segera di masa depan.

#### postprocess_model[[diffusers.DiffusersQuantizer.postprocess_model]]

```python
postprocess_model(model: ModelMixin, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L206)

**Parameter:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Model yang akan dikuantisasi

kwargs (`dict`, *opsional*) : Argumen kata kunci yang diteruskan ke `_process_model_after_weight_loading`.

Lakukan proses pascapemrosesan model setelah pemuatan bobot. Pastikan untuk menimpa metode abstrak `_process_model_after_weight_loading`.

#### preprocess_model[[diffusers.DiffusersQuantizer.preprocess_model]]

```python
preprocess_model(model: ModelMixin, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L190)

**Parameter:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Model yang akan dikuantisasi

kwargs (`dict`, *opsional*) : Argumen kata kunci yang diteruskan ke `_process_model_before_weight_loading`.

Mengatur atribut model dan/atau mengonversi model sebelum pemuatan bobot. Pada titik ini, model harus diinisialisasi pada perangkat meta sehingga Anda dapat dengan bebas memanipulasi kerangka model untuk mengganti modul secara in-place. Pastikan untuk menimpa metode abstrak `_process_model_before_weight_loading`.

#### update_device_map[[diffusers.DiffusersQuantizer.update_device_map]]

```python
update_device_map(device_map: dict[str, typing.Any] | None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L79)

**Parameter:**

device_map (`dict | str`, *opsional*) : device_map yang diteruskan melalui metode `from_pretrained`.

Override metode ini jika Anda ingin mengganti device map yang ada dengan yang baru. Misalnya, untuk bitsandbytes, karena `accelerate` adalah persyaratan wajib, jika tidak ada device_map yang di-pass, maka device_map akan diset ke `"auto"``

#### update_missing_keys[[diffusers.DiffusersQuantizer.update_missing_keys]]

```python
update_missing_keys(model, missing_keys: list[str], prefix: str)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L103)

**Parameter:**

missing_keys (`list[str]`, *opsional*) : Daftar kunci yang hilang di checkpoint dibandingkan dengan state dict dari model

Override metode ini jika Anda ingin menyesuaikan `missing_keys`.

#### update_torch_dtype[[diffusers.DiffusersQuantizer.update_torch_dtype]]

```python
update_torch_dtype(torch_dtype: torch.dtype)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L68)

**Parameter:**

torch_dtype (`torch.dtype`) : dtype input yang diteruskan dalam `from_pretrained`

Beberapa metode kuantisasi memerlukan pengaturan dtype model secara eksplisit ke dtype target. Anda perlu menimpa metode ini jika ingin memastikan perilaku tersebut tetap terjaga

#### validate_environment[[diffusers.DiffusersQuantizer.validate_environment]]

```python
validate_environment(*args, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L163)

Metode ini digunakan untuk memeriksa potensi konflik dengan argumen yang diteruskan dalam `from_pretrained`. Anda perlu mendefinisikannya untuk semua kuantizer masa depan yang diintegrasikan dengan diffusers. Jika tidak ada pemeriksaan eksplisit yang diperlukan, cukup kembalikan apa pun.