# Квантование

Техники квантования снижают затраты памяти и вычислительных ресурсов, представляя веса и активации с помощью типов данных с пониженной точностью, таких как 8-битные целые числа (int8). Это позволяет загружать более крупные модели, которые в обычном режиме не помещаются в память, а также ускорять инференс. Transformers поддерживает алгоритмы квантования AWQ и GPTQ, а также 8-битное и 4-битное квантование с помощью bitsandbytes.

Техники квантования, не поддерживаемые в Transformers, можно добавить с помощью класса `HfQuantizer`.

Узнайте, как квантовать модели, в руководстве [Квантование](../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"`) : целевой тип данных для весов после квантования. Поддерживаемые значения: ("float8","int8","int4","int2")

activations (`str`, *необязательный*) : целевой dtype для активаций после квантования. Поддерживаемые значения: (None,"int8","float8")

modules_to_not_convert (`list`, *необязательный*, по умолчанию `None`) : Список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют, чтобы некоторые модули оставались в исходной точности (например, энкодер Whisper, энкодер Llava, слои gate в 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`, *optional*, по умолчанию 1) : Количество кодовых книг для процедуры аддитивного квантования.

nbits_per_codebook (`int`, *optional*, по умолчанию 16) : Количество бит, кодирующих один вектор кодовой книги. Размер кодовых книг составляет 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`) : вычисляет ошибку прокси для каждого слоя

config_for_layers (`Dict`, *необязательный*, по умолчанию `{}`) : параметры квантования для каждого слоя

shared_layer_config (`Dict`, *необязательный*, по умолчанию `{}`) : общие параметры квантования для слоёв

modules_to_not_convert (`list`, *необязательный*, по умолчанию `None`) : Список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют, чтобы некоторые модули оставались в исходной точности (например, энкодер Whisper, энкодер Llava, слои gate в 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`, *optional*, по умолчанию `None`) : Список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют сохранения некоторых модулей в исходной точности (например, энкодер Whisper, энкодер Llava, слои gate в Mixtral). Обратите внимание, что напрямую квантовать с помощью transformers нельзя; для квантования моделей HF обратитесь к документации `AutoAWQ`.

Это обёртка, содержащая все возможные атрибуты и функции, с которыми можно работать с моделью, загруженной с использованием квантования awq библиотеки `auto-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"`) : целевой тип данных для весов. Поддерживается только значение "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. - путь к *каталогу*, содержащему файлы словаря, необходимые для токенизатора, например, сохранённые с помощью метода [save_pretrained()](/docs/transformers/main/ru/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`, *optional*, по умолчанию 0.1) : Доля среднего значения диагонали гессиана, используемая для демпфирования. Рекомендуемое значение — 0.1.

desc_act (`bool`, *необязательный*, по умолчанию `False`) : Квантовать ли столбцы в порядке убывания размера активации. Установка значения False может значительно ускорить инференс, но перплексия может немного ухудшиться. Также известно как act-order.

act_group_aware (`bool`, *необязательный*, по умолчанию `True`) : Использовать GAR (group aware activation order) при квантовании. Имеет измеримое положительное влияние на качество квантования. Применимо только при `desc_act = False`. Принудительно устанавливается в `False`, если `desc_act = True`.

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` и другие. См. backends 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`, *необязательный*) : Идентификатор токена отступа. Требуется для подготовки набора данных, когда `batch_size` > 1.

max_input_length (`int`, *optional*) : Максимальная длина входных данных. Это необходимо для инициализации буфера, размер которого зависит от ожидаемой максимальной длины входных данных. Параметр специфичен для бэкенда exllama с act-order.

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 одновременно, так как они независимы. Затем мы квантуем слой `self_attn.o_proj` при уже квантованных слоях q, k, v. Таким образом, мы получаем лучшие результаты, поскольку это отражает реальный вход, который получит `self_attn.o_proj` при квантованной модели.

Это обёртка, содержащая все возможные атрибуты и функции, с которыми можно работать с моделью, загруженной с помощью API `optimum` для квантования 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)

Получить совместимый dict для конфигурации optimum gptq

## 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`) : Этот флаг используется для включения 8-битного квантования с помощью LLM.int8().

load_in_4bit (`bool`, *необязательный*, по умолчанию `False`) : Этот флаг используется для включения 4-битного квантования путём замены слоёв Linear на слои FP4/NF4 из `bitsandbytes`.

llm_int8_threshold (`float`, *optional*, по умолчанию 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`) : Этот флаг предназначен для продвинутых сценариев использования и пользователей, знакомых с данной функцией. Если вы хотите разделить модель на разные части и запустить некоторые из них в int8 на GPU, а другие — в fp32 на CPU, вы можете использовать этот флаг. Это полезно для выгрузки (offloading) больших моделей, таких как `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, соответствующие атрибутам конфигурации по умолчанию, для лучшей читаемости и сериализует в словарь 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 и пока не может быть легко использован вне контекста этого метода.

Атрибуты 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)

при необходимости дополнительного объема памяти для квантования отрегулируйте аргумент max_memory для infer_auto_device_map()

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

Классы Op, загружающие сериализованные тензоры, например `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. Десериализация формирует параметры одного модуля, поэтому выполняется только в общих конвертерах. Декуантизация также выполняется перед операциями конвертеров модели, например, перед объединением по экспертам.

#### 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` из предварительно квантованной контрольной точки. Если этот параметр не квантован (тип float), используется входной `dtype`, полученный из инициализированного `nn.Module`.

Если метод квантования имеет `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]`, *необязательный*) : device_map, передаваемый через метод `from_pretrained`.

Переопределите этот метод, если вы хотите передать новое устройство map, чтобы переопределить существующее. Например, для bitsandbytes, поскольку `accelerate` является обязательным требованием, если 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`) : входной dtype, передаваемый в `from_pretrained`

Некоторые методы квантования требуют явного задания 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, *необязательный*, по умолчанию 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. По умолчанию 512. Входное измерение матриц дополняется до этого значения. Уменьшение этого значения ниже 512 снизит качество квантования.

group_size (int, *optional*, по умолчанию 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, *необязательный*) : Параметры для динамической конфигурации. Ключ — это имя слоя, а значение — конфигурация квантования. Если задано, каждый слой, указанный своим идентификатором, будет использовать свою собственную конфигурацию квантования.

skip_modules (`list[str]`, *необязательный*, по умолчанию `['lm_head']`) : Список слоев `nn.Linear`, которые нужно пропустить.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные параметры, из которых инициализируется объект конфигурации.

Это обёртка над BaseQuantizeConfig из hqq.

#### 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, соответствующие атрибутам конфигурации по умолчанию, для лучшей читаемости и сериализует в словарь 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)

Класс конфигурации для Metal-аффинного квантования, ориентированного на устройства Apple Silicon (MPS).

Этот метод квантования использует Metal-ядра `mlx-quantization-metal-kernels` из Hugging Face Hub для выполнения аффинного квантования (масштабы + qbiases) с настраиваемой разрядностью и размером группы. Квантованные веса упаковываются в тензоры `uint32`, а прямой проход использует слиянные 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`, *optional*, по умолчанию 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]`, *необязательный*) : доля сжатия модели в виде float от 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`, квантованные веса деквантуются обратно в исходный тип данных модели (например, BF16) при загрузке, что требуется для дообучения или сохранения модели в её исходном типе данных. Если `False`, веса остаются в сжатом виде, и compressed-tensors распаковывает их при первом проходе.

use_optimized_inference (`bool`, *необязательный*, по умолчанию `False`) : если `True`, слои, для которых у нас есть ядра, сохраняют свои квантованные веса и выполняются через эти ядра (в настоящее время W8A8 FP8, на CUDA SM89+, XPU или MPS с torch >= 2.15). Только для вывода и включается явно: без этого параметра модель проходит через стандартный путь 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`) : Возвращать ли список неиспользованных аргументов keyword. Используется в методе `from_pretrained` класса `PreTrainedModel`.

kwargs (`dict[str, Any]`) : Дополнительные параметры, из которых инициализируется объект конфигурации.

**Возвращает:** `QuantizationConfigMixin`

Объект конфигурации, созданный из этих параметров.

Создаёт экземпляр [CompressedTensorsConfig](/docs/transformers/main/ru/main_classes/quantization#transformers.CompressedTensorsConfig) из словаря параметров Python. При необходимости распаковывает аргументы из вложенного 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, соответствующие атрибутам конфигурации по умолчанию, для лучшей читаемости и сериализует в словарь 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`) : экземпляр `AOBaseConfig` из torchao, задающий тип квантования, например `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` параметры квантования весов вычисляются динамически во время каждого прямого прохода (например, на основе текущих значений весов). Это позволяет адаптироваться к изменениям весов в процессе обучения (обучение с учётом квантования — QAT). В режиме `offline` параметры квантования вычисляются заранее *до* инференса. Затем эти параметры фиксируются и загружаются в квантованную модель. Как правило, это приводит к меньшим накладным расходам во время выполнения по сравнению с онлайн-квантованием.

use_rms_norm (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять RMSNorm к активациям перед квантованием. Это соответствует подходу из оригинальной статьи BitNet, где активации нормализуются перед квантованием/упаковкой.

rms_norm_eps (`float`, *optional*, по умолчанию 1e-06) : Значение эпсилона, используемое в слое RMSNorm для численной стабильности.

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) : Задаёт количество бит для весов, нулевых точек первого порядка и масштабов. В настоящее время поддерживается только bits = 3.

beta1 (`int`, *optional*, по умолчанию 16) : ширина плитки SpQR. В настоящее время поддерживается только beta1 = 16.

beta2 (`int`, *optional*, по умолчанию 16) : Высота плитки SpQR. В настоящее время поддерживается только beta2 = 16.

shapes (`Optional`, *optional*) : Словарь, содержащий форму каждого объекта. Это необходимо, так как по самим битам, 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"`) : Тип данных для хранения масштабов весов по блокам: `"float"` (fp32, стиль V3) или `"ue8m0"` (1 байт, `torch.float8_e8m0fnu`, стиль V4).

expert_dtype (`str`, *необязательный*, по умолчанию `"fp8"`) : Формат весов экспертов MoE: `"fp8"` или `"fp4"` для FP4-упакованных экспертов DeepSeek-V4.

FineGrainedFP8Config — это класс конфигурации для тонкозернистого квантования FP8, используемый преимущественно для моделей deepseek.

#### 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"` — для обучения, а `"pytorch"` — на устройствах, отличных от CUDA.

scale_rule (`str`, по умолчанию "mse", *необязательный*, по умолчанию `"mse"`) : Правило, используемое при выборе масштабов блоков. Может быть `"mse"`, `"mae"` или `"abs_max"` для Four Over Six, `"static_6"` для квантования NVFP4 по умолчанию или `"static_4"` для масштабирования всех блоков до максимального значения 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"`) : Тип данных, используемый для прямого прохода.

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`, он будет установлен в 16 для `"nvfp4"` и 32 для `"mxfp4"`.

pseudoquantization (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли псевдоквантование на базе Triton. Обязателен для GPU, не являющихся Blackwell. Не обеспечивает ускорения. Предназначен для отладки.

transform_init (`str`, *необязательный*, по умолчанию `"hadamard"`) : метод инициализации матрицы предварительной обработки. Может принимать значения `"hadamard"`, `"identity"` или `"gsr"`.

modules_to_not_convert (`list`, *optional*) : Список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют, чтобы некоторые модули оставались в исходной точности.

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.

Передайте это в:

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`) : Развернуть каждый вес при загрузке в обычную плотную модель. Всегда корректно, но отказывается от экономии памяти; это также автоматический вариант при отсутствии ядра matmul для типов квантования файла.

Загрузите квантованную контрольную точку GGUF, оставив её веса в блоках GGUF.