# Quanto

> [!WARNING]
> Quanto arka ucu kullanımdan kaldırılmıştır ve 1.0.0 sürümünde kaldırılacaktır. [bitsandbytes](./bitsandbytes) veya [torchao](./torchao) gibi diğer desteklenen [kuantizasyon arka uçlarından](./overview) birine geçmeyi düşünün.

[Quanto](https://github.com/huggingface/optimum-quanto), [Optimum](https://huggingface.co/docs/optimum/en/index) için bir PyTorch kuantizasyon arka ucudur. Çok yönlülük ve sadelik göz önünde bulundurularak tasarlanmıştır:

- Tüm özellikler, acil modda (eager mode) kullanılabilir (izlenemeyen modellerle çalışır)
- Kuantizasyon farkındalıklı eğitimi destekler
- Kantize modeller `torch.compile` ile uyumludur
- Quantize edilmiş modeller cihazdan bağımsızdır (ör. CUDA, XPU, MPS, CPU)

Quanto arka ucunu kullanabilmek için öncelikle `optimum-quanto>=0.2.6` ve `accelerate` paketlerini yüklemeniz gerekir.

```shell
pip install optimum-quanto accelerate
```

Artık `QuantoConfig` nesnesini `from_pretrained()` metoduna geçirerek bir modeli kuantize edebilirsiniz. Quanto kütüphanesi `nn.Conv2d` ve `nn.LayerNorm` modüllerini kuantize etmeye izin verse de, Diffusers şu anda yalnızca bir modeldeki `nn.Linear` katmanlarındaki ağırlıkların kuantize edilmesini desteklemektedir. Aşağıdaki kod parçası, Quanto ile `float8` kuantizasyonunun nasıl uygulanacağını göstermektedir.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)

pipe = FluxPipeline.from_pretrained(model_id, transformer=transformer, dtype=dtype)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt, num_inference_steps=50, guidance_scale=4.5, max_sequence_length=512
).images[0]
image.save("output.png")
```

## Belirli modüllerde Kuantizasyonu Atlayın

`QuantoConfig` içindeki `modules_to_not_convert` argümanını kullanarak belirli modüller üzerinde kuantizasyon uygulamasını atlamak mümkündür. Lütfen bu argümana geçirilen modüllerin `state_dict` içindeki modüllerin anahtarlarıyla eşleştiğinden emin olun.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8", modules_to_not_convert=["proj_out"])
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
```

## Quanto Backend ile `from_single_file` kullanımı

`QuantoConfig`, `~FromOriginalModelMixin.from_single_file` ile uyumludur.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

ckpt_path = "https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/flux1-dev.safetensors"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_single_file(ckpt_path, quantization_config=quantization_config, dtype=torch.bfloat16)
```

## Kantize Edilmiş Modellerin Kaydedilmesi

Diffusers, `~ModelMixin.save_pretrained` yöntemi kullanılarak Quanto modellerini serialize etmeyi destekler.

Doğrudan Quanto kütüphanesiyle kuantize edilen modeller ile Diffusers kullanılarak Quanto arka uç olarak kullanılan modeller için seri hale getirme ve yükleme gereksinimleri farklıdır. Şu anda, doğrudan Quanto ile kuantize edilen modelleri `~ModelMixin.from_pretrained` kullanarak Diffusers'a yüklemek mümkün değildir.

```python
import torch
from diffusers import FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="float8")
transformer = FluxTransformer2DModel.from_pretrained(
      model_id,
      subfolder="transformer",
      quantization_config=quantization_config,
      dtype=torch.bfloat16,
)
# save quantized model to reuse
transformer.save_pretrained("<your quantized model save path>")

# you can reload your quantized model with
model = FluxTransformer2DModel.from_pretrained("<your quantized model save path>")
```

## Quanto ile `torch.compile` kullanımı

Şu anda Quanto arka ucu aşağıdaki kuantizasyon türleri için `torch.compile` desteklemektedir:

- `int8` ağırlıkları

```python
import torch
from diffusers import FluxPipeline, FluxTransformer2DModel, QuantoConfig

model_id = "black-forest-labs/FLUX.1-dev"
quantization_config = QuantoConfig(weights_dtype="int8")
transformer = FluxTransformer2DModel.from_pretrained(
    model_id,
    subfolder="transformer",
    quantization_config=quantization_config,
    dtype=torch.bfloat16,
)
transformer = torch.compile(transformer, mode="max-autotune", fullgraph=True)

pipe = FluxPipeline.from_pretrained(
    model_id, transformer=transformer, dtype=dtype
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"
images = pipe("A cat holding a sign that says hello").images[0]
images.save("flux-quanto-compile.png")
```

## Desteklenen Kuantizasyon Türleri

### Ağırlıklar

- float8
- int8
- int4
- int2