# 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. Transformers mendukung algoritma kuantisasi AWQ dan GPTQ, serta mendukung kuantisasi 8-bit dan 4-bit dengan bitsandbytes.

Teknik kuantisasi yang tidak didukung di Transformers dapat ditambahkan dengan kelas `HfQuantizer`.

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

## QuantoConfig[[transformers.QuantoConfig]]

#### transformers.QuantoConfig[[transformers.QuantoConfig]]

```python
transformers.QuantoConfig(weights = 'int8', activations = None, modules_to_not_convert: list | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1021)

**Parameter:**

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

activations (`str`, *opsional*) : dtype target untuk aktivasi setelah kuantisasi. Nilai yang didukung adalah (None,"int8","float8")

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).

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

#### post_init[[transformers.QuantoConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1049)

Pemeriksa keselamatan yang memastikan argumen benar

## AqlmConfig[[transformers.AqlmConfig]]

#### transformers.AqlmConfig[[transformers.AqlmConfig]]

```python
transformers.AqlmConfig(in_group_size: int = 8, out_group_size: int = 1, num_codebooks: int = 1, nbits_per_codebook: int = 16, linear_weights_not_to_quantize: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L865)

**Parameter:**

in_group_size (`int`, *opsional*, defaultnya 8) : Ukuran grup di sepanjang dimensi input.

out_group_size (`int`, *opsional*, default 1) : Ukuran grup di sepanjang dimensi output. Disarankan untuk selalu menggunakan 1.

num_codebooks (`int`, *opsional*, default 1) : Jumlah codebook untuk prosedur Additive Quantization.

nbits_per_codebook (`int`, *opsional*, default 16) : Jumlah bit untuk mengkodekan satu vektor codebook. Ukuran codebook adalah 2**nbits_per_codebook.

linear_weights_not_to_quantize (`Optional[list[str]]`, *opsional*) : Daftar jalur lengkap dari parameter bobot `nn.Linear` yang tidak boleh dikuantisasi.

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

Ini adalah kelas pembungkus tentang parameter `aqlm`.

#### post_init[[transformers.AqlmConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L902)

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

## VptqConfig[[transformers.VptqConfig]]

#### transformers.VptqConfig[[transformers.VptqConfig]]

```python
transformers.VptqConfig(enable_proxy_error: bool = False, config_for_layers: dict = {}, shared_layer_config: dict = {}, modules_to_not_convert: list | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L980)

**Parameter:**

enable_proxy_error (`bool`, *opsional*, defaultnya `False`) : hitung error proxy untuk setiap layer

config_for_layers (`Dict`, *opsional*, defaultnya `{}`) : parameter kuantisasi untuk setiap layer

shared_layer_config (`Dict`, *opsional*, defaultnya `{}`) : parameter kuantisasi bersama di antara lapisan

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).

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

Ini adalah kelas pembungkus tentang parameter `vptq`.

#### post_init[[transformers.VptqConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1010)

Pemeriksa keselamatan yang memastikan argumen benar

## AwqConfig[[transformers.AwqConfig]]

#### transformers.AwqConfig[[transformers.AwqConfig]]

```python
transformers.AwqConfig(bits: int = 4, group_size: int = 128, zero_point: bool = True, backend: AwqBackend = <AwqBackend.AUTO: 'auto'>, modules_to_not_convert: list | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L799)

**Parameter:**

bits (`int`, *opsional*, defaultnya 4) : Jumlah bit untuk kuantisasi.

group_size (`int`, *opsional*, default 128) : Ukuran grup yang digunakan untuk kuantisasi. Nilai yang direkomendasikan adalah 128 dan -1 menggunakan kuantisasi per kolom.

zero_point (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan kuantisasi titik nol.

backend (`AwqBackend`, *opsional*, defaultnya `AwqBackend.AUTO`) : Backend kuantisasi.

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). Perhatikan bahwa Anda tidak dapat menguantisasi secara langsung dengan transformers, silakan merujuk ke dokumentasi `AutoAWQ` untuk menguantisasi model HF.

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang dimuat menggunakan kuantisasi awq dari pustaka `auto-awq` yang bergantung pada backend auto_awq.

## EetqConfig[[transformers.EetqConfig]]

#### transformers.EetqConfig[[transformers.EetqConfig]]

```python
transformers.EetqConfig(weights: str = 'int8', modules_to_not_convert: list | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1062)

**Parameter:**

weights (`str`, *opsional*, defaultnya `"int8"`) : dtype target untuk bobot. Nilai yang didukung hanya "int8"

modules_to_not_convert (`list`, *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 pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan `eetq`.

#### post_init[[transformers.EetqConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1086)

Pemeriksa keselamatan yang memastikan argumen benar

## GPTQConfig[[transformers.GPTQConfig]]

#### transformers.GPTQConfig[[transformers.GPTQConfig]]

```python
transformers.GPTQConfig(bits: int, tokenizer: Any = None, dataset: list[str] | str | None = None, group_size: int = 128, damp_percent: float = 0.1, desc_act: bool = False, act_group_aware: bool = True, sym: bool = True, true_sequential: bool = True, format: str = 'gptq', meta: dict[str, typing.Any] | None = None, backend: str | None = None, model_seqlen: int | None = None, block_name_to_quantize: str | None = None, module_name_preceding_first_block: list[str] | None = None, batch_size: int = 1, pad_token_id: int | None = None, max_input_length: int | None = None, cache_block_outputs: bool = True, modules_in_block_to_quantize: list[list[str]] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L617)

**Parameter:**

bits (`int`) : Jumlah bit untuk kuantisasi, angka yang didukung adalah (2, 3, 4, 8).

tokenizer (`str` atau `PreTrainedTokenizerBase`, *opsional*) : Tokenizer yang digunakan untuk memproses dataset. Anda dapat memberikan salah satu dari berikut: - Objek tokenizer kustom. - String, *model id* dari tokenizer yang sudah ditentukan dan dihosting di dalam repo model di huggingface.co. - Path ke *direktori* yang berisi file kosakata yang diperlukan oleh tokenizer, misalnya yang disimpan menggunakan metode [save_pretrained()](/docs/transformers/main/id/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), contohnya `./my_model_directory/`.

dataset (`Union[list[str]]`, *opsional*) : Dataset yang digunakan untuk kuantisasi. Anda dapat menyediakan dataset Anda sendiri dalam bentuk daftar string atau hanya menggunakan dataset asli yang digunakan dalam paper GPTQ ['wikitext2','c4','c4-new']

group_size (`int`, *opsional*, default 128) : Ukuran grup yang digunakan untuk kuantisasi. Nilai yang direkomendasikan adalah 128 dan -1 menggunakan kuantisasi per kolom.

damp_percent (`float`, *opsional*, default 0.1) : Persentase dari diagonal rata-rata Hessian yang digunakan untuk peredaman. Nilai yang direkomendasikan adalah 0.1.

desc_act (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengkuantisasi kolom berdasarkan urutan ukuran aktivasi yang menurun. Mengaturnya ke False dapat mempercepat inferensi secara signifikan, tetapi perplexity mungkin menjadi sedikit lebih buruk. Juga dikenal sebagai act-order.

act_group_aware (`bool`, *opsional*, defaultnya `True`) : Gunakan GAR (group aware activation order) selama kuantisasi. Memiliki dampak positif yang terukur pada kualitas kuantisasi. Hanya berlaku ketika `desc_act = False`. Akan dipaksa menjadi `False` ketika `desc_act = True`.

sym (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan kuantisasi simetris.

true_sequential (`bool`, *opsional*, defaultnya `True`) : Apakah akan melakukan kuantisasi sekuensial bahkan di dalam satu blok Transformer. Alih-alih mengkuantisasi seluruh blok sekaligus, kami melakukan kuantisasi per lapisan. Akibatnya, setiap lapisan mengalami kuantisasi menggunakan input yang telah melewati lapisan-lapisan yang dikuantisasi sebelumnya.

format (`str`, *opsional*, defaultnya `"gptq"`) : Format bobot GPTQ. `gptq` (v1) didukung oleh gptqmodel. `gptq_v2` hanya untuk gptqmodel.

meta (`dict[str, any]`, *opsional*) : Properti, seperti tooling:version, yang tidak secara langsung berkontribusi pada kuantisasi atau inferensi kuantisasi disimpan di meta. yaitu `meta.quantizer`: ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *opsional*) : Mengontrol kernel mana yang akan digunakan. Nilai valid untuk gptqmodel adalah `auto`, `auto_trainable` dan lainnya. Ref backend gptqmodel: https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py

model_seqlen (`int`, *opsional*) : Panjang maksimum urutan yang dapat diterima oleh model.

block_name_to_quantize (`str`, *opsional*) : Nama blok transformers yang akan dikuantisasi. Jika None, kami akan menyimpulkan nama blok menggunakan pola umum (mis. model.layers)

module_name_preceding_first_block (`list[str]`, *opsional*) : Lapisan yang mendahului blok Transformer pertama.

batch_size (`int`, *opsional*, default 1) : Ukuran batch yang digunakan saat memproses dataset

pad_token_id (`int`, *opsional*) : ID token pad. Diperlukan untuk menyiapkan dataset ketika `batch_size` > 1.

max_input_length (`int`, *opsional*) : Panjang input maksimum. Ini diperlukan untuk menginisialisasi buffer yang bergantung pada panjang input maksimum yang diharapkan. Ini spesifik untuk backend exllama dengan act-order.

cache_block_outputs (`bool`, *opsional*, defaultnya `True`) : Apakah akan meng-cache output blok untuk digunakan kembali sebagai input untuk blok berikutnya.

modules_in_block_to_quantize (`list[list[str]]`, *opsional*) : Daftar dari daftar nama modul yang akan dikuantisasi dalam blok yang ditentukan. Argumen ini berguna untuk mengecualikan modul linear tertentu dari proses kuantisasi. Blok yang akan dikuantisasi dapat ditentukan dengan mengatur `block_name_to_quantize`. Kami akan menguantisasi setiap daftar secara berurutan. Jika tidak diatur, kami akan menguantisasi semua lapisan linear. Contoh: `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`. Dalam contoh ini, kami akan terlebih dahulu menguantisasi lapisan q,k,v secara bersamaan karena mereka independen. Kemudian, kami akan menguantisasi lapisan `self_attn.o_proj` dengan lapisan q,k,v yang sudah dikuantisasi. Dengan cara ini, kami akan mendapatkan hasil yang lebih baik karena mencerminkan input nyata yang akan diterima oleh `self_attn.o_proj` ketika model dikuantisasi.

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan api `optimum` untuk kuantisasi GPTQ yang bergantung pada backend gptqmodel.

#### from_dict_optimum[[transformers.GPTQConfig.from_dict_optimum]]

```python
from_dict_optimum(config_dict)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L788)

Dapatkan kelas yang kompatibel dengan dict konfigurasi gptq optimum

#### post_init[[transformers.GPTQConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L738)

Pemeriksa keselamatan yang memastikan argumen benar

#### to_dict_optimum[[transformers.GPTQConfig.to_dict_optimum]]

```python
to_dict_optimum()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L782)

Dapatkan dict yang kompatibel untuk konfigurasi gptq optimum

## BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

#### transformers.BitsAndBytesConfig[[transformers.BitsAndBytesConfig]]

```python
transformers.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/transformers/blob/main/src/transformers/utils/quantization_config.py#L390)

**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 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 mem-packing parameter 4-bit yang terkuantisasi.

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`.

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[[transformers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L551)

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

#### post_init[[transformers.BitsAndBytesConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L521)

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

#### quantization_method[[transformers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L557)

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

#### to_diff_dict[[transformers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L588)

**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.

## HfQuantizer[[transformers.quantizers.HfQuantizer]]

#### transformers.quantizers.HfQuantizer[[transformers.quantizers.HfQuantizer]]

```python
transformers.quantizers.HfQuantizer(quantization_config: QuantizationConfigMixin, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L74)

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

Attributes quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`): Konfigurasi kuantisasi yang mendefinisikan parameter kuantisasi dari model Anda yang ingin dikuantisasi. requires_calibration (`bool`): Apakah metode kuantisasi memerlukan kalibrasi model sebelum digunakan.

#### adjust_max_memory[[transformers.quantizers.HfQuantizer.adjust_max_memory]]

```python
adjust_max_memory(max_memory: dict)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L148)

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

#### dequantize[[transformers.quantizers.HfQuantizer.dequantize]]

```python
dequantize(model, dtype = None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L239)

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

#### get_load_operations[[transformers.quantizers.HfQuantizer.get_load_operations]]

```python
get_load_operations()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L323)

Kelas Op yang memuat tensor terserialisasi, misalnya `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. Deserialisasi membangun parameter dari satu modul, sehingga hanya berjalan pada konverter umum. Dequantisasi juga berjalan sebelum op dari konverter model, misalnya sebelum per-expert merge.

#### get_new_dtype[[transformers.quantizers.HfQuantizer.get_new_dtype]]

```python
get_new_dtype(converter, param, dtype: torch.dtype | None)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L134)

Hal ini terjadi pada saat materialisasi, ketika tensor dikirim dari disk ke perangkat. `dtype` untuk meng-cast tensor checkpoint pre-quantized `param`. Jika param tersebut tidak terkuantisasi (tipe float), kami menggunakan `dtype` input yang berasal dari `nn.Module` yang telah diinisialisasi.

Jika metode kuantisasi memiliki `Deserializer` atau `Dequantizer` (fungsi load), kami mengembalikan None sehingga ditangani oleh mereka.

#### get_state_dict_and_metadata[[transformers.quantizers.HfQuantizer.get_state_dict_and_metadata]]

```python
get_state_dict_and_metadata(model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L290)

Dapatkan state dict dan metadata. Berguna ketika kita perlu memodifikasi sedikit state dict karena kuantisasi

#### get_weight_conversions[[transformers.quantizers.HfQuantizer.get_weight_conversions]]

```python
get_weight_conversions()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L331)

Kembalikan proses pemuatan yang akan dilakukan pada parameter mana pun yang tidak cocok dengan konverter model

#### param_needs_quantization[[transformers.quantizers.HfQuantizer.param_needs_quantization]]

```python
param_needs_quantization(model: PreTrainedModel, param_name: str, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L152)

Periksa apakah parameter tertentu perlu dikuantisasi.

#### postprocess_model[[transformers.quantizers.HfQuantizer.postprocess_model]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L207)

**Parameter:**

model (`~transformers.PreTrainedModel`) : 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[[transformers.quantizers.HfQuantizer.preprocess_model]]

```python
preprocess_model(model: PreTrainedModel, dtype = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L184)

**Parameter:**

model (`~transformers.PreTrainedModel`) : 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`.

#### remove_quantization_config[[transformers.quantizers.HfQuantizer.remove_quantization_config]]

```python
remove_quantization_config(model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L227)

Hapus konfigurasi kuantisasi dari model.

#### update_attn_implementation[[transformers.quantizers.HfQuantizer.update_attn_implementation]]

```python
update_attn_implementation(config)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L177)

Melihat `attn_implementation` yang diminta sebelum model dibangun, sehingga kuantizer dapat menyetelnya secara default.

#### update_device_map[[transformers.quantizers.HfQuantizer.update_device_map]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L112)

**Parameter:**

device_map (`Union[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_dtype[[transformers.quantizers.HfQuantizer.update_dtype]]

```python
update_dtype(dtype: torch.dtype)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L100)

**Parameter:**

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

#### update_parallel_plan[[transformers.quantizers.HfQuantizer.update_parallel_plan]]

```python
update_parallel_plan(model, plan: dict)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L166)

Memperbarui `model.tp_plan` atau `model.ep_plan` (rencana lengkap, yang digabungkan dari konfigurasi dan semua sub-konfigurasi) untuk memperhitungkan kunci kustom kuantizer seperti 'inv_scale'

#### update_weight_conversions[[transformers.quantizers.HfQuantizer.update_weight_conversions]]

```python
update_weight_conversions(weight_conversions, model)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L341)

Membuat konverter model (dari pemetaan konversi) memuat nama yang diserialisasi. Parameter model yang menentukan, misalnya untuk penggabungan `experts.*.gate_proj.weight` ke dalam `experts.gate_up_proj`:
- `experts.gate_up_proj_scale_inv` adalah param: salinan menggabungkan `experts.*.gate_proj.weight_scale_inv` ke dalamnya
- jika tidak, konverter juga mengumpulkan `experts.*.gate_proj.weight_scale_inv`, operasi dequantize dijalankan terlebih dahulu

#### validate_environment[[transformers.quantizers.HfQuantizer.validate_environment]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L158)

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

## HiggsConfig[[transformers.HiggsConfig]]

#### transformers.HiggsConfig[[transformers.HiggsConfig]]

```python
transformers.HiggsConfig(bits: int = 4, p: int = 2, modules_to_not_convert: list[str] | None = None, hadamard_size: int = 512, group_size: int = 256, tune_metadata: dict[str, typing.Any] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1315)

**Parameter:**

bits (int, *opsional*, default 4) : Jumlah bit yang digunakan untuk kuantisasi. Bisa 2, 3, atau 4. Default adalah 4.

p (int, *opsional*, default 2) : Dimensi grid kuantisasi. 1 dan 2 didukung. 2 selalu lebih baik dalam praktik. Default adalah 2.

modules_to_not_convert (`list`, *opsional*, default ["lm_head"]) : Daftar lapisan linear yang tidak boleh dikuantisasi.

hadamard_size (int, *opsional*, default 512) : Ukuran Hadamard untuk metode HIGGS. Default adalah 512. Dimensi input matriks akan di-*pad* hingga nilai ini. Menurunkan nilai ini di bawah 512 akan mengurangi kualitas kuantisasi.

group_size (int, *opsional*, default 256) : Ukuran grup untuk metode HIGGS. Bisa 64, 128, atau 256. Menurunkannya hampir tidak memengaruhi kinerja. Default adalah 256. Harus menjadi pembagi dari hadamard_size.

tune_metadata ('dict', *opsional*, default {}) : Metadata per modul (bentuk blok gemm, metadata GPU, dll.) untuk menyimpan hasil penyetelan kernel. Default adalah kamus kosong. Diisi secara otomatis selama penyetelan.

HiggsConfig adalah kelas konfigurasi untuk kuantisasi menggunakan metode HIGGS.

#### post_init[[transformers.HiggsConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1356)

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

## HqqConfig[[transformers.HqqConfig]]

#### transformers.HqqConfig[[transformers.HqqConfig]]

```python
transformers.HqqConfig(nbits: int = 4, group_size: int = 64, view_as_float: bool = False, axis: int | None = None, dynamic_config: dict | None = None, skip_modules: list = ['lm_head'], **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L277)

**Parameter:**

nbits (`int`, *opsional*, default 4) : Jumlah bit. Nilai yang didukung adalah (8, 4, 3, 2, 1).

group_size (`int`, *opsional*, defaultnya 64) : Nilai group-size. Nilai yang didukung adalah nilai apa pun yang habis dibagi weight.shape[axis]).

view_as_float (`bool`, *opsional*, defaultnya `False`) : Tampilkan bobot terkuantisasi sebagai float (digunakan dalam pelatihan terdistribusi) jika disetel ke `True`.

axis (`Optional[int]`, *opsional*) : Sumbu tempat pengelompokan dilakukan. Nilai yang didukung adalah 0 atau 1.

dynamic_config (dict, *opsional*) : Parameter untuk konfigurasi dinamis. Kuncinya adalah nama tag dari layer dan nilainya adalah konfigurasi kuantisasi. Jika diatur, setiap layer yang ditentukan oleh id-nya akan menggunakan konfigurasi kuantisasi khusus miliknya.

skip_modules (`list[str]`, *opsional*, defaultnya `['lm_head']`) : Daftar lapisan `nn.Linear` yang akan dilewati.

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

Ini adalah pembungkus (wrapper) di sekitar BaseQuantizeConfig dari hqq.

#### from_dict[[transformers.HqqConfig.from_dict]]

```python
from_dict(config: dict)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L342)

Override dari from_dict, yang digunakan dalam AutoQuantizationConfig.from_dict di quantizers/auto.py

#### post_init[[transformers.HqqConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L337)

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

#### to_diff_dict[[transformers.HqqConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L367)

**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.

## MetalConfig[[transformers.MetalConfig]]

#### transformers.MetalConfig[[transformers.MetalConfig]]

```python
transformers.MetalConfig(bits: int = 4, group_size: int = 64, modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1825)

Kelas konfigurasi untuk kuantifikasi afine Metal yang menargetkan perangkat Apple Silicon (MPS).

Metode kuantisasi ini menggunakan kernel Metal `mlx-quantization-metal-kernels` dari Hugging Face Hub untuk melakukan kuantisasi afine (scales + qbiases) dengan lebar bit dan ukuran grup yang dapat dikonfigurasi. Bobot yang dikuantisasi dikemas ke dalam tensor `uint32` dan jalur maju menggunakan kernel Metal dequantization + matmul yang terpadu.

## Mxfp4Config[[transformers.Mxfp4Config]]

#### transformers.Mxfp4Config[[transformers.Mxfp4Config]]

```python
transformers.Mxfp4Config(modules_to_not_convert: list | None = None, dequantize: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1791)

**Parameter:**

modules_to_not_convert (`list`, *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.

dequantize (`bool`, *opsional*, default ke `False`) : Apakah kami mendekuantisasi model ke presisi bf16 atau tidak

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang dimuat menggunakan kuantisasi mxfp4.

## NVFP4Config[[transformers.NVFP4Config]]

#### transformers.NVFP4Config[[transformers.NVFP4Config]]

```python
transformers.NVFP4Config(modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2067)

**Parameter:**

modules_to_not_convert (`list[str]`, *opsional*) : Pola nama modul yang harus tetap dalam presisi aslinya.

kwargs (`dict[str, Any]`, *opsional*) : Nilai tambahan diabaikan dan dilaporkan melalui logger Transformers.

Konfigurasi untuk kuantisasi bobot NVFP4 secara langsung.

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

#### transformers.FbgemmFp8Config[[transformers.FbgemmFp8Config]]

```python
transformers.FbgemmFp8Config(activation_scale_ub: float = 1200.0, modules_to_not_convert: list | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1284)

**Parameter:**

activation_scale_ub (`float`, *opsional*, default 1200.0) : Batas atas skala aktivasi. Ini digunakan saat melakukan kuantisasi aktivasi input.

modules_to_not_convert (`list`, *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 pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang dimuat menggunakan kuantisasi fbgemm fp8.

## CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

#### transformers.CompressedTensorsConfig[[transformers.CompressedTensorsConfig]]

```python
transformers.CompressedTensorsConfig(config_groups: dict[str, typing.Union[ForwardRef('QuantizationScheme'), list[str]]] | None = None, format: str = 'dense', quantization_status: QuantizationStatus = 'initialized', kv_cache_scheme: typing.Optional[ForwardRef('QuantizationArgs')] = None, global_compression_ratio: float | None = None, ignore: list[str] | None = None, quant_method: str = 'compressed-tensors', run_compressed: bool | None = None, dequantize: bool = False, use_optimized_inference: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1095)

**Parameter:**

config_groups (`typing.dict[str, typing.Union[ForwardRef('QuantizationScheme'), typing.list[str]]]`, *opsional*) : kamus yang memetakan nama grup ke definisi skema kuantisasi

format (`str`, *opsional*, defaultnya `"dense"`) : format penyimpanan bobot, misalnya `dense`, `float-quantized` atau `pack-quantized`

quantization_status (`QuantizationStatus`, *opsional*, defaultnya `"initialized"`) : status model dalam siklus hidup kuantisasi, yaitu 'initialized', 'calibration', 'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`, *opsional*) : menentukan kuantisasi dari kv cache. Jika None, kv cache tidak dikuantisasi.

global_compression_ratio (`typing.Union[float, NoneType]`, *opsional*) : persentase kompresi model berupa float 0-1

ignore (`typing.Union[typing.list[str], NoneType]`, *opsional*) : nama atau tipe layer yang tidak akan dikuantisasi, mendukung regex yang diawali dengan 're:'

quant_method (`str`, *opsional*, defaultnya `"compressed-tensors"`) : jangan ditimpa, harusnya compressed-tensors

run_compressed (`bool`, *opsional*) : tidak digunakan lagi, gunakan `dequantize` sebagai gantinya. Satu-satunya efeknya adalah mengatur `dequantize` ke kebalikannya, `run_compressed=False` yang berarti `dequantize=True`.

dequantize (`bool`, *opsional*, defaultnya `False`) : ketika `True`, bobot terkuantisasi akan didekuantisasi kembali ke dtype model (misalnya BF16) saat pemuatan, yang diperlukan untuk fine-tuning atau menyimpan model dalam dtype aslinya. Ketika `False`, bobot dibiarkan dalam bentuk terkompresnya dan compressed-tensors akan mendekompresinya pada forward pass pertama.

use_optimized_inference (`bool`, *opsional*, default `False`) : ketika `True`, lapisan yang skemanya memiliki kernel akan mempertahankan bobot terkuantisasinya dan dijalankan melalui kernel tersebut (saat ini W8A8 FP8, pada CUDA SM89+, XPU, atau MPS dengan torch >= 2.15). Hanya untuk inferensi, dan bersifat opt-in: tanpanya, model akan melewati rute compressed-tensors reguler. Diabaikan ketika `dequantize=True`.

Ini adalah kelas pembungkus yang menangani opsi konfigurasi kuantisasi compressed-tensors. Ini adalah pembungkus di sekitar `compressed_tensors.QuantizationConfig`

#### from_dict[[transformers.CompressedTensorsConfig.from_dict]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1192)

**Parameter:**

config_dict (`dict[str, Any]`) : Kamus yang akan digunakan untuk membuat objek konfigurasi.

return_unused_kwargs (`bool`,*opsional*, defaultnya `False`) : Apakah akan mengembalikan daftar argumen kata kunci yang tidak digunakan. Digunakan untuk metode `from_pretrained` di `PreTrainedModel`.

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

**Mengembalikan:** `QuantizationConfigMixin`

Objek konfigurasi yang diinstansiasi dari parameter tersebut.

Membuat instans [CompressedTensorsConfig](/docs/transformers/main/id/main_classes/quantization#transformers.CompressedTensorsConfig) dari kamus Python berisi parameter. Secara opsional, membuka bungkus argumen apa pun dari nested quantization_config

#### to_dict[[transformers.CompressedTensorsConfig.to_dict]]

```python
to_dict()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1217)

Konfigurasi kuantisasi yang akan ditambahkan ke config.json

Menserialisasi instance ini ke dalam kamus Python. Mengembalikan: `dict[str, Any]`: Kamus dari semua atribut yang membentuk instance konfigurasi ini.

#### to_diff_dict[[transformers.CompressedTensorsConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1232)

**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.

## TorchAoConfig[[transformers.TorchAoConfig]]

#### transformers.TorchAoConfig[[transformers.TorchAoConfig]]

```python
transformers.TorchAoConfig(quant_type: AOBaseConfig, modules_to_not_convert: list | None = None, include_input_output_embeddings: bool = False, untie_embedding_weights: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1460)

**Parameter:**

quant_type (`AOBaseConfig`) : Instans `AOBaseConfig` torchao yang menentukan jenis kuantisasi, misalnya `Int4WeightOnlyConfig(group_size=32)`, `Int8WeightOnlyConfig()`, `Int8DynamicActivationInt8WeightConfig()`, `Float8WeightOnlyConfig()`, dan sebagainya.

modules_to_not_convert (`list`, *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.

include_input_output_embeddings (`bool`, *opsional*, defaultnya `False`) : Apakah akan menyertakan embedding dalam kuantisasi atau tidak. Jika flag ini disetel, input embedding juga akan dihapus dari daftar module_not_to_convert.

untie_embedding_weights (`bool`, *opsional*, defaultnya `False`) : Apakah akan melepaskan ikatan bobot saat kita mengkuantisasi bobot input embedding yang terikat dengan bobot lain.

Kelas konfigurasi untuk teknik kuantisasi/kejarangan torchao.

Contoh:

```python
from torchao.quantization import Int4WeightOnlyConfig

quantization_config = TorchAoConfig(Int4WeightOnlyConfig(group_size=32))
model = AutoModelForCausalLM.from_pretrained(
    model_id, device_map="cuda", torch_dtype=torch.bfloat16, quantization_config=quantization_config
)
```

#### from_dict[[transformers.TorchAoConfig.from_dict]]

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

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1543)

Buat konfigurasi dari kamus.

#### get_apply_tensor_subclass[[transformers.TorchAoConfig.get_apply_tensor_subclass]]

```python
get_apply_tensor_subclass()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1529)

Kembalikan konfigurasi kuantisasi yang akan diterapkan.

#### post_init[[transformers.TorchAoConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1511)

Validasi konfigurasi dan atur nilai bawaan.

#### to_dict[[transformers.TorchAoConfig.to_dict]]

```python
to_dict()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1533)

Mengonversi konfigurasi menjadi kamus.

## BitNetQuantConfig[[transformers.BitNetQuantConfig]]

#### transformers.BitNetQuantConfig[[transformers.BitNetQuantConfig]]

```python
transformers.BitNetQuantConfig(modules_to_not_convert: list | None = None, linear_class: str = 'bitlinear', quantization_mode: str = 'offline', use_rms_norm: bool = False, rms_norm_eps: float | None = 1e-06, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1563)

**Parameter:**

modules_to_not_convert (`Optional[List]`, *opsional*) : Secara opsional, menyediakan daftar jalur lengkap dari parameter bobot `nn.Linear` yang tidak boleh dikuantisasi. Nilainya secara default adalah None.

linear_class (`str`, *opsional*, defaultnya `"bitlinear"`) : Jenis kelas linear yang akan digunakan. Bisa berupa `bitlinear` atau `autobitlinear`.

quantization_mode (`str`, *opsional*, defaultnya `"offline"`) : Mode kuantisasi yang akan digunakan. Bisa berupa `online` atau `offline`. Pada mode `online`, parameter kuantisasi bobot dihitung secara dinamis selama setiap forward pass (misalnya, berdasarkan nilai bobot saat ini). Hal ini dapat beradaptasi terhadap perubahan bobot selama pelatihan (Quantization-Aware Training - QAT). Pada mode `offline`, parameter kuantisasi dihitung sebelumnya *sebelum* inferensi. Parameter-parameter ini kemudian ditetapkan dan dimuat ke dalam model terkuantisasi. Hal ini umumnya menghasilkan overhead runtime yang lebih rendah dibandingkan kuantisasi online.

use_rms_norm (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan RMSNorm pada aktivasi sebelum kuantisasi. Ini sesuai dengan pendekatan dari paper BitNet asli, yaitu menormalisasi aktivasi sebelum kuantisasi/packing.

rms_norm_eps (`float`, *opsional*, default 1e-06) : Nilai epsilon yang digunakan pada lapisan RMSNorm untuk stabilitas numerik.

kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang dapat digunakan oleh backend kuantisasi tertentu atau versi masa depan.

Kelas konfigurasi untuk menerapkan kuantisasi BitNet.

#### post_init[[transformers.BitNetQuantConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1612)

Pemeriksa keselamatan yang memastikan argumen benar

## SpQRConfig[[transformers.SpQRConfig]]

#### transformers.SpQRConfig[[transformers.SpQRConfig]]

```python
transformers.SpQRConfig(bits: int = 3, beta1: int = 16, beta2: int = 16, shapes: dict[str, int] | None = None, modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1619)

**Parameter:**

bits (`int`, *opsional*, default 3) : Menentukan jumlah bit untuk bobot serta titik nol dan skala orde pertama. Saat ini hanya bits = 3 yang didukung.

beta1 (`int`, *opsional*, default 16) : Lebar tile SpQR. Saat ini hanya beta1 = 16 yang didukung.

beta2 (`int`, *opsional*, default 16) : Tinggi tile SpQR. Saat ini hanya beta2 = 16 yang didukung.

shapes (`Optional`, *opsional*) : Kamus yang menyimpan bentuk dari setiap objek. Kami membutuhkan ini karena tidak mungkin untuk menyimpulkan ukuran pasti parameter hanya dari bits, beta1, beta2.

modules_to_not_convert (`Optional[list[str]]`, *opsional*) : Secara opsional, menyediakan daftar jalur lengkap dari parameter bobot `nn.Linear` yang tidak boleh dikuantisasi. Bawaan adalah None.

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

Ini adalah kelas pembungkus untuk parameter `spqr`. Silakan merujuk ke publikasi asli untuk detail lebih lanjut.

#### post_init[[transformers.SpQRConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1660)

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

## FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

#### transformers.FineGrainedFP8Config[[transformers.FineGrainedFP8Config]]

```python
transformers.FineGrainedFP8Config(activation_scheme: str = 'dynamic', weight_block_size: tuple = (128, 128), dequantize: bool = False, modules_to_not_convert: list | None = None, modules_to_convert: list | None = None, scale_fmt: str = 'float', expert_dtype: str = 'fp8', **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1682)

**Parameter:**

activation_scheme (`str`, *opsional*, defaultnya `"dynamic"`) : Skema yang digunakan untuk aktivasi, default dan satu-satunya skema yang didukung saat ini adalah "dynamic".

weight_block_size (`typing.tuple[int, int]`, *opsional*, defaultnya `(128, 128)`) : Ukuran blok bobot untuk kuantisasi, defaultnya adalah (128, 128).

dequantize (`bool`, *opsional*, defaultnya `False`) : Apakah model akan didekuantisasi saat dimuat.

modules_to_not_convert (`list`, *opsional*) : Daftar nama modul yang tidak boleh dikonversi selama kuantisasi.

modules_to_convert (`list`, *opsional*) : Daftar nama modul tambahan, seperti tabel embedding, yang harus dikonversi selama kuantisasi.

scale_fmt (`str`, *opsional*, defaultnya `"float"`) : dtype penyimpanan untuk skala bobot per blok: `"float"` (fp32, gaya V3) atau `"ue8m0"` (1 byte `torch.float8_e8m0fnu`, gaya V4).

expert_dtype (`str`, *opsional*, defaultnya `"fp8"`) : Format bobot para ahli MoE: `"fp8"`, atau `"fp4"` untuk ahli FP4-packed dari DeepSeek-V4.

FineGrainedFP8Config adalah kelas konfigurasi untuk kuantisasi FP8 berbutir halus yang terutama digunakan untuk model deepseek.

#### post_init[[transformers.FineGrainedFP8Config.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1729)

Pemeriksa keselamatan yang memastikan argumen benar

## QuarkConfig[[transformers.QuarkConfig]]

#### transformers.QuarkConfig[[transformers.QuarkConfig]]

```python
transformers.QuarkConfig(**kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1749)

## FourOverSixConfig[[transformers.FourOverSixConfig]]

#### transformers.FourOverSixConfig[[transformers.FourOverSixConfig]]

```python
transformers.FourOverSixConfig(activation_dtype: str | None = None, activation_scale_rule: str | None = None, dtype: str = 'nvfp4', gradient_dtype: str | None = None, gradient_scale_rule: str | None = None, keep_master_weights: bool = False, matmul_backend: str | None = None, output_dtype: str | None = 'bfloat16', quantize_backend: str | None = None, scale_rule: str = 'mse', weight_dtype: str | None = None, weight_scale_2d: bool = False, weight_scale_rule: str | None = None, module_config_overrides: dict[str, dict[str, typing.Any]] | None = None, modules_to_not_convert: list[str] | None = ['lm_head'], **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1869)

**Parameter:**

activation_dtype (`str`, *opsional*) : Tipe data yang digunakan saat mengkuantisasi tensor aktivasi. Jika tidak disediakan, `dtype` yang digunakan.

activation_scale_rule (`str`, *opsional*) : Aturan penskalaan yang digunakan saat memilih skala untuk blok dalam tensor aktivasi. Jika tidak disediakan, `scale_rule` yang digunakan.

dtype (`str`, default "nvfp4", *opsional*, defaultnya `"nvfp4"`) : Tipe data yang digunakan untuk bobot, aktivasi, dan tensor lapisan. Bisa berupa `"nvfp4"` atau `"mxfp4"`.

gradient_dtype (`str`, *opsional*) : Tipe data yang digunakan saat mengkuantisasi tensor gradien. Jika tidak disediakan, `dtype` yang digunakan.

gradient_scale_rule (`str`, *opsional*) : Aturan penskalaan yang digunakan saat memilih skala untuk blok dalam tensor gradien. Jika tidak disediakan, `scale_rule` yang digunakan.

keep_master_weights (`bool`, default False, *opsional*, default ke `False`) : Apakah akan mempertahankan bobot master. Jika `True`, bobot presisi tinggi dipertahankan sepanjang waktu dan bobot dikuantisasi secara online pada setiap forward pass. Ini berguna untuk pelatihan terkuantisasi.

matmul_backend (`str`, *opsional*) : Backend yang akan digunakan untuk perkalian matriks. Bisa berupa `"cutlass"` atau `"pytorch"`. Jika tidak disediakan, CUTLASS akan digunakan jika tersedia, dan PyTorch akan digunakan jika tidak.

output_dtype (`str`, *opsional*, defaultnya `"bfloat16"`) : Tipe data yang digunakan untuk output dari layer. Bisa berupa `"bfloat16"` atau `"float16"`.

quantize_backend (`str`, *opsional*) : Backend yang akan digunakan untuk kuantisasi. Bisa berupa `"cuda"`, `"triton"`, atau `"pytorch"`. Jika tidak disediakan, backend tercepat akan dipilih berdasarkan lingkungan Anda dan berdasarkan opsi yang didukung oleh masing-masing backend. Umumnya, `"cuda"` akan digunakan untuk inferensi, `"triton"` akan digunakan untuk pelatihan, dan `"pytorch"` akan digunakan pada perangkat non-CUDA.

scale_rule (`str`, default "mse", *opsional*, defaultnya `"mse"`) : Aturan yang digunakan saat memilih skala blok. Bisa berupa `"mse"`, `"mae"`, atau `"abs_max"` untuk Four Over Six, `"static_6"` untuk kuantisasi NVFP4 default, atau `"static_4"` untuk menskalakan semua blok ke nilai maksimum 4.

weight_dtype (`str`, *opsional*) : Tipe data yang digunakan saat mengkuantisasi tensor bobot. Jika tidak disediakan, `dtype` yang digunakan.

weight_scale_2d (`bool`, default False, *opsional*, default ke `False`) : Apakah akan menghitung faktor skala pada tensor bobot dalam blok 2D. Hal ini harus dilakukan selama pelatihan.

weight_scale_rule (`str`, *opsional*) : Aturan penskalaan yang digunakan saat memilih skala untuk blok dalam tensor bobot. Jika tidak disediakan, `scale_rule` yang digunakan.

module_config_overrides (`dict[str, dict[str, Any]]`, *opsional*) : Kamus berisi penggantian konfigurasi yang spesifik untuk modul. Kunci harus berupa nama modul, dan nilainya harus berupa kamus yang berisi konfigurasi kuantisasi untuk modul tersebut. Hal ini dapat digunakan untuk menimpa konfigurasi bawaan untuk modul tertentu.

modules_to_not_convert (`list[str]`, *opsional*, defaultnya `['lm_head']`) : Daftar modul yang dikecualikan dari kuantisasi. Secara default, `lm_head` dikecualikan.

Ini adalah kelas pembungkus yang berisi semua opsi untuk kuantisasi dengan `fouroversix`. Singkatnya, Four Over Six adalah modifikasi dari kuantisasi NVFP4 yang secara adaptif menskalakan nilai terbesar di setiap blok 16 nilai FP4 menjadi 4 atau 6. Memilih skala 6 menggunakan rentang penuh nilai FP4, tetapi memilih skala 4 memungkinkan distribusi error kuantisasi yang lebih seragam. Lihat publikasi aslinya untuk detail lebih lanjut: https://arxiv.org/abs/2512.02010.

## FPQuantConfig[[transformers.FPQuantConfig]]

#### transformers.FPQuantConfig[[transformers.FPQuantConfig]]

```python
transformers.FPQuantConfig(forward_dtype: str = 'nvfp4', forward_method: str = 'abs_max', backward_dtype: str = 'bf16', store_master_weights: bool = False, hadamard_group_size: int | None = None, pseudoquantization: bool = False, transform_init: str = 'hadamard', modules_to_not_convert: list[str] | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1371)

**Parameter:**

forward_dtype (`str`, *opsional*, defaultnya `"nvfp4"`) : dtype yang digunakan untuk forward pass.

forward_method (`str`, *opsional*, defaultnya `"abs_max"`) : Skala yang digunakan untuk forward pass. Bisa berupa `"abs_max"` atau `"quest"`. `"abs_max"` lebih baik untuk PTQ, `"quest"` lebih baik untuk QAT.

backward_dtype (`str`, *opsional*, defaultnya `"bf16"`) : dtype yang digunakan untuk backward pass.

store_master_weights (`bool`, *opsional*, defaultnya `False`) : Apakah akan menyimpan bobot master. Diperlukan untuk QAT pada bobot layer.

hadamard_group_size (`int`, *opsional*) : Ukuran grup untuk transformasi hadamard sebelum kuantisasi untuk `"quest"` yang sesuai dengan ukuran grup MXFP4 (32). Jika `None`, nilainya akan diatur menjadi 16 untuk `"nvfp4"` dan 32 untuk `"mxfp4"`.

pseudoquantization (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan pseudo-kuantisasi berbasis Triton. Wajib untuk GPU non-Blackwell. Tidak memberikan peningkatan kecepatan. Untuk keperluan debugging.

transform_init (`str`, *opsional*, defaultnya `"hadamard"`) : metode untuk menginisialisasi matriks pra-pemrosesan. Bisa berupa `"hadamard"`, `"identity"` atau `"gsr"`.

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

FPQuantConfig adalah kelas konfigurasi untuk kuantisasi menggunakan metode FPQuant.

#### post_init[[transformers.FPQuantConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1418)

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

## AutoRoundConfig[[transformers.AutoRoundConfig]]

#### transformers.AutoRoundConfig[[transformers.AutoRoundConfig]]

```python
transformers.AutoRoundConfig(bits: int = 4, group_size: int = 128, sym: bool = True, backend: str = 'auto', **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L208)

**Parameter:**

bits (`int`, *opsional*, default 4) : Jumlah bit untuk kuantisasi, angka yang didukung adalah (2, 3, 4, 5, 6, 7, 8).

group_size (`int`, *opsional*, default 128) : Nilai group-size

sym (`bool`, *opsional*, defaultnya `True`) : Apakah menggunakan kuantisasi simetris

backend (`str`, *opsional*, defaultnya `"auto"`) : Backend inferensi. Secara default, AutoRound memilih backend yang kompatibel berdasarkan perangkat, pengaturan kuantisasi, dan pustaka yang terpasang. Lihat [Menentukan backend inferensi](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend) untuk semua opsi backend.

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat dengan kuantisasi AutoRound.

#### post_init[[transformers.AutoRoundConfig.post_init]]

```python
post_init()
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L239)

Pemeriksa keselamatan yang memastikan argumen benar.

## SinqConfig[[transformers.SinqConfig]]

#### transformers.SinqConfig[[transformers.SinqConfig]]

```python
transformers.SinqConfig(nbits: int = 4, group_size: int = 64, tiling_mode: str = '1D', method: str = 'sinq', modules_to_not_convert: list[str] | None = None, **kwargs: Any)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1964)

**Parameter:**

nbits (`int`, default 4) : Bit kuantisasi untuk bobot.

group_size (`int`, default 64) : Ukuran grup yang digunakan dalam kuantisasi bobot SINQ (harus kelipatan dari 8).

tiling_mode (`str`, default "1D") : Mode tiling untuk SINQ (biasanya "1D"; "2D" jika didukung oleh backend Anda).

method (`str`, default "sinq") : "sinq" – SINQ hanya-berat tanpa kalibrasi "asinq" – A-SINQ (sadar-aktivasi), tidak didukung di Hugging Face. Silakan merujuk ke repositori resmi SINQ.

modules_to_not_convert (`list[str]`, *opsional*) : Daftar nama/modul prefix yang akan dipertahankan dalam presisi penuh.

- ****kwargs** : Argumen pengguna tambahan (disimpan di `_extra_kwargs` untuk round-tripping).

Konfigurasi kuantisasi untuk SINQ / A-SINQ.

Lewatkan ini ke:

AutoModel.from_pretrained(..., quantization_config=SinqConfig(...))

## GgufConfig[[transformers.GgufConfig]]

#### transformers.GgufConfig[[transformers.GgufConfig]]

```python
transformers.GgufConfig(gguf_file: str | None = None, dequantize: bool = False, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2087)

**Parameter:**

gguf_file (`str`, *opsional*) : path ke file `.gguf` yang menyimpan bobot. Bisa dibiarkan kosong jika namanya ditentukan melalui `from_pretrained(..., gguf_file=...)`, yang akan mengisinya.

dequantize (`bool`, *opsional*, defaultnya `False`) : Alih-alih, uraikan setiap bobot saat pemuatan ke dalam model padat biasa. Selalu benar, tetapi mengorbankan penghematan memori; ini juga merupakan fallback otomatis ketika tidak ada kernel matmul yang tersedia untuk tipe kuantisasi file.

Muat checkpoint GGUF yang dikuantisasi dengan bobotnya tetap dalam blok GGUF.