# Lượng tử hóa

Các kỹ thuật lượng tử hóa giảm chi phí bộ nhớ và tính toán bằng cách biểu diễn trọng số và kích hoạt bằng các kiểu dữ liệu độ chính xác thấp hơn như số nguyên 8-bit (int8). Điều này cho phép nạp các mô hình lớn hơn mà bình thường bạn không thể đặt vừa vào bộ nhớ, đồng thời tăng tốc suy luận.

> [!TIP]
> Tìm hiểu cách lượng tử hóa các mô hình trong hướng dẫn [Quantization](../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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/pipe_quant_config.py#L34)

**Tham số:**

quant_backend (`str`) : Backend lượng tử hóa sẽ được sử dụng. Khi sử dụng tùy chọn này, chúng ta giả định rằng backend khả dụng cho cả `diffusers` và `transformers`.

quant_kwargs (`dict`) : Tham số để khởi tạo lớp backend lượng tử hóa.

components_to_quantize (`list`) : Các thành phần của pipeline cần được lượng tử hóa.

quant_mapping (`dict`) : Ánh xạ định nghĩa các thông số lượng tử hóa sẽ được sử dụng cho các thành phần của pipeline. Khi sử dụng đối số này, người dùng không cần cung cấp `quant_backend`, `quant_kawargs` và `components_to_quantize`.

Lớp cấu hình được sử dụng khi áp dụng lượng tử hóa theo thời gian thực vào [from_pretrained()](/docs/diffusers/v0.43.0/vi/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

## BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

#### diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L427)

**Tham số:**

compute_dtype (`torch.dtype`, mặc định là `torch.bfloat16`) : Kiểu dữ liệu của các activation và các lớp chưa được lượng tử hóa. Các thiết bị không có các kernel FP8 hoặc NVFP4 đã tích hợp sẽ khử lượng tử hóa các trọng số sang kiểu dữ liệu này trong mỗi bước truyền thẳng.

Cấu hình để nạp các checkpoint đã lượng tử hóa bằng các phương án `fp8r` và `nvfp4` của Black Forest Labs.

Cả hai phương án đều được đọc từ checkpoint thông qua `~FromSingleFileMixin.from_single_file`; việc lượng tử hóa mô hình trực tiếp không được hỗ trợ. Một lớp tuyến tính sẽ được lượng tử hóa khi trọng số của nó đi kèm với các tensor tỷ lệ:

- `fp8r`: `weight` là `float8_e4m3fn` với hình dạng `[N, K]` và `weight_scale` là thang đo fp32 cho từng hàng `[N]`.
- `nvfp4`: `weight` là `uint8` với shape `[N, K/2]` (hai giá trị E2M1 trên mỗi byte), `weight_scale` là block scale `float8_e4m3fn` `[N, K/16]`, và `weight_scale_2` cùng `input_scale` là các scalar fp32 chứa global weight scale và activation scale đã hiệu chuẩn (bố cục NVFP4 của ModelOpt).

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L171)

**Tham số:**

load_in_8bit (`bool`, *tùy chọn*, mặc định là `False`) : Cờ này được sử dụng để bật lượng tử hóa 8-bit với LLM.int8().

load_in_4bit (`bool`, *tùy chọn*, mặc định là `False`) : Cờ này được dùng để bật lượng tử hóa 4-bit bằng cách thay thế các lớp Linear bằng các lớp FP4/NF4 từ `bitsandbytes`.

llm_int8_threshold (`float`, *optional*, mặc định là 6.0) : Tham số này tương ứng với ngưỡng ngoại lệ cho việc phát hiện ngoại lệ như được mô tả trong bài báo `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale`: https://huggingface.co/papers/2208.07339 Bất kỳ giá trị trạng thái ẩn nào vượt quá ngưỡng này sẽ được coi là ngoại lệ và các phép toán trên những giá trị đó sẽ được thực hiện ở fp16. Các giá trị thường có phân phối chuẩn, nghĩa là phần lớn các giá trị nằm trong khoảng [-3,5, 3,5], nhưng có một số ngoại lệ hệ thống đặc biệt có phân phối rất khác nhau ở các mô hình lớn. Những ngoại lệ này thường nằm trong khoảng [-60, -6] hoặc [6, 60]. Lượng tử hóa Int8 hoạt động tốt với các giá trị có độ lớn ~5, nhưng vượt quá mức đó sẽ gây ra sự suy giảm hiệu suất đáng kể. Ngưỡng mặc định tốt là 6, nhưng có thể cần ngưỡng thấp hơn cho các mô hình kém ổn định hơn (mô hình nhỏ, fine-tuning).

llm_int8_skip_modules (`list[str]`, *tùy chọn*) : Một danh sách rõ ràng các module mà chúng ta không muốn chuyển đổi sang 8-bit. Điều này hữu ích cho các mô hình như Jukebox, vốn có nhiều đầu ở các vị trí khác nhau và không nhất thiết ở vị trí cuối cùng. Ví dụ, đối với các mô hình `CausalLM`, `lm_head` cuối cùng thường được giữ nguyên `dtype` ban đầu.

llm_int8_enable_fp32_cpu_offload (`bool`, *tuỳ chọn*, mặc định là `False`) : Cờ này được sử dụng cho các trường hợp nâng cao và người dùng đã nắm rõ tính năng này. Nếu bạn muốn chia mô hình thành các phần khác nhau và chạy một số phần ở int8 trên GPU và một số phần ở fp32 trên CPU, bạn có thể sử dụng cờ này. Điều này hữu ích để offload các mô hình lớn như `google/flan-t5-xxl`. Lưu ý rằng các thao tác int8 sẽ không được chạy trên CPU.

llm_int8_has_fp16_weight (`bool`, *tùy chọn*, mặc định là `False`) : Cờ này chạy LLM.int8() với trọng số chính 16-bit. Điều này hữu ích cho fine-tuning vì trọng số không cần phải được chuyển đổi qua lại cho bước truyền ngược.

bnb_4bit_compute_dtype (`torch.dtype` hoặc str, *tùy chọn*, mặc định là `torch.float32`) : Thiết lập kiểu tính toán, có thể khác với kiểu đầu vào. Ví dụ, đầu vào có thể là fp32, nhưng phép tính có thể được đặt thành bf16 để tăng tốc.

bnb_4bit_quant_type (`str`,  *tùy chọn*, mặc định là `"fp4"`) : Thiết lập kiểu dữ liệu lượng tử hóa trong các lớp bnb.nn.Linear4Bit. Các tùy chọn là kiểu dữ liệu FP4 và NF4, được chỉ định bằng `fp4` hoặc `nf4`.

bnb_4bit_use_double_quant (`bool`, *tùy chọn*, mặc định là `False`) : Cờ này được sử dụng cho lượng tử hóa lồng nhau, trong đó các hằng số lượng tử hóa từ lần lượng tử hóa đầu tiên được lượng tử hóa lại.

bnb_4bit_quant_storage (`torch.dtype` hoặc str, *tùy chọn*, mặc định là `torch.uint8`) : Thiết lập kiểu lưu trữ để đóng gói các tham số lượng tử hóa 4-bit.

kwargs (`dict[str, Any]`, *tùy chọn*) : Các tham số bổ sung để khởi tạo đối tượng cấu hình.

Đây là một lớp bao (wrapper class) cho tất cả các thuộc tính và tính năng có thể thao tác với một mô hình đã được tải bằng `bitsandbytes`.

Điều này thay thế `load_in_8bit` hoặc `load_in_4bit` do đó cả hai tùy chọn đều loại trừ lẫn nhau.

Hiện tại chỉ hỗ trợ lượng tử hóa `LLM.int8()`, `FP4` và `NF4`. Nếu có thêm các phương pháp được thêm vào `bitsandbytes`, thì sẽ có thêm các đối số cho lớp này.

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

```python
is_quantizable()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L343)

Trả về `True` nếu mô hình có thể lượng tử hóa, ngược lại trả về `False`.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L313)

Trình kiểm tra an toàn để đảm bảo các đối số là chính xác - đồng thời thay thế một số đối số NoneType bằng giá trị mặc định của chúng.

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

```python
quantization_method()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L349)

Phương thức này trả về phương pháp lượng tử hóa được sử dụng cho mô hình. Nếu mô hình không thể lượng tử hóa, nó sẽ trả về `None`.

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

```python
to_diff_dict()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L380)

**Trả về:** `dict[str, Any]`

Từ điển chứa tất cả các thuộc tính cấu thành lên bản thể cấu hình này,

Xóa tất cả các thuộc tính khỏi config tương ứng với các thuộc tính mặc định của config để tăng tính dễ đọc và xuất ra thành một từ điển Python.

## GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L404)

**Tham số:**

compute_dtype : (`torch.dtype`, mặc định là `torch.float32`): Thiết lập kiểu tính toán, có thể khác với kiểu đầu vào. Ví dụ, đầu vào có thể là fp32, nhưng phép tính có thể được đặt thành bf16 để tăng tốc.

Đây là một lớp cấu hình cho các kỹ thuật Lượng tử hóa 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L451)

**Tham số:**

compute_dtype (`torch.dtype`, mặc định là `torch.bfloat16`) : dtype thời gian chạy được sử dụng bởi các bộ đệm số dấu phẩy động trong các module lượng tử hóa.

svdq_w4a4 (`dict`, *tùy chọn*) : Cấu hình mục tiêu SVDQ W4A4 rõ ràng với `precision`, `group_size`, `rank` và `targets`.

awq_w4a16 (`dict`, *tùy chọn*) : Cấu hình đích AWQ W4A16 rõ ràng với `precision`, `group_size` và `targets`.

Cấu hình để nạp các checkpoint của Nunchaku Lite.

Hỗ trợ Nunchaku Lite trong Diffusers tải các checkpoint đã lượng tử hóa trước. Để tạo một checkpoint tương thích, hãy sử dụng [`diffuse-compressor`](https://github.com/rootonchair/diffuse-compressor) để chọn hoặc điều chỉnh cấu hình đích cho kiến trúc mô hình, lượng tử hóa và xuất transformer, sau đó đóng gói nó thành một pipeline Diffusers với `quantization_config` gọn nhẹ được lưu trong `config.json`.

State dict được xuất ra phải khớp chính xác với kiến trúc của mô hình Diffusers đích. Các checkpoint đã được lượng tử hóa với các phép chiếu QKV hợp nhất sẽ không thể nạp vào cấu hình mô hình kỳ vọng các module chiếu Q, K và V riêng biệt.

Ví dụ cấu hình `config.json` dạng nén:

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L669)

**Tham số:**

weights_dtype (`str`, *tùy chọn*, mặc định là `"int8"`) : Kiểu dữ liệu đích cho trọng số sau khi lượng tử hóa. Các giá trị được hỗ trợ là ("float8","int8","int4","int2")

Đây là một lớp bao (wrapper class) cho tất cả các thuộc tính và tính năng có thể thao tác với một mô hình đã được tải bằng `quanto`.

`QuantoConfig` đã bị ngừng hỗ trợ và sẽ bị loại bỏ trong phiên bản 1.0.0. Hãy cân nhắc chuyển sang một trong các backend lượng tử hóa được hỗ trợ khác, chẳng hạn như [BitsAndBytesConfig](/docs/diffusers/v0.43.0/vi/api/quantization#diffusers.BitsAndBytesConfig) hoặc [TorchAoConfig](/docs/diffusers/v0.43.0/vi/api/quantization#diffusers.TorchAoConfig).

modules_to_not_convert (`list`, *tùy chọn*, mặc định là `None`): Danh sách các module không cần lượng tử hóa, hữu ích khi lượng tử hóa các mô hình yêu cầu một số module phải giữ nguyên độ chính xác gốc (ví dụ: encoder của Whisper, encoder của Llava, các lớp gate của Mixtral).

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L703)

Trình kiểm tra an toàn đảm bảo các đối số là chính xác

## SDNQConfig[[diffusers.SDNQConfig]]

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L981)

**Tham số:**

weights_dtype (`str`, *tùy chọn*, mặc định là `"int8"`) : Kiểu dữ liệu đích cho trọng số sau khi lượng tử hóa, ví dụ `"int8"`, `"uint4"`, `"float8_e4m3fn"`. Xem `sdnq.common.accepted_weight_dtypes` để biết tất cả các giá trị được hỗ trợ.

group_size (`int`, *tuỳ chọn*, mặc định là `0`) : Số lượng phần tử của một tensor chia sẻ cùng một nhóm lượng tử hóa. `0` tự động chọn dựa trên `weights_dtype`, `-1` tắt nhóm hóa và sử dụng lượng tử hóa theo hàng.

use_svd (`bool`, *tùy chọn*, mặc định là `False`) : Có áp dụng thuật toán SVDQuant trên nền lượng tử hóa SDNQ hay không.

use_quantized_matmul (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng matmul lượng tử hóa INT8 / FP8 / FP16 trong bước truyền tiến (forward pass) thay vì BF16 / FP16 hay không.

modules_to_not_convert (`list`, *tùy chọn*, mặc định là `None`) : Danh sách các module cần bỏ qua trong quá trình lượng tử hóa.

kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung được chuyển tiếp đến `sdnq.SDNQConfig` (ví dụ: `quantized_matmul_dtype`, `svd_rank`, `use_hadamard`, `quant_conv`, `quant_embedding`, `modules_dtype_dict`).

Lớp cấu hình cho SDNQ (SD.Next Quantization).

Thư viện `sdnq` đi kèm với cấu hình và bộ lượng tử hóa tương thích với diffusers; lớp này là một nhà máy mỏng, chuyển việc xử lý sang cho chúng để các checkpoint có `quant_method="sdnq"` được nạp một cách bản địa với diffusers. Tất cả các đối số đều được chuyển tiếp đến `sdnq.SDNQConfig`. Yêu cầu thư viện `sdnq`: `pip install sdnq`.

Tham khảo: 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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L572)

**Tham số:**

quant_type (`AOBaseConfig`) : Một instance của subclass `AOBaseConfig` chỉ định loại lượng tử hóa. Xem [tài liệu torchao](https://docs.pytorch.org/ao/main/api_ref_quantization.html#inference-apis-for-quantize) để biết các lớp cấu hình khả dụng (ví dụ: `Int4WeightOnlyConfig`, `Int8WeightOnlyConfig`, `Float8WeightOnlyConfig`, `Float8DynamicActivationFloat8WeightConfig`, v.v.).

modules_to_not_convert (`list[str]`, *tùy chọn*, mặc định là `None`) : Danh sách các module không cần lượng tử hóa, hữu ích khi lượng tử hóa các mô hình yêu cầu một số module phải giữ nguyên độ chính xác ban đầu.

Đây là một lớp cấu hình cho các kỹ thuật lượng tử hóa/sparse của torchao.

Ví dụ:
```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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L637)

Tạo cấu hình từ một từ điển.

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

```python
get_apply_tensor_subclass()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L659)

Tạo phương pháp lượng tử hóa phù hợp dựa trên cấu hình.

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

```python
to_dict()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/quantization_config.py#L623)

Chuyển đổi cấu hình thành từ điển.

## DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L34)

Lớp trừu tượng của bộ lượng tử hóa HuggingFace. Hiện tại hỗ trợ lượng tử hóa các mô hình diffusers của HF để suy luận và/hoặc lượng tử hóa. Lớp này chỉ được sử dụng cho diffusers.models.modeling_utils.ModelMixin.from_pretrained và chưa thể dễ dàng sử dụng bên ngoài phạm vi của phương thức đó.

Attributes quantization_config (`diffusers.quantizers.quantization_config.QuantizationConfigMixin`): Cấu hình lượng tử hóa xác định các tham số lượng tử hóa của mô hình mà bạn muốn lượng tử hóa. modules_to_not_convert (`list[str]`, *không bắt buộc*): Danh sách tên module không chuyển đổi khi lượng tử hóa mô hình. required_packages (`list[str]`, *không bắt buộc*): Danh sách các gói pip bắt buộc phải cài đặt trước khi sử dụng bộ lượng tử hóa requires_calibration (`bool`): Phương pháp lượng tử hóa có yêu cầu hiệu chuẩn mô hình trước khi sử dụng hay không.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L133)

điều chỉnh đối số max_memory của infer_auto_device_map() nếu cần thêm bộ nhớ cho lượng tử hóa

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L91)

**Tham số:**

torch_dtype (`torch.dtype`, *tùy chọn*) : torch_dtype được sử dụng để tính toán device_map.

Ghi đè phương thức này nếu bạn muốn điều chỉnh biến `target_dtype` được sử dụng trong `from_pretrained` để tính toán device_map trong trường hợp device_map là một `str`. Ví dụ, với bitsandbytes chúng tôi ép đặt `target_dtype` thành `torch.int8` và với 4-bit chúng tôi truyền một enum tùy chỉnh `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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L137)

kiểm tra xem một thành phần state_dict đã được nạp có phải là một phần của tham số đã lượng tử hóa + một số kiểm tra hợp lệ; chỉ được định nghĩa cho các phương pháp lượng tử hóa yêu cầu tạo ra các tham số mới cho quá trình lượng tử hóa.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L157)

kiểm tra xem tham số đã lượng tử hóa có hình dạng mong đợi hay không.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L151)

lấy các thành phần cần thiết từ state_dict và tạo tham số đã lượng tử hóa.

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

```python
dequantize(model)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L219)

Có thể khử lượng tử hóa mô hình để lấy lại mô hình gốc, với một số suy giảm về độ chính xác / hiệu suất. Lưu ý rằng không phải tất cả các phương án lượng tử hóa đều hỗ trợ điều này.

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

```python
get_cuda_warm_up_factor()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L232)

Hệ số được sử dụng trong `caching_allocator_warmup` để tính số byte cần phân bổ trước nhằm khởi động cuda. Hệ số 2 có nghĩa là chúng ta phân bổ toàn bộ số byte trong mô hình rỗng (vì chúng ta phân bổ ở fp16), hệ số 4 có nghĩa là chúng ta phân bổ một nửa bộ nhớ của các trọng số nằm trong mô hình rỗng, v.v...

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

```python
get_special_dtypes_update(model, torch_dtype: torch.dtype)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L113)

**Tham số:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Mô hình cần lượng tử hóa

torch_dtype (`torch.dtype`) : dtype được truyền vào phương thức `from_pretrained`.

trả về dtypes cho các module không được lượng tử hóa - được sử dụng để tính toán device_map trong trường hợp truyền một str làm device_map. Phương thức sẽ sử dụng `modules_to_not_convert` được sửa đổi trong `_process_model_before_weight_loading`. Các model `diffusers` hiện chưa có thuộc tính `modules_to_not_convert` nhưng điều này có thể thay đổi trong tương lai.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L206)

**Tham số:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Mô hình cần lượng tử hóa

kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa được truyền cùng với `_process_model_after_weight_loading`.

Xử lý hậu xử lý mô hình sau khi nạp trọng số. Đảm bảo ghi đè phương thức trừu tượng `_process_model_after_weight_loading`.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L190)

**Tham số:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Mô hình cần lượng tử hóa

kwargs (`dict`, *tùy chọn*) : Các đối số từ khóa được truyền cùng với `_process_model_before_weight_loading`.

Đặt thuộc tính mô hình và/hoặc chuyển đổi mô hình trước khi nạp trọng số. Ở bước này, mô hình nên được khởi tạo trên thiết bị meta để bạn có thể tự do thao tác trên khung xương của mô hình nhằm thay thế các module tại chỗ. Hãy đảm bảo ghi đè phương thức trừu tượng `_process_model_before_weight_loading`.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L79)

**Tham số:**

device_map (`dict | str`, *tùy chọn*) : device_map được truyền qua phương thức `from_pretrained`.

Ghi đè phương thức này nếu bạn muốn ghi đè bản đồ thiết bị hiện có bằng một bản đồ mới. Ví dụ, đối với bitsandbytes, vì `accelerate` là một yêu cầu bắt buộc, nếu không truyền device_map, thì device_map sẽ được đặt thành `"auto"``

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L103)

**Tham số:**

missing_keys (`list[str]`, *tùy chọn*) : Danh sách các khóa bị thiếu trong checkpoint so với state dict của mô hình

Ghi đè phương thức này nếu bạn muốn điều chỉnh `missing_keys`.

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L68)

**Tham số:**

torch_dtype (`torch.dtype`) : Kiểu dữ liệu đầu vào được truyền vào `from_pretrained`

Một số phương pháp lượng tử hóa yêu cầu đặt rõ dtype của mô hình thành dtype đích. Bạn cần ghi đè phương thức này nếu muốn đảm bảo hành vi đó được giữ nguyên

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

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

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/quantizers/base.py#L163)

Phương thức này được sử dụng để kiểm tra các xung đột tiềm ẩn với các đối số được truyền vào `from_pretrained`. Bạn cần định nghĩa nó cho tất cả các bộ lượng tử hóa trong tương lai được tích hợp với diffusers. Nếu không cần kiểm tra rõ ràng, chỉ cần trả về không.