# GPTQ

[GPT-QModel](https://github.com/ModelCloud/GPTQModel) projesi (Python paketi `gptqmodel`), GPTQ algoritmasını uygular. Bu, eğitim sonrası bir kuantizasyon tekniğidir ve ağırlık matrisinin her satırı, hatayı en aza indiren bir ağırlık sürümünü bulmak için bağımsız olarak kuantize edilir. Bu ağırlıklar int4'e kuantize edilir, ancak çıkarım sırasında anlık olarak fp16'ya geri yüklenir. Bu, int4 ağırlıkların GPU'nun küresel belleğinde değil, birleştirilmiş (fused) bir çekirdekte kuantizasyonunun kaldırılması (dequantize) sayesinde bellek kullanımını 4 katına kadar azaltabilir. Daha düşük bit genişliğinin iletişim için daha az zaman alması nedeniyle çıkarım da daha hızlıdır.

AutoGPTQ, Transformers tarafından artık desteklenmemektedir. Bunun yerine GPT-QModel yükleyin.

Önce Accelerate, Transformers ve Optimum'u yükleyin.

```bash
pip install --upgrade accelerate optimum transformers
```

Ardından GPT-QModel'i yüklemek için aşağıdaki komutu çalıştırın.

```bash
pip install gptqmodel --no-build-isolation
```

[GPTQConfig](/docs/transformers/main/tr/main_classes/quantization#transformers.GPTQConfig) sınıfı oluşturun ve kuantizasyon için bit sayısını, ağırlıkları kuantize etmek için kalibrasyon yapılacak veri setini ve veri setini hazırlamak için bir tokenizer belirleyin.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
gptq_config = GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer)
```

Kendi veri setinizi bir dize listesi olarak iletebilirsiniz, ancak GPTQ makalesindeki aynı veri setini kullanmanız şiddetle önerilir.

```py
dataset = ["gptqmodel is an easy-to-use model quantization library with user-friendly apis, based on the GPTQ algorithm."]
gptq_config = GPTQConfig(bits=4, dataset=dataset, tokenizer=tokenizer)
```

Kantizasyon için bir model yükleyin ve [GPTQConfig](/docs/transformers/main/tr/main_classes/quantization#transformers.GPTQConfig) nesnesini [from_pretrained()](/docs/transformers/main/tr/model_doc/auto#transformers.AutoModel.from_pretrained) fonksiyonuna iletin. Modelin belleğe sığmasına yardımcı olmak için modeli otomatik olarak CPU'ya taşımak ve kantizasyon sırasında model modüllerinin CPU ile GPU arasında taşınmasına izin vermek için `device_map="auto"` parametresini ayarlayın.

```py
quantized_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", device_map="auto", quantization_config=gptq_config)
```

Bir veri seti çok büyük olduğu için bellek yetersizliği yaşıyorsanız (disk offload desteklenmez), cihazınızda (GPU ve CPU) kullanılacak bellek miktarını ayarlamak için `max_memory` parametresini iletmeyi deneyin.

```py
quantized_model = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-125m",
    device_map="auto",
    max_memory={0: "30GiB", 1: "46GiB", "cpu": "30GiB"},
    quantization_config=gptq_config
)
```

> [!WARNING]
> Donanımınıza bağlı olarak, bir modeli sıfırdan kuantize etmek biraz zaman alabilir. [facebook/opt-350m](https://huggingface.co/facebook/opt-350m) modelini ücretsiz katmandaki bir Google Colab GPU'sunda kuantize etmek yaklaşık 5 dakika sürse de, 175B parametreli bir modeli NVIDIA A100 üzerinde kuantize etmek yaklaşık 4 saat sürer. Bir modeli kuantize etmeden önce, Hub'da modelin GPTQ-kuantize edilmiş bir sürümünün zaten var olup olmadığını kontrol etmek iyi bir fikirdir.

Bir model kuantize edildikten sonra, modeli ve tokenizer'ı Hub'a göndermek ve orada kolayca paylaşılabilir ve erişilebilir hale getirmek için [push_to_hub()](/docs/transformers/main/tr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) işlevini kullanabilirsiniz. Bu işlem [GPTQConfig](/docs/transformers/main/tr/main_classes/quantization#transformers.GPTQConfig) nesnesini de kaydeder.

```py
quantized_model.push_to_hub("opt-125m-gptq")
tokenizer.push_to_hub("opt-125m-gptq")
```

[save_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) kuantize edilmiş modeli yerel olarak kaydeder. Model `device_map` parametresiyle kuantize edildiyse, kaydetmeden önce tüm modeli bir GPU'ya veya CPU'ya taşıdığınızdan emin olun. Aşağıdaki örnek, modeli CPU üzerinde kaydeder.

```py
quantized_model.save_pretrained("opt-125m-gptq")
tokenizer.save_pretrained("opt-125m-gptq")

# if quantized with device_map set
quantized_model.to("cpu")
quantized_model.save_pretrained("opt-125m-gptq")
```

[from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) ile bir kuantize modeli yeniden yükleyin ve modelin, ihtiyaç duyulanından daha fazla bellek kullanmadan daha hızlı yüklenmesi için modelin tüm kullanılabilir GPU'lara otomatik olarak dağıtılmasını sağlamak üzere `device_map="auto"` ayarlayın.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto")
```

## Marlin

[Marlin](https://github.com/IST-DASLab/marlin), yalnızca 4-bit CUDA GPTQ çekirdeğidir ve NVIDIA A100 GPU (Ampere) mimarisi için yüksek düzeyde optimize edilmiştir. Yükleme, dekuantizasyon ve dekuantize edilmiş ağırlıkların çalıştırılması yüksek düzeyde paralelleştirilmiştir; bu da orijinal CUDA GPTQ çekirdeğine kıyasla önemli bir çıkarım (inference) iyileşmesi sağlar. Marlin yalnızca kuantize edilmiş çıkarım için kullanılabilir ve model kuantizasyonunu desteklemez.

Marlin çıkarımı, [GPTQConfig](/docs/transformers/main/tr/main_classes/quantization#transformers.GPTQConfig) içindeki `backend` parametresiyle etkinleştirilebilir.

```py

from transformers import AutoModelForCausalLM, GPTQConfig

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto", quantization_config=GPTQConfig(bits=4, backend="marlin"))
```

## GPT-QModel

GPT-QModel, Transformers içindeki GPTQ için aktif olarak sürdürülen arka uçtur. Başlangıçta AutoGPTQ'dan ayrılmış (fork) olup, daha sonra daha hızlı kuantizasyon, daha düşük bellek kullanımı ve daha doğru varsayılanlar gibi önemli iyileştirmelerle farklılaşmıştır.

GPT-QModel, simetrik kuantizasyona kıyasla kuantizasyon hatalarını potansiyel olarak düşürebilen asimetrik kuantizasyon sağlar. Eski AutoGPTQ checkpoint'leriyle geriye dönük uyumlu değildir ve tüm çekirdekler (Marlin) asimetrik kuantizasyonu desteklemez.

GPT-QModel, en son LLM modelleri, çok modlu modeller (Qwen2-VL ve Ovis1.6-VL), platformlar (Linux, macOS, Windows 11) ve donanımlar (AMD ROCm, Apple Silicon, Intel/AMD CPU'lar ve Intel Datacenter Max/Arc GPU'ları vb.) için daha geniş kapsamlı destek sunar.

Marlin çekirdekleri A100 GPU'lar için de güncellenmiştir ve diğer çekirdekler, eski modeller ile düzensiz giriş/çıkış özelliklerine sahip modeller için otomatik dolgu (auto-padding) içerecek şekilde güncellenmiştir.

## Kaynaklar

Pratik bir deneyim için PEFT [notebook](https://colab.research.google.com/drive/1_TIrmuKOFhuRRiTWN94iLKUFu6ZX4ceb?usp=sharing) ile GPTQ kuantizasyonunu çalıştırın.