# 양자화

Quantization 기법은 8비트 정수(int8)와 같은 저정밀도 데이터 타입으로 가중치와 activations를 표현하여 메모리 및 계산 비용을 줄입니다. 이를 통해 일반적으로 메모리에 적재할 수 없었던 더 큰 모델을 로드하고 추론 속도를 높일 수 있습니다. 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/v5.23.0/src/transformers/utils/quantization_config.py#L1021)

**매개변수:**

weights (`str`, *선택 사항*, 기본값 `"int8"`) : 양자화 후 가중치의 대상 dtype입니다. 지원되는 값은 ("float8","int8","int4","int2")입니다.

activations (`str`, *선택 사항*) : 양자화 후 activations의 대상 dtype입니다. 지원되는 값은 (None,"int8","float8")입니다.

modules_to_not_convert (`list`, *선택 사항*, 기본값 `None`) : 양자화하지 않을 모듈 목록입니다. 일부 모듈은 원래 정밀도를 유지해야 하는 모델(예: Whisper encoder, Llava encoder, Mixtral gate layers)을 양자화할 때 유용합니다.

`quanto`를 사용하여 로드한 모델에서 사용할 수 있는 모든 가능한 속성과 기능에 대한 래퍼 클래스입니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L865)

**매개변수:**

in_group_size (`int`, *선택 사항*, 기본값 8) : 입력 차원 방향의 그룹 크기입니다.

out_group_size (`int`, *선택 사항*, 기본값 1) : 출력 차원 방향의 그룹 크기. 항상 1을 사용하는 것이 권장됩니다.

num_codebooks (`int`, *선택 사항*, 기본값 1) : Additive Quantization 절차에 사용할 codebook의 수입니다.

nbits_per_codebook (`int`, *선택 사항*, 기본값 16) : 단일 codebook 벡터를 인코딩하는 비트 수. Codebook의 크기는 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/v5.23.0/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[str, typing.Any] = {}, shared_layer_config: dict[str, typing.Any] = {}, modules_to_not_convert: list | None = None, **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L980)

**매개변수:**

enable_proxy_error (`bool`, *선택 사항*, 기본값 `False`) : 각 레이어에 대한 프록시 오류를 계산합니다

config_for_layers (`Dict`, *선택 사항*, 기본값 `{}`) : 각 레이어에 대한 양자화 매개변수

shared_layer_config (`Dict`, *선택 사항*, 기본값 `{}`) : 레이어 간 공유되는 양자화 매개변수

modules_to_not_convert (`list`, *선택 사항*, 기본값 `None`) : 양자화하지 않을 모듈 목록입니다. 일부 모듈은 원래 정밀도를 유지해야 하는 모델(예: Whisper encoder, Llava encoder, Mixtral gate layers)을 양자화할 때 유용합니다.

kwargs (`dict[str, Any]`, *선택 사항*) : 설정 객체를 초기화할 때 사용할 추가 매개변수.

`vptq` 매개변수에 대한 래퍼 클래스입니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L799)

**매개변수:**

bits (`int`, *선택 사항*, 기본값 4) : 양자화할 비트 수입니다.

group_size (`int`, *선택 사항*, 기본값 128) : 양자화에 사용할 그룹 크기입니다. 권장 값은 128이며, -1은 컬럼별 양자화를 사용합니다.

zero_point (`bool`, *선택 사항*, 기본값 `True`) : zero point quantization을 사용할지 여부.

backend (`AwqBackend`, *선택 사항*, 기본값 `AwqBackend.AUTO`) : 양자화 백엔드입니다.

modules_to_not_convert (`list`, *선택 사항*, 기본값 `None`) : 양자화하지 않을 모듈 목록입니다. 일부 모듈을 원래 정밀도로 유지해야 하는 모델(예: Whisper encoder, Llava encoder, Mixtral gate layers)을 양자화할 때 유용합니다. 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/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L617)

**매개변수:**

bits (`int`) : 양자화할 비트 수. 지원되는 값은 (2, 3, 4, 8)입니다.

tokenizer (`str` 또는 `PreTrainedTokenizerBase`, *선택 사항*) : 데이터셋을 처리하는 데 사용되는 토크나이저입니다. 다음 중 하나를 전달할 수 있습니다. - 사용자 정의 토크나이저 객체. - huggingface.co의 모델 저장소에 호스팅된 사전 정의된 토크나이저의 *모델 ID* 문자열. - 토크나이저에 필요한 어휘 파일을 포함하는 *디렉터리* 경로. 예를 들어 [save_pretrained()](/docs/transformers/v5.23.0/ko/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) 메서드를 사용하여 저장한 경우, `./my_model_directory/`와 같습니다.

dataset (`Union[list[str]]`, *선택*) : 양자화에 사용할 데이터셋입니다. 문자열 목록으로 직접 데이터셋을 제공하거나, GPTQ 논문에서 사용된 원래 데이터셋(['wikitext2','c4','c4-new'])을 그대로 사용할 수 있습니다.

group_size (`int`, *선택 사항*, 기본값 128) : 양자화에 사용할 그룹 크기입니다. 권장 값은 128이며, -1은 컬럼별 양자화를 사용합니다.

damp_percent (`float`, *선택 사항*, 기본값 0.1) : 감쇠에 사용할 평균 Hessian 대각선의 비율입니다. 권장 값은 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`, *선택 사항*, 기본값 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를 통해 gptqmodel 백엔드를 기반으로 GPTQ 양자화를 수행하여 로드한 모델에서 사용할 수 있는 모든 속성과 기능에 대한 래퍼 클래스입니다.

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

```python
from_dict_optimum(config_dict)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L788)

optimum gptq config dict와 호환되는 클래스를 가져옵니다

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L782)

optimum gptq config에 호환되는 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/v5.23.0/src/transformers/utils/quantization_config.py#L390)

**매개변수:**

load_in_8bit (`bool`, *선택 사항*, 기본값 `False`) : 이 플래그는 LLM.int8()을 사용하여 8-bit 양자화를 활성화하는 데 사용됩니다.

load_in_4bit (`bool`, *선택 사항*, 기본값 `False`) : 이 플래그는 `bitsandbytes`의 FP4/NF4 레이어로 Linear 레이어를 교체하여 4-bit 양자화를 활성화하는 데 사용됩니다.

llm_int8_threshold (`float`, *선택 사항*, 기본값 6.0) : `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale` 논문에서 설명하는 이상치 감지를 위한 임계값에 해당합니다: https://huggingface.co/papers/2208.07339 이 임계값을 초과하는 hidden states 값은 이상치로 간주되며, 해당 값에 대한 연산은 fp16으로 수행됩니다. 값은 일반적으로 정규 분포를 따르므로 대부분의 값이 [-3.5, 3.5] 범위에 있지만, 대규모 모델에서는 분포가 현저히 다른 일부 체계적인 이상치가 존재합니다. 이러한 이상치는 주로 [-60, -6] 또는 [6, 60] 구간에 위치합니다. Int8 양자화는 크기가 약 5인 값에 잘 작동하지만, 그 이상에서는 상당한 성능 저하가 발생합니다. 좋은 기본 임계값은 6이지만, 불안정한 모델(작은 모델, fine-tuning)의 경우 더 낮은 임계값이 필요할 수 있습니다.

llm_int8_skip_modules (`list[str]`, *선택*) : 8-bit으로 변환하지 않을 모듈의 명시적 목록입니다. 이는 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-bit 메인 가중치로 실행합니다. 역전파 시 가중치를 왕복 변환할 필요가 없어 fine-tuning에 유용합니다.

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/v5.23.0/src/transformers/utils/quantization_config.py#L551)

모델이 양자화 가능한 경우 `True`, 그렇지 않은 경우 `False`를 반환합니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L521)

인수가 올바른지 확인하는 안전 검사기입니다. 또한 일부 NoneType 인수를 기본값으로 대체합니다.

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

```python
quantization_method()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L588)

**반환값:** `dict[str, Any]`

이 구성 인스턴스를 구성하는 모든 속성의 사전,

더 나은 가독성을 위해 기본 config 속성에 해당하는 모든 속성을 config에서 제거하고 Python dictionary로 직렬화합니다.

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

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

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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[str, int | str])
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/quantizers/base.py#L323)

직렬화 텐서를 로드하는 Op 클래스, 예: `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. 역직렬화(deserialization)는 하나의 모듈 매개변수를 구성하므로 일반 변환기(general converters)에서만 실행됩니다. 역양자화(dequantization)도 모델 변환기의 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/v5.23.0/src/transformers/quantizers/base.py#L134)

이것은 텐서가 디스크에서 장치로 전송되는 materialization 시점에 발생합니다. 사전 양자화 체크포인트의 텐서 `param`을 변환할 `dtype`입니다. 해당 `param`이 양자화되지 않은 경우(부동소수점 타입)에는 초기화된 `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/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/quantizers/base.py#L152)

주어진 param이 양자화되어야 하는지 확인합니다.

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

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/quantizers/base.py#L184)

**매개변수:**

model (`~transformers.PreTrainedModel`) : 양자화할 모델

kwargs (`dict`, *선택 사항*) : `_process_model_before_weight_loading`에 함께 전달되는 키워드 인자입니다.

가중치 로딩 전에 모델 속성을 설정하고/또는 모델을 변환합니다. 이 시점에서 모델은 meta device에 초기화되어 있어야 하므로, 모듈을 제자리(in-place)로 교체하기 위해 모델의 골격을 자유롭게 조작할 수 있습니다. 추상 메서드 `_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/v5.23.0/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/v5.23.0/src/transformers/quantizers/base.py#L177)

모델이 빌드되기 전에 요청된 `attn_implementation`을 확인하므로, quantizer가 기본값으로 설정할 수 있습니다.

#### 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/v5.23.0/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/v5.23.0/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[str, str])
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/quantizers/base.py#L341)

`experts.*.gate_proj.weight`를 `experts.gate_up_proj`로 병합하는 경우와 같이, 모델의 params가 예를 들어 어떤 방식으로 병합할지 결정합니다.
- `experts.gate_up_proj_scale_inv`은 매개변수입니다: 복사본은 `experts.*.gate_proj.weight_scale_inv`을 여기에 병합합니다
- 그렇지 않으면 변환기가 `experts.*.gate_proj.weight_scale_inv`도 수집하고, dequantize op가 먼저 실행됩니다

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

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/quantizers/base.py#L158)

이 메서드는 `from_pretrained`를 통해 전달되는 인자와의 잠재적 충돌을 확인하는 데 사용됩니다. Transformers와 통합되는 모든 향후 quantizer에 대해 이 메서드를 정의해야 합니다. 명시적인 확인이 필요하지 않은 경우 아무것도 반환하지 않으면 됩니다.

## 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/v5.23.0/src/transformers/utils/quantization_config.py#L1315)

**매개변수:**

bits (int, *선택 사항*, 기본값 4) : 양자화에 사용할 비트 수입니다. 2, 3 또는 4를 사용할 수 있으며 기본값은 4입니다.

p (int, *선택 사항*, 기본값 2) : 양자화 그리드 차원입니다. 1과 2를 지원합니다. 실제로는 2가 항상 더 좋습니다. 기본값은 2입니다.

modules_to_not_convert (`list`, *선택 사항*, 기본값 ["lm_head"]) : 양자화하지 않아야 하는 선형 레이어 목록.

hadamard_size (int, *선택 사항*, 기본값 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/v5.23.0/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[str] = ['lm_head'], **kwargs)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L277)

**매개변수:**

nbits (`int`, *선택 사항*, 기본값 4) : 비트 수. 지원되는 값은 (8, 4, 3, 2, 1)입니다.

group_size (`int`, *선택 사항*, 기본값 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[str, typing.Any])
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L367)

**반환값:** `dict[str, Any]`

이 구성 인스턴스를 구성하는 모든 속성의 사전,

더 나은 가독성을 위해 기본 config 속성에 해당하는 모든 속성을 config에서 제거하고 Python dictionary로 직렬화합니다.

## 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/v5.23.0/src/transformers/utils/quantization_config.py#L1825)

Apple Silicon(MPS) 장치를 대상으로 하는 Metal affine 양자화를 위한 설정 클래스입니다.

이 양자화 방법은 Hugging Face Hub의 `mlx-quantization-metal-kernels` Metal 커널을 사용하여, 설정 가능한 비트 폭과 그룹 크기를 가진 아핀 양자화(scales + 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/v5.23.0/src/transformers/utils/quantization_config.py#L1791)

**매개변수:**

modules_to_not_convert (`list`, *선택 사항*, 기본값 `None`) : 양자화하지 않을 모듈 목록입니다. 일부 모듈은 원래의 정밀도를 유지해야 하는 모델의 양자화에 유용합니다.

dequantize (`bool`, *선택 사항*, 기본값 `False`) : 모델을 bf16 정밀도로 역양자화할지 여부

…를 사용하여 로드한 모델에서 활용할 수 있는 모든 속성과 기능에 대한 래퍼 클래스입니다.

## 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/v5.23.0/src/transformers/utils/quantization_config.py#L2067)

**매개변수:**

modules_to_not_convert (`list[str]`, *선택 사항*) : 원래 정밀도를 유지해야 하는 모듈 이름 패턴입니다.

kwargs (`dict[str, Any]`, *선택 사항*) : 추가 값은 무시되고 Transformers 로거를 통해 보고됩니다.

on-the-fly 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/v5.23.0/src/transformers/utils/quantization_config.py#L1284)

**매개변수:**

activation_scale_ub (`float`, *선택 사항*, 기본값 1200.0) : 활성화 스케일 상한값입니다. 입력 활성화 양자화 시 사용됩니다.

modules_to_not_convert (`list`, *선택 사항*, 기본값 `None`) : 양자화하지 않을 모듈 목록입니다. 일부 모듈은 원래의 정밀도를 유지해야 하는 모델의 양자화에 유용합니다.

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/v5.23.0/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 cache의 양자화를 지정합니다. None인 경우 kv cache는 양자화되지 않습니다.

global_compression_ratio (`typing.Union[float, NoneType]`, *선택 사항*) : 모델 압축의 0-1 float 비율

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으로 fine-tuning을 수행하거나 모델을 저장할 때 필요합니다. `False`인 경우, 가중치는 압축된 형태로 유지되며 compressed-tensors가 첫 번째 forward pass에서 이를 압축 해제합니다.

use_optimized_inference (`bool`, *선택 사항*, 기본값 `False`) : `True`인 경우, 커널이 있는 스킴의 레이어는 양자화된 가중치를 유지하고 해당 커널을 통해 실행됩니다(현재 W8A8 FP8, CUDA SM89+, XPU 또는 torch >= 2.15 환경의 MPS). 추론 전용이며 옵트인 방식입니다. 이 옵션이 없으면 모델은 일반적인 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/v5.23.0/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/v5.23.0/ko/main_classes/quantization#transformers.CompressedTensorsConfig)를 생성합니다. 필요에 따라 중첩된 quantization_config에서 args를 해제합니다.

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

```python
to_dict()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L1232)

**반환값:** `dict[str, Any]`

이 구성 인스턴스를 구성하는 모든 속성의 사전,

더 나은 가독성을 위해 기본 config 속성에 해당하는 모든 속성을 config에서 제거하고 Python dictionary로 직렬화합니다.

## 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/v5.23.0/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`) : 다른 가중치와 연결(tied)된 입력 임베딩 가중치를 양자화할 때 가중치를 분리(untie)할지 여부.

torchao 양자화/희소화 기법을 위한 Config 클래스입니다.

예:

```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/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L1529)

적용할 양자화 설정을 반환합니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L1511)

설정을 검증하고 기본값을 설정합니다.

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

```python
to_dict()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L1563)

**매개변수:**

modules_to_not_convert (`Optional[List]`, *선택 사항*) : `nn.Linear` 가중치 매개변수의 전체 경로 목록을 선택적으로 제공합니다. 양자화하지 않을 대상입니다. 기본값은 None입니다.

linear_class (`str`, *선택 사항*, 기본값 `"bitlinear"`) : 사용할 linear 클래스의 유형입니다. `bitlinear` 또는 `autobitlinear` 중 하나여야 합니다.

quantization_mode (`str`, *선택 사항*, 기본값 `"offline"`) : 사용할 양자화 모드입니다. `online` 또는 `offline` 중 하나를 지정할 수 있습니다. `online` 모드에서는 가중치 양자화 매개변수가 각 forward pass 동안 동적으로 계산됩니다(예: 현재 가중치 값에 기반). 이는 학습 중 가중치 변경에 적응할 수 있습니다(Quantization-Aware Training - QAT). `offline` 모드에서는 양자화 매개변수가 추론 *이전*에 미리 계산됩니다. 이 매개변수는 고정된 상태로 양자화 모델에 로드됩니다. 일반적으로 온라인 양자화보다 런타임 오버헤드가 낮습니다.

use_rms_norm (`bool`, *선택 사항*, 기본값 `False`) : 양자화 전에 활성화에 RMSNorm을 적용할지 여부입니다. 이는 양자화/패킹 전에 활성화를 정규화하는 원래 BitNet 논문의 방식과 일치합니다.

rms_norm_eps (`float`, *선택 사항*, 기본값 1e-06) : RMSNorm 레이어에서 수치적 안정성을 위해 사용되는 epsilon 값입니다.

kwargs (`dict[str, Any]`, *선택*) : 특정 양자화 백엔드나 향후 버전에서 사용할 수 있는 추가 키워드 인자입니다.

BitNet 양자화를 적용하기 위한 구성 클래스입니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L1619)

**매개변수:**

bits (`int`, *선택 사항*, 기본값 3) : 가중치와 1차 zero-point 및 scale에 사용할 비트 수를 지정합니다. 현재 bits = 3만 지원됩니다.

beta1 (`int`, *선택 사항*, 기본값 16) : SpQR 타일 폭. 현재 beta1 = 16만 지원됩니다.

beta2 (`int`, *선택 사항*, 기본값 16) : SpQR 타일 높이. 현재 beta2 = 16만 지원됩니다.

shapes (`Optional`, *선택 사항*) : 각 객체의 shape를 담는 dictionary입니다. 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/v5.23.0/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[int, int] = (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/v5.23.0/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-packed 전문가를 위한 `"fp4"`.

FineGrainedFP8Config는 주로 deepseek 모델에 사용되는 세밀한 FP8 양자화를 위한 설정 클래스입니다.

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

```python
post_init()
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/quantization_config.py#L1729)

인수가 올바른지 확인하는 안전 검사기

## QuarkConfig[[transformers.QuarkConfig]]

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

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/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/v5.23.0/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`, *선택 사항*) : gradient tensor의 블록에서 scale을 선택할 때 사용할 scaling rule입니다. 제공되지 않으면 `scale_rule`이 사용됩니다.

keep_master_weights (`bool`, 기본값 False, *선택 사항*, 기본값 `False`) : 마스터 가중치를 유지할지 여부입니다. `True`인 경우, 항상 고정밀 가중치를 유지하고 각 forward pass에서 가중치를 온라인으로 양자화합니다. 이는 양자화 학습에 유용합니다.

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 factor를 계산할지 여부입니다. 이는 학습 중에 수행해야 합니다.

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는 16개의 FP4 값으로 구성된 각 블록에서 가장 큰 값을 4 또는 6으로 적응적으로 스케일링하는 NVFP4 양자화의 변형입니다. 스케일 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/v5.23.0/src/transformers/utils/quantization_config.py#L1371)

**매개변수:**

forward_dtype (`str`, *선택 사항*, 기본값 `"nvfp4"`) : forward pass에 사용할 dtype입니다.

forward_method (`str`, *선택 사항*, 기본값 `"abs_max"`) : forward pass에 사용할 scaling입니다. `"abs_max"` 또는 `"quest"`를 사용할 수 있습니다. `"abs_max"`는 PTQ에, `"quest"`는 QAT에 더 적합합니다.

backward_dtype (`str`, *선택 사항*, 기본값 `"bf16"`) : 역전파에 사용할 dtype입니다.

store_master_weights (`bool`, *선택 사항*, 기본값 `False`) : 마스터 가중치를 저장할지 여부입니다. 레이어 가중치에 대한 QAT에 필요합니다.

hadamard_group_size (`int`, *선택 사항*) : `"quest"`의 경우 양자화 전 hadamard 변환에 사용되는 그룹 크기입니다. 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/v5.23.0/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/v5.23.0/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/v5.23.0/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/v5.23.0/src/transformers/utils/quantization_config.py#L1964)

**매개변수:**

nbits (`int`, 기본값 4) : 가중치에 사용할 양자화 비트 수입니다.

group_size (`int`, 기본값 64) : SINQ 가중치 양자화에 사용되는 그룹 크기(8의 배수여야 합니다).

tiling_mode (`str`, 기본값 "1D") : SINQ의 Tiling 모드(보통 "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에 대한 양자화 설정입니다.

다음에 전달하세요:

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/v5.23.0/src/transformers/utils/quantization_config.py#L2087)

**매개변수:**

gguf_file (`str`, *선택 사항*) : 가중치가 저장된 `.gguf` 파일의 경로입니다. `from_pretrained(..., gguf_file=...)`를 통해 파일명이 지정되면 이 값이 자동으로 채워지므로 생략할 수 있습니다.

dequantize (`bool`, *선택 사항*, 기본값 `False`) : 로드 시점에 모든 가중치를 일반 dense 모델로 unpack합니다. 항상 정확하지만 메모리 절약을 포기하게 되며, 파일의 양자화 유형에 해당하는 matmul 커널이 없는 경우에도 자동으로 이 방식으로 폴백됩니다.

GGUF 블록에 가중치를 그대로 유지한 양자화된 GGUF 체크포인트를 로드합니다.