Kasım 3, 2025 8 dk okuma süresi

MXFP4 ile 4-Bit Devrimi: İnternetsiz ChatGPT

Microscaling FP4 ile 20B’yi 16 GB’a sığdır, 120B’yi tek GPU’da dene.

TL;DR

• MXFP4 (Microscaling FP4), 4-bit FP formatını block-wise scale factor ile birleştiriyor.
• Amaç: VRAM kullanımını ~4× düşürmek, memory bandwidth ihtiyacını azaltmak, throughput’u artırmak — accuracy’yi çok bozmadan.
• Sonuç: GPT-OSS-120B ≈ 80 GB, GPT-OSS-20B ≈ 16 GB civarı yüklenebiliyor. Bu da tek GPU’da veya güçlü bir masaüstünde mümkün hale geliyor.

1) Problem neydi?

Büyük modeller normalde BF16 / FP16 gibi 16-bit formatlarla tutuluyor. Bu şu anlama geliyor:

• Her weight 16 bit.
• 120B parametreli bir model → yüzlerce GB VRAM.
• inference sırasında memory bandwidth patlıyor, latency yükseliyor.

Bu, ev tipi donanımı tamamen oyunun dışına atıyordu.

2) MXFP4 fikri ne yapıyor?

MXFP4 diyor ki:

1. Weights’i küçük bloklara ayır (örnek: 32 değerlik blok).
2. Her blok için tek bir scale factor seç.
3. O bloktaki her weight’i bu scale factor ile normalize et ve FP4’e (4-bit floating point) quantize et.
4. Saklarken: sadece FP4 değerleri + o bloğun scale factor’ü tutuluyor.
5. inference sırasında geri açarken: FP4 değer × scale factor ≈ orijinal weight.

Bu yaklaşıma microscaling deniyor. Yani “tek tek her elemana değil, block bazında ölçek uygulama”.

Bunun olayı şu:

• Sadece düz INT4 gibi davranmıyor.
• Block-wise scale sayesinde outlier değerler bir bloğu tamamen bozup saturate etmesin diye kontrol altında tutuluyor.
• Accuracy INT4’e göre çok daha iyi korunuyor.

3) Teknik detay: FP4 tarafı

MXFP4, FP4 formatını (E2M1 gibi varyantlar) kullanıyor:

• sign bit
• exponent bits
• mantissa bit

Tek başına FP4 çok agresif (sadece 16 possible value). Bu tek başına kullanılırsa çoğu layer için aşırı bilgi kaybı yaratır.

Ama block başına ayrı scale factor tutunca bu sınırlı 4-bit değerler pratikte çok daha geniş bir numeric range’i kapsayabiliyor. Yani sen aslında “FP4 + scale factor” kombinasyonuyla efektif olarak “daha zengin bir temsil” elde etmiş oluyorsun.

Bu yüzden MXFP4, “INT4 nicemledim bitti” yaklaşımından farklı: burada block-scale’lenmiş FP4 var, tek global scale yok.

4) Training tarafı niye zor ama önemli?

Eskiden düşük bit quantization (4-bit, 3-bit vs.) genelde sadece inference sonrası yapılırdı. Yani model FP16 ile eğitilir, sonra publish ederken sıkıştırılırdı.

OpenAI tarafında kritik kırılma şu oldu:

• GPT-OSS modelleri zaten MXFP4 hassasiyetinde train edilecek şekilde tasarlandı / fine-tune edildi.
• Yani bu format sadece sonradan yapılan “compression hack” değil, training loop’un bir parçası.

Bunu mümkün kılmak için birkaç trik kullanılıyor:

• stochastic rounding (rounding bias birikmesin diye)
• block-wise quantization öncesi Hadamard transform ile outlier dağıtmak
• MoE yapılarında hangi ağırlıklar MXFP4’e gidecek, hangileri daha yüksek precision kalacak kararını dinamik vermek (gating/dispatch gibi hassas kısımlar genelde daha yüksek precision bırakılıyor).

Bu sayede model tamamen çökmeden 4-bit’e yaklaşabiliyor.

5) MXFP4 vs INT4 vs FP8 (mental model)

• INT4 (uniform, tek scale):

  • minimum VRAM, ama accuracy çok kötüleşebilir çünkü tek scale factor bütün aralığı açıklamaya çalışıyor.
  • outlier varsa bittin.

• FP8 (mesela E4M3, E5M2):

  • hâlâ low precision ama 8-bit olduğundan temsil gücü çok daha iyi.
  • FPGA/GPU tarafında native support yaygınlaşıyor.
  • VRAM tasarrufu var ama 4-bit kadar agresif değil.

• MXFP4 (microscaling FP4):

  • 4-bit kadar sıkı depolama
  • block-wise scale ile INT4’teki “tek scale her şeyi mahvetti” problemini hafifletiyor
  • inference sırasında hız/throughput ciddi şekilde iyileşebiliyor; çünkü compute kernel FP4-native ise çok daha fazla operasyonu paralel yapabiliyorsun.

Kısaca: MXFP4 = “4-bit footprint + FP8’e yakın davranış”

6) Donanım tarafı (gerçek dünya)

Burada kritik konu GPU mimarisi.

• NVIDIA Blackwell (B-serisi) GPU’larda native FP4 support var. Yani compute kernels doğrudan FP4 ile çalışıyor. Bu da throughput’u inanılmaz artırıyor (FP16’ya göre birkaç kat) ve latency’yi aşağı çekiyor.
• NVIDIA Hopper (H100) gibi kartlarda FP8 çok iyi durumda ama FP4 tam native değil. Yazılımsal yollarla MXFP4 inference yapılabiliyor ama Blackwell kadar verimli değil.
• Eski tüketici GPU’larda (RTX 4090 vs.) bu iş daha da hileli: sen 4-bit ağırlıkları load ediyorsun ama runtime bazı şeyleri BF16/FP16’a geri şişiriyor → hız kazancı dramatik şekilde düşüyor. VRAM tasarrufu da sınırlanıyor.

Şunu bilmek önemli: MXFP4 future-proof, yani tasarım “ileride bu donanım zaten FP4’ü doğrudan koşacak” varsayımıyla geliyor. Bugün her makinede mucize bekleme.

7) Model boyutu — sayılar

Bu rakamlar neden hype yaratıyor?

• gpt-oss-120B MXFP4 checkpoint ≈ 80 GB civarı.

  • FP16 dursaydı ~240 GB seviyesinde olurdu.

• gpt-oss-20B MXFP4 checkpoint ≈ 16 GB civarı.

  • Bu artık “tek güçlü PC + iyi bir GPU” klasmanına girdi demek.

Bu ne demek pratikte? Artık 20B sınıfı bir modelle kendi makinen üzerinde inference yapabilirsin. Cloud bağımlılığı azalıyor. Bu, hem gizlilik (local inference) hem gecikme kontrolü (senin network’ün dışında kimse yok) açısından güzek.

8) LM Studio ile GPT-OSS-20B (MXFP4) nasıl ayağa kalkar?

Burası “ben bunu masaüstümde denemek istiyorum” kısmı.

8.1 Kurulum

1. LM Studio’yu indir (Win/macOS/Linux).
2. Soldan “Discover” tabına gir

Sistem tarafı:

• 16 GB+ RAM en azından cevap alabilmek için yeterli. Sağlıklı çalıştırmak için 32+ olmalı.
• VRAM ne kadar yüksekse o kadar iyi.
• GPU offload varsa inference ciddi hızlanır.
• CPU-only mod da mümkün ama yavaş olur.

8.2 Modeli seçmek

1. Arama çubuğuna: gpt-oss-20b yaz.

2. OpenAI / gpt-oss-20b model card’ına gir. Burada genelde birden fazla checkpoint görürsün:

   • MXFP4 / FP4 tarzı build (OpenAI’nin yayınladığı gibi).
   • GGUF quantized varyantlar (llama.cpp / MLX uyumlu).  * Eğer macos kullanıyorsanız kesinlikle MLX versiyonu indiriniz (MLX konusu üzerine yazmak istediğim bir konu, belki yakında onunla ilgili de bir yazı gelebilir).

8.3 Modeli yüklemek ve sohbet etmek

• Download → Load.
• context length ve GPU offload gibi ayarları LM Studio arayüzünden yap.
• “Chat” sekmesinde direkt konuşmaya başlayabilirsin.
• Load öncesi context lengthi düşürmenizi tavsiye ederim (1024).

Bu noktada aslında local inference yapıyorsun. Yani prompt’un makineden çıkmıyor.

8.4 Local API (OpenAI-compatible endpoint)

LM Studio bir OpenAI-compatible endpoint açabiliyor (default genelde http://localhost:1234/v1 gibi). Sen bunu kendi kodundan sanki OpenAI API’siymiş gibi çağırabiliyorsun.

cURL örneği:

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-oss-20b",
    "messages": [
      {"role": "user", "content": "MXFP4'ü iki cümlede anlat."}
    ],
    "temperature": 0.3
  }'

Python örneği:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="not-needed"
)

resp = client.chat.completions.create(
    model="openai/gpt-oss-20b",
    messages=[{"role": "user", "content": "quantization block-scale mantığı nedir?"}],
    temperature=0.3,
)

print(resp.choices[0].message.content)

Bu kısım şu işe yarıyor:

• Kendi makinen artık bir mini “OpenAI server” gibi.
• İstersen kendi uygulamanda bu modeli kullanabilirsin.
• Yani inference tamamen local kalırken API arayüzün değişmiyor.

Bu developer için aşırı rahat: mevcut OpenAI client kodunu neredeyse aynen kullanıyorsun, sadece base_url değişiyor.

10) Final

MXFP4 güzel bir pazarlama adı değil; ciddi bir mimari fikir:

• block-wise quantization
• shared scale factor
• FP4-level footprint

Bu kombinasyon, büyük dil modellerini “cloud-only oyuncak” olmaktan çıkarıp masaüstüne indiriyor.

Ve güzel tarafı şu: LM Studio gibi araçlarla GPT-OSS-20B’yi gerçekten kendin ayağa kaldırıp deneyebiliyorsun. Bu, sadece okumak değil; gerçekten elini modele sürmek demek.