Nedir Bu Quantizaton?

Sayısal veri türleri: LLM’in içindeki her bir bireysel sayısal değeri temsil etmek için kullanılan bit sayısını ve formatını belirtir.

• Model Ağırlıkları (Weights): Bir LLM, nöronlar arasındaki bağlantıların gücünü temsil eden milyarlarca ağırlıktan oluşur. Her bir ağırlık, FP32, FP16, BF16 formatında bir sayıdır.
• Gömülmeler (Embeddings): Kelimelerin, cümlelerin veya belgelerin LLM tarafından anlaşılan sayısal temsilleri olan vektörlerdir. Bu vektörlerin her bir boyutu (elemanı) yine bu sayısal veri türlerinden biriyle ifade edilir. Örneğin, 768 boyutlu bir embedding vektörünün her bir 768 elemanı bir FP16 sayısı olabilir.

Detaylar için benim bu yazımı hazırlarken izlediğim eğitim videolarını izleyebilirsiniz: Eğitim Önerileri:

• Deeplearning.ai: Quantization Fundamentals with Hugging Face
• Deeplearning.ai: **Quantization in Depth**

İçindekliler:

1. Sayısal Veri Türleri
2. Quantization Nedir?
3. GPTQ Quantization Nedir?
4. “Fine-tuning” ve “GPTQ Quantization Train” Farkı Nedir?
5. Projeye Başlangıç: Modelimizin indirmek ve quantization için data hazırlama
6. Gerçekleştiriyoruz: GPTQ Quantization işlemi
7. Test Ediyoruz: Model test: Inference
8. Örnek: Google Colab Üzerinden Basit Bir GPTQ Quantization

1- Sayısal Veri Türleri:

Sayısal veri türleri: bilgisayarın sayıları nasıl temsil ettiğini ve sakladığını ifade eder.

Bazı sayısal veri türü çeşitleri:

• FP32 (Single-Precision Floating-Point)
• FP16 (Half-Precision Floating-Point)
• BF16 (BFloat16 — Brain Floating-Point)
• INT8 (8-bit Integer)
• INT4 (4-bit Integer)

işaret biti: sayının işareti (pozitif/negatif)

üs biti: sayının büyüklüğünü belirleyen, yani onu 2'nin kaçıncı kuvvetiyle çarpacağımızı gösterir.

mantis biti: sayının anlamlı basamaklarını (kesir kısmını) tutan kısımdır.

FP32 (Single-Precision Floating-Point): Sayıları temsil etmek için 32 bit kullanır. Bitlerin dağılımı:

• 1 bit: İşaret (pozitif/negatif)
• 8 bit: Üs (exponent) — sayının büyüklük mertebesini belirler.
• 23 bit: Mantis (kesir kısmı) — sayının hassasiyetini belirler.
• Aralık ±3.4 x 10³⁸ (10 üzeri 38)

FP16(Half-Precision Floating-Point):

• 1 bit: İşaret
• 8 bit: Üs (FP32 ile aynı!)
• 7 bit: Mantis
• Aralık: Aralık ±3.4 x 10³⁸ =FP32
• FP32 ile aynı dinamik aralığa sahiptir (yaklaşık ±3.4 x 10⁽³⁸⁾), ancak FP16'dan bile daha düşük hassasiyete (daha az mantis biti) sahiptir. 8 bit üs kullandığı için, FP32 ile yaklaşık olarak aynı büyüklük mertebesindeki sayıları temsil edebilir. Sadece 7 bit mantisa kullandığı için, FP32'ye kıyasla önemli ölçüde daha düşük hassasiyete sahiptir

INT8 (8-bit Integer):

• 1 bit: işaret
• 7 bit: Mantis
• Aralık: -128 ile +127 arasında

INT4 (4-bit Integer):

• 1 bit: işaret
• 3 bit: Mantis
• Aralık: -8 ile +7 arasında

2- Quantization Nedir?

Quantization (çeyrekleme diyebiliriz): yapay zeka modellerinin bellek ve işlem gücü tüketimini azaltmak için kullanılan bir teknik olup, ağırlıkları ve aktivasyonları daha düşük hassasiyetli veri tipleriyle ifade eder. like 8-bit integer (int8) instead of the usual 32-bit floating point (float32).

Bit sayısını azaltmak, ortaya çıkan modelin daha az bellek depolaması gerektirmesi, daha az enerji tüketmesi (teoride) ve matris çarpımı gibi işlemlerin tamsayı aritmetiğiyle çok daha hızlı gerçekleştirilebilmesi anlamına gelir.

Kısaca formül açıklaması: Afinne scheme = r = S * (q - Z)

r = float32 değeri

s = pozitif bir float 32 sayısı (işlem sırasında hesaplanır)

q = x(float32) değerinin int8 (”8” bit kullanılarak elde edilen “int” tam sayısı) karşılığıdır

z = bir int8 tam sayısıdır (float32’de (0,0) gelen değerin int8 deki karşılığıdır)

8bit’e Quantization:

Float32 den 8bit’e quantize işlemi birazcık karmaşık olabiliyor çünkü 8bit sadece 256 farklı değer alabiliyor. Fakat float32’de bu aralık daha fazla. Arkasında derin bir matematik yatıyor merak edenler için linkini ekledim.

Simetrik quantization:

Quantize edilecek aralığın simetrik olduğu varsayılır yani [-a,a] gibi. Yukarıda bulunan Z değerini sıfıra alır. Simetrik quantization kolaylık olarak işimize gelse de varsaydığımızdan ötürü 256 değerden birini kaybederiz

Quantization Example: FP32 to INT8

Dequantization Exmaple: INT8 to FP32

Compare original tensor and de-quantized tensor:

Neden Quantization’a İhtiyaç Duyuyoruz?

Quantization (Nicemleme), büyük yapay zeka modellerini daha küçük, daha hızlı ve daha verimli hale getirmek için kullanılan bir tekniktir.

1.Bellek Tüketimini Azaltmak (Ram/Vram)

• Büyük modeller genellikle FP32 formatında saklanır. Bu çok fazla bellek tüketir.

2.Daha Hızlı Çalışma (Inference Speed)

• INT8 işlemleri, FP32 işlemlerinden daha hızlıdır çünkü daha az hesaplama gerektirir.

3.Düşük Donanımlı Cihazlarda Çalıştırabilme

• FP32 model çalıştırmak için genellikle büyük GPU’lar gerekir.

4. Enerji Verimliliği

• Az bellek, az işlem → daha düşük enerji tüketimi.

Quantization yöntemleri

Linear Quantization:

• AWQ: Activation-aware Weight Quantization
• GPTQ: GPT Quantized
• BNB: BitsandBytes Quantization

Yakın Zamandaki En Gelişmiş Kuantizasyon Yöntemleri:

• LLM.INT8 (sadece 8 bit)
• QLoRA (sadece 4 bit)
• AWQ
• GPTQ
• SmoothQuant

3. GPTQ Quantization Nedir?

**GPTQ* = Generative Pre-trained Transformer Quantization (Üretici Ön-Eğitimli Dönüştürücü Çeyrekleme ya da Niceleme)*

ChatGPT = Chat Generative Pre-trained Transformer

Bu kısımdaki önemli noktalardan birisi “Pre-trained” ifadesi çünkü “pre-trained” yani ön-eğitimli demek aslında modelimizi önceden büyük genel bir veri ile eğitmiş olduğumuzu ve sonrasında eğitilen modelle GPTQ yöntemi ile quantization yapmamız gerektiğini açıklıyor. GPTQ yönteminde quantize ettikten sonra fine tune etmek daha karmaşıkmış.

Bu projede neden GPTQ Quantization yöntemini kullanmak istiyoruz:

Watsonx.ai ortamında çalıştırılmak istenilen bir proje gerçekleştirmek istedim. Bundan kaynaklı quantization yöntemimizde watsonx.ai’ın konfigürasyonlarına uygun olarak ilerlememiz gerekiyor.

Watsonx.ai Mixtral sürümü için GTPQ quantization tekniğini destekliyor. Bundan dolayı biz de mistral-large versiyonu için aynı sürümü desteklediğini düşünüyoruz. Bundan kaynaklı modelimizi GPTQ yöntemi ile quantize etmeye çalışacağız.

• Not: Mistral ve Mixtral LLM’leri aynı ekip tarafından oluşturulmuştur.

Watsonx.ai: IBM watsonx.ai, fikirlerinizi ve gereksinimlerinizi gerçeğe dönüştürmek için ihtiyaç duyduğunuz API’ler, araçlar, modeller ve çalışma zamanları koleksiyonuyla yapay zeka hizmetleri geliştirmek ve bunları seçtiğiniz uygulamalara dağıtmak için kurumsal düzeyde bir stüdyodur. Açık kaynak büyük dil modelleri (LLM) ile çalışmanı sağlar, kendi modellerini yükleyip özelleştirmeni veya IBM’in hazır modellerini kullanmanı sağlar.

Hedefimiz:

Ulaşmak istediğimiz nokta: Mistral-Large-2407-GPTQ-INT8

• Mistral-Large-2407: Modelin ismi
• GPTQ (Generalized Post-Training Quantization): Quantization yöntemi
• Generalize: farklı model mimarilerine daha genel bir şekilde uygulanabildiğini ifade eder.
• Post-Traning: Quantization işleminin modelin ana eğitimi tamamlandıktan sonra uygulandığını belirtir.
• Quantization: Modelin ağırlıklarının daha düşük bit hassasiyetine dönüştürülmesi işlemidir.
• INT8: Dönüştürmek istediğimiz değer yani 8-bit

4. “Fine-tuning” ve “GPTQ Quantization Train” Farkı Nedir?

Fine- tuning

Fine-tuning (ince ayar), önceden eğitilmiş büyük bir yapay zeka modelini (örneğin LLaMA, Mistral, GPT gibi) belirli bir görev veya veri kümesi için yeniden eğitme işlemidir.

Neden Yapılır?

Önceden eğitilmiş modeller, genel bilgileri kapsar. Ancak belirli bir iş için örneğin bankacılık işlemleri için yeterince uzmanlaşmamış olabilirler. Fine-tuning ile model, bu özel alandaki verilerle “alan bilgisi” kazanır ve konuya hakimiyeti artar.

• Büyük dil modeli = Genel kültürlü biri
• Fine-tuning = Bu kişiye özel bir konuda örneğin bankacılık konusunda eğitim vermek

Örnek olarak

• GPT modeli genel sohbet eder.
• Ama bankanın genel bilgileri ile özel verilerle fine-tune edilirse: Artık bankanın genel yapısı ve eğitildiği geri kalan bilgiler hakkında bilgi sahibi olmuş olur.

GPTQ Quantization’daki train ile fine-tuning arasındaki fark

Fine-tuning:

• Eğitim verisi: Genellikle etiketlenmiş veya özel amaçlı büyük bir veri kümesi kullanılır.
• Ağırlıklar güncellenir: Tüm (veya bazı) katmanların ağırlıkları güncellenir, bu da modeli yeni bilgiyle donatır.
• Yeniden eğitim var: Model, herhangi bir yeni görev veya hedef için yeniden eğitilir.
• Hedef: Modelin davranışını değiştirmek veya iyileştirmek.

GPTQ Quantization:

Bu tür yöntemlerde model zaten eğitilmiştir ve quantiation işlemi mevcut ağırlıklar üzerinde yapılır. Ancak, bu ağırlıkları sadece “rastgele” quantize etmek doğruluk kaybına neden olur. İşte burada istatistiksel analiz devreye girer.

• Eğitim verisi: GPTQ, genelde küçük bir veri seti üzerinde çalışır, ama bu “training” değildir. Bu veri sadece istatistik toplamak içindir.
• Ağırlıklar değişmez: Modelin ağırlıkları esasen değiştirilmez; sadece ağırlıkların düşük bitli (örn. 8-bit) temsili öğrenilir.
• Yeniden eğitme yok: Model, herhangi bir yeni görev veya hedef için yeniden eğitilmez.
• Hedef: Modelin doğruluğunu minimum kayıpla koruyarak düşük bitli hale getirmek.

Neden İstatistik Toplanıyor?

1. Katman çıkışlarını (activation) ve girişlerini analiz etmek.
2. Hangi ağırlıkların daha önemli olduğunu hesaplamak (örneğin Hessian matrisi veya loss eğilimleriyle).
3. Ağırlıkları önem sırasına göre kuantize etmek (önemli olanları daha hassas, önemsiz olanları daha kaba).
4. Bu sırada loss’un artmaması için gradient tabanlı optimizasyon ile küçük düzeltmeler yapmak (ama bu klasik eğitim değil).

Neden Bu Gerekli?

Eğer bu istatistiksel analiz yapılmazsa ve ağırlıklar doğrudan quantize edilirse, özellikle 4-bit gibi agresif kuantizasyonlar da:

• Modelin doğruluğu ciddi düşer (bazı durumlarda %20'ye kadar).
• Özellikle dil modellerinde anlam bütünlüğü bozulabilir.

5. Projeye Başlangıç: Modelimizi indirmek ve quantization için data hazırlamak:

İlk olarak ulaşmak istediğimiz hedefimizi hatırlayalım:

Hedefimiz:

Ulaşmak istediğimiz hedef: Mistral-Large-2407-GPTQ-INT8

Yapılacaklar:

1. Modelin indirilmesi
2. GPTQ Quantize işleminde train edilecek dataların hazırlanması
3. Quantization işlemi

Modelin indirilmesi:

Mistral-Large versiyonunu indirerek başlıyoruz. (Bu kısımda transformers ve huggingface_hub kütüphanesi ile bu işlemi yapacağız eğer bir problem çıkarsa dökümantasyonda bulunan “mistral_inference” ile indirme ve kullanma işlemleri denenebilir.

Ön işlem:

1. Hugging face hesabımıza giriş yapıyoruz.
2. Mistral-Large versiyonunu kullanabilmemiz için erişim izni almamız lazım. Hugging face üzerinden erişim izni formunu dolduruyoruz.

Modelin indirilmesi:

1. Install işlemlerimizi gerçekleştiriyoruz:

pip install transformers huggingface_hub

2. Modeli indirebilmek için hugging face giriş işlemlerini gerçekleştiriyoruz:

# Hugging Face Hub'dan (<https://huggingface.co/settings/tokens>) aldığınız
# 'read' yetkisine sahip Access Token'ınızı buraya yapıştırın.
hf_token = "YOUR_HUGGING_FACE_TOKEN" # <--- TOKEN'INIZI BURAYA YAPIŞTIRIN

# Basit token kontrolü (boş veya varsayılan değerse uyarı ver)
if not hf_token or hf_token == "YOUR_HUGGING_FACE_TOKEN":
    print("UYARI: Hugging Face token'ınızı kod içindeki 'hf_token' değişkenine atamanız gerekiyor!")
    # İsterseniz burada exit() ile çıkabilirsiniz, ancak hata kontrolü yapmayacaktık.
    # exit()

(Alternatif Kalıcı Çözüm) huggingface-cli üzerinden giriş yapın. IDLE’ınızın bulunduğu terminale

huggingface-cli login

3. Modelimizi indiriyoruz:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "mistralai/Mistral-Large-Instruct-2407"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto")

Bu işlemlerden sonra modelimiz için artık indirilmiş durumda.

Modelimizin indirildiğini test etmek için:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 1. Model Kimliği
model_id = "mistralai/Mistral-Large-Instruct-2407"
# 2. Tokenizer ve Modeli Yükle (Yerel önbellekten denenir)
print("Model ve tokenizer yükleniyor...")
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16, # Bellek için önemli
    device_map="auto"          # Otomatik cihaz ataması
)
print("Yükleme tamamlandı.")
# 3. Basit Girdi Hazırla
messages = [{"role": "user", "content": "Kısaca kendini tanıtır mısın?"}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
inputs = inputs.to(model.device) # Girdiyi modelin cihazına gönder
# 4. Kısa Bir Çıktı Üret
print("Çıktı üretiliyor...")
outputs = model.generate(inputs, max_new_tokens=50) # Maksimum 50 yeni token üret
# 5. Çıktıyı Yazdır
decoded_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("\\n--- Model Çıktısı ---")
print(decoded_output)
print("--------------------")

Bu kısımda outputumuz istediğimiz gibiyse modelimiz indirilmiş ve çalışıyor demektir.

Test için verilerin hazırlanması:

Verilerin ayarlanması:

Verilerimizin “Markdown or Latex” formatında olması gerekiyor. Eğer verilerimiz “PDF” formatındaysa bunları “Markdown” formatına dönüştürülmesi gerekiyor.

PDF Dönüştürme:

Online dönüştürme: İşlem, sizin bilgisayarınızda değil, doc2x servisinin sunucularında gerçekleşir.

1. PDFDeal kütüphanesini kurun

pip install --upgrade pdfdeal

2. Kurulum yapıldıktan sonra PDF dönüştürmesini gerçekeştirin

from pdfdeal import Doc2X
from pdfdeal import get_files
client = Doc2X(apikey='xxx') # doc2x apikey 
file_list, rename = get_files(path=r"path/PDF", mode="pdf", out="md")
success, failed, flag = client.pdfdeal(
    pdf_file=file_list,
    output_path=r"OutputPath/PDF",
    output_format='md',
    output_names=rename,
)
print(success)
print(failed)
print(flag)

Offline dönüştürme: Bu yöntemde, PDF dönüşümü tamamen sizin kendi bilgisayarınızda, yerel olarak kurduğunuz bir kütüphane (MagicPDF) aracılığıyla yapılır.

3. Libreoffice kütüphanesini indirin:

# linux/osx
apt-get/yum/brew install libreoffice

# windows
install libreoffice 
append "install_dir\\LibreOffice\\program" to ENVIRONMENT PATH

4. MagicPDF kütüphanesini kurun:

pip install fairy-doc[cpu] # cpu kullanılacaksa
or
pip install fairy-doc[gpu] # gpu kullanılacaksa

5. Kurulum yapıldıktan sonra PDF dönüştürmesini gerçekleştirin

import os # Dosya yolu işlemleri için os modülünü ekleyelim

# 1. Gerekli sınıfı MagicPDF kütüphanesinden import edin
from magic_doc.docconv import DocConverter

# 2. DocConverter nesnesini oluşturun
converter = DocConverter(s3_config=None)

# 3. PDF dosyasını Markdown'a dönüştürün
pdf_dosya_yolu = "path/to/your/local/document.pdf" # <-- KENDİ PDF DOSYANIZIN YOLUNU BURAYA YAZIN

# Çıktı dosyasının adını belirleyelim (PDF ile aynı isimde, .md uzantılı)
# Örneğin: "path/to/your/local/document.pdf" -> "path/to/your/local/document.md"
dosya_adi_uzantisiz, _ = os.path.splitext(pdf_dosya_yolu)
cikti_dosya_yolu = dosya_adi_uzantisiz + ".md"
print(f"'{pdf_dosya_yolu}' dosyası Markdown'a dönüştürülüyor...")
markdown_icerik, zaman_maliyeti = converter.convert(pdf_dosya_yolu, conv_timeout=300)
print(f"Dönüşüm tamamlandı. Süre: {zaman_maliyeti:.2f} saniye")

# 4. Dönüştürülen Markdown içeriğini bir dosyaya kaydet
try:
    with open(cikti_dosya_yolu, 'w', encoding='utf-8') as f:
        f.write(markdown_icerik)
    print(f"Markdown içeriği başarıyla '{cikti_dosya_yolu}' dosyasına kaydedildi.")
except Exception as e:
    print(f"Dosyaya yazma sırasında bir hata oluştu: {e}"

GPTQ için ihtiyacınız olan şey, modelin normalde karşılaşacağı türden temsili metin örnekleridir. Yani, PDF’lerden çıkarıp işlediğiniz Markdown dosyalarının sadece ham metin içerikleri yeterlidir.

6. Gerçekleştiriyoruz: GPTQ Quantization işlemi

GPTQ kütüphanesi

• Normalde “auto_gptq” adında bir kütüphane kullanılıyormuş fakat artık çalışmalarını durdurmuş.
• Kullanılacak kütüphane: GPTQModel

Installation işlemlerimizi gerçekleştiriyoruz.

pip install -v gptqmodel --no-build-isolation
pip install transformers datasets accelerate torch huggingface_hub

Import işlemlerimizi gerçekleştiriyoruz.

import os
from gptqmodel import GPTQModel, QuantizeConfig

Modeli indirebilmek için hugging face giriş işlemlerini gerçekleştiriyoruz:

# Hugging Face Hub'dan (<https://huggingface.co/settings/tokens>) aldığınız
# 'read' yetkisine sahip Access Token'ınızı buraya yapıştırın.
hf_token = "YOUR_HUGGING_FACE_TOKEN" # <--- TOKEN'INIZI BURAYA YAPIŞTIRIN

# Basit token kontrolü (boş veya varsayılan değerse uyarı ver)
if not hf_token or hf_token == "YOUR_HUGGING_FACE_TOKEN":
    print("UYARI: Hugging Face token'ınızı kod içindeki 'hf_token' değişkenine atamanız gerekiyor!")
    # İsterseniz burada exit() ile çıkabilirsiniz, ancak hata kontrolü yapmayacaktık.
    # exit()

(Alternatif Kalıcı Çözüm) huggingface-cli üzerinden giriş yapın. IDLE’ınızın bulunduğu terminale

huggingface-cli login

Komutunu yazarak hugging face sitesine giriş yapın ve kalıcı olarak giriş yapmış bulunmaktasınız herhangi bir huggingface token’ı kullanmaya gerek yok.

1. Kalibrasyon Veri Setini Hazırlama

input_folder = "processed_markdowns"  # İşlenmiş girdilerin (.md) olduğu klasör
calibration_data = []
sample_limit = 128 # Kalibrasyon için kullanılacak örnek sayısı

print(f"Adım 1: Kalibrasyon verisi '{input_folder}' klasöründen okunuyor...")
# Klasördeki .md dosyalarını oku
for filename in os.listdir(input_folder):
    if filename.endswith(".md") and len(calibration_data) < sample_limit:
        file_path = os.path.join(input_folder, filename)
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
            if content: # Boş dosyaları ekleme
                 calibration_data.append(content)
print(f"Kalibrasyon için {len(calibration_data)} metin örneği hazırlandı.")
# Eğer hiç veri okunamadıysa kod devam ederken hata verecektir.

2. GPTQ Quantization konfigrasyonları ve modelin yüklenmesi:

# Ayarlar
model_id = "mistralai/Mistral-Large-Instruct-2407" # Quantize edilecek model
quant_path = "mistral-large-instruct-2407-gptqmodel-8bit" # Quantize edilmiş modelin kaydedileceği klasör

# Quantization yapılandırması (GPTQModel README'sine göre)
quant_config = QuantizeConfig(
    bits=8,         # Hedef bit sayısı
    group_size=128  # Grup boyutu
    v2=True         # Deneysel GPTQ v2 (daha fazla VRAM gerektirir)
)
print(f"\\nAdım 2: '{model_id}' modeli yükleniyor ve quantize ediliyor...")
print(f"Quantization yapılandırması: bits={quant_config.bits}, group_size={quant_config.group_size}")
# Bu adım çok fazla RAM/VRAM kullanacaktır!
model = GPTQModel.load(model_id, quant_config)
print("Model başarıyla yüklendi (quantization öncesi).")

3. Quantization işleminin başlatılması

# Bu adım GPU'yu yoğun kullanacak ve uzun sürebilir!
print("Quantization işlemi başlatılıyor...")
model.quantize(calibration_data, batch_size=1) # batch_size=1 varsayılan olarak kullanılıyor, VRAM yeterliyse artırılabilir.
#batch_size oluşturulan grupların içerisindeki burada 128 elemandan 1 tanesi ile test edilmesi.
print("Quantization işlemi tamamlandı.")

4. Quantization modelinin kaydedilmesi:

# Quantize edilmiş modeli kaydet
print(f"Quantize edilmiş model '{quant_path}' altına kaydediliyor...")
model.save(quant_path)
print("Kaydetme işlemi tamamlandı.")

print("\\nQuantization işlemi başarıyla tamamlandı (hata oluşmadıysa).")

Bu işlemlerden sonra kendi hazırladığımız train setimizle beraber quantization işlememiz gerçekleştirilmiş olacaktır. Burada GPTQ’yü diğer quantization işlemlerinden ayıran şey batch_size ile modelin doğruluğunu test ederek modelin veri tipini küçültmesidir.

7. Test Ediyoruz: Model test: Inference

Inference: Önceden eğitilmiş veya quantize edilmiş bir modeli alıp, ona bir girdi (prompt, mesaj listesi, metin vb.) vererek modelin bu girdiye dayalı bir çıktı (metin, cevap vb.) üretmesini sağlama işlemidir.

1. (Opsiyonel) Model ve verinin temizlenmesi (bu kısım sistemi rahatlatmak için önemli ama yapılmadan da geçilebilir.

print(f"\\nAdım 3: Quantize edilmiş model '{quant_path}' yükleniyor...")

del model
del calibration_data
if torch.cuda.is_available():
    torch.cuda.empty_cache()

2. Quantize edilmiş modeli yükle

# Bu, quantize edilmiş, daha az bellek kullanan modeli yükler.
quantized_model = GPTQModel.load(quant_path)
print("Quantize edilmiş model başarıyla yüklendi.")

3. Basit bir input ile test et ve çıktı üret

# Basit bir test girdisi (prompt)
test_prompt = "Türkiye'nin başkenti neresidir?"
print(f"\\nTest girdisi: '{test_prompt}'")

# Inference yap (çıktı üret)
print("Inference yapılıyor...")

# max_new_tokens: Üretilecek maksimum token sayısı (isteğe bağlı)
result_tokens = quantized_model.generate(test_prompt, max_new_tokens=50)[0] # İlk sonucu (token listesini) al

4. Sonucu yazdır

result_text = quantized_model.tokenizer.decode(result_tokens)
print("\\n--- Model Çıktısı ---")
print(result_text)
print("--------------------")
print("\\nInference testi tamamlandı.")

8. Örnek: Google Colab Üzerinden Basit Bir GPTQ Quantization

Quantization işleminin anlaşılabilmesi için google colab üzerinden basit bir örnek oluşturdum. Buradan sizde test edebilirsiniz.

• Quantization işlemini gpu ile gerçekleştireceğimiz için google colab’deki notebook sayfamızdın üstüne bulunan “Çalışma zamanı (Runtime)” kısmına basıyoruz ve oradan “Çalışma zamanı türünü değiştir (change runtime type)” a basıyoruz. Açılan kısımda “CPU” seçili olarak gelecektir. Buradan “T4 GPU” seçeneğini seçiyoruz ve artık “CPU” ile değil “GPU” ile çalışır bir sistem elde etmiş oluyoruz.

1. Installationlar:

!pip install datasets
!pip install gptqmodel
!pip install huggingface_hub
!pip install transformers

database, gptqmodel, transfoerm huggingface_hub kütüphanelerini install ediyoruz.

2. Importlar:

from datasets import load_dataset
from gptqmodel import GPTQModel, QuantizeConfig
from huggingface_hub import login # Import login function
from transformers import AutoTokenizer

install ettiğimiz dataset, gptmodel, huggingface_hub ve transformers kütüphanlerimizi import ediyoruz.

3. Modelimizin yüklenmesi ve yeni oluşacak modelin adlandırılması:

model_id = "facebook/opt-125m"  # Modelin ismi
quant_path = "facebook-opt-125m-8bit" # Modelin quantization işleminden sonraki kaydedilecek klasörün ismi

#login(token="YOUR_HUGGING_FACE_TOKEN") LLM'e erişebilmek için huggingface üzerinden token'ınız ile giriş yapmanız gerekiyor.
#Fakat bu örnekte erişim izni gerekemeyen bir LLM üzerinde deneme gerçekleştirdim.
tokenizer = AutoTokenizer.from_pretrained(model_id) #Modelimizi tokenize ediyoruz. Eğer modelimiz yoksa hugging face üzerinden indiriyor.

İndireceğimiz modelimizin ismini ve quantization işlemi sonrasında oluşturacağımız yeni halinin ekleneceği klasörün adını yazıyoruz. AutoTokinzer.from_pretrained kodumuz; modelimiz, makinamızda yoksa indiriyor ve sonrasında tokenize ediyor.

4. GPTQ Quantization işlemimiz:

#dataset kütüphanemizde bulunan allenai/c4 datasetimizi GPTQ Quantization işlemindeki "train" kısmı için kullanacağız.
calibration_dataset = load_dataset(
    "allenai/c4",
    data_files="en/c4-train.00001-of-01024.json.gz",
    split="train"
).select(range(1024))["text"]

# Datasetimizdeki verilerin uzundu ve hatalar aldım. Bunun için max_lengt kısmı belirledik ve modelimize yükleyebildik.
max_length = 512  # **Change this to a smaller value**
calibration_dataset = [text[:max_length] for text in calibration_dataset]

#Quantizaton işlemimizin konfigrasyon ayarları
quant_config = QuantizeConfig(bits=8, group_size=128)

# Belirlediğimiz konfigrasyon ayarlarını modelimizi konfigüre etmek için kullanacağız.
model = GPTQModel.load(model_id, quant_config)

# increase `batch_size` to match gpu/vram specs to speed up quantization
model.quantize(calibration_dataset, batch_size=1)
model.save(quant_path)

• Train datasetimizi indiriyoruz ve ayarlamalarını yapıyoruz. Ayrıca problem yaşamamk için bir max_length belirliyoruz.
• QuantizeConfig ile kaç bite cevireceğimiz ve kaçarlı gruplar halinde çevireceğimiz işlemidir.
• GPTQModel.load kodumuz tokenize etmiş olduğumuz modelimizi, QuantizeConfig’de belirlediğimiz konfigrasyon ayalarıyla kuantize edilmeye hazırlar.
• model.quantize kodumuz ise indirmiş olduğumuz datasetimizi alarak kalibrasyon işlemlerini gerçekleştiriyor. Burada group_size=128 olarak belirledik yani 128’li gruplar halinde gerçekleştiriyor ve batch_size=1 de her grubun 1 tane veri ile kalibrasyon testine sokulmasını anlatmış oluyor.
• Yeni oluşturduğumuz modelimizi “quant_path” teki belirlediğimiz yeni klasör ismimizin kaydediyoruz.

5. Quantization öncesi ve sonrası modellerin boyut karşılaştırması:

import torch
from transformers import AutoModelForCausalLM
import logging

def get_model_size(model):
    """Quantization işleminin başarıyla gerçekleşip gerçekleşmediğini kontrol etmek için LLM'lerimizin boyutlarına bakıyoruz."""
    param_size = 0
    for param in model.parameters():
        param_size += param.nelement() * param.element_size()
    buffer_size = 0
    for buffer in model.buffers():
        buffer_size += buffer.nelement() * buffer.element_size()
    size_all_mb = (param_size + buffer_size) / 1024**2
    return size_all_mb

# Quantization işlemi öncesindeki LLM modelimiz
original_model = AutoModelForCausalLM.from_pretrained(model_id)
original_dtype = next(original_model.parameters()).dtype
original_size = get_model_size(original_model)

# Quantization işlemi sonucundaki LLM modelimiz
quantized_model = GPTQModel.load(quant_path)
quantized_dtype = next(quantized_model.model.parameters()).dtype
quantized_size = get_model_size(quantized_model.model)

# Boyutları yazdırıyoruz.
print(f"Original Model Data Type: {original_dtype}")
print(f"Original Model Size: {original_size:.2f} MB")
print(f"Quantized Model Data Type: {quantized_dtype}")
print(f"Quantized Model Size: {quantized_size:.2f} MB")

Output:

Original Model Data Type: torch.float32
Original Model Size: 477.75 MB
Quantized Model Data Type: torch.float16
Quantized Model Size: 160.09 MB

6. Modelin doğrulunun testi:

Modelimizin doğruluğunu aynı inputları hem ana modele hem quantize edilmiş modele vererek test ediyoruz.

# Test için input girdilerimiz
input_text_1 = "How are you today"
input_text_2 = "Where is the white house"

# Girişleri quantize edilmiş modelle aynı cihaza taşı
# quantize modelimiz cuda da çalışacak diye varsayıyoruz eğer çalışmıyorsa cpu'ya alıyoruz.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Orijinal modeli aynı cihaza taşıyın (bir önceki düzeltmede yapılmıştı, burada da tekrar ediliyor)
original_model.to(device)

# İlk inputu tokenize ediyoruz ve cihaza taşıyoruz.
inputs_1 = tokenizer(input_text_1, return_tensors="pt")
inputs_1 = inputs_1.to(device)

# İkinci inputu tokenize ediyoruz ve cihaza taşıyoruz.
inputs_2 = tokenizer(input_text_2, return_tensors="pt")
inputs_2 = inputs_2.to(device)

# --- İlk Input (input_text_1) ile Modelleri Test Etme ---
print(f"Testing with input: '{input_text_1}'")

# Orijinal modelden çıktı üret
with torch.no_grad():
    original_outputs_1 = original_model.generate(**inputs_1, max_new_tokens=20)
    original_output_text_1 = tokenizer.decode(original_outputs_1[0], skip_special_tokens=True)

# Quanzite edilmiş modelden çıktı üret
with torch.no_grad():
    quantized_outputs_1 = quantized_model.generate(**inputs_1, max_new_tokens=20)
    quantized_output_text_1 = tokenizer.decode(quantized_outputs_1[0], skip_special_tokens=True)

# Çıktıları yazdır
print("Original Model Output (Input 1):")
print(original_output_text_1)
print("\\nQuantized Model Output (Input 1):")
print(quantized_output_text_1)
print("-" * 30) # Ayırıcı çizgi

# İkinci Input (input_text_2) ile Modelleri Test Etme 
print(f"Testing with input: '{input_text_2}'")

# Orijinal modelden çıktı üret
with torch.no_grad():
    original_outputs_2 = original_model.generate(**inputs_2, max_new_tokens=20)
    original_output_text_2 = tokenizer.decode(original_outputs_2[0], skip_special_tokens=True)

# Quanzite edilmiş modelden çıktı üret
with torch.no_grad():
    quantized_outputs_2 = quantized_model.generate(**inputs_2, max_new_tokens=20)
    quantized_output_text_2 = tokenizer.decode(quantized_outputs_2[0], skip_special_tokens=True)

# Çıktıları yazdır
print("Original Model Output (Input 2):")
print(original_output_text_2)
print("\\nQuantized Model Output (Input 2):")
print(quantized_output_text_2)

Output:

Original Model Output (Input 1):
How are you today?
I'm doing alright. I'm just not feeling well. I'm not feeling well either

Quantized Model Output (Input 1):
How are you today?
I'm doing alright. I'm just tired. I'm not sure if I'm going
------------------------------
Testing with input: 'Where is the white house'
Original Model Output (Input 2):
Where is the white house?
It's in the middle of the city.
Quantized Model Output (Input 2):
Where is the white house?
It's in the middle of the city.

Evet çıktılarımız ile aldığımız cevaplar birbirlerine oldukça yakınlar yani şunu söyleyebiliriz “train” ettiğimiz verilerde doğru ölçeklemeler yapılmış ve veri kaybı az olmuş durumda. Quantization işlemi çalışıyor.