Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /tr /api /quantization.md
mishig
about 21 hours ago
preview code
download
raw
27.2 kB
# Kantizasyon

Kantizasyon teknikleri, ağırlıkları ve aktivasyonları 8-bit tamsayılar (int8) gibi daha düşük hassasiyetli veri türleriyle temsil ederek bellek ve hesaplama maliyetlerini azaltır. Bu, normalde belleğe sığdıramayacağınız daha büyük modelleri yüklemenizi ve çıkarımı hızlandırmanızı sağlar.

> [!TIP]
> [Kantizasyon](../quantization/overview) kılavuzunda modelleri nasıl kantize edeceğinizi öğrenin.

## PipelineQuantizationConfig[[diffusers.PipelineQuantizationConfig]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/pipe_quant_config.py#L34)

**Parametreler:**

quant_backend (`str`) : Kullanılacak kuantizasyon arka ucu. Bu seçenek kullanıldığında, arka ucun hem `diffusers` hem de `transformers` için kullanılabilir olduğu varsayılır.
quant_kwargs (`dict`) : Kuantizasyon arka uç sınıfını başlatmak için parametreler.

components_to_quantize (`list`) : Kuantize edilecek bir pipeline'ın bileşenleri.

quant_mapping (`dict`) : Pipeline bileşenleri için kullanılacak kuantizasyon özelliklerini tanımlayan eşleme. Bu argüman kullanıldığında, kullanıcıların `quant_backend`, `quant_kawargs` ve `components_to_quantize` değerlerini sağlaması beklenmez.
[from_pretrained()](/docs/diffusers/main/tr/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained) uygulaması sırasında anlık olarak (on-the-fly) nicelleştirme (quantization) uygulanırken kullanılacak yapılandırma sınıfı.
## BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]
#### diffusers.BFLQuantizationConfig[[diffusers.BFLQuantizationConfig]]
```python
diffusers.BFLQuantizationConfig(compute_dtype: 'torch.dtype' | None = None)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L436)
**Parametreler:**
compute_dtype (`torch.dtype`, varsayılan olarak `torch.bfloat16`) : Aktivasyonların ve kuantize edilmemiş katmanların dtype'ı. Füzyonlu FP8 veya NVFP4 çekirdekleri olmayan cihazlar, her ileri geçişte ağırlıkları bu dtype'a dekuantize eder.
Black Forest Labs tarafından `fp8r` ve `nvfp4` şemalarıyla nicelenmiş kontrol noktalarının yüklenmesi için yapılandırma.
Her iki şema da `~FromSingleFileMixin.from_single_file` üzerinden checkpoint'ten okunur; modelin anlık olarak kuantize edilmesi desteklenmez. Bir lineer katman, ağırlığı ölçek tensörleriyle birlikte geldiğinde kuantize edilir:
- `fp8r`: `weight`, `float8_e4m3fn` tipinde ve `[N, K]` boyutundadır; `weight_scale` ise satır başına fp32 ölçeklendirme faktörüdür, boyutu `[N]`'dur.
- `nvfp4`: `weight`, `uint8` tipinde ve `[N, K/2]` boyutludur (bayt başına iki E2M1 değeri), `weight_scale` bir `float8_e4m3fn` blok ölçeğidir ve boyutu `[N, K/16]`'dır, `weight_scale_2` ve `input_scale` ise küresel ağırlık ölçeğini ve kalibre edilmiş aktivasyon ölçeğini tutan fp32 skalerleridir (ModelOpt NVFP4 yerleşimi).
## BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]
#### diffusers.BitsAndBytesConfig[[diffusers.BitsAndBytesConfig]]
```python
diffusers.BitsAndBytesConfig(load_in_8bit = False, load_in_4bit = False, llm_int8_threshold = 6.0, llm_int8_skip_modules = None, llm_int8_enable_fp32_cpu_offload = False, llm_int8_has_fp16_weight = False, bnb_4bit_compute_dtype = None, bnb_4bit_quant_type = 'fp4', bnb_4bit_use_double_quant = False, bnb_4bit_quant_storage = None, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L173)
**Parametreler:**
load_in_8bit (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu bayrak, LLM.int8() ile 8-bit kuantizasyonu etkinleştirmek için kullanılır.
load_in_4bit (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu bayrak, `bitsandbytes` kütüphanesinden FP4/NF4 katmanlarıyla Linear katmanlarını değiştirerek 4-bit kuantizasyonu etkinleştirmek için kullanılır.
llm_int8_threshold (`float`, *isteğe bağlı*, varsayılan 6.0) : Bu, `LLM.int8() : 8-bit Matrix Multiplication for Transformers at Scale` makalesinde açıklandığı üzere aykırı değer tespiti için aykırı değer eşiğine karşılık gelir: https://huggingface.co/papers/2208.07339 Bu eşiğin üzerindeki herhangi bir gizli durum değeri aykırı değer olarak kabul edilir ve bu değerler üzerindeki işlem fp16 ile yapılır. Değerler genellikle normal dağılıma sahiptir, yani çoğu değer [-3.5, 3.5] aralığındadır, ancak büyük modellerde çok farklı dağılan bazı istisnai sistematik aykırı değerler vardır. Bu aykırı değerler genellikle [-60, -6] veya [6, 60] aralığındadır. Int8 kuantizasyonu ~5 büyüklüğündeki değerler için iyi çalışır, ancak bunun ötesinde önemli bir performans cezası vardır. İyi bir varsayılan eşik 6'dır, ancak daha az kararlı modeller (küçük modeller, ince ayar) için daha düşük bir eşik gerekebilir.
llm_int8_skip_modules (`list[str]`, *isteğe bağlı*) : 8-bit'e dönüştürmek istemediğimiz modüllerin açık bir listesi. Bu, Jukebox gibi farklı konumlarda birden fazla başa sahip olan ve bunların son konumda bulunmadığı modeller için faydalıdır. Örneğin `CausalLM` modellerinde, son `lm_head` genellikle orijinal `dtype`'inde tutulur.

llm_int8_enable_fp32_cpu_offload (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu bayrak, gelişmiş kullanım senaryoları ve bu özelliğin farkında olan kullanıcılar için kullanılır. Modelinizi farklı parçalara ayırıp bazı parçaları GPU'da int8, bazı parçaları CPU'da fp32 olarak çalıştırmak istiyorsanız bu bayrağı kullanabilirsiniz. Bu, `google/flan-t5-xxl` gibi büyük modelleri dışa aktarmak (offload) için faydalıdır. Not: int8 işlemleri CPU'da çalıştırılmaz.
llm_int8_has_fp16_weight (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu bayrak, LLM.int8() işlevini 16 bit ana ağırlıklarla çalıştırır. Bu, geriye yayılım için ağırlıkların ileri geri dönüştürülmesine gerek kalmadığından ince ayar için faydalıdır.
bnb_4bit_compute_dtype (`torch.dtype` veya str, *isteğe bağlı*, varsayılan `torch.float32`) : Bu, giriş türünden farklı olabilecek hesaplama türünü ayarlar. Örneğin, girdiler fp32 olabilir, ancak hızlandırma için hesaplama bf16 olarak ayarlanabilir.

bnb_4bit_quant_type (`str`,  *isteğe bağlı*, varsayılan `"fp4"`) : Bu, bnb.nn.Linear4Bit katmanlarındaki kuantizasyon veri türünü ayarlar. Seçenekler, `fp4` veya `nf4` ile belirtilen FP4 ve NF4 veri türleridir.
bnb_4bit_use_double_quant (`bool`, *isteğe bağlı*, varsayılan `False`) : Bu bayrak, ilk kuantizasyondan gelen kuantizasyon sabitlerinin yeniden kuantize edildiği iç içe kuantizasyon için kullanılır.
bnb_4bit_quant_storage (`torch.dtype` veya str, *isteğe bağlı*, varsayılan `torch.uint8`) : Bu, kuantize edilmiş 4-bit parametreleri paketlemek için depolama türünü ayarlar.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : Yapılandırma nesnesinin başlatılacağı ek parametreler.

`bitsandbytes` kullanılarak yüklenmiş bir modelde oynayabileceğiniz tüm olası öznitelikler ve özellikler hakkında bir sarmalayıcı sınıfıdır.

Bu, `load_in_8bit` veya `load_in_4bit` yerine geçer; bu nedenle her iki seçenek de birbirini dışlar.

Şu anda yalnızca `LLM.int8()`, `FP4` ve `NF4` kuantizasyonunu destekler. `bitsandbytes` kütüphanesine daha fazla yöntem eklenirse, bu sınıfa da daha fazla argüman eklenir.

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

```python
is_quantizable()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L352)

Model kuantize edilebilirse `True`, aksi halde `False` döndürür.

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

```python
post_init()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L315)

Argümanların doğru olduğunu kontrol eden güvenlik denetleyicisi - bazı NoneType argümanlarını da varsayılan değerleriyle değiştirir.

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

```python
quantization_method()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L358)

Bu yöntem, model için kullanılan kuantizasyon yöntemini döndürür. Model kuantize edilemezse `None` döndürür.

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

```python
to_diff_dict()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L389)

**Dönüş:** `dict[str, Any]`

Bu yapılandırma örneğini oluşturan tüm özniteliklerin sözlüğü,

Daha iyi okunabilirlik için config'ten varsayılan config özniteliklerine karşılık gelen tüm öznitelikleri kaldırır ve bir Python sözlüğüne seri hale getirir.

## GGUFQuantizationConfig[[diffusers.GGUFQuantizationConfig]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L413)

**Parametreler:**

compute_dtype : (`torch.dtype`, varsayılan `torch.float32`): Bu, giriş türünden farklı olabilecek hesaplama türünü ayarlar. Örneğin, girdiler fp32 olabilir, ancak hızlandırma için hesaplama bf16 olarak ayarlanabilir.
Bu, GGUF Kuantizasyon teknikleri için bir yapılandırma sınıfıdır.
## NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]
#### diffusers.NunchakuLiteQuantizationConfig[[diffusers.NunchakuLiteQuantizationConfig]]
```python
diffusers.NunchakuLiteQuantizationConfig(compute_dtype: 'torch.dtype' | str | None = None, svdq_w4a4: dict[str, Any] | None = None, awq_w4a16: dict[str, Any] | None = None, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L460)
**Parametreler:**

compute_dtype (`torch.dtype`, varsayılan olarak `torch.bfloat16`) : Kuantize modüllerdeki kayan noktalı tamponlar tarafından kullanılan çalışma zamanı dtype.
svdq_w4a4 (`dict`, *isteğe bağlı*) : `precision`, `group_size`, `rank` ve `targets` içeren açık SVDQ W4A4 hedef yapılandırması.

awq_w4a16 (`dict`, *isteğe bağlı*) : `precision`, `group_size` ve `targets` içeren açık AWQ W4A16 hedef yapılandırması.

Nunchaku Lite kontrol noktalarının yüklenmesi için yapılandırma.

Diffusers'taki Nunchaku Lite desteği, önceden kantize edilmiş checkpoint'leri yükler. Uyumlu bir checkpoint oluşturmak için [`diffuse-compressor`](https://github.com/rootonchair/diffuse-compressor) aracını kullanarak model mimarisi için bir hedef yapılandırma seçin veya uyarlayın, transformer'ı kantize edin ve dışa aktarın, ardından kompakt `quantization_config` değerini `config.json` içinde saklayan bir Diffusers pipeline olarak paketleyin.

Dışa aktarılan state dict, hedef Diffusers model mimarisiyle tam olarak eşleşmelidir. Füzyonlu QKV projeksiyonları ile kuantize edilmiş checkpoint'ler, ayrı Q, K ve V projeksiyon modülleri bekleyen bir model yapılandırmasına yüklenemez.

Örnek kompakt `config.json` yapılandırması:

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

## QuantoConfig[[diffusers.QuantoConfig]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L676)

**Parametreler:**

weights_dtype (`str`, *isteğe bağlı*, varsayılan `"int8"`) : Kuantizasyon sonrası ağırlıklar için hedef dtype. Desteklenen değerler ("float8","int8","int4","int2")
`quanto` kullanılarak yüklenmiş bir modelle oynayabileceğiniz tüm olası öznitelikler ve özellikler hakkında bir sarmalayıcı sınıfıdır.
`QuantoConfig` kullanımdan kaldırılmıştır ve 1.0.0 sürümünde kaldırılacaktır. [BitsAndBytesConfig](/docs/diffusers/main/tr/api/quantization#diffusers.BitsAndBytesConfig) veya [TorchAoConfig](/docs/diffusers/main/tr/api/quantization#diffusers.TorchAoConfig) gibi diğer desteklenen nicelleştirme (quantization) altyapılarından birine geçmeyi düşünün.
modules_to_not_convert (`list`, *isteğe bağlı*, varsayılan `None`): Kuantize edilmeyecek modüllerin listesi, bazı modüllerin orijinal hassasiyetlerinde bırakılmasını açıkça gerektiren modellerin kuantize edilmesi için faydalıdır (ör. Whisper encoder, Llava encoder, Mixtral gate katmanları).

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

```python
post_init()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L710)

Argümanların doğru olduğunu kontrol eden güvenlik denetleyicisi

## SDNQConfig[[diffusers.SDNQConfig]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L988)

**Parametreler:**

weights_dtype (`str`, *isteğe bağlı*, varsayılan `"int8"`) : Kuantizasyon sonrası ağırlıkların hedef veri türü, örn. `"int8"`, `"uint4"`, `"float8_e4m3fn"`. Desteklenen tüm değerler için `sdnq.common.accepted_weight_dtypes` dosyasına bakın.

group_size (`int`, *isteğe bağlı*, varsayılan `0`) : Bir tensörün kaç elemanının aynı kuantizasyon grubunu paylaştığı. `0`, `weights_dtype` değerine göre otomatik seçim yapar; `-1` gruplamayı devre dışı bırakır ve satır bazlı kuantizasyon kullanır.

use_svd (`bool`, *isteğe bağlı*, varsayılan `False`) : SDNQ kuantizasyonu üzerine SVDQuant algoritmasının uygulanıp uygulanmayacağı.
use_quantized_matmul (`bool`, *isteğe bağlı*, varsayılan `False`) : BF16 / FP16 yerine ileri geçişte kuantize edilmiş INT8 / FP8 / FP16 matmul kullanılıp kullanılmayacağı.
modules_to_not_convert (`list`, *isteğe bağlı*, varsayılan `None`) : Kuantizasyon sırasında atlanacak modüllerin listesi.

kwargs (`dict[str, Any]`, *isteğe bağlı*) : `sdnq.SDNQConfig`'ye (ör. `quantized_matmul_dtype`, `svd_rank`, `use_hadamard`, `quant_conv`, `quant_embedding`, `modules_dtype_dict`) iletilen ek anahtar kelime argümanları.

SDNQ (SD.Next Quantization) için yapılandırma sınıfı.

`sdnq` kütüphanesi, kendi diffusers uyumlu yapılandırmasını ve nicelendiricisini içerir; bu sınıf, `quant_method="sdnq"` kontrol noktalarının diffusers ile yerel olarak yüklenmesini sağlamak üzere onlara ertelenen ince bir fabrikadır. Tüm argümanlar `sdnq.SDNQConfig` sınıfına iletilir. `sdnq` kütüphanesi gereklidir: `pip install sdnq`.

Referans: https://github.com/Disty0/sdnq

## TorchAoConfig[[diffusers.TorchAoConfig]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L581)

**Parametreler:**

quant_type (`AOBaseConfig`) : Kuantizasyon türünü belirten bir `AOBaseConfig` alt sınıfı örneği. Kullanılabilir yapılandırma sınıfları için [torchao belgelerini](https://docs.pytorch.org/ao/main/api_ref_quantization.html#inference-apis-for-quantize) inceleyin (ör. `Int4WeightOnlyConfig`, `Int8WeightOnlyConfig`, `Float8WeightOnlyConfig`, `Float8DynamicActivationFloat8WeightConfig` vb.).
modules_to_not_convert (`list[str]`, *isteğe bağlı*, varsayılan `None`) : Kuantize edilmeyecek modüllerin listesi, bazı modüllerin orijinal hassasiyetlerinde bırakılmasını açıkça gerektiren modelleri kuantize etmek için kullanışlıdır.

Bu, torchao kuantizasyon/sıralama teknikleri için bir yapılandırma sınıfıdır.

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

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L644)

Sözlükten yapılandırma oluşturun.

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

```python
get_apply_tensor_subclass()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L666)

Yapılandırmaya dayalı uygun kuantizasyon yöntemini oluşturun.

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

```python
to_dict()
```

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/quantization_config.py#L630)

Yapılandırmayı sözlüğe dönüştürür.

## DiffusersQuantizer[[diffusers.DiffusersQuantizer]]

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L34)

HuggingFace quantizer'ının soyut sınıfı. Şu anda, çıkarım ve/veya kuantizasyon için HF diffusers modellerini kuantize etmeyi destekler. Bu sınıf yalnızca diffusers.models.modeling_utils.ModelMixin.from_pretrained tarafından kullanılır ve henüz o yöntemin kapsamı dışında kolayca kullanılamaz.

Attributes quantization_config (`diffusers.quantizers.quantization_config.QuantizationConfigMixin`): Modelinizi kuantize etmek istediğiniz kuantizasyon parametrelerini tanımlayan kuantizasyon yapılandırması. modules_to_not_convert (`list[str]`, *isteğe bağlı*): Model kuantize edilirken dönüştürülmemesi gereken modül adlarının listesi. required_packages (`list[str]`, *isteğe bağlı*): Kuantizatör kullanılmadan önce kurulması gereken pip paketlerinin listesi. requires_calibration (`bool`): Kuantizasyon yönteminin kullanılmadan önce modelin kalibre edilmesini gerektirip gerektirmediği.

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L133)

Ekstra belleğe ihtiyaç duyuluyorsa infer_auto_device_map() için max_memory argümanını ayarlayın

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L91)

**Parametreler:**

torch_dtype (`torch.dtype`, *isteğe bağlı*) : device_map'in hesaplanmasında kullanılan torch_dtype.
`from_pretrained` içinde, device_map bir `str` olduğunda device_map'i hesaplamak için kullanılan `target_dtype` değişkenini ayarlamak istiyorsanız bu yöntemi geçersiz kılın. Örneğin, bitsandbytes için `target_dtype` değerini `torch.int8` olarak zorunlu ayarlıyoruz ve 4-bit için özel bir enum olan `accelerate.CustomDtype.int4` geçiriyoruz.

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L137)

Yüklenen state_dict bileşeninin, kuantize parametrenin bir parçası olup olmadığını kontrol eder ve bazı doğrulamalar yapar; yalnızca kuantizasyon için yeni parametreler oluşturmayı gerektiren kuantizasyon yöntemleri için tanımlıdır.
#### check_quantized_param_shape[[diffusers.DiffusersQuantizer.check_quantized_param_shape]]
```python
check_quantized_param_shape(*args, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L157)
kuantize edilmiş parametrenin beklenen şekle sahip olup olmadığını kontrol eder.
#### create_quantized_param[[diffusers.DiffusersQuantizer.create_quantized_param]]
```python
create_quantized_param(*args, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L151)
state_dict'ten gerekli bileşenleri alır ve quantize edilmiş parametreyi oluşturur.
#### dequantize[[diffusers.DiffusersQuantizer.dequantize]]
```python
dequantize(model)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L219)
Modeli orijinal modelini geri almak için potansiyel olarak dekuantize edin; bu işlemde doğruluk / performans kaybı yaşanabilir. Dikkat edin, tüm kuantizasyon şemaları bunu desteklemez.
#### get_cuda_warm_up_factor[[diffusers.DiffusersQuantizer.get_cuda_warm_up_factor]]
```python
get_cuda_warm_up_factor()
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L232)
`caching_allocator_warmup` içinde cuda'yı ısıtmak için önceden ayırtılacak bayt sayısını elde etmek için kullanılacak çarpan. 2 çarpanı, boş modeldeki tüm baytların ayrıldığını (fp16'da ayırma yapıldığı için) ifade eder; 4 çarpanı, boş modelde bulunan ağırlıkların yarısı kadar belleğin ayrıldığını vb. ifade eder.
#### get_special_dtypes_update[[diffusers.DiffusersQuantizer.get_special_dtypes_update]]
```python
get_special_dtypes_update(model, torch_dtype: torch.dtype)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L113)
**Parametreler:**
model (`~diffusers.models.modeling_utils.ModelMixin`) : Kuantize edilecek model
torch_dtype (`torch.dtype`) : `from_pretrained` metoduna geçirilen dtype.
kuantize edilmemiş modüller için dtypes döndürür - bir str, device_map olarak geçirildiğinde device_map'in hesaplanması için kullanılır. Yöntem, `_process_model_before_weight_loading` içinde değiştirilen `modules_to_not_convert`'i kullanır. `diffusers` modellerinde henüz herhangi bir `modules_to_not_convert` özniteliği yoktur ancak bu, gelecekte yakında değişebilir.
#### postprocess_model[[diffusers.DiffusersQuantizer.postprocess_model]]
```python
postprocess_model(model: ModelMixin, **kwargs)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L206)
**Parametreler:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Kuantize edilecek model

kwargs (`dict`, *isteğe bağlı*) : `_process_model_after_weight_loading` ile birlikte iletilen anahtar kelime argümanları.

Ağırlıkların yüklenmesinin ardından modeli son işlemeye (post-process) tabi tutun. Soyut `_process_model_after_weight_loading` metodunu geçersiz kıldığınızdan emin olun.

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L190)

**Parametreler:**

model (`~diffusers.models.modeling_utils.ModelMixin`) : Kuantize edilecek model

kwargs (`dict`, *isteğe bağlı*) : `_process_model_before_weight_loading` ile birlikte iletilen anahtar kelime argümanları.

Ağırlıkların yüklenmesinden önce model özniteliklerini ayarlamak ve/veya modeli dönüştürmek. Bu noktada modelin meta cihazda başlatılmış olması gerekir; böylece modülleri yerinde değiştirmek için modelin iskeletini serbestçe manipüle edebilirsiniz. Soyut `_process_model_before_weight_loading` metodunu geçersiz kılmayı unutmayın.

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L79)

**Parametreler:**

device_map (`dict | str`, *isteğe bağlı*) : `from_pretrained` yöntemi üzerinden geçirilen device_map.
Mevcut cihaz haritasını yeni bir harita ile geçersiz kılmak istiyorsanız bu yöntemi geçersiz kılın. Örneğin, `accelerate` zorunlu bir gereksinim olduğu için, bitsandbytes için bir device_map geçirilmezse, device_map `"auto"` olarak ayarlanır.
#### update_missing_keys[[diffusers.DiffusersQuantizer.update_missing_keys]]
```python
update_missing_keys(model, missing_keys: list, prefix: str)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L103)
**Parametreler:**
missing_keys (`list[str]`, *isteğe bağlı*) : Modelin state dict'ine kıyasla checkpoint'te eksik olan anahtarların listesi
`missing_keys` değerlerini ayarlamak istiyorsanız bu yöntemi geçersiz kılın.
#### update_torch_dtype[[diffusers.DiffusersQuantizer.update_torch_dtype]]
```python
update_torch_dtype(torch_dtype: torch.dtype)
```
[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L68)
**Parametreler:**
torch_dtype (`torch.dtype`) : `from_pretrained` içine geçirilen girdi dtype'ı

Bazı kuantizasyon yöntemleri, modelin dtype değerinin hedef dtype olarak açıkça ayarlanmasını gerektirir. Bu davranışın korunmasını sağlamak istiyorsanız bu yöntemi geçersiz kılmanız gerekir

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

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

[Kaynak](https://github.com/huggingface/diffusers/blob/main/src/diffusers/quantizers/base.py#L163)

Bu yöntem, `from_pretrained` ile geçirilen argümanlarla olası çakışmaları kontrol etmek için kullanılır. diffusers ile entegre edilecek tüm gelecekteki kuantizörler için bunu tanımlamanız gerekir. Açık bir kontrol gerekmiyorsa, hiçbir şey döndürmeyin.
Xet Storage Details

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