Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /ru /api /quantization.md
mishig
2 days ago
preview code
download
raw
36.2 kB
# Квантование

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

> [!TIP]
> Узнайте, как квантовать модели, в руководстве [Квантование](../quantization/overview).

## PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/pipe_quant_config.py#L34)

**Параметры:**

quant_backend (`str`) : Бэкенд квантования, который будет использоваться. При использовании этого параметра предполагается, что бэкенд доступен как для `diffusers`, так и для `transformers`.
quant_kwargs (`dict`) : Параметры для инициализации класса бэкенда квантования.

components_to_quantize (`list`) : Компоненты конвейера, подлежащие квантованию.

quant_mapping (`dict`) : Соответствие, определяющее спецификации квантования, используемые для компонентов конвейера. При использовании этого аргумента от пользователей не ожидается предоставление `quant_backend`, `quant_kawargs` и `components_to_quantize`.
Класс конфигурации, используемый при применении квантования на лету в [from_pretrained()](/docs/diffusers/main/ru/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).
## BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]
#### diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]
```python
diffusers.BFLQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L427)
**Параметры:**
compute_dtype (`torch.dtype`, по умолчанию `torch.bfloat16`) : Тип данных для активаций и неоквантованных слоев. На устройствах без слиянных ядер FP8 или NVFP4 веса деквантуются в этот тип данных на каждом проходе вперед.
Конфигурация для загрузки контрольных точек, квантованных с использованием схем Black Forest Labs `fp8r` и `nvfp4`.
Обе схемы читаются из контрольной точки через `~FromSingleFileMixin.from_single_file`; квантование модели на лету не поддерживается. Линейный слой квантуется, если его вес сопровождается тензорами масштаба:
- `fp8r`: `weight` имеет тип `float8_e4m3fn` и форму `[N, K]`, а `weight_scale` — это fp32-масштаб для каждой строки с формой `[N]`.
- `nvfp4`: `weight` имеет тип `uint8` и форму `[N, K/2]` (два значения E2M1 на байт), `weight_scale` — это блочный масштаб `float8_e4m3fn` формы `[N, K/16]`, а `weight_scale_2` и `input_scale` — скаляры fp32, хранящие глобальный масштаб весов и откалиброванный масштаб активаций (раскладка ModelOpt NVFP4).
## BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]
#### diffusers.BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]
```python
diffusers.BitsAndBytesConfig(load_in_8bit = False, load_in_4bit = False, llm_int8_threshold = 6.0, llm_int8_skip_modules = None, llm_int8_enable_fp32_cpu_offload = False, llm_int8_has_fp16_weight = False, bnb_4bit_compute_dtype = None, bnb_4bit_quant_type = 'fp4', bnb_4bit_use_double_quant = False, bnb_4bit_quant_storage = None, **kwargs)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L171)
**Параметры:**
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`.

Это заменяет `load_in_8bit` или `load_in_4bit`, поэтому оба варианта взаимоисключающи.

В настоящее время поддерживаются только квантование `LLM.int8()`, `FP4` и `NF4`. Если в `bitsandbytes` будут добавлены новые методы, то в этот класс будут добавлены соответствующие аргументы.

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

```python
is_quantizable()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L343)

Возвращает `True`, если модель можно квантовать, иначе `False`.

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

```python
post_init()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L313)

Проверка безопасности, что аргументы корректны — также заменяет некоторые аргументы типа NoneType их значениями по умолчанию.

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

```python
quantization_method()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L349)

Этот метод возвращает метод квантования, использованный для модели. Если модель не поддерживает квантование, возвращается `None`.

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

```python
to_diff_dict()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L380)

**Возвращает:** `dict[str, Any]`

Словарь всех атрибутов, из которых состоит этот экземпляр конфигурации,

Удаляет все атрибуты из config, соответствующие атрибутам конфигурации по умолчанию, для лучшей читаемости и сериализует в словарь Python.

## GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L404)

**Параметры:**

compute_dtype : (`torch.dtype`, по умолчанию `torch.float32`): задает вычислительный тип, который может отличаться от типа входных данных. Например, входные данные могут быть fp32, но для ускорения вычислений можно установить bf16.
Это класс конфигурации для методов квантования GGUF.
## NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]
#### diffusers.NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]
```python
diffusers.NunchakuLiteQuantizationConfig(compute_dtype: 'torch.dtype' | str | None = None, svdq_w4a4: dict[str, Any] | None = None, awq_w4a16: dict[str, Any] | None = None, **kwargs)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L451)
**Параметры:**

compute_dtype (`torch.dtype`, по умолчанию `torch.bfloat16`) : dtype, используемый во время выполнения для буферов с плавающей точкой в квантованных модулях.
svdq_w4a4 (`dict`, *необязательный*) : Явная целевая конфигурация SVDQ W4A4 с параметрами `precision`, `group_size`, `rank` и `targets`.

awq_w4a16 (`dict`, *необязательный*) : Явная целевая конфигурация AWQ W4A16 с параметрами `precision`, `group_size` и `targets`.

Конфигурация для загрузки контрольных точек Nunchaku Lite.

Поддержка Nunchaku Lite в Diffusers позволяет загружать предварительно квантованные контрольные точки. Чтобы создать совместимую контрольную точку, используйте [`diffuse-compressor`](https://github.com/rootonchair/diffuse-compressor), чтобы выбрать или адаптировать целевую конфигурацию для архитектуры модели, выполнить квантование и экспорт трансформера, а затем упаковать его в пайплайн Diffusers с компактным `quantization_config`, сохранённым в `config.json`.

Экспортированный state dict должен точно соответствовать архитектуре целевой модели Diffusers. Чекпоинты, квантованные с использованием объединённых QKV-проекций, не будут загружены в конфигурацию модели, ожидающую отдельные модули проекций Q, K и V.

Пример компактной конфигурации `config.json`:

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

## QuantoConfig[[diffusers.QuantoConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L669)

**Параметры:**

weights_dtype (`str`, *необязательный*, по умолчанию `"int8"`) : целевой тип данных для весов после квантования. Поддерживаемые значения: ("float8","int8","int4","int2")
Это обёртка, содержащая все возможные атрибуты и возможности, с которыми можно работать с моделью, загруженной с помощью `quanto`.
`QuantoConfig` устарела и будет удалена в версии 1.0.0. Рекомендуется перейти на один из других поддерживаемых бэкендов квантования, например [BitsAndBytesConfig](/docs/diffusers/main/ru/api/quantization#diffusers.BitsAndBytesConfig) или [TorchAoConfig](/docs/diffusers/main/ru/api/quantization#diffusers.TorchAoConfig).
modules_to_not_convert (`list`, *необязательный*, по умолчанию `None`): список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют, чтобы некоторые модули оставались в исходной точности (например, энкодер Whisper, энкодер Llava, слои gate в Mixtral).

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

```python
post_init()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L703)

Проверка безопасности: аргументы корректны

## SDNQConfig[[diffusers.SDNQConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L981)

**Параметры:**

weights_dtype (`str`, *необязательный*, по умолчанию `"int8"`) : целевой тип данных для весов после квантования, например `"int8"`, `"uint4"`, `"float8_e4m3fn"`. См. `sdnq.common.accepted_weight_dtypes` для всех поддерживаемых значений.

group_size (`int`, *optional*, по умолчанию `0`) : Сколько элементов тензора входят в одну группу квантования. Значение `0` автоматически выбирает размер группы на основе `weights_dtype`, а `-1` отключает группировку и использует построчное квантование.

use_svd (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли применять алгоритм SVDQuant поверх квантования SDNQ.
use_quantized_matmul (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли квантованное INT8 / FP8 / FP16 матричное умножение на прямом проходе вместо BF16 / FP16.
modules_to_not_convert (`list`, *необязательный*, по умолчанию `None`) : Список модулей, которые нужно пропустить при квантовании.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в `sdnq.SDNQConfig` (например, `quantized_matmul_dtype`, `svd_rank`, `use_hadamard`, `quant_conv`, `quant_embedding`, `modules_dtype_dict`).

Класс конфигурации для SDNQ (SD.Next Quantization).

Библиотека `sdnq` предоставляет собственный конфиг и квантизатор, совместимые с diffusers; данный класс представляет собой тонкую фабрику, которая делегирует работу этим компонентам, чтобы чекпоинты с `quant_method="sdnq"` загружались нативно в diffusers. Все аргументы передаются в `sdnq.SDNQConfig`. Требуется библиотека `sdnq`: `pip install sdnq`.

Ссылка: https://github.com/Disty0/sdnq

## TorchAoConfig[[diffusers.TorchAoConfig]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L572)

**Параметры:**

quant_type (`AOBaseConfig`) : экземпляр подкласса `AOBaseConfig`, определяющий тип квантования. См. [документацию torchao](https://docs.pytorch.org/ao/main/api_ref_quantization.html#inference-apis-for-quantize) для доступных классов конфигурации (например, `Int4WeightOnlyConfig`, `Int8WeightOnlyConfig`, `Float8WeightOnlyConfig`, `Float8DynamicActivationFloat8WeightConfig` и т. д.).
modules_to_not_convert (`list[str]`, *необязательный*, по умолчанию `None`) : Список модулей, которые не следует квантовать. Полезно для квантования моделей, которые явно требуют, чтобы некоторые модули оставались в исходной точности.

Это класс конфигурации для методов квантования и разреженности torchao.

Пример:
```python
from diffusers import FluxTransformer2DModel, TorchAoConfig
from torchao.quantization import Int8WeightOnlyConfig
quantization_config = TorchAoConfig(Int8WeightOnlyConfig())
transformer = FluxTransformer2DModel.from_pretrained(
    "black-forest-labs/Flux.1-Dev",
    subfolder="transformer",
    quantization_config=quantization_config,
    torch_dtype=torch.bfloat16,
)
```

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L637)

Создание конфигурации из словаря.

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

```python
get_apply_tensor_subclass()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L659)

Создайте соответствующий метод квантования на основе конфигурации.

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

```python
to_dict()
```

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L623)

Преобразование конфигурации в словарь.

## DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L34)

Абстрактный класс квантизатора HuggingFace. На данный момент поддерживает квантизацию моделей HF diffusers для вывода и/или квантизации. Этот класс используется только в diffusers.models.modeling_utils.ModelMixin.from_pretrained и пока не может быть легко использован вне контекста этого метода.

Attributes quantization_config (`diffusers.quantizers.quantization_config.QuantizationConfigMixin`): Конфигурация квантования, определяющая параметры квантования модели, которую вы хотите квантовать. modules_to_not_convert (`list[str]`, *необязательно*): Список имён модулей, которые не следует конвертировать при квантовании модели. required_packages (`list[str]`, *необязательно*): Список необходимых pip-пакетов, которые нужно установить перед использованием квантизатора. requires_calibration (`bool`): Требует ли метод квантования калибровки модели перед её использованием.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L133)

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

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L91)

**Параметры:**

torch_dtype (`torch.dtype`, *необязательный*) : torch_dtype, используемый для вычисления device_map.
Переопределите этот метод, если вы хотите изменить переменную `target_dtype`, используемую в `from_pretrained` для вычисления device_map, в случае, если device_map является `str`. Например, для bitsandbytes мы принудительно устанавливаем `target_dtype` в `torch.int8`, а для 4-битного режима передаем пользовательский enum `accelerate.CustomDtype.int4`.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L137)

проверяет, является ли загруженный компонент state_dict частью квантованного параметра + выполняет некоторую валидацию; определено только для методов квантования, требующих создания новых параметров для квантования.
#### check_quantized_param_shape[[diffusers.DiffusersQuantizer.check_quantized_param_shape]]
```python
check_quantized_param_shape(*args, **kwargs)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L157)
проверяет, имеет ли квантованный параметр ожидаемую форму.
#### create_quantized_param[[diffusers.DiffusersQuantizer.create_quantized_param]]
```python
create_quantized_param(*args, **kwargs)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L151)
забирает необходимые компоненты из state_dict и создаёт квантованный параметр.
#### dequantize[[diffusers.DiffusersQuantizer.dequantize]]
```python
dequantize(model)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L219)
Возможно, деквантовать модель, чтобы получить исходную модель, с некоторой потерей точности / производительности. Обратите внимание, что не все схемы квантования поддерживают эту операцию.
#### get_cuda_warm_up_factor[[diffusers.DiffusersQuantizer.get_cuda_warm_up_factor]]
```python
get_cuda_warm_up_factor()
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L232)
Коэффициент, используемый в `caching_allocator_warmup` для определения количества байт, которые следует зарезервировать заранее для прогрева cuda. Коэффициент 2 означает, что мы выделяем все байты пустой модели (поскольку выделение происходит в fp16), коэффициент 4 означает, что мы выделяем половину памяти, занимаемой весами в пустой модели, и т. д.
#### get_special_dtypes_update[[diffusers.DiffusersQuantizer.get_special_dtypes_update]]
```python
get_special_dtypes_update(model, torch_dtype: torch.dtype)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L113)
**Параметры:**
model (`~diffusers.models.modeling_utils.ModelMixin`) : модель для квантования
torch_dtype (`torch.dtype`) : dtype, переданный в метод `from_pretrained`.
возвращает dtypes для модулей, которые не квантованы — используется для вычисления device_map в случае, если в качестве device_map передаётся str. Метод использует `modules_to_not_convert`, которое изменяется в `_process_model_before_weight_loading`. У моделей `diffusers` пока нет атрибутов `modules_to_not_convert`, но это может измениться в будущем.
#### postprocess_model[[diffusers.DiffusersQuantizer.postprocess_model]]
```python
postprocess_model(model: ModelMixin, **kwargs)
```
[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L206)
**Параметры:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : модель для квантования

kwargs (`dict`, *необязательный*) : Ключевые аргументы, которые передаются вместе с `_process_model_after_weight_loading`.

Выполните постобработку модели после загрузки весов. Убедитесь, что вы переопределяете абстрактный метод `_process_model_after_weight_loading`.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L190)

**Параметры:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : модель для квантования

kwargs (`dict`, *необязательный*) : Ключевые аргументы, которые передаются вместе с `_process_model_before_weight_loading`.

Установка атрибутов модели и/или преобразование модели до загрузки весов. На этом этапе модель должна быть инициализирована на meta-устройстве, поэтому вы можете свободно манипулировать каркасом модели, чтобы заменить модули на месте. Убедитесь, что вы переопределяете абстрактный метод `_process_model_before_weight_loading`.

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L79)

**Параметры:**

device_map (`dict | str`, *необязательный*) : device_map, передаваемый через метод `from_pretrained`.

Переопределите этот метод, если вы хотите передать новое устройство map, чтобы переопределить существующее. Например, для bitsandbytes, поскольку `accelerate` является обязательным требованием, если device_map не передан, device_map устанавливается в `"auto"``

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L103)

**Параметры:**

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

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L68)

**Параметры:**

torch_dtype (`torch.dtype`) : входной dtype, передаваемый в `from_pretrained`

Некоторые методы квантования требуют явного задания dtype модели целевым dtype. Вам нужно переопределить этот метод, если вы хотите убедиться, что это поведение сохраняется

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

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

[Источник](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L163)

Этот метод используется для потенциальной проверки конфликтов с аргументами, передаваемыми в `from_pretrained`. Его необходимо определить для всех будущих квантизаторов, интегрированных с diffusers. Если явная проверка не требуется, просто верните ничего.
Xet Storage Details

Size:: 36.2 kB
Xet hash:: dead3b6a7ddcb93487ad558a918950716ed4e6ca03754c2ccc7c70638afba218
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.