diffusers/main/vi/api/quantization.md

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.

Tìm hiểu cách lượng tử hóa các mô hình trong hướng dẫn Quantization.

PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

diffusers.PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

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

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

BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

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

Nguồn

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]]

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

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]]

is_quantizable()

Nguồn

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]]

post_init()

Nguồn

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]]

quantization_method()

Nguồn

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]]

to_diff_dict()

Nguồn

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]]

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

Nguồn

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]]

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

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 để 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:

{
  "_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]]

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

Nguồn

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 hoặc 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]]

post_init()

Nguồn

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]]

diffusers.SDNQConfig(*args, **kwargs)

Nguồn

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]]

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

Nguồn

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 để 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ụ:

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]]

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

Nguồn

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

get_apply_tensor_subclass[[diffusers.TorchAoConfig.get_apply_tensor_subclass]]

get_apply_tensor_subclass()

Nguồn

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]]

to_dict()

Nguồn

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

DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

diffusers.DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

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

Nguồn

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]]

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

Nguồn

đ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]]

adjust_target_dtype(torch_dtype: torch.dtype)

Nguồn

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]]

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

Nguồn

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]]

check_quantized_param_shape(*args, **kwargs)

Nguồn

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]]

create_quantized_param(*args, **kwargs)

Nguồn

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]]

dequantize(model)

Nguồn

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]]

get_cuda_warm_up_factor()

Nguồn

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]]

get_special_dtypes_update(model, torch_dtype: torch.dtype)

Nguồn

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]]

postprocess_model(model: ModelMixin, **kwargs)

Nguồn

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]]

preprocess_model(model: ModelMixin, **kwargs)

Nguồn

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]]

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

Nguồn

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]]

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

Nguồn

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]]

update_torch_dtype(torch_dtype: torch.dtype)

Nguồn

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]]

validate_environment(*args, **kwargs)

Nguồn

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.