# 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. Transformers hỗ trợ các thuật toán lượng tử hóa AWQ và GPTQ, và hỗ trợ lượng tử hóa 8-bit và 4-bit với bitsandbytes.

Các kỹ thuật lượng tử hóa không được hỗ trợ trong Transformers có thể được thêm vào bằng lớp `HfQuantizer`.

Tìm hiểu cách lượng tử hóa các mô hình trong hướng dẫn [Quantization](../quantization/overview).

## QuantoConfig[[transformers.QuantoConfig]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1021)

**Tham số:**

weights (`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")

activations (`str`, *tùy chọn*) : Kiểu dữ liệu đích cho các kích hoạt sau khi lượng tử hóa. Các giá trị được hỗ trợ là (None,"int8","float8")

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

Đâ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`.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1049)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L865)

**Tham số:**

in_group_size (`int`, *tuỳ chọn*, mặc định là 8) : Kích thước nhóm dọc theo chiều đầu vào.

out_group_size (`int`, *optional*, mặc định là 1) : Kích thước nhóm dọc theo chiều đầu ra. Khuyến nghị luôn sử dụng 1.

num_codebooks (`int`, *optional*, mặc định là 1) : Số lượng codebook cho quy trình Additive Quantization.

nbits_per_codebook (`int`, *optional*, mặc định là 16) : Số bit mã hóa một vector codebook đơn lẻ. Kích thước codebook là 2**nbits_per_codebook.

linear_weights_not_to_quantize (`Optional[list[str]]`, *tùy chọn*) : Danh sách các đường dẫn đầy đủ của các tham số trọng số `nn.Linear` không được lượng tử hóa.

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 quanh các tham số của `aqlm`.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L902)

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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L980)

**Tham số:**

enable_proxy_error (`bool`, *tùy chọn*, mặc định là `False`) : tính toán lỗi proxy cho từng lớp

config_for_layers (`Dict`, *tùy chọn*, mặc định là `{}`) : tham số lượng tử hóa cho từng lớp

shared_layer_config (`Dict`, *tùy chọn*, mặc định là `{}`) : các tham số lượng tử hóa dùng chung giữa các lớp

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

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 quanh các tham số `vptq`.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1010)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L799)

**Tham số:**

bits (`int`, *tuỳ chọn*, mặc định là 4) : Số bit để lượng tử hóa.

group_size (`int`, *tuỳ chọn*, mặc định là 128) : Kích thước nhóm để sử dụng cho lượng tử hóa. Giá trị được khuyến nghị là 128 và -1 sử dụng lượng tử hóa theo cột.

zero_point (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng lượng tử hóa điểm không hay không.

backend (`AwqBackend`, *tùy chọn*, mặc định là `AwqBackend.AUTO`) : Backend lượng tử hóa.

modules_to_not_convert (`list`, *optional*, 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). Lưu ý rằng bạn không thể lượng tử hóa trực tiếp bằng transformers, vui lòng tham khảo tài liệu của `AutoAWQ` để lượng tử hóa các mô hình HF.

Đây là một lớp wrapper bao gồm tất cả các thuộc tính và tính năng có thể thao tác với một model đã được nạp bằng lượng tử hóa awq của thư viện `auto-awq`, dựa trên backend auto_awq.

## EetqConfig[[transformers.EetqConfig]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1062)

**Tham số:**

weights (`str`, *tùy chọn*, mặc định là `"int8"`) : Kiểu dữ liệu đích cho các trọng số. Giá trị được hỗ trợ duy nhất là "int8"

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 ban đầu.

Đâ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 `eetq`.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1086)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L617)

**Tham số:**

bits (`int`) : Số bit để lượng tử hóa, các giá trị được hỗ trợ là (2, 3, 4, 8).

tokenizer (`str` hoặc `PreTrainedTokenizerBase`, *không bắt buộc*) : Tokenizer được sử dụng để xử lý bộ dữ liệu. Bạn có thể truyền: - Một đối tượng tokenizer tùy chỉnh. - Một chuỗi, *model id* của một tokenizer có sẵn được lưu trữ trong kho model trên huggingface.co. - Đường dẫn đến một *thư mục* chứa các tệp từ vựng cần thiết cho tokenizer, chẳng hạn như đã được lưu bằng phương thức [save_pretrained()](/docs/transformers/main/vi/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), ví dụ: `./my_model_directory/`.

dataset (`Union[list[str]]`, *tùy chọn*) : Bộ dữ liệu được sử dụng để lượng tử hóa. Bạn có thể cung cấp bộ dữ liệu của riêng mình dưới dạng danh sách các chuỗi hoặc chỉ cần sử dụng các bộ dữ liệu gốc được dùng trong bài báo GPTQ ['wikitext2','c4','c4-new']

group_size (`int`, *tuỳ chọn*, mặc định là 128) : Kích thước nhóm để sử dụng cho lượng tử hóa. Giá trị được khuyến nghị là 128 và -1 sử dụng lượng tử hóa theo cột.

damp_percent (`float`, *optional*, mặc định là 0.1) : Phần trăm của đường chéo Hessian trung bình được sử dụng để giảm chấn. Giá trị được khuyến nghị là 0.1.

desc_act (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có lượng tử hóa các cột theo thứ tự kích thước kích hoạt giảm dần hay không. Đặt giá trị này thành False có thể tăng tốc độ suy luận đáng kể, nhưng độ perplexity có thể trở nên kém đi một chút. Còn được gọi là act-order.

act_group_aware (`bool`, *tùy chọn*, mặc định là `True`) : Sử dụng GAR (thứ tự kích hoạt nhận thức nhóm) trong quá trình lượng tử hóa. Có tác động tích cực đáng đo được đến chất lượng lượng tử hóa. Chỉ áp dụng khi `desc_act = False`. Sẽ bị ép thành `False` khi `desc_act = True`.

sym (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng lượng tử hóa đối xứng hay không.

true_sequential (`bool`, *tùy chọn*, mặc định là `True`) : Có thực hiện lượng tử hóa tuần tự ngay cả trong một khối Transformer duy nhất hay không. Thay vì lượng tử hóa toàn bộ khối một lần, chúng tôi thực hiện lượng tử hóa theo từng lớp. Do đó, mỗi lớp trải qua quá trình lượng tử hóa bằng các đầu vào đã đi qua các lớp được lượng tử hóa trước đó.

format (`str`, *tùy chọn*, mặc định là `"gptq"`) : Định dạng trọng số GPTQ. `gptq` (v1) được hỗ trợ bởi gptqmodel. `gptq_v2` chỉ dành cho gptqmodel.

meta (`dict[str, any]`, *tùy chọn*) : Các thuộc tính không trực tiếp đóng góp vào lượng tử hóa hoặc suy luận lượng tử, chẳng hạn như tooling:version, được lưu trữ trong meta. Ví dụ: `meta.quantizer`: ["optimum:_version_", "gptqmodel:_version_"]

backend (`str`, *tùy chọn*) : Kiểm soát kernel nào sẽ được sử dụng. Các giá trị hợp lệ cho gptqmodel là `auto`, `auto_trainable` và nhiều hơn nữa. Tham khảo backends của gptqmodel: https://github.com/ModelCloud/GPTQModel/blob/main/gptqmodel/utils/backend.py

model_seqlen (`int`, *tuỳ chọn*) : Độ dài tối đa của chuỗi mà mô hình có thể nhận.

block_name_to_quantize (`str`, *tùy chọn*) : Tên khối transformers cần lượng tử hóa. Nếu là None, chúng tôi sẽ suy luận tên khối bằng cách sử dụng các mẫu phổ biến (ví dụ: model.layers)

module_name_preceding_first_block (`list[str]`, *tùy chọn*) : Các lớp nằm trước khối Transformer đầu tiên.

batch_size (`int`, *tuỳ chọn*, mặc định là 1) : Kích thước lô (batch size) được sử dụng khi xử lý bộ dữ liệu

pad_token_id (`int`, *tùy chọn*) : id của token pad. Cần thiết để chuẩn bị bộ dữ liệu khi `batch_size` > 1.

max_input_length (`int`, *optional*) : Độ dài tối đa của đầu vào. Điều này cần thiết để khởi tạo một bộ đệm phụ thuộc vào độ dài đầu vào tối đa được mong đợi. Nó đặc thù cho backend exllama với act-order.

cache_block_outputs (`bool`, *tùy chọn*, mặc định là `True`) : Có nên lưu bộ đệm đầu ra của khối để tái sử dụng làm đầu vào cho khối tiếp theo hay không.

modules_in_block_to_quantize (`list[list[str]]`, *tùy chọn*) : Danh sách các danh sách tên module cần lượng tử hóa trong khối được chỉ định. Tham số này hữu ích để loại trừ một số module tuyến tính khỏi việc lượng tử hóa. Khối cần lượng tử hóa có thể được chỉ định bằng cách đặt `block_name_to_quantize`. Chúng tôi sẽ lượng tử hóa từng danh sách theo thứ tự. Nếu không được đặt, chúng tôi sẽ lượng tử hóa tất cả các lớp tuyến tính. Ví dụ: `modules_in_block_to_quantize =[["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"], ["self_attn.o_proj"]]`. Trong ví dụ này, trước tiên chúng tôi sẽ lượng tử hóa đồng thời các lớp q, k, v vì chúng độc lập với nhau. Sau đó, chúng tôi sẽ lượng tử hóa lớp `self_attn.o_proj` với các lớp q, k, v đã được lượng tử hóa. Bằng cách này, chúng tôi sẽ đạt được kết quả tốt hơn vì nó phản ánh đầu vào thực tế mà `self_attn.o_proj` sẽ nhận được khi mô hình được lượng tử hóa.

Đây là một lớp wrapper bao gồm tất cả các thuộc tính và tính năng có thể thao tác với một model đã được nạp bằng api `optimum` cho lượng tử hóa GPTQ dựa trên backend gptqmodel.

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

```python
from_dict_optimum(config_dict)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L788)

Lớp tương thích với từ điển cấu hình gptq của optimum

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L738)

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

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

```python
to_dict_optimum()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L782)

Lấy dict tương thích cho cấu hình gptq của optimum

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L390)

**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 đượ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`.

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[[transformers.BitsAndBytesConfig.is_quantizable]]

```python
is_quantizable()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L551)

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

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L521)

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[[transformers.BitsAndBytesConfig.quantization_method]]

```python
quantization_method()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L557)

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[[transformers.BitsAndBytesConfig.to_diff_dict]]

```python
to_diff_dict()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L588)

**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.

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

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L74)

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 transformers của HF để suy luận và/hoặc lượng tử hóa. Lớp này chỉ được sử dụng cho transformers.PreTrainedModel.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 (`transformers.utils.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. 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[[transformers.quantizers.HfQuantizer.adjust_max_memory]]

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L148)

đ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

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L239)

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_load_operations[[transformers.quantizers.HfQuantizer.get_load_operations]]

```python
get_load_operations()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L323)

Các lớp Op nạp các tensor đã được serialize, ví dụ `{"deserialize": Mxfp4Deserialize, "dequantize": Mxfp4Dequantize}`. Một quá trình deserialize xây dựng các tham số của một module, do đó nó chỉ chạy trên các bộ chuyển đổi chung. Một quá trình dequantize cũng chạy trước các op của các bộ chuyển đổi của mô hình, ví dụ trước một thao tác merge theo từng expert.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L134)

Điều này xảy ra vào thời điểm materialization, khi tensor được gửi từ đĩa sang thiết bị. `dtype` để chuyển đổi tensor checkpoint đã lượng tử hóa trước `param`. Nếu tham số đó không được lượng tử hóa (kiểu float), chúng ta sử dụng `dtype` đầu vào đến từ `nn.Module` đã được khởi tạo.

Nếu phương pháp lượng tử hóa có `Deserializer` hoặc `Dequantizer` (hàm nạp), chúng tôi trả về None để chúng xử lý.

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

```python
get_state_dict_and_metadata(model)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L290)

Lấy state dict và metadata. Hữu ích khi chúng ta cần chỉnh sửa một chút state dict do lượng tử hóa

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

```python
get_weight_conversions()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L331)

Trả về thao tác tải cần thực hiện cho bất kỳ tham số nào không khớp với bộ chuyển đổi của mô hình

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L152)

Kiểm tra xem một tham số nhất định có cần được lượng tử hóa hay không.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L207)

**Tham số:**

model (`~transformers.PreTrainedModel`) : 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[[transformers.quantizers.HfQuantizer.preprocess_model]]

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L184)

**Tham số:**

model (`~transformers.PreTrainedModel`) : 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`.

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

```python
remove_quantization_config(model)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L227)

Xóa cấu hình lượng tử hóa khỏi mô hình.

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

```python
update_attn_implementation(config)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L177)

Xem `attn_implementation` được yêu cầu trước khi mô hình được xây dựng, để bộ lượng tử hóa có thể đặt giá trị mặc định cho nó.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L112)

**Tham số:**

device_map (`Union[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_dtype[[transformers.quantizers.HfQuantizer.update_dtype]]

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L100)

**Tham số:**

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

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L166)

Cập nhật tại chỗ `model.tp_plan` hoặc `model.ep_plan` (các kế hoạch đầy đủ, được hợp nhất từ cấu hình và tất cả các cấu hình con) để tính đến các khóa tùy chỉnh của bộ lượng tử hóa như 'inv_scale'

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L341)

Khiến các bộ chuyển đổi của mô hình (từ ánh xạ chuyển đổi) nạp các tên đã được phân tích chuỗi. Các tham số của mô hình quyết định, ví dụ đối với việc hợp nhất `experts.*.gate_proj.weight` vào `experts.gate_up_proj`:
- `experts.gate_up_proj_scale_inv` là một tham số: một bản sao gộp `experts.*.gate_proj.weight_scale_inv` vào nó
- nếu không, trình chuyển đổi cũng thu thập `experts.*.gate_proj.weight_scale_inv`, thao tác khử lượng hóa sẽ chạy trước

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/quantizers/base.py#L158)

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 transformers. Nếu không cần kiểm tra rõ ràng, chỉ cần trả về không.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1315)

**Tham số:**

bits (int, *tùy chọn*, mặc định là 4) : Số bit được sử dụng cho lượng tử hóa. Có thể là 2, 3 hoặc 4. Mặc định là 4.

p (int, *tùy chọn*, mặc định là 2) : Kích thước lưới lượng tử hóa. Hỗ trợ 1 và 2. Trong thực tế, 2 luôn tốt hơn. Mặc định là 2.

modules_to_not_convert (`list`, *tùy chọn*, mặc định là ["lm_head"]) : Danh sách các lớp tuyến tính không nên được lượng tử hóa.

hadamard_size (int, *tùy chọn*, mặc định là 512) : Kích thước Hadamard cho phương pháp HIGGS. Mặc định là 512. Chiều kích đầu vào của các ma trận sẽ được đệm (padding) lên giá trị này. Giảm giá trị này xuống dưới 512 sẽ làm giảm chất lượng lượng tử hóa.

group_size (int, *tùy chọn*, mặc định là 256) : Kích thước nhóm cho phương pháp HIGGS. Có thể là 64, 128 hoặc 256. Việc giảm giá trị này hầu như không ảnh hưởng đến hiệu suất. Mặc định là 256. Phải là ước số của hadamard_size.

tune_metadata ('dict', *tùy chọn*, mặc định là {}) : Metadata theo module (hình dạng khối gemm, metadata GPU, v.v.) để lưu kết quả tinh chỉnh kernel. Mặc định là một từ điển rỗng. Được thiết lập tự động trong quá trình tinh chỉnh.

HiggsConfig là một lớp cấu hình cho lượng tử hóa sử dụng phương pháp HIGGS.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1356)

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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L277)

**Tham số:**

nbits (`int`, *tuỳ chọn*, mặc định là 4) : Số bit. Các giá trị được hỗ trợ là (8, 4, 3, 2, 1).

group_size (`int`, *tuỳ chọn*, mặc định là 64) : Giá trị group-size. Các giá trị được hỗ trợ là bất kỳ giá trị nào chia hết cho weight.shape[axis]).

view_as_float (`bool`, *tùy chọn*, mặc định là `False`) : Xem trọng lượng đã lượng tử hóa dưới dạng float (được sử dụng trong huấn luyện phân tán) nếu đặt thành `True`.

axis (`Optional[int]`, *tuỳ chọn*) : Trục thực hiện nhóm. Các giá trị được hỗ trợ là 0 hoặc 1.

dynamic_config (dict, *tùy chọn*) : Các tham số cho cấu hình động. Khóa là tên thẻ của lớp và giá trị là cấu hình lượng tử hóa. Nếu được đặt, mỗi lớp được chỉ định bằng id của nó sẽ sử dụng cấu hình lượng tử hóa riêng của lớp đó.

skip_modules (`list[str]`, *tùy chọn*, mặc định là `['lm_head']`) : Danh sách các lớp `nn.Linear` cần bỏ qua.

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à lớp bao quanh BaseQuantizeConfig của hqq.

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L342)

Ghi đè from_dict, được sử dụng trong AutoQuantizationConfig.from_dict trong quantizers/auto.py

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L337)

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.

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

```python
to_diff_dict()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L367)

**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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1825)

Lớp cấu hình cho lượng tử hóa affine Metal nhắm đến các thiết bị Apple Silicon (MPS).

Phương pháp lượng tử hóa này sử dụng các kernel Metal `mlx-quantization-metal-kernels` từ Hugging Face Hub để thực hiện lượng tử hóa affine (scales + qbiases) với độ rộng bit và kích thước nhóm có thể cấu hình. Các trọng số đã được lượng tử hóa được đóng gói vào các tensor `uint32` và bước truyền thẳng sử dụng các kernel Metal kết hợp dequantization + matmul.

## Mxfp4Config[[transformers.Mxfp4Config]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1791)

**Tham số:**

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 ban đầu.

dequantize (`bool`, *tùy chọn*, mặc định là `False`) : Xác định xem có khử lượng tử hóa mô hình xuống độ chính xác bf16 hay không

Đây là một lớp wrapper bao gồm tất cả các thuộc tính và tính năng có thể thao tác với một model đã được nạp bằng lượng tử hóa mxfp4.

## NVFP4Config[[transformers.NVFP4Config]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2067)

**Tham số:**

modules_to_not_convert (`list[str]`, *tùy chọn*) : Các mẫu tên module cần giữ nguyên độ chính xác ban đầu.

kwargs (`dict[str, Any]`, *tùy chọn*) : Các giá trị bổ sung sẽ bị bỏ qua và được báo cáo thông qua trình ghi log của Transformers.

Cấu hình cho lượng tử hóa trọng số NVFP4 theo thời gian thực.

## FbgemmFp8Config[[transformers.FbgemmFp8Config]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1284)

**Tham số:**

activation_scale_ub (`float`, *optional*, mặc định là 1200.0) : Giới hạn trên của thang kích hoạt. Giá trị này được sử dụng khi lượng hóa kích hoạt đầu vào.

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 ban đầu.

Đây là một lớp wrapper bao gồm tất cả các thuộc tính và tính năng có thể thao tác với một model đã được nạp bằng lượng tử hóa 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1095)

**Tham số:**

config_groups (`typing.dict[str, typing.Union[ForwardRef('QuantizationScheme'), typing.list[str]]]`, *tùy chọn*) : từ điển ánh xạ tên nhóm đến định nghĩa phương án lượng tử hóa

format (`str`, *tùy chọn*, mặc định là `"dense"`) : định dạng lưu trữ trọng số, ví dụ `dense`, `float-quantized` hoặc `pack-quantized`

quantization_status (`QuantizationStatus`, *tùy chọn*, mặc định là `"initialized"`) : trạng thái của mô hình trong vòng đời lượng tử hóa, ví dụ 'initialized', 'calibration', 'frozen'

kv_cache_scheme (`typing.Union[QuantizationArgs, NoneType]`, *tùy chọn*) : chỉ định lượng hóa của bộ đệm kv. Nếu là None, bộ đệm kv sẽ không được lượng hóa.

global_compression_ratio (`typing.Union[float, NoneType]`, *tùy chọn*) : tỷ lệ phần trăm nén mô hình dạng float từ 0 đến 1

ignore (`typing.Union[typing.list[str], NoneType]`, *tùy chọn*) : tên hoặc kiểu lớp không cần lượng tử hóa, hỗ trợ regex có tiền tố 're:'

quant_method (`str`, *tùy chọn*, mặc định là `"compressed-tensors"`) : không ghi đè, phải là compressed-tensors

run_compressed (`bool`, *tuỳ chọn*) : đã bị ngừng hỗ trợ, hãy dùng `dequantize` thay thế. Tác dụng duy nhất của nó là đặt `dequantize` thành giá trị ngược lại, `run_compressed=False` có nghĩa là `dequantize=True`.

dequantize (`bool`, *tùy chọn*, mặc định là `False`) : khi `True`, các trọng lượng đã lượng tử hóa sẽ được khử lượng tử hóa trở lại kiểu dữ liệu của mô hình (ví dụ: BF16) tại thời điểm tải, đây là điều cần thiết để tinh chỉnh hoặc lưu mô hình ở kiểu dữ liệu gốc. Khi `False`, các trọng lượng sẽ được giữ ở dạng nén và compressed-tensors sẽ giải nén chúng trong lần truyền tiến đầu tiên.

use_optimized_inference (`bool`, *tuỳ chọn*, mặc định là `False`) : khi `True`, các lớp mà chúng tôi có kernel sẽ giữ nguyên trọng lượng đã lượng tử hóa và chạy thông qua các kernel đó (hiện tại là W8A8 FP8, trên CUDA SM89+, XPU, hoặc MPS với torch >= 2.15). Chỉ dùng cho suy luận và phải bật thủ công: nếu không bật, mô hình sẽ đi qua đường dẫn compressed-tensors thông thường. Bỏ qua khi `dequantize=True`.

Đây là một lớp wrapper xử lý các tùy chọn cấu hình lượng tử hóa compressed-tensors. Nó là một lớp wrapper bao quanh `compressed_tensors.QuantizationConfig`

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1192)

**Tham số:**

config_dict (`dict[str, Any]`) : Từ điển sẽ được dùng để khởi tạo đối tượng cấu hình.

return_unused_kwargs (`bool`,*tuỳ chọn*, mặc định là `False`) : Có trả về danh sách các đối số từ khóa không được sử dụng hay không. Được dùng cho phương thức `from_pretrained` trong `PreTrainedModel`.

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

**Trả về:** `QuantizationConfigMixin`

Đối tượng cấu hình được khởi tạo từ các tham số đó.

Tạo một [CompressedTensorsConfig](/docs/transformers/main/vi/main_classes/quantization#transformers.CompressedTensorsConfig) từ một từ điển Python chứa các tham số. Tùy chọn mở bọc bất kỳ args nào từ quantization_config lồng nhau

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

```python
to_dict()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1217)

Cấu hình lượng tử hóa cần được thêm vào config.json

Chuẩn hóa bản thể này thành một từ điển Python. Trả về: `dict[str, Any]`: Từ điển chứa tất cả các thuộc tính cấu thành bản thể cấu hình này.

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

```python
to_diff_dict()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1232)

**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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1460)

**Tham số:**

quant_type (`AOBaseConfig`) : Một instance `AOBaseConfig` của torchao chỉ định loại lượng tử hóa, ví dụ `Int4WeightOnlyConfig(group_size=32)`, `Int8WeightOnlyConfig()`, `Int8DynamicActivationInt8WeightConfig()`, `Float8WeightOnlyConfig()`, v.v.

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 ban đầu.

include_input_output_embeddings (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có bao gồm embedding trong quá trình lượng tử hóa hay không. Nếu đặt cờ này, input embedding cũng sẽ được loại bỏ khỏi danh sách module_not_to_convert.

untie_embedding_weights (`bool`, *tùy chọn*, mặc định là `False`) : Có nên tách các trọng số khi chúng ta đang lượng tử hóa các trọng số nhúng đầu vào được liên kết với các trọng số khác hay không.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1543)

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

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

```python
get_apply_tensor_subclass()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1529)

Trả về cấu hình lượng hóa cần áp dụng.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1511)

Xác thực cấu hình và đặt các giá trị mặc định.

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

```python
to_dict()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1533)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1563)

**Tham số:**

modules_to_not_convert (`Optional[List]`, *optional*) : Tùy chọn, cung cấp một danh sách các đường dẫn đầy đủ của các tham số trọng số `nn.Linear` không được lượng tử hóa. Mặc định là None.

linear_class (`str`, *tùy chọn*, mặc định là `"bitlinear"`) : Kiểu lớp tuyến tính cần sử dụng. Có thể là `bitlinear` hoặc `autobitlinear`.

quantization_mode (`str`, *tùy chọn*, mặc định là `"offline"`) : Chế độ lượng tử hóa cần sử dụng. Có thể là `online` hoặc `offline`. Ở chế độ `online`, các tham số lượng tử hóa trọng số được tính toán động trong mỗi lần truyền tiến (ví dụ: dựa trên các giá trị trọng số hiện tại). Điều này có thể thích ứng với các thay đổi của trọng số trong quá trình huấn luyện (Quantization-Aware Training - QAT). Ở chế độ `offline`, các tham số lượng tử hóa được tính toán trước *trước khi* suy luận. Các tham số này sau đó được cố định và nạp vào mô hình đã lượng tử hóa. Điều này thường dẫn đến chi phí thời gian chạy thấp hơn so với lượng tử hóa online.

use_rms_norm (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có áp dụng RMSNorm lên các kích hoạt trước khi lượng tử hóa hay không. Điều này phù hợp với cách tiếp cận của bài báo BitNet gốc, trong đó các kích hoạt được chuẩn hóa trước khi lượng tử hóa/gói.

rms_norm_eps (`float`, *optional*, mặc định là 1e-06) : Giá trị epsilon được sử dụng trong lớp RMSNorm để đảm bảo ổn định số học.

kwargs (`dict[str, Any]`, *tùy chọn*) : Các đối số từ khóa bổ sung có thể được sử dụng bởi các backend lượng tử hóa cụ thể hoặc các phiên bản tương lai.

Lớp cấu hình để áp dụng lượng tử hóa BitNet.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1612)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1619)

**Tham số:**

bits (`int`, *optional*, mặc định là 3) : Chỉ định số bit cho trọng số và các điểm zero-order cùng với các thang đo. Hiện tại chỉ hỗ trợ bits = 3.

beta1 (`int`, *tuỳ chọn*, mặc định là 16) : Độ rộng tile SpQR. Hiện tại chỉ hỗ trợ beta1 = 16.

beta2 (`int`, *tuỳ chọn*, mặc định là 16) : Chiều cao của tile SpQR. Hiện tại chỉ hỗ trợ beta2 = 16.

shapes (`Optional`, *optional*) : Một từ điển chứa hình dạng của từng đối tượng. Chúng ta cần điều này vì không thể suy ra kích thước chính xác của các tham số chỉ từ bits, beta1, beta2.

modules_to_not_convert (`Optional[list[str]]`, *tùy chọn*) : Tùy chọn, cung cấp một danh sách các đường dẫn đầy đủ của các tham số trọng số `nn.Linear` sẽ không được lượng tử hóa. Mặc định là None.

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à lớp bọc cho các tham số `spqr`. Xem thêm chi tiết trong bài báo gốc.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1660)

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.

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1682)

**Tham số:**

activation_scheme (`str`, *tùy chọn*, mặc định là `"dynamic"`) : Phương án được sử dụng cho kích hoạt, phương án mặc định và cũng là phương án duy nhất được hỗ trợ hiện tại là "dynamic".

weight_block_size (`typing.tuple[int, int]`, *tùy chọn*, mặc định là `(128, 128)`) : Kích thước của các khối trọng số cho lượng tử hóa, mặc định là (128, 128).

dequantize (`bool`, *tùy chọn*, mặc định là `False`) : Có nên khử lượng tử hóa mô hình trong quá trình tải hay không.

modules_to_not_convert (`list`, *tùy chọn*) : Một danh sách tên module không nên được chuyển đổi trong quá trình lượng tử hóa.

modules_to_convert (`list`, *tùy chọn*) : Một danh sách các tên module bổ sung, chẳng hạn như bảng nhúng, cần được chuyển đổi trong quá trình lượng tử hóa.

scale_fmt (`str`, *tùy chọn*, mặc định là `"float"`) : Kiểu dtype lưu trữ của các thang trọng số theo khối: `"float"` (fp32, kiểu V3) hoặc `"ue8m0"` (1 byte `torch.float8_e8m0fnu`, kiểu V4).

expert_dtype (`str`, *tùy chọn*, mặc định là `"fp8"`) : Định dạng của trọng số chuyên gia MoE: `"fp8"`, hoặc `"fp4"` cho các chuyên gia FP4-packed của DeepSeek-V4.

FineGrainedFP8Config là một lớp cấu hình cho lượng tử hóa FP8 chi tiết, chủ yếu được sử dụng cho các mô hình deepseek.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1729)

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

## QuarkConfig[[transformers.QuarkConfig]]

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

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

[Nguồn](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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1869)

**Tham số:**

activation_dtype (`str`, *tùy chọn*) : Kiểu dữ liệu cần sử dụng khi lượng tử hóa các tensor kích hoạt. Nếu không được cung cấp, `dtype` sẽ được sử dụng.

activation_scale_rule (`str`, *tùy chọn*) : Quy tắc mở rộng (scaling rule) được sử dụng khi chọn thang đo (scale) cho các khối trong tensor kích hoạt. Nếu không được cung cấp, `scale_rule` sẽ được sử dụng.

dtype (`str`, mặc định "nvfp4", *tuỳ chọn*, mặc định là `"nvfp4"`) : Kiểu dữ liệu được sử dụng cho trọng số, kích hoạt và tensor của lớp. Có thể là `"nvfp4"` hoặc `"mxfp4"`.

gradient_dtype (`str`, *tùy chọn*) : Kiểu dữ liệu được sử dụng khi lượng tử hóa các tensor gradient. Nếu không được cung cấp, `dtype` sẽ được sử dụng.

gradient_scale_rule (`str`, *tùy chọn*) : Quy tắc mở rộng (scaling rule) được sử dụng khi chọn thang đo (scale) cho các khối trong tensor gradient. Nếu không được cung cấp, `scale_rule` sẽ được sử dụng.

keep_master_weights (`bool`, mặc định False, *tùy chọn*, mặc định là `False`) : Có giữ trọng số gốc hay không. Nếu `True`, trọng số độ chính xác cao sẽ luôn được giữ và trọng số sẽ được lượng tử hóa trực tuyến trong mỗi bước truyền thẳng. Điều này hữu ích cho việc huấn luyện đã lượng tử hóa.

matmul_backend (`str`, *tùy chọn*) : Backend để sử dụng cho các phép nhân ma trận. Có thể là `"cutlass"` hoặc `"pytorch"`. Nếu không được cung cấp, CUTLASS sẽ được sử dụng nếu khả dụng, ngược lại PyTorch sẽ được sử dụng.

output_dtype (`str`, *tùy chọn*, mặc định là `"bfloat16"`) : Kiểu dữ liệu được sử dụng cho đầu ra của lớp. Có thể là `"bfloat16"` hoặc `"float16"`.

quantize_backend (`str`, *tùy chọn*) : Backend để sử dụng cho lượng tử hóa. Có thể là `"cuda"`, `"triton"` hoặc `"pytorch"`. Nếu không được cung cấp, backend nhanh nhất sẽ được chọn dựa trên môi trường của bạn và dựa trên các tùy chọn được hỗ trợ bởi từng backend. Thông thường, `"cuda"` sẽ được sử dụng cho suy luận, `"triton"` sẽ được sử dụng cho huấn luyện, và `"pytorch"` sẽ được sử dụng trên các thiết bị không phải CUDA.

scale_rule (`str`, mặc định "mse", *tuỳ chọn*, mặc định là `"mse"`) : Quy tắc sử dụng khi chọn thang đo khối. Có thể là `"mse"`, `"mae"` hoặc `"abs_max"` cho Four Over Six, `"static_6"` cho lượng tử hóa NVFP4 mặc định, hoặc `"static_4"` để điều chỉnh tất cả các khối về giá trị tối đa là 4.

weight_dtype (`str`, *tùy chọn*) : Kiểu dữ liệu được sử dụng khi lượng tử hóa các tensor trọng số. Nếu không được cung cấp, `dtype` sẽ được sử dụng.

weight_scale_2d (`bool`, mặc định False, *tùy chọn*, mặc định là `False`) : Có tính toán các hệ số tỷ lệ trên các tensor trọng số trong các khối 2D hay không. Việc này nên được thực hiện trong quá trình huấn luyện.

weight_scale_rule (`str`, *tùy chọn*) : Quy tắc mở rộng (scaling rule) được sử dụng khi chọn thang đo (scale) cho các khối trong các tensor trọng số. Nếu không được cung cấp, `scale_rule` sẽ được sử dụng.

module_config_overrides (`dict[str, dict[str, Any]]`, *tùy chọn*) : Một từ điển chứa các cấu hình ghi đè cụ thể cho từng module. Các khóa phải là tên module, và các giá trị phải là các từ điển chứa cấu hình lượng tử hóa cho module đó. Điều này có thể được sử dụng để ghi đè cấu hình mặc định cho các module cụ thể.

modules_to_not_convert (`list[str]`, *tùy chọn*, mặc định là `['lm_head']`) : Danh sách các module cần loại trừ khỏi quá trình lượng tử hóa. Mặc định, `lm_head` sẽ bị loại trừ.

Đây là một lớp wrapper chứa tất cả các tùy chọn cho lượng tử hóa với `fouroversix`. Tóm lại, Four Over Six là một biến thể của lượng tử hóa NVFP4, trong đó giá trị lớn nhất trong mỗi khối 16 giá trị FP4 được tự động điều chỉnh về 4 hoặc 6. Việc chọn thang đo 6 sử dụng toàn bộ phạm vi giá trị FP4, trong khi chọn thang đo 4 cho phép phân bố sai số lượng tử hóa đồng đều hơn. Tham khảo bài báo gốc để biết thêm chi tiết: 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)
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1371)

**Tham số:**

forward_dtype (`str`, *tùy chọn*, mặc định là `"nvfp4"`) : Kiểu dữ liệu (dtype) được sử dụng cho bước truyền thẳng (forward pass).

forward_method (`str`, *tùy chọn*, mặc định là `"abs_max"`) : Phương pháp scale cần sử dụng cho bước forward. Có thể là `"abs_max"` hoặc `"quest"`. `"abs_max"` phù hợp hơn cho PTQ, `"quest"` phù hợp hơn cho QAT.

backward_dtype (`str`, *tùy chọn*, mặc định là `"bf16"`) : Kiểu dữ liệu (dtype) được sử dụng cho bước truyền ngược (backward pass).

store_master_weights (`bool`, *tùy chọn*, mặc định là `False`) : Xác định có lưu trữ trọng số chính hay không. Cần thiết cho QAT trên trọng số lớp.

hadamard_group_size (`int`, *optional*) : Kích thước nhóm cho phép biến đổi hadamard trước khi lượng tử hóa đối với `"quest"`, khớp với kích thước nhóm của MXFP4 (32). Nếu là `None`, giá trị sẽ được đặt thành 16 cho `"nvfp4"` và 32 cho `"mxfp4"`.

pseudoquantization (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng giả lượng tử hóa dựa trên Triton hay không. Bắt buộc đối với các GPU không phải Blackwell. Không mang lại bất kỳ tốc độ tăng nào. Dùng cho mục đích gỡ lỗi.

transform_init (`str`, *tùy chọn*, mặc định là `"hadamard"`) : một phương pháp để khởi tạo ma trận tiền xử lý. Có thể là `"hadamard"`, `"identity"` hoặc `"gsr"`.

modules_to_not_convert (`list`, *optional*) : 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.

FPQuantConfig là một lớp cấu hình cho lượng tử hóa sử dụng phương pháp FPQuant.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1418)

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.

## AutoRoundConfig[[transformers.AutoRoundConfig]]

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L208)

**Tham số:**

bits (`int`, *tuỳ chọn*, mặc định là 4) : Số bit để lượng tử hóa, các giá trị được hỗ trợ là (2, 3, 4, 5, 6, 7, 8).

group_size (`int`, *tùy chọn*, mặc định là 128) : Giá trị group-size

sym (`bool`, *tùy chọn*, mặc định là `True`) : Có sử dụng lượng tử hóa đối xứng hay không

backend (`str`, *tùy chọn*, mặc định là `"auto"`) : Backend suy luận. Mặc định, AutoRound chọn một backend tương thích dựa trên thiết bị, cài đặt lượng tử hóa và các thư viện đã cài đặt. Xem [Chỉ định backend suy luận](https://github.com/intel/auto-round/blob/main/docs/step_by_step.md#specify-inference-backend) để biết tất cả các tùy chọn backend.

Đây là một lớp wrapper bao gồm tất cả các thuộc tính và tính năng có thể thao tác với một model đã được nạp bằng lượng tử hóa AutoRound.

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

```python
post_init()
```

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L239)

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

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L1964)

**Tham số:**

nbits (`int`, mặc định 4) : Số bit lượng tử hóa cho trọng số.

group_size (`int`, mặc định 64) : Kích thước nhóm được sử dụng trong lượng hóa trọng số SINQ (phải là bội số của 8).

tiling_mode (`str`, mặc định "1D") : Chế độ chia ô cho SINQ (thường là "1D"; "2D" nếu backend của bạn hỗ trợ).

method (`str`, mặc định "sinq") : "sinq" – SINQ chỉ trọng số, không cần hiệu chuẩn "asinq" – A-SINQ (nhận thức kích hoạt), không được hỗ trợ trong Hugging Face. Vui lòng tham khảo kho lưu trữ SINQ chính thức.

modules_to_not_convert (`list[str]`, *tùy chọn*) : Danh sách tên module/đầu vào (prefix) cần giữ ở độ chính xác đầy đủ.

- ****kwargs** : Các đối số bổ sung từ người dùng (được giữ trong `_extra_kwargs` để phục vụ cho việc truyền ngược lại).

Cấu hình lượng tử hóa cho SINQ / A-SINQ.

Truyền điều này đến:

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

[Nguồn](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/quantization_config.py#L2087)

**Tham số:**

gguf_file (`str`, *tùy chọn*) : đường dẫn đến tệp `.gguf` chứa các trọng số. Có thể bỏ qua nếu tên tệp được chỉ định thông qua `from_pretrained(..., gguf_file=...)`, hàm này sẽ tự điền vào.

dequantize (`bool`, *tùy chọn*, mặc định là `False`) : Thay vào đó, giải nén mọi trọng số khi tải vào một mô hình dense thông thường. Luôn chính xác, nhưng từ bỏ việc tiết kiệm bộ nhớ; đây cũng là phương án dự phòng tự động khi không có kernel matmul nào khả dụng cho các kiểu lượng tử hóa của tệp.

Tải checkpoint GGUF đã lượng tử hóa với trọng số được giữ trong các khối GGUF.