# 量子化

Quantization技術は、8ビット整数（int8）などの低精度データ型で重みと活性化を表現することで、メモリおよび計算コストを削減します。これにより、通常ではメモリに収まらない大きなモデルを読み込むことができ、推論の高速化も実現します。TransformersはAWQとGPTQの量子化アルゴリズムをサポートしており、bitsandbytesによる8ビットおよび4ビットの量子化にも対応しています。

Transformers でサポートされていない量子化手法は、`HfQuantizer` クラスによって追加できます。

[Quantization](../quantization/overview)ガイドで、モデルの量子化方法について学びましょう。

## QuantoConfig[[transformers.QuantoConfig]]

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

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

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

**パラメータ:**

weights (`str`、*任意*、デフォルトは`"int8"`) : 量子化後の重みのターゲット dtype。サポートされる値は ("float8","int8","int4","int2") です

activations (`str`, *任意*) : 量子化後のアクティベーションのターゲット dtype。サポートされる値は (None,"int8","float8") です

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデル（例：Whisper エンコーダー、Llava エンコーダー、Mixtral のゲート層）を量子化する際に役立ちます。

これは、`quanto`を使用して読み込まれたモデルで操作可能なすべての属性や機能に関するラッパークラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

## 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)
```

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

**パラメータ:**

in_group_size (`int`、*任意*、デフォルトは 8) : 入力次元に沿ったグループサイズ。

out_group_size (`int`、*optional*、デフォルトは 1) : 出力次元に沿ったグループサイズです。常に 1 を使用することをお勧めします。

num_codebooks (`int`、*任意*、デフォルトは 1) : Additive Quantization 手順におけるコードブックの数。

nbits_per_codebook (`int`、*optional*、デフォルトは 16) : 1 つのコードブックベクトルをエンコードするビット数。コードブックのサイズは 2**nbits_per_codebook です。

linear_weights_not_to_quantize (`Optional[list[str]]`, *任意*) : 量子化しない`nn.Linear`の重みパラメータのフルパスのリスト。

kwargs (`dict[str, Any]`、*省略可*) : 設定オブジェクトの初期化に使用する追加のパラメータ。

これは`aqlm`のパラメータに関するラッパークラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

## 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)
```

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

**パラメータ:**

enable_proxy_error (`bool`、*任意*、デフォルトは `False`) : 各レイヤーの proxy error を計算します

config_for_layers (`Dict`、*任意*、デフォルトは`{}`) : 各層の量子化パラメータ

shared_layer_config (`Dict`、*任意*、デフォルトは`{}`) : 各レイヤー間で共有される量子化パラメータ

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデル（例：Whisper エンコーダー、Llava エンコーダー、Mixtral のゲート層）を量子化する際に役立ちます。

kwargs (`dict[str, Any]`、*省略可*) : 設定オブジェクトの初期化に使用する追加のパラメータ。

これは`vptq`のパラメータに関するラッパークラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

## 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)
```

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

**パラメータ:**

bits (`int`、*optional*、デフォルトは 4) : 量子化に使用するビット数。

group_size (`int`、*optional*、デフォルトは 128) : 量子化に使用するグループサイズです。推奨値は 128 で、-1 を指定するとカラムごとの量子化を使用します。

zero_point (`bool`、*任意*、デフォルトは`True`) : ゼロポイント量子化を使用するかどうか。

backend (`AwqBackend`、*任意*、デフォルトは`AwqBackend.AUTO`) : 量子化バックエンド。

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデル（例: Whisper エンコーダー、Llava エンコーダー、Mixtral のゲート層）を量子化する際に役立ちます。なお、transformers を直接使用して量子化することはできません。HF モデルの量子化については、`AutoAWQ` のドキュメントを参照してください。

`auto-awq` ライブラリの awq 量子化（auto_awq バックエンドに依存）を使用して読み込まれたモデルで操作可能な、すべての属性および機能に関するラッパークラスです。

## EetqConfig[[transformers.EetqConfig]]

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

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

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

**パラメータ:**

weights (`str`、*任意*、デフォルトは`"int8"`) : 重みのターゲット dtype。サポートされる値は "int8" のみです

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデルの量子化に役立ちます。

`eetq` を使用して読み込まれたモデルで操作可能な、すべての属性や機能に関するラッパークラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

## 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)
```

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

**パラメータ:**

bits (`int`) : 量子化するビット数。サポートされている値は (2, 3, 4, 8) です。

tokenizer (`str` または `PreTrainedTokenizerBase`、*任意*) : データセットを処理するために使用するトークナイザー。以下を渡すことができます。 - カスタムなトークナイザーオブジェクト。 - huggingface.co のモデルリポジトリにホストされている事前定義されたトークナイザーの *モデル ID* を示す文字列。 - トークナイザーに必要な語彙ファイルを含む *ディレクトリ* のパス。例えば、[save_pretrained()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) メソッドを使用して保存されたものなど、`./my_model_directory/` のように指定します。

dataset (`Union[list[str]]`、*任意*) : 量子化に使用されるデータセットです。文字列のリストとして独自のデータセットを指定するか、GPTQ論文で使用された元のデータセット ['wikitext2','c4','c4-new'] をそのまま使用できます。

group_size (`int`、*optional*、デフォルトは 128) : 量子化に使用するグループサイズです。推奨値は 128 で、-1 を指定するとカラムごとの量子化を使用します。

damp_percent (`float`、*任意*、デフォルト値は 0.1) : ダンピングに使用するヘッセ行列の対角成分の平均値の割合です。推奨値は 0.1 です。

desc_act (`bool`、*任意*、デフォルトは `False`) : アクティベーションサイズが大きい順に列を量子化するかを指定します。False に設定すると推論が大幅に高速化されますが、パープレキシティがわずかに悪化する可能性があります。act-order としても知られています。

act_group_aware (`bool`、*任意*、デフォルトは `True`) : 量子化時に GAR（group aware activation order）を使用します。量子化の品質に測定可能なプラスの影響があります。`desc_act = False` の場合のみ適用可能です。`desc_act = True` の場合は、強制的に `False` に設定されます。

sym (`bool`、*任意*、デフォルトは`True`) : 対称量子化を使用するかどうか。

true_sequential (`bool`、*任意*、デフォルトは`True`) : 単一の Transformer ブロック内であっても、逐次量子化を実行するかどうか。ブロック全体を一度に量子化するのではなく、レイヤーごとに量子化を実行します。その結果、各レイヤーは、それまでに量子化されたレイヤーを通過した入力を用いて量子化されます。

format (`str`、*任意*、デフォルトは`"gptq"`) : GPTQの重み形式。`gptq`（v1）はgptqmodelでサポートされています。`gptq_v2`はgptqmodelのみで利用可能です。

meta (`dict[str, any]`、*任意*) : 量子化や量子化推論に直接寄与しないプロパティ（例: tooling:version）は meta に保存されます。つまり、`meta.quantizer`: ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *省略可*) : 使用するカーネルを制御します。gptqmodel の有効な値は `auto`、`auto_trainable` などです。gptqmodel のバックエンドに関する詳細は、https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py を参照してください。

model_seqlen (`int`, *任意*) : モデルが受け取れる最大シーケンス長。

block_name_to_quantize (`str`, *任意*) : 量子化対象の transformers ブロック名。None の場合、一般的なパターン（例: model.layers）を使用してブロック名を推論します。

module_name_preceding_first_block (`list[str]`、*任意*) : 最初の Transformer ブロックの前にあるレイヤー。

batch_size (`int`、*optional*、デフォルトは 1)：データセットを処理する際に使用するバッチサイズ

pad_token_id (`int`, *任意*) : パッドトークンID。`batch_size` > 1 の場合、データセットの準備に必要です。

max_input_length (`int`, *任意*) : 最大入力長です。これは、最大予想入力長に依存するバッファを初期化するために必要です。act-order を使用する場合の exllama バックエンド固有の項目です。

cache_block_outputs (`bool`、*任意*、デフォルトは`True`) : ブロックの出力をキャッシュし、後続のブロックの入力として再利用するかどうかを指定します。

modules_in_block_to_quantize (`list[list[str]]`、*任意*) : 指定されたブロック内で量子化対象とするモジュール名のリストのリストです。この引数は、特定の線形モジュールを量子化対象から除外する場合に便利です。量子化対象のブロックは、`block_name_to_quantize`を設定することで指定できます。各リストは順番に量子化されます。設定されていない場合、すべての線形層が量子化されます。例: `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`。この例では、q、k、v 層は相互に独立しているため、まず同時に量子化します。その後、q、k、v 層が量子化された状態で `self_attn.o_proj` 層を量子化します。これにより、モデルが量子化された際に `self_attn.o_proj` が実際に受け取る入力を反映できるため、より良い結果が得られます。

`optimum` API を使用して GPTQ 量子化（gptqmodel バックエンドを使用）で読み込まれたモデルで操作可能な、すべての属性や機能に関するラッパークラスです。

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

```python
from_dict_optimum(config_dict)
```

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

optimum の gptq 設定辞書から互換クラスを取得します

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

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

```python
to_dict_optimum()
```

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

optimum の gptq 設定に互換性のある dict を取得します

## 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)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L390)

**パラメータ:**

load_in_8bit (`bool`、*任意*、デフォルトは`False`) : このフラグは、LLM.int8() による 8 ビット量子化を有効にするために使用されます。

load_in_4bit (`bool`、*任意*、デフォルトは`False`) : このフラグは、`bitsandbytes`のFP4/NF4レイヤーでLinearレイヤーを置き換えることにより、4ビット量子化を有効にするために使用されます。

llm_int8_threshold (`float`, *任意*、デフォルト値は 6.0) : `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale` 論文で説明されているアウター検出の閾値に対応します: https://huggingface.co/papers/2208.07339 この閾値を超える隠れ状態の値はアウターとみなされ、それらの値に対する演算は fp16 で行われます。値は通常、正規分布に従っており、ほとんどの値は [-3.5, 3.5] の範囲内にありますが、大規模モデルでは分布が大きく異なる、系統的なアウターがいくつか存在します。これらのアウターは、しばしば [-60, -6] または [6, 60] の区間にあります。Int8 量子化は、大きさ ~5 の値に対してはよく機能しますが、それを超えると、顕著な性能の低下が生じます。適切なデフォルトの閾値は 6 ですが、より不安定なモデル（小規模モデル、ファインチューニング）では、より低い閾値が必要になる場合があります。

llm_int8_skip_modules (`list[str]`、*任意*) : 8ビットに変換したくないモジュールの明示的なリストです。これは、Jukeboxのように異なる位置に複数のヘッドを持ち、必ずしも最後の位置にあるとは限らないモデルに有用です。例えば、`CausalLM`モデルでは、最後の`lm_head`は元の`dtype`のまま保持されます。

llm_int8_enable_fp32_cpu_offload (`bool`、*任意*、デフォルトは`False`) : このフラグは、高度なユースケースや、この機能について認識しているユーザー向けに使用されます。モデルを異なる部分に分割し、一部の部分を GPU で int8 として、別の部分を CPU で fp32 として実行したい場合は、このフラグを使用できます。これは、`google/flan-t5-xxl`のような大規模モデルのオフロードに有用です。なお、int8 演算は CPU 上では実行されません。

llm_int8_has_fp16_weight (`bool`、*任意*、デフォルトは`False`) : このフラグを指定すると、LLM.int8() が 16 ビットのメインウェイトで実行されます。バックワードパスのためにウェイトを往復変換する必要がないため、ファインチューニングに有用です。

bnb_4bit_compute_dtype (`torch.dtype` または str、*任意*、デフォルトは `torch.float32`) : 入力タイプとは異なる場合がある計算タイプを設定します。例えば、入力が fp32 であっても、高速化のために計算を bf16 に設定できます。

bnb_4bit_quant_type (`str`、*任意*、デフォルトは`"fp4"`) : bnb.nn.Linear4Bitレイヤーの量子化データ型を設定します。オプションとして、`fp4`または`nf4`で指定されるFP4およびNF4データ型があります。

bnb_4bit_use_double_quant (`bool`、*任意*、デフォルトは`False`) : 最初の量子化から得られた量子化定数をさらに量子化するための、ネストされた量子化で使用するフラグです。

bnb_4bit_quant_storage (`torch.dtype` または str、*任意*、デフォルトは `torch.uint8`) : 量子化された 4 ビットのパラメータをパックするためのストレージ型を設定します。

kwargs (`dict[str, Any]`、*省略可*) : 設定オブジェクトの初期化に使用する追加のパラメータ。

これは、`bitsandbytes`を使用して読み込まれたモデルで操作可能なすべての属性や機能に関するラッパークラスです。

現在、`LLM.int8()`、`FP4`、および`NF4`の量子化のみをサポートしています。`bitsandbytes`にさらにメソッドが追加された場合、このクラスにも引数が追加されます。

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

```python
is_quantizable()
```

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

モデルが量子化可能であれば`True`を、そうでなければ`False`を返します。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

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

```python
quantization_method()
```

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

このメソッドは、モデルに使用された量子化手法を返します。モデルが量子化できない場合、`None`を返します。

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

```python
to_diff_dict()
```

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

**戻り値:** `dict[str, Any]`

この設定インスタンスを構成するすべての属性の辞書、

デフォルトの config 属性に対応するすべての属性を config から削除し、可読性を向上させます。その後、Python の辞書にシリアライズします。

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

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

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

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

HuggingFace の量子化器の抽象クラスです。現時点では、推論および/または量子化のための HF transformers モデルの量子化をサポートしています。このクラスは transformers.PreTrainedModel.from_pretrained のみで使用され、現時点ではそのメソッドのスコープ外で簡単に使用することはできません。

Attributes quantization_config (`transformers.utils.quantization_config.QuantizationConfigMixin`): 量子化対象のモデルの量子化パラメータを定義する量子化設定です。 requires_calibration (`bool`): 量子化手法が、モデルを使用する前にキャリブレーションを必要とするかどうかを示します。

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

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

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

量子化に追加のメモリが必要な場合は、infer_auto_device_map() の max_memory 引数を調整してください

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

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

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

モデルをデクアンタイズして元のモデルを復元できますが、精度やパフォーマンスが若干低下する可能性があります。なお、すべてのクアンタイズ方式がこの操作をサポートしているわけではありません。

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

```python
get_load_operations()
```

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

`{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}` のように、シリアライズされたテンソルを読み込む Op クラスを指定します。デシリアライズは 1 つのモジュールのパラメータを構築するため、汎用コンバーターでのみ実行されます。デクアンタイズも、モデルのコンバーターの Op、例えば per-expert merge の前に実行されます。

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

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

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

これは、テンソルがディスクからデバイスに送信されるマテリアライゼーション時に発生します。`dtype` は、事前量子化されたチェックポイントのテンソル `param` をキャストするための型です。その `param` が量子化されていない（float 型）場合、初期化済みの `nn.Module` から渡される入力 `dtype` を使用します。

量子化手法に`Deserializer`または`Dequantizer`（読み込み関数）がある場合、それらによって処理されるため、Noneを返します。

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

```python
get_state_dict_and_metadata(model)
```

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

state dict とメタデータを取得します。量子化により state dict を少し修正する必要がある場合に便利です

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

```python
get_weight_conversions()
```

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

モデルのコンバーターに一致しないパラメーターに対して実行するローディングを返します

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

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

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

与えられたパラメータが量子化の対象であるかどうかを確認します。

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

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

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

**パラメータ:**

model (`~transformers.PreTrainedModel`) : 量子化対象のモデル

kwargs (`dict`, *任意*) : `_process_model_after_weight_loading` に渡されるキーワード引数です。

重みの読み込み後にモデルを後処理します。抽象メソッド`_process_model_after_weight_loading`をオーバーライドすることを忘れないでください。

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

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

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

**パラメータ:**

model (`~transformers.PreTrainedModel`) : 量子化対象のモデル

kwargs (`dict`, *任意*) : `_process_model_before_weight_loading` に渡されるキーワード引数です。

重みの読み込み前にモデルの属性を設定し、/またはモデルの変換を行います。この時点でモデルは meta デバイス上で初期化されているため、モジュールをその場で置き換える目的で、モデルのスケルトンを自由に操作できます。抽象メソッド `_process_model_before_weight_loading` をオーバーライドすることを忘れないでください。

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

```python
remove_quantization_config(model)
```

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

モデルから量子化設定を削除します。

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

```python
update_attn_implementation(config)
```

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

モデルが構築される前に要求された`attn_implementation`を確認するため、クオンタイザーがデフォルト値を設定できます。

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

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

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

**パラメータ:**

device_map (`Union[dict, str]`、*任意*) : `from_pretrained` メソッドに渡される device_map です。

既存の device map を新しいものの上書きで渡す場合は、このメソッドをオーバーライドしてください。例えば、`accelerate` は必須要件であるため、bitsandbytes の場合、device_map が渡されない場合は、device_map が `"auto"` に設定されます。

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

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

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

**パラメータ:**

dtype (`torch.dtype`) : `from_pretrained` に渡される入力 dtype

一部の量子化手法では、モデルのdtypeをターゲットのdtypeに明示的に設定する必要があります。その動作を維持したい場合は、このメソッドをオーバーライドする必要があります。

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

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

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

`model.tp_plan` または `model.ep_plan`（設定とすべてのサブ設定からマージされた完全なプラン）を、'inv_scale' などの量子化器のカスタムキーを考慮するように、その場で更新します

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

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

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

モデルのコンバーター（変換マッピングから）がシリアライズされた名前を読み込むようにします。マージの例として、`experts.*.gate_proj.weight` を `experts.gate_up_proj` にマージする場合、モデルのパラメータが決定します。
- `experts.gate_up_proj_scale_inv` はパラメータであり、コピーによって `experts.*.gate_proj.weight_scale_inv` がこれにマージされます。
- そうしないと、コンバーターは`experts.*.gate_proj.weight_scale_inv`も収集してしまい、dequantize 演算が先に実行されてしまいます。

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

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

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

このメソッドは、`from_pretrained`に渡される引数との潜在的な競合を、必要に応じてチェックするために使用されます。Transformers に統合される将来のすべてのクオンタイザーに対して、このメソッドを定義する必要があります。明示的なチェックが不要な場合は、何も返さないようにしてください。

## 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)
```

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

**パラメータ:**

bits (int, *optional*, デフォルトは 4) : 量子化に使用するビット数。2、3、4 のいずれかを指定できます。デフォルトは 4 です。

p (int, *optional*, デフォルトは 2) : 量子化グリッドの次元です。1 と 2 がサポートされています。実際には 2 の方が常に優れています。デフォルトは 2 です。

modules_to_not_convert (`list`、*任意*、デフォルトは ["lm_head"]) : 量子化すべきでない線形層のリスト。

hadamard_size (int, *optional*, デフォルトは 512) : HIGGS 法における Hadamard サイズです。デフォルト値は 512 です。行列の入力次元は、この値にパディングされます。この値を 512 未満にすると、量子化の品質が低下します。

group_size (int, *任意*、デフォルトは 256) : HIGGS 手法のグループサイズです。64、128、または 256 を指定できます。値を下げてもパフォーマンスへの影響はほとんどありません。デフォルトは 256 です。hadamard_size の約数である必要があります。

tune_metadata ('dict', *任意*、デフォルトは {}) : カーネルチューニング結果を保存するためのモジュール単位のメタデータ（GEMM ブロック形状、GPU メタデータなど）。デフォルトは空の辞書です。チューニング中に自動的に設定されます。

HiggsConfig は、HIGGS 手法を用いた量子化のための設定クラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

## 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)
```

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

**パラメータ:**

nbits (`int`, *任意*, デフォルトは 4) : ビット数。サポートされる値は (8, 4, 3, 2, 1) です。

group_size (`int`、*optional*、デフォルト値は 64) : グループサイズ値。サポートされる値は、weight.shape[axis]で割り切れる任意の値です。

view_as_float (`bool`、*任意*、デフォルトは`False`) : `True`に設定すると、量子化された重みを float として扱います（分散学習で使用）。

axis (`Optional[int]`, *任意*) : グルーピングを実行する軸。サポートされる値は 0 または 1 です。

dynamic_config (dict, *任意*) : 動的設定のパラメータです。キーはレイヤーの名前タグ、値は量子化設定です。設定した場合、id で指定された各レイヤーは、それぞれ専用の量子化設定を使用します。

skip_modules (`list[str]`、*任意*、デフォルトは`['lm_head']`) : スキップする`nn.Linear`レイヤーのリスト。

kwargs (`dict[str, Any]`、*省略可*) : 設定オブジェクトの初期化に使用する追加のパラメータ。

これはhqqのBaseQuantizeConfigのラッパーです。

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

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

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

Override from_dict, used in AutoQuantizationConfig.from_dict in quantizers/auto.py

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

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

```python
to_diff_dict()
```

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

**戻り値:** `dict[str, Any]`

この設定インスタンスを構成するすべての属性の辞書、

デフォルトの config 属性に対応するすべての属性を config から削除し、可読性を向上させます。その後、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)
```

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

Apple Silicon (MPS) デバイスを対象とする Metal アフィン量子化用の設定クラスです。

この量子化手法は、Hugging Face Hub からの `mlx-quantization-metal-kernels` Metal カーネルを使用して、ビット幅とグループサイズを設定可能なアフィン量子化（スケール + qbiases）を実行します。量子化された重みは `uint32` テンソルにパックされ、フォワードパスでは融合されたデ量子化 + matmul Metal カーネルが使用されます。

## Mxfp4Config[[transformers.Mxfp4Config]]

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

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

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

**パラメータ:**

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデルの量子化に役立ちます。

dequantize (`bool`、*任意*、デフォルトは`False`) : モデルを bf16 精度にデクアンタイズするかどうか

これは、mxfp4 量子化を使用して読み込まれたモデルで操作可能なすべての属性や機能に関するラッパークラスです。

## NVFP4Config[[transformers.NVFP4Config]]

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

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

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

**パラメータ:**

modules_to_not_convert (`list[str]`、*任意*) : 元の精度を維持すべきモジュール名のパターン。

kwargs (`dict[str, Any]`、*省略可*) : 追加の値は無視され、Transformers のロガーを通じて報告されます。

オンザフライのNVFP4重み量子化の設定。

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

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

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

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

**パラメータ:**

activation_scale_ub (`float`、*任意*、デフォルト値は 1200.0) : アクティベーションのスケーリングの上限値です。入力アクティベーションの量子化時に使用されます。

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデルの量子化に役立ちます。

これは、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)
```

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

**パラメータ:**

config_groups (`typing.dict[str, typing.Union[ForwardRef('QuantizationScheme'), typing.list[str]]]`、*任意*) : グループ名を量子化スキームの定義にマッピングする辞書

format (`str`、*任意*、デフォルトは`"dense"`) : 重みが保存される形式。例: `dense`、`float-quantized`、`pack-quantized`

quantization_status (`QuantizationStatus`、*任意*、デフォルトは`"initialized"`) : 量子化ライフサイクルにおけるモデルのステータス。例: 'initialized'、'calibration'、'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`、*任意*) : kv キャッシュの量子化を指定します。None の場合、kv キャッシュは量子化されません。

global_compression_ratio (`typing.Union[float, NoneType]`、*任意*) : モデル圧縮の割合（0〜1の浮動小数点数）

ignore (`typing.Union[typing.list[str], NoneType]`、*任意*) : 量子化しないレイヤーの名前または型を指定します。're:' で始まる正規表現をサポートします。

quant_method (`str`、*任意*、デフォルトは `"compressed-tensors"`) : 上書きしないでください。compressed-tensors である必要があります

run_compressed (`bool`, *任意*) : 非推奨です。`dequantize` を使用してください。唯一の効果は、`dequantize` をその逆の `run_compressed=False`、つまり `dequantize=True` に設定することです。

dequantize (`bool`、*任意*、デフォルトは `False`) : `True` の場合、ロード時に量子化された重みがモデルの dtype（例：BF16）にデ量子化されます。これは、モデルのファインチューニングや元の dtype での保存に必要です。`False` の場合、重みは圧縮された形式のまま保持され、compressed-tensors が最初の forward pass でそれらをデコンプレスします。

use_optimized_inference (`bool`、*任意*、デフォルトは`False`)：`True`の場合、カーネルが用意されているスキームのレイヤーは量子化された重みを保持したまま、それらのカーネルを通じて実行されます（現在は CUDA SM89 以上、XPU、または torch >= 2.15 の MPS での W8A8 FP8）。推論専用であり、オプトイン方式です。これを指定しない場合、モデルは通常の compressed-tensors の経路を通ります。`dequantize=True`の場合は無視されます。

これは、compressed-tensors の量子化設定オプションを処理するラッパークラスです。`compressed_tensors.QuantizationConfig` のラッパーです。

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

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

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

**パラメータ:**

config_dict (`dict[str, Any]`) : 設定オブジェクトをインスタンス化するために使用される辞書。

return_unused_kwargs (`bool`、*任意*、デフォルトは`False`) : 未使用のキーワード引数のリストを返すかどうか。`PreTrainedModel`の`from_pretrained`メソッドで使用されます。

kwargs (`dict[str, Any]`) : 設定オブジェクトの初期化に使用する追加のパラメータ。

**戻り値:** `QuantizationConfigMixin`

これらのパラメータからインスタンス化された設定オブジェクト。

Pythonのパラメータ辞書から[CompressedTensorsConfig](/docs/transformers/main/ja/main_classes/quantization#transformers.CompressedTensorsConfig)をインスタンス化します。必要に応じて、ネストされたquantization_config内の引数を展開します。

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

```python
to_dict()
```

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

config.json に追加する量子化設定

このインスタンスを Python の辞書にシリアライズします。戻り値: `dict[str, Any]`: この設定インスタンスを構成するすべての属性の辞書。

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

```python
to_diff_dict()
```

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

**戻り値:** `dict[str, Any]`

この設定インスタンスを構成するすべての属性の辞書、

デフォルトの config 属性に対応するすべての属性を config から削除し、可読性を向上させます。その後、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)
```

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

**パラメータ:**

quant_type (`AOBaseConfig`) : 量子化の種類を指定する torchao の `AOBaseConfig` インスタンス。例: `Int4WeightOnlyConfig(group_size=32)`、`Int8WeightOnlyConfig()`、`Int8DynamicActivationInt8WeightConfig()`、`Float8WeightOnlyConfig()` など。

modules_to_not_convert (`list`、*任意*、デフォルトは`None`) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデルの量子化に役立ちます。

include_input_output_embeddings (`bool`、*任意*、デフォルトは`False`) : 量子化に埋め込みを含めるかどうかを指定します。このフラグが設定されている場合、入力埋め込みはmodule_not_to_convertリストからも削除されます。

untie_embedding_weights (`bool`、*任意*、デフォルトは`False`) : 入力埋め込みの重みが他の重みと共有されている場合、量子化時に重みの共有を解除するかどうかを指定します。

torchaoの量子化/スパース化手法用の設定クラス。

例:

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

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

辞書から設定を作成します。

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

```python
get_apply_tensor_subclass()
```

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

適用する量子化設定を返します。

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

```python
post_init()
```

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

設定を検証し、デフォルト値を設定します。

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

```python
to_dict()
```

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

設定を辞書に変換します。

## 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)
```

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

**パラメータ:**

modules_to_not_convert (`Optional[List]`, *任意*) : 量子化しない`nn.Linear`の重みパラメータのフルパスのリストを指定できます。デフォルトはNoneです。

linear_class (`str`、*任意*、デフォルトは`"bitlinear"`) : 使用する線形クラスのタイプ。`bitlinear`または`autobitlinear`のいずれかです。

quantization_mode (`str`、*任意*、デフォルトは`"offline"`) : 使用する量子化モードです。`online`または`offline`のいずれかです。`online`モードでは、重みの量子化パラメータが各フォワードパス中に動的に計算されます（例：現在の重みの値に基づく）。これにより、学習中の重みの変化に適応できます（Quantization-Aware Training - QAT）。`offline`モードでは、量子化パラメータが推論の*前*に事前計算されます。これらのパラメータは固定され、量子化モデルに読み込まれます。これにより、オンライン量子化と比較して、ランタイムオーバーヘッドが一般的に低くなります。

use_rms_norm (`bool`, *任意*, デフォルトは `False`) : 量子化の前にアクティベーションに RMSNorm を適用するかどうか。これは、量子化/パッキングの前にアクティベーションを正規化するという、元の BitNet 論文のアプローチと一致します。

rms_norm_eps (`float`、*optional*、デフォルト値は 1e-06) : RMSNorm レイヤーで数値安定性のために使用される epsilon 値。

kwargs (`dict[str, Any]`、*省略可*) : 特定の量子化バックエンドや将来のバージョンで使用される可能性のある追加のキーワード引数。

BitNet量子化を適用するための設定クラス。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

## 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)
```

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

**パラメータ:**

bits (`int`、*optional*、デフォルトは 3) : 重みおよび 1 次ゼロポイントとスケールのビット数を指定します。現在サポートされているのは bits = 3 のみです。

beta1 (`int`、*optional*、デフォルトは 16) : SpQR のタイル幅。現在サポートされているのは beta1 = 16 のみです。

beta2 (`int`、*任意*、デフォルトは 16) : SpQR タイルの高さ。現在サポートされているのは beta2 = 16 のみです。

shapes (`Optional`、*任意*) : 各オブジェクトの形状を保持する辞書です。bits、beta1、beta2 だけではパラメータの正確なサイズを推定できないため、この情報が必要です。

modules_to_not_convert (`Optional[list[str]]`、*任意*) : 量子化しない`nn.Linear`の重みパラメータのフルパスのリストを指定できます。デフォルトはNoneです。

kwargs (`dict[str, Any]`、*省略可*) : 設定オブジェクトの初期化に使用する追加のパラメータ。

これは`spqr`のパラメータに関するラッパークラスです。詳細については、元の論文を参照してください。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

## 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)
```

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

**パラメータ:**

activation_scheme (`str`、*任意*、デフォルトは`"dynamic"`) : アクティベーションに使用されるスキームです。デフォルトであり、現時点でサポートされている唯一のスキームは "dynamic" です。

weight_block_size (`typing.tuple[int, int]`、*任意*、デフォルトは`(128, 128)`) : 量子化における重みブロックのサイズ。デフォルトは (128, 128) です。

dequantize (`bool`、*任意*、デフォルトは`False`) : モデルの読み込み時にデクアンタイズを行うかどうか。

modules_to_not_convert (`list`, *任意*) : 量子化時に変換すべきでないモジュール名のリスト。

modules_to_convert (`list`, *任意*) : 量子化時に変換すべき追加のモジュール名（埋め込みテーブルなど）のリスト。

scale_fmt (`str`、*任意*、デフォルトは `"float"`) : ブロックごとの重みスケールのストレージ dtype: `"float"`（fp32、V3スタイル）または `"ue8m0"`（1バイトの `torch.float8_e8m0fnu`、V4スタイル）。

expert_dtype (`str`、*任意*、デフォルトは `"fp8"`) : MoEエキスパートの重みの形式: `"fp8"`、または DeepSeek-V4 の FP4 パック済みエキスパート用の `"fp4"`。

FineGrainedFP8Config は、主に deepseek モデルで利用される、細粒度の FP8 量子化用の設定クラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー

## QuarkConfig[[transformers.QuarkConfig]]

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

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

[ソース](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)
```

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

**パラメータ:**

activation_dtype (`str`, *省略可*) : アクティベーションテンソルの量子化に使用するデータ型。指定しない場合、`dtype` が使用されます。

activation_scale_rule (`str`, *任意*) : アクティベーションテンソルのブロックに対してスケールを選択する際に使用するスケーリングルール。指定しない場合、`scale_rule` が使用されます。

dtype (`str`、デフォルト "nvfp4"、*任意*、デフォルトは `"nvfp4"`) : レイヤーの重み、活性化、テンソルに使用するデータ型。`"nvfp4"` または `"mxfp4"` を指定できます。

gradient_dtype (`str`, *省略可*) : グラデーションテンソルの量子化に使用するデータ型。指定しない場合、`dtype` が使用されます。

gradient_scale_rule (`str`、*任意*) : グラデーションテンソルのブロックに対してスケールを選択する際に使用するスケーリングルール。指定しない場合、`scale_rule` が使用されます。

keep_master_weights (`bool`、デフォルトは False、*任意*、デフォルトは `False`) : マスターウェイトを保持するかどうか。`True` の場合、常に高精度のウェイトが保持され、各フォワードパスでウェイトがオンラインで量子化されます。これは量子化トレーニングに有用です。

matmul_backend (`str`, *任意*) : 行列積に使用するバックエンド。`"cutlass"`または`"pytorch"`を指定できます。指定しない場合、利用可能な場合はCUTLASSが、それ以外の場合はPyTorchが使用されます。

output_dtype (`str`、*任意*、デフォルトは`"bfloat16"`) : レイヤーの出力に使用するデータ型。`"bfloat16"`または`"float16"`を指定できます。

quantize_backend (`str`, *任意*) : 量子化に使用するバックエンド。`"cuda"`、`"triton"`、または `"pytorch"` を指定できます。指定しない場合、実行環境と各バックエンドがサポートするオプションに基づいて、最速のバックエンドが自動的に選択されます。通常、推論には `"cuda"`、学習には `"triton"`、CUDA 以外のデバイスには `"pytorch"` が使用されます。

scale_rule (`str`、デフォルト "mse"、*任意*、デフォルトは `"mse"`) : ブロックスケールを選択する際に使用するルール。Four Over Six の場合は `"mse"`、`"mae"`、または `"abs_max"`、デフォルトの NVFP4 量子化の場合は `"static_6"`、すべてのブロックを最大値 4 にスケーリングする場合は `"static_4"` を指定できます。

weight_dtype (`str`, *省略可*) : 重みテンソルを量子化するために使用するデータ型。指定しない場合、`dtype` が使用されます。

weight_scale_2d (`bool`、デフォルトは False、*任意*、デフォルトは `False`) : 2D ブロック内の重みテンソルに対してスケール係数を計算するかどうか。これは学習中に実行すべきです。

weight_scale_rule (`str`、*任意*) : 重みテンソルのブロックに対してスケールを選択する際に使用するスケーリングルール。指定しない場合、`scale_rule` が使用されます。

module_config_overrides (`dict[str, dict[str, Any]]`, *任意*) : モジュール固有の設定オーバーライドの辞書です。キーにはモジュール名を、値にはそのモジュールの量子化設定を含む辞書を指定します。これにより、特定のモジュールのデフォルト設定をオーバーライドできます。

modules_to_not_convert (`list[str]`、*任意*、デフォルトは `['lm_head']`) : 量子化から除外するモジュールのリストです。デフォルトでは、`lm_head` が除外されます。

これは `fouroversix` による量子化のすべてのオプションを含むラッパークラスです。簡単に言うと、Four Over Six は NVFP4 量子化の改良版であり、16 個の FP4 値からなる各ブロック内の最大値を 4 または 6 に適応的にスケーリングします。スケーリングに 6 を選択すると FP4 値の全範囲を利用できますが、4 を選択すると量子化誤差の分布がより均一になります。詳細は元の論文を参照してください: 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)
```

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

**パラメータ:**

forward_dtype (`str`、*任意*、デフォルトは`"nvfp4"`) : 前向きパスに使用する dtype。

forward_method (`str`、*任意*、デフォルトは `"abs_max"`) : 前向きパスで使用するスケーリング。 `"abs_max"` または `"quest"` を指定できます。 `"abs_max"` は PTQ に適しており、 `"quest"` は QAT に適しています。

backward_dtype (`str`、*任意*、デフォルトは`"bf16"`) : 逆伝播に使用する dtype。

store_master_weights (`bool`、*任意*、デフォルトは `False`) : マスタウェイトを保存するかどうか。レイヤーウェイトに対する QAT に必要です。

hadamard_group_size (`int`, *optional*) : `"quest"` の場合、量子化前のハダマード変換のグループサイズです。MXFP4 のグループサイズ（32）と一致します。`None` の場合、`"nvfp4"` では 16 に、`"mxfp4"` では 32 に設定されます。

pseudoquantization (`bool`、*任意*、デフォルトは`False`) : Triton ベースの疑似量子化を使用するかどうか。Blackwell 以外の GPU では必須です。速度向上にはなりません。デバッグ目的で使用します。

transform_init (`str`、*任意*、デフォルトは`"hadamard"`) : 前処理行列を初期化する方法。 `"hadamard"`、`"identity"`、または`"gsr"`を指定できます。

modules_to_not_convert (`list`, *任意*) : 量子化しないモジュールのリストです。一部のモジュールを元の精度のまま残すことが明示的に必要なモデルの量子化に役立ちます。

FPQuantConfig は、FPQuant 手法による量子化用の設定クラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。一部のNoneType引数をデフォルト値に置き換えることも行います。

## AutoRoundConfig[[transformers.AutoRoundConfig]]

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

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

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

**パラメータ:**

bits (`int`, *任意*, デフォルトは 4) : 量子化に使用するビット数。サポートされている値は (2, 3, 4, 5, 6, 7, 8) です。

group_size (`int`、*任意*、デフォルトは 128) : グループサイズ値

sym (`bool`、*任意*、デフォルトは`True`) : 対称量子化を行うかどうか

backend (`str`、*任意*、デフォルトは`"auto"`) : 推論バックエンドです。デフォルトでは、AutoRound はデバイス、量子化設定、およびインストールされているライブラリに基づいて、互換性のあるバックエンドを選択します。すべてのバックエンドオプションについては、[推論バックエンドの指定](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend)を参照してください。

これは、AutoRound量子化によって読み込まれたモデルで操作可能なすべての属性や機能に関するラッパークラスです。

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

```python
post_init()
```

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

引数が正しいことを確認するセーフティチェッカー。

## 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)
```

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

**パラメータ:**

nbits (`int`、デフォルト 4) : 重みの量子化ビット数。

group_size (`int`、デフォルト 64) : SINQ 重み量子化で使用するグループサイズ（8 の倍数である必要があります）。

tiling_mode (`str`、デフォルト "1D") : SINQ のタイルリングモード（通常は "1D"、バックエンドがサポートしている場合は "2D"）。

method (`str`、デフォルト値 "sinq") : "sinq" – 校正不要の重みのみ SINQ "asinq" – A-SINQ（活性化認識型）、Hugging Face ではサポートされていません。公式の SINQ リポジトリを参照してください。

modules_to_not_convert (`list[str]`、*任意*) : 完全な精度で保持するモジュール名/プレフィックスのリスト。

- ****kwargs** : 追加のユーザー引数（`_extra_kwargs` に保持され、ラウンドトリップに使用されます）。

SINQ / A-SINQ用のQuantization config。

これを渡す先:

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

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

**パラメータ:**

gguf_file (`str`, *省略可*) : 重みを保持する`.gguf`ファイルへのパス。`from_pretrained(..., gguf_file=...)`で指定された場合は、そこに値が設定されるため、省略できます。

dequantize (`bool`、*任意*、デフォルトは `False`) : 読み込み時にすべての重みを通常の dense モデルに展開します。常に正しく動作しますが、メモリ削減の恩恵を失います。ファイルの量子化タイプに対応する matmul カーネルが利用できない場合の自動フォールバックとしても機能します。

GGUFブロック内に重みを保持したまま、量子化されたGGUFチェックポイントをロードします。