diffusers/main/id/api/quantization.md

Kuantisasi

Teknik kuantisasi mengurangi biaya memori dan komputasi dengan merepresentasikan bobot dan aktivasi menggunakan tipe data presisi rendah seperti bilangan bulat 8-bit (int8). Hal ini memungkinkan pemuatan model yang lebih besar yang biasanya tidak muat di memori, serta mempercepat inferensi.

Pelajari cara mengkuantisasi model dalam panduan Kuantisasi.

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)

Sumber

Parameter:

quant_backend (str) : Backend kuantisasi yang akan digunakan. Saat menggunakan opsi ini, kami mengasumsikan bahwa backend tersebut tersedia untuk diffusers dan transformers.

quant_kwargs (dict) : Parameter untuk menginisialisasi kelas backend kuantisasi.

components_to_quantize (list) : Komponen dari pipeline yang akan dikuantisasi.

quant_mapping (dict) : Pemetaan yang mendefinisikan spesifikasi kuantisasi yang akan digunakan untuk komponen pipeline. Saat menggunakan argumen ini, pengguna tidak diharapkan untuk menyediakan quant_backend, quant_kawargs, dan components_to_quantize.

Kelas konfigurasi yang digunakan saat menerapkan kuantisasi secara langsung pada from_pretrained().

BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]

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

Sumber

Parameter:

compute_dtype (torch.dtype, defaultnya torch.bfloat16) : dtype dari aktivasi dan lapisan yang tidak dikuantisasi. Perangkat tanpa kernel FP8 atau NVFP4 yang terintegrasi akan mendekuantisasi bobot ke dtype ini pada setiap langkah maju (forward pass).

Konfigurasi untuk memuat checkpoint yang dikuantisasi dengan skema fp8r dan nvfp4 dari Black Forest Labs.

Kedua skema dibaca dari checkpoint melalui ~FromSingleFileMixin.from_single_file; kuantisasi model secara langsung tidak didukung. Lapisan linear dikuantisasi ketika bobotnya disertai tensor skala:

• fp8r: weight adalah float8_e4m3fn dengan bentuk [N, K] dan weight_scale adalah skala fp32 per baris [N].
• nvfp4: weight adalah uint8 dengan bentuk [N, K/2] (dua nilai E2M1 per byte), weight_scale adalah skala blok float8_e4m3fn [N, K/16], dan weight_scale_2 serta input_scale adalah skalar fp32 yang menyimpan skala bobot global dan skala aktivasi yang dikalibrasi (layout ModelOpt NVFP4).

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)

Sumber

Parameter:

load_in_8bit (bool, opsional, defaultnya False) : Flag ini digunakan untuk mengaktifkan kuantisasi 8-bit dengan LLM.int8().

load_in_4bit (bool, opsional, defaultnya False) : Flag ini digunakan untuk mengaktifkan kuantisasi 4-bit dengan mengganti lapisan Linear dengan lapisan FP4/NF4 dari bitsandbytes.

llm_int8_threshold (float, opsional, default 6.0) : Ini sesuai dengan ambang batas outlier untuk deteksi outlier seperti yang dijelaskan dalam paper LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale: https://huggingface.co/papers/2208.07339 Nilai hidden states mana pun yang berada di atas ambang batas ini akan dianggap sebagai outlier dan operasi pada nilai-nilai tersebut akan dilakukan dalam fp16. Nilai biasanya terdistribusi secara normal, artinya sebagian besar nilai berada dalam rentang [-3.5, 3.5], tetapi ada beberapa outlier sistematis yang sangat berbeda distribusinya pada model besar. Outlier ini sering berada dalam interval [-60, -6] atau [6, 60]. Kuantisasi Int8 bekerja dengan baik untuk nilai dengan magnitudo ~5, tetapi melampaui itu, terdapat penalti kinerja yang signifikan. Ambang batas default yang baik adalah 6, tetapi ambang batas yang lebih rendah mungkin diperlukan untuk model yang lebih tidak stabil (model kecil, fine-tuning).

llm_int8_skip_modules (list[str], opsional) : Daftar eksplisit modul yang tidak ingin dikonversi ke 8-bit. Ini berguna untuk model seperti Jukebox yang memiliki beberapa head di berbagai tempat dan tidak selalu di posisi terakhir. Misalnya, untuk model CausalLM, lm_head terakhir biasanya tetap dipertahankan dalam dtype aslinya.

llm_int8_enable_fp32_cpu_offload (bool, opsional, defaultnya False) : Flag ini digunakan untuk kasus penggunaan lanjutan dan pengguna yang memahami fitur ini. Jika Anda ingin membagi model Anda ke dalam bagian-bagian berbeda dan menjalankan beberapa bagian dalam int8 di GPU serta beberapa bagian dalam fp32 di CPU, Anda dapat menggunakan flag ini. Hal ini berguna untuk offloading model besar seperti google/flan-t5-xxl. Perhatikan bahwa operasi int8 tidak akan dijalankan di CPU.

llm_int8_has_fp16_weight (bool, opsional, defaultnya False) : Flag ini menjalankan LLM.int8() dengan bobot utama 16-bit. Hal ini berguna untuk fine-tuning karena bobot tidak perlu dikonversi bolak-balik untuk backward pass.

bnb_4bit_compute_dtype (torch.dtype atau str, opsional, defaultnya torch.float32) : Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input mungkin fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan.

bnb_4bit_quant_type (str, opsional, defaultnya "fp4") : Ini mengatur tipe data kuantisasi di lapisan bnb.nn.Linear4Bit. Opsi yang tersedia adalah tipe data FP4 dan NF4 yang ditentukan oleh fp4 atau nf4.

bnb_4bit_use_double_quant (bool, opsional, defaultnya False) : Flag ini digunakan untuk kuantisasi bersarang, di mana konstanta kuantisasi dari kuantisasi pertama dikuantisasi lagi.

bnb_4bit_quant_storage (torch.dtype atau str, opsional, defaultnya torch.uint8) : Ini mengatur tipe penyimpanan untuk mengemas parameter 4-bit yang dikuantisasi.

kwargs (dict[str, Any], opsional) : Parameter tambahan untuk menginisialisasi objek konfigurasi.

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan bitsandbytes.

Ini menggantikan load_in_8bit atau load_in_4bit, sehingga kedua opsi tersebut saling eksklusif.

Saat ini hanya mendukung kuantisasi LLM.int8(), FP4, dan NF4. Jika metode lain ditambahkan ke bitsandbytes, maka argumen tambahan akan ditambahkan ke kelas ini.

is_quantizable[[diffusers.BitsAndBytesConfig.is_quantizable]]

is_quantizable()

Sumber

Mengembalikan True jika model dapat dikuantisasi, False jika tidak.

post_init[[diffusers.BitsAndBytesConfig.post_init]]

post_init()

Sumber

Pemeriksa keselamatan yang memastikan argumen benar - juga mengganti beberapa argumen NoneType dengan nilai default-nya.

quantization_method[[diffusers.BitsAndBytesConfig.quantization_method]]

quantization_method()

Sumber

Metode ini mengembalikan metode kuantisasi yang digunakan untuk model. Jika model tidak dapat dikuantisasi, metode ini mengembalikan None.

to_diff_dict[[diffusers.BitsAndBytesConfig.to_diff_dict]]

to_diff_dict()

Sumber

Mengembalikan: dict[str, Any]

Kamus dari semua atribut yang membentuk instance konfigurasi ini,

Menghapus semua atribut dari config yang sesuai dengan atribut config default untuk keterbacaan yang lebih baik dan melakukan serialisasi ke kamus Python.

GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

diffusers.GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

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

Sumber

Parameter:

compute_dtype : (torch.dtype, defaultnya torch.float32): Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input mungkin fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan.

Ini adalah kelas konfigurasi untuk teknik kuantisasi 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)

Sumber

Parameter:

compute_dtype (torch.dtype, defaultnya torch.bfloat16) : dtype runtime yang digunakan oleh buffer floating-point di dalam modul terkuantisasi.

svdq_w4a4 (dict, opsional) : Konfigurasi target SVDQ W4A4 eksplisit dengan precision, group_size, rank, dan targets.

awq_w4a16 (dict, opsional) : Konfigurasi target AWQ W4A16 eksplisit dengan precision, group_size, dan targets.

Konfigurasi untuk memuat checkpoint Nunchaku Lite.

Dukungan Nunchaku Lite di Diffusers memuat checkpoint prequantized. Untuk membuat checkpoint yang kompatibel, gunakan diffuse-compressor untuk memilih atau menyesuaikan konfigurasi target untuk arsitektur model, melakukan kuantisasi dan mengekspor transformer, serta mengemasnya sebagai pipeline Diffusers dengan quantization_config ringkas yang disimpan di config.json.

State dict yang diekspor harus cocok persis dengan arsitektur model Diffusers target. Checkpoint yang dikuantisasi dengan proyeksi QKV yang digabungkan tidak akan dapat dimuat ke dalam konfigurasi model yang mengharapkan modul proyeksi Q, K, dan V yang terpisah.

Contoh konfigurasi config.json ringkas:

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

Sumber

Parameter:

weights_dtype (str, opsional, defaultnya "int8") : dtype target untuk bobot setelah kuantisasi. Nilai yang didukung adalah ("float8","int8","int4","int2")

Ini adalah kelas pembungkus untuk semua atribut dan fitur yang mungkin dapat Anda gunakan pada model yang telah dimuat menggunakan quanto.

QuantoConfig tidak lagi didukung dan akan dihapus pada versi 1.0.0. Pertimbangkan untuk beralih ke salah satu backend kuantisasi lain yang didukung, seperti BitsAndBytesConfig atau TorchAoConfig.

modules_to_not_convert (list, opsional, default ke None): Daftar modul yang tidak akan dikuantisasi, berguna untuk menguantisasi model yang secara eksplisit membutuhkan beberapa modul tetap berada pada presisi aslinya (misalnya encoder Whisper, encoder Llava, lapisan gate Mixtral).

post_init[[diffusers.QuantoConfig.post_init]]

post_init()

Sumber

Pemeriksa keselamatan yang memastikan argumen benar

SDNQConfig[[diffusers.SDNQConfig]]

diffusers.SDNQConfig[[diffusers.SDNQConfig]]

diffusers.SDNQConfig(*args, **kwargs)

Sumber

Parameter:

weights_dtype (str, opsional, defaultnya "int8") : dtype target untuk bobot setelah kuantisasi, misalnya "int8", "uint4", "float8_e4m3fn". Lihat sdnq.common.accepted_weight_dtypes untuk semua nilai yang didukung.

group_size (int, opsional, defaultnya 0) : Berapa banyak elemen tensor yang berbagi grup kuantisasi yang sama. 0 memilih secara otomatis berdasarkan weights_dtype, -1 menonaktifkan pengelompokan dan menggunakan kuantisasi per baris.

use_svd (bool, opsional, defaultnya False) : Apakah akan menerapkan algoritma SVDQuant di atas kuantisasi SDNQ.

use_quantized_matmul (bool, opsional, defaultnya False) : Apakah akan menggunakan matmul INT8 / FP8 / FP16 yang dikuantisasi pada forward pass alih-alih BF16 / FP16.

modules_to_not_convert (list, opsional, defaultnya None) : Daftar modul yang akan dilewati selama kuantisasi.

kwargs (dict[str, Any], opsional) : Argumen kata kunci tambahan yang diteruskan ke sdnq.SDNQConfig (mis. quantized_matmul_dtype, svd_rank, use_hadamard, quant_conv, quant_embedding, modules_dtype_dict).

Kelas konfigurasi untuk SDNQ (SD.Next Quantization).

Perpustakaan sdnq menyediakan konfigurasi dan kuantizer yang kompatibel dengan diffusers; kelas ini adalah pabrik tipis yang mendelegasikan ke mereka sehingga checkpoint dengan quant_method="sdnq" dapat dimuat secara native dengan diffusers. Semua argumen diteruskan ke sdnq.SDNQConfig. Memerlukan perpustakaan sdnq: pip install sdnq.

Referensi: 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)

Sumber

Parameter:

quant_type (AOBaseConfig) : Instans subclass AOBaseConfig yang menentukan tipe kuantisasi. Lihat dokumentasi torchao untuk kelas konfigurasi yang tersedia (misalnya Int4WeightOnlyConfig, Int8WeightOnlyConfig, Float8WeightOnlyConfig, Float8DynamicActivationFloat8WeightConfig, dll.).

modules_to_not_convert (list[str], opsional, default ke None) : Daftar modul yang tidak akan dikuantisasi, berguna untuk mengkuantisasi model yang secara eksplisit membutuhkan beberapa modul tetap berada pada presisi aslinya.

Ini adalah kelas konfigurasi untuk teknik kuantisasi/keroposan torchao.

Contoh:

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)

Sumber

Buat konfigurasi dari kamus.

get_apply_tensor_subclass[[diffusers.TorchAoConfig.get_apply_tensor_subclass]]

get_apply_tensor_subclass()

Sumber

Buat metode kuantisasi yang sesuai berdasarkan konfigurasi.

to_dict[[diffusers.TorchAoConfig.to_dict]]

to_dict()

Sumber

Mengonversi konfigurasi menjadi kamus.

DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

diffusers.DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

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

Sumber

Kelas abstrak dari kuantizer HuggingFace. Saat ini mendukung kuantisasi model HF diffusers untuk inferensi dan/atau kuantisasi. Kelas ini hanya digunakan untuk diffusers.models.modeling_utils.ModelMixin.from_pretrained dan belum dapat dengan mudah digunakan di luar cakupan metode tersebut.

Attributes quantization_config (diffusers.quantizers.quantization_config.QuantizationConfigMixin): Konfigurasi kuantisasi yang mendefinisikan parameter kuantisasi dari model Anda yang ingin dikuantisasi. modules_to_not_convert (list[str], opsional): Daftar nama modul yang tidak akan dikonversi saat mengkuantisasi model. required_packages (list[str], opsional): Daftar paket pip yang wajib diinstal sebelum menggunakan kuantizer. requires_calibration (bool): Apakah metode kuantisasi memerlukan kalibrasi model sebelum digunakan.

adjust_max_memory[[diffusers.DiffusersQuantizer.adjust_max_memory]]

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

Sumber

sesuaikan argumen max_memory untuk infer_auto_device_map() jika memori tambahan diperlukan untuk kuantisasi

adjust_target_dtype[[diffusers.DiffusersQuantizer.adjust_target_dtype]]

adjust_target_dtype(torch_dtype: torch.dtype)

Sumber

Parameter:

torch_dtype (torch.dtype, opsional) : torch_dtype yang digunakan untuk menghitung device_map.

Override metode ini jika Anda ingin menyesuaikan variabel target_dtype yang digunakan dalam from_pretrained untuk menghitung device_map dalam kasus device_map berupa str. Misalnya, untuk bitsandbytes kami memaksa target_dtype menjadi torch.int8 dan untuk 4-bit kami meneruskan enum kustom 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)

Sumber

memeriksa apakah komponen state_dict yang dimuat merupakan bagian dari param kuantisasi + beberapa validasi; hanya didefinisikan untuk metode kuantisasi yang memerlukan pembuatan parameter baru untuk kuantisasi.

check_quantized_param_shape[[diffusers.DiffusersQuantizer.check_quantized_param_shape]]

check_quantized_param_shape(*args, **kwargs)

Sumber

memeriksa apakah parameter terkuantisasi memiliki bentuk yang diharapkan.

create_quantized_param[[diffusers.DiffusersQuantizer.create_quantized_param]]

create_quantized_param(*args, **kwargs)

Sumber

mengambil komponen yang diperlukan dari state_dict dan membuat param yang dikuantisasi.

dequantize[[diffusers.DiffusersQuantizer.dequantize]]

dequantize(model)

Sumber

Potensi untuk mendekuantisasi model guna mengambil model asli, dengan sedikit penurunan akurasi / kinerja. Perhatikan bahwa tidak semua skema kuantisasi mendukung ini.

get_cuda_warm_up_factor[[diffusers.DiffusersQuantizer.get_cuda_warm_up_factor]]

get_cuda_warm_up_factor()

Sumber

Faktor yang digunakan dalam caching_allocator_warmup untuk mendapatkan jumlah byte yang akan dialokasikan sebelumnya guna pemanasan cuda. Faktor 2 berarti kita mengalokasikan semua byte dalam model kosong (karena kita mengalokasikan dalam fp16), faktor 4 berarti kita mengalokasikan setengah memori dari bobot yang berada dalam model kosong, dan seterusnya...

get_special_dtypes_update[[diffusers.DiffusersQuantizer.get_special_dtypes_update]]

get_special_dtypes_update(model, torch_dtype: torch.dtype)

Sumber

Parameter:

model (~diffusers.models.modeling_utils.ModelMixin) : Model yang akan dikuantisasi

torch_dtype (torch.dtype) : dtype yang diteruskan ke metode from_pretrained.

mengembalikan dtypes untuk modul yang tidak dikuantisasi - digunakan untuk perhitungan device_map dalam kasus di mana str dilewatkan sebagai device_map. Metode ini akan menggunakan modules_to_not_convert yang dimodifikasi di _process_model_before_weight_loading. Model diffusers belum memiliki atribut modules_to_not_convert tetapi ini bisa berubah segera di masa depan.

postprocess_model[[diffusers.DiffusersQuantizer.postprocess_model]]

postprocess_model(model: ModelMixin, **kwargs)

Sumber

Parameter:

model (~diffusers.models.modeling_utils.ModelMixin) : Model yang akan dikuantisasi

kwargs (dict, opsional) : Argumen kata kunci yang diteruskan ke _process_model_after_weight_loading.

Lakukan proses pascapemrosesan model setelah pemuatan bobot. Pastikan untuk menimpa metode abstrak _process_model_after_weight_loading.

preprocess_model[[diffusers.DiffusersQuantizer.preprocess_model]]

preprocess_model(model: ModelMixin, **kwargs)

Sumber

Parameter:

model (~diffusers.models.modeling_utils.ModelMixin) : Model yang akan dikuantisasi

kwargs (dict, opsional) : Argumen kata kunci yang diteruskan ke _process_model_before_weight_loading.

Mengatur atribut model dan/atau mengonversi model sebelum pemuatan bobot. Pada titik ini, model harus diinisialisasi pada perangkat meta sehingga Anda dapat dengan bebas memanipulasi kerangka model untuk mengganti modul secara in-place. Pastikan untuk menimpa metode abstrak _process_model_before_weight_loading.

update_device_map[[diffusers.DiffusersQuantizer.update_device_map]]

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

Sumber

Parameter:

device_map (dict | str, opsional) : device_map yang diteruskan melalui metode from_pretrained.

Override metode ini jika Anda ingin mengganti device map yang ada dengan yang baru. Misalnya, untuk bitsandbytes, karena accelerate adalah persyaratan wajib, jika tidak ada device_map yang di-pass, maka device_map akan diset ke `"auto"``

update_missing_keys[[diffusers.DiffusersQuantizer.update_missing_keys]]

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

Sumber

Parameter:

missing_keys (list[str], opsional) : Daftar kunci yang hilang di checkpoint dibandingkan dengan state dict dari model

Override metode ini jika Anda ingin menyesuaikan missing_keys.

update_torch_dtype[[diffusers.DiffusersQuantizer.update_torch_dtype]]

update_torch_dtype(torch_dtype: torch.dtype)

Sumber

Parameter:

torch_dtype (torch.dtype) : dtype input yang diteruskan dalam from_pretrained

Beberapa metode kuantisasi memerlukan pengaturan dtype model secara eksplisit ke dtype target. Anda perlu menimpa metode ini jika ingin memastikan perilaku tersebut tetap terjaga

validate_environment[[diffusers.DiffusersQuantizer.validate_environment]]

validate_environment(*args, **kwargs)

Sumber

Metode ini digunakan untuk memeriksa potensi konflik dengan argumen yang diteruskan dalam from_pretrained. Anda perlu mendefinisikannya untuk semua kuantizer masa depan yang diintegrasikan dengan diffusers. Jika tidak ada pemeriksaan eksplisit yang diperlukan, cukup kembalikan apa pun.