Fri Aug 07 2026
Hadi dürüst olalım: temel bir LLM'i ajan olarak kullanmak, stagista "şirketin tüm stratejisini yönet" demek kadar naïftir 😅 Ben de başlangıçta "zaten model her şeyi biliyor, prompt yazayım halleder" diye düşündüm. Spoiler: halledemiyor.
Bir müşteri destek ajanı hayal edin. Müşteri: "Siparişim #12345 iptal edildi mi?" der. Temel model ne yapar? "Bilmiyorum, veritabanına bakmadım" der — çünkü bilmiyor, sadece tahmin ediyor. Oysa ajanınız:
Kod asistanı örneğine geçelim. "Bu repo nasıl deploy edilir?" sorusuna temel model generic bir CI/CD şablonu yazar. Ama sizin repoda:
docker-compose.prod.yml varmake migrate ile çalışırModel bunu bilemez — çünkü sizin özel bağlamınızı (context) görmemiş.
"Son çeyrekte churn rate nasıldı?" sorusuna temel model SQL yazar. Ama:
usr_churn_events_v2 (model users bekler)churn tanımınız: "30 gün login yok + abonelik iptal" (model bilmez)Model yanıltıcı ama güvenli görünen bir sorgu üretir. Production'da bu felakettir 💥
| Senaryo | Ne Oldu? | Çözüm |
|---|---|---|
| İlk ajanım | Prompt engineering ile "çözmeye" çalıştım → 3 gün sonra prompt 2000 satır oldu, yine hallolmadı | Fine-tune + RAG kombinasyonu |
| Kod asistanı | Model sürekli npm install yazıyordu, biz pnpm kullanıyorduk |
Domain-specific data ile SFT |
| Destek botu | "Para iadesi politikası?" → model Amazon politikasını anlattı 😂 | Şirket belgeleri üzerinde QLoRA |
Ortak nokta: Temel model genel bilgi üretir. Ajanınıza özel bilgi + davranış + format lazım.
Ne zaman SFT/QLoRA'ya yönelmeliyiz? 🎯
RAG ve prompt engineering güçlü araçlar ✨ — özellikle:
Ama günlük iş akışlarında bu yöntemler sık sık kısır döngüye girer 🔁. İşte nedenler:
Senaryo: Bir finans şirketinde otomatik rapor hazırlama ajanı kurduk.
- RAG: Geçen yılın bilançoları, mevzuat PDF’leri, iç politikalar yüklendi.
- Prompt: “Şirket terminolojisini kullan, 5 sayfalık özet yaz, riskleri vurgula.”
Ne oldu?
| Etki | Açıklama |
|---|---|
| Token maliyeti | 3‑4 kat daha fazla token tüketildi (yeniden deneme, düzeltme döngüleri) 💰 |
| Gecikme | Her iterasyon ~30 sn → toplam 5‑10 dk bekleme ⏱ |
| İnsan müdahalesi | 2 analist manuel düzeltme yapmak zorunda kaldı → ROI düştü 📉 |
| Güven | Ekip “ajanı güvenmiyor” diyerek yeni projelere direndi 🚫 |
Hadi bir sonraki bölümde bu eksikleri nasıl kapatabileceğimize (agentic workflows, tool use, evaluation loops) bakalım 🚀
Hangi yöntem sizin için en uygun? Aşağıdaki tablo ve karar ağacı ile kendi durumunuzu hızlıca eşleştirebilirsiniz 🎯
| Özellik | SFT (Supervised Fine‑Tuning) | QLoRA (4‑bit Quantized LoRA) | Tam Fine‑Tuning |
|---|---|---|---|
| Veri miktarı | 1 K – 10 K örnek 📄 | 500 – 5 K örnek 📄 | 10 K – 100 K+ örnek 📄 |
| GPU bellek gereksinimi | 1×A100 40 GB (fp16) 🎮 | 1×A100 24 GB (4‑bit) 🎮 | 4×A100 80 GB (fp16/bf16) 🎮 |
| Eğitim süresi | 2‑4 saat ⏱ | 1‑2 saat ⏱ | 12‑48 saat ⏱ |
| Model kalitesi | Orta‑yüksek (task‑specific) ⭐⭐⭐ | Yüksek (LoRA + quant) ⭐⭐⭐⭐ | En yüksek (full weights) ⭐⭐⭐⭐⭐ |
| Bakım maliyeti | Düşük (tek model, tek checkpoint) 💰 | Çok düşük (adapter dosyası ~MB) 💰 | Yüksek (büyük checkpoint, versiyonlama) 💰 |
Not: Sayılar tipik 7B‑13B parametreli modeller için; model boyutu büyüdükçe bellek ve süre lineer artar.
Veri setiniz < 1 K mi?
GPU bütçeniz 1×A100 40 GB veya altı mı?
En yüksek kalite şart mı? (ör. üretimde kritik hata payı)
Modeli sık güncellemeniz gerekiyor mu? (ör. haftalık yeni veri)
Bu matris ve ağaç, kendi kısıtlarınızı (veri, GPU, zaman, kalite) göz önünde bulundurarak doğru yolu seçmenizi kolaylaştırır ✅.
Hadi şimdi kendi senaryonuzu tabloya yerleştirin ve yola çıkın! 🚀
Hazırsan QLoRA’nın iki ana bacağını — 4‑bit NF4 quantize ve LoRA adaptörleri — bir kahve molası süresinde kavrayalım ☕️
| Parametre | Ne Yapar? | Pratik İpucu |
|---|---|---|
| r (rank) | Eğitilecek düşük‑boyutlu matrislerin boyutunu belirler. r=8 → her katmanda 8 × d_model boyutunda iki matris (A, B) eklenir. |
Küçük r → daha az parametre, daha hızlı eğitim; çok küçük olursa ifade yeteneği düşer. |
| α (alpha) | LoRA güncellemesini ölçeklendirir: ΔW = (α / r) · B @ A. |
Genelde α = 2·r veya α = 16 gibi bir kural kullanılır; büyük α → daha güçlü adaptasyon ama overfit riski. |
Küçük formül / pseudo‑kod ile matris boyutlarını görelim:
# d_model = 4096 (örnek)
r = 8
A ∈ ℝ^(r × d_model) # (8, 4096)
B ∈ ℝ^(d_model × r) # (4096, 8)
ΔW = (α / r) * (B @ A) # (4096, 4096) → orijinal ağırlık boyutu
Bu sayede sadece 2 × r × d_model ≈ 65 K parametre eğitiyoruz; orijinal 16 M parametrenin %0.4’ü 🎉
# -------------------------------------------------
# 1️⃣ 4‑bit NF4 quantize ile modeli yükle
# -------------------------------------------------
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
model_id = "meta-llama/Llama-2-7b-hf" # örnek model
bnb_cfg = BitsAndBytesConfig(
load_in_4bit=True, # 4‑bit modu
bnb_4bit_quant_type="nf4", # NF4 quantizasyon
bnb_4bit_use_double_quant=True, # double quant için hafif artı
bnb_4bit_compute_dtype=torch.bfloat16 # hesaplama dtype
)
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_cfg,
device_map="auto",
torch_dtype=torch.bfloat16,
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
# -------------------------------------------------
# 2️⃣ LoRA adaptörünü tanımla ve modele ekle
# -------------------------------------------------
lora_cfg = LoraConfig(
r=8, # rank
lora_alpha=16, # alpha
target_modules=["q_proj", "v_proj"], # dikkat katmanları
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_cfg)
model.print_trainable_parameters() # eğitilebilir parametre sayısını gör
# -------------------------------------------------
# Artık model 4‑bit quantize + LoRA (r=8, α=16) hazır 🎉
# -------------------------------------------------
Ne oldu?
BitsAndBytesConfig ile model NF4 4‑bit olarak yüklendi → VRAM ≈5 GB.LoraConfig(r=8, lora_alpha=16) sayesinde sadece ~65 K parametre fine‑tune edilebilir.get_peft_model adaptörleri orijinal ağırlıkların üzerine ekler; inference sırasında merge edip tek bir 4‑bit model olarak da kullanabilirsiniz.Özetle: 4‑bit NF4 hafifletir, LoRA esnekleştirir. Birleşince “bu kadar hafif ama bu kadar güçlü” hissi verir 🎯.
Bir sonraki bölümde bu pipeline’ı bir instruction‑tuning veri seti üzerinde nasıl koşturacağımızı görelim 🚀
Hazırsan başlayalım 🚀. Aşağıdaki adımları sırayla uygulayarak GPU destekli bir Python ortamı hazırlayabilirsin.
nvcc --version # CUDA toolkit sürümü
nvidia-smi # Sürücü ve GPU bilgisi
python3 -m venv .venv # .venv klasörü oluşur
source .venv/bin/activate # Linux/macOS
# .venv\Scripts\activate # Windows PowerShell
İpucu:
pip install --upgrade pipile pip’i güncellemeyi unutma.
requirements.txt dosyasını hazırla# requirements.txt
torch==2.3.0+cu121 # CUDA 12.1 için; cu118 ise CUDA 11.8
transformers==4.41.0
accelerate==0.30.0
peft==0.11.0
bitsandbytes==0.43.0
datasets==2.19.0
+cu121 / +cu118 etiketi, CUDA sürümüne göre değişir.bitsandbytes 8‑bit/4‑bit quantizasyon için CUDA 11.8+ gerektirir.pip install -r requirements.txt
Kurulum bittikten sonra hızlı bir test:
import torch, transformers, bitsandbytes
print("CUDA available:", torch.cuda.is_available())
print("GPU:", torch.cuda.get_device_name(0))
| Hata | Neden | Çözüm |
|---|---|---|
| CUDA out of memory | Model / batch size GPU belleğini aşıyor | • torch.cuda.empty_cache() • batch_size küçült • Gradient accumulation kullan • 8‑bit/4‑bit quantizasyon (bitsandbytes) etkinleştir |
| Version mismatch: torch CUDA 12.1 vs driver 11.8 | PyTorch wheel CUDA sürümü sürücüyle uyuşmuyor | • nvidia-smi ile sürücü sürümünü kontrol et • Uygun torch wheel’ını seç (cu118 / cu121) • Gerekirse CUDA toolkit’i güncelle |
ModuleNotFoundError: No module named 'bitsandbytes' |
Paket kurulamamış ya da CUDA yok | • pip install bitsandbytes==0.43.0 • CUDA 11.8+ olduğundan emin ol • `ldconfig -p |
ImportError: libcusparse.so.11 |
CUDA kütüphaneleri PATH’te yok | • export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-12.1/lib64 (sürüme göre) • .bashrc / .zshrc ekleyip source et |
pip install yavaş / timeout |
PyPI mirror sorunu | • pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt (Çin mirror) • Veya --timeout 120 ekle |
python -c "import torch; print('Torch:', torch.__version__, '| CUDA:', torch.version.cuda)"
python -c "import transformers; print('Transformers:', transformers.__version__)"
python -c "import bitsandbytes; print('bitsandbytes ok')"
Her şey yolunda giderse “Ortam hazır 🎉” mesajını görürsün. Artık Hugging Face modellerini, LoRA/PEFT fine‑tuning’ini ve bitsandbytes quantizasyonunu sorunsuz çalıştırabilirsin.
Özet:
pip güncelle.requirements.txt ile tek komutta kur.Şimdi model eğitimine / inference’e geçebilirsin. 🚀
Hazırsan başlayalım 🚀
Ajanlarımızın system / user / assistant diyaloglarını model eğitimi için uygun bir formata (JSONL veya Parquet) dönüştürmek, veri kalitesini garanti altına almak ve daha sonra datasets kütüphanesiyle hızlıca train/validation ayırmak için birkaç adım yeterli.
system alanında topla.instruction / response olarak yeniden adlandır.meta dict’inde sakla — eğitimde kullanmasak da debug için hayat kurtarıyor.def normalize_dialog(raw: dict) -> dict:
"""Ham diyalog dict'ini instruction‑response formatına çevirir."""
return {
"instruction": raw["user"].strip(),
"response": raw["assistant"].strip(),
"system": raw.get("system", "").strip(),
"meta": {k: v for k, v in raw.items() if k not in {"user", "assistant", "system"}}
}
Bu sayede her satır tek bir eğitim örneği haline gelir ve downstream işlemler (tokenizasyon, batching) çok daha basit olur.
datasets ile Yükleme / Splitfrom datasets import load_dataset, DatasetDict
# 1️⃣ JSONL dosyasını oku
ds = load_dataset("json", data_files="data/dialogs.jsonl", split="train")
# 2️⃣ Normalizasyon fonksiyonunu uygula
ds = ds.map(lambda ex: normalize_dialog(ex))
# 3️⃣ Kalite kontrolleri (aşağıda tanımlı) – duplicate & kısa cevapları at
ds = ds.filter(is_clean)
# 4️⃣ Train / Validation ayır (ör. %90 / %10)
splits = ds.train_test_split(test_size=0.1, seed=42)
dataset_dict = DatasetDict({
"train": splits["train"],
"validation": splits["test"]
})
# 5️⃣ Parquet olarak kaydet (daha hızlı I/O)
dataset_dict.save_to_disk("data/processed_dialogs")
Nasıl çalışıyor?
load_dataset("json", ...) satırı JSONL’i Hugging Face Dataset objesine çevirir.map ile her satırı normalize_dialog fonksiyonundan geçiririz.filter(is_clean) ile kalite kontrolünü uygularız (aşağıya bak).train_test_split rastgele ama reproducible (seed=42) bir bölme yapar.save_to_disk Parquet tabanlı bir formatta diske yazar — eğitim script’lerinde load_from_disk ile saniyeler içinde yüklenir.| Teknik | Ne İşe Yarar? | Nasıl Uygulanır? |
|---|---|---|
| Few‑shot örnekler | Modelin bağlam öğrenmesini hızlandırır. | Her instruction’ın başına 2‑3 örnek instruction‑response çifti ekle (prompt template içinde). |
| Negatif örnekler | Yanlış cevapları tanıma yeteneği kazandırır. | Aynı instruction için yanlış/hallucinated bir response üret, label: 0 etiketiyle ekle. |
| Çoklu görev karıştırması (multi‑task mixing) | Genellemeyi artırır, overfitting’e engel olur. | Farklı görev türlerini (QA, summarization, code) aynı dataset içinde shuffle ederek karıştır. |
İpucu: Augmentation yaparken orijinal veri dağıtımını bozmamak için her teknikten %10‑%15 civarında ekleme yap — sonra
train_test_splittekrar çalıştır.
def is_clean(example: dict) -> bool:
"""
- Duplicate instruction'ları atar (hash tabanlı).
- Çok kısa (<5 token) response'ları eler.
- Boş system mesajı olanları kabul eder (opsiyonel).
"""
# 1️⃣ Duplicate kontrolü (global set kullanarak)
instr_hash = hash(example["instruction"])
if instr_hash in is_clean.seen:
return False
is_clean.seen.add(instr_hash)
# 2️⃣ Çok kısa cevap filtresi
if len(example["response"].split()) < 5:
return False
return True
# Static set init
is_clean.seen = set()
Ne oluyor burada?
is_clean.seen fonksiyon özelliği olarak global bir set tutar; map/filter sırasında aynı instruction hash’i ikinci kez görüldüğünde False döner → duplicate düşer.response kelime sayısı <5 ise muhtemelen “Tamam” veya “Anladım” gibi bilgi taşımayan cevaplar → filtrelenir.normalize_dialog ile instruction‑response yapısına çevir.datasets ile JSONL yükle → map → filter(is_clean) → train_test_split.load_from_disk ile hızlıca eriş.Artık elinizde temiz, dengeli ve model‑ready bir veri seti var 🎉
Bir sonraki bölümde bu veri setini tokenization & packing adımlarıyla nasıl optimize edeceğimize bakacağız. Hadi devam edelim!
Hazırsan tam bir eğitim betiği üzerinden gidelim.
Aşağıda train_qlora.py dosyasını parça parça anlatıyorum; her bloğu ne işe yaradığını kısaca özetleyeceğim 🎯
import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
Trainer,
BitsAndBytesConfig,
EarlyStoppingCallback,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
import wandb # 👉 WandB loglama için (istersen TensorBoard da kullanabilirsin)
Ne yaptık?
BitsAndBytesConfig → 4‑bit/8‑bit quantization ayarlarıLoraConfig + get_peft_model → LoRA adapter eklemeEarlyStoppingCallback → erken durdurmawandb → deney takibi (opsiyonel)bnb_config = BitsAndBytesConfig(
load_in_4bit=True, # 4‑bit yükle
bnb_4bit_quant_type="nf4", # NormalFloat4
bnb_4bit_compute_dtype=torch.bfloat16, # Hesaplama bf16
bnb_4bit_use_double_quant=True, # Double quantization
)
Neden?
GPU belleğini %70‑80 oranında tasarruf eder, büyük modelleri tek GPU’ya sığdırır 🎉
model_id = "meta-llama/Llama-2-7b-hf" # 👈 Kendi modelini buraya yaz
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=bnb_config,
device_map="auto", # Otomatik GPU/CPU dağıtımı
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token # Pad token yoksa eos kullan
model.config.pad_token_id = tokenizer.pad_token_id
İpucu: device_map="auto" sayesinde model parçaları GPU’lara yayılır, manuel to("cuda") gerekmez.
# 4‑bit eğitim için gradient checkpointing ve kbit training hazırlığı
model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
lora_config = LoraConfig(
r=16, # LoRA rank
lora_alpha=32, # Scaling
target_modules=["q_proj", "v_proj"], # Hangi linear layer’lara ekle
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters() # ✅ Sadece LoRA parametreleri eğitilecek
Ne oluyor?
prepare_model_for_kbit_training → quantize edilmiş modelde gradient flow’unu düzeltir.
get_peft_model → sadece LoRA matrisleri requires_grad=True olur, geri kalan dondurulur ❄️
def format_example(example):
# Basit instruction‑response birleştirme
prompt = f"### Instruction:\n{example['instruction']}\n\n### Response:\n{example['output']}"
return {"text": prompt}
dataset = load_dataset("tatsu-lab/alpaca", split="train")
dataset = dataset.map(format_example, remove_columns=dataset.column_names)
def tokenize(batch):
return tokenizer(
batch["text"],
truncation=True,
max_length=1024,
padding="max_length",
)
tokenized_ds = dataset.map(tokenize, batched=True, remove_columns=["text"])
tokenized_ds.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])
Özet:
format_example → modelin beklediği prompt şablonutokenize → input_ids, attention_mask, labels (labels = input_ids kopyası)training_args = TrainingArguments(
output_dir="./qlora-llama2-7b",
per_device_train_batch_size=2, # 🎛 GPU belleğine göre ayarla
gradient_accumulation_steps=8, # Etkili batch = 2*8 = 16
learning_rate=2e-4,
num_train_epochs=3,
fp16=False, # bf16 kullanıyorsak fp16=False
bf16=True, # Ampere+ GPU’larda bf16 daha stabil
logging_steps=10,
evaluation_strategy="steps",
eval_steps=200,
save_steps=200,
save_total_limit=2,
load_best_model_at_end=True,
metric_for_best_model="eval_loss",
greater_is_better=False,
report_to="wandb", # 👉 "tensorboard" da yazabilirsin
run_name="qlora-llama2-7b-run",
seed=42,
)
Neden bu değerler?
gradient_accumulation_steps → büyük batch simülasyonubf16=True → Ampere (RTX 30xx/40xx, A100) kartlarda hız + numerik stabilitereport_to="wandb" → deneyleri Weights & Biases’ta görselleştirir 📈trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_ds,
tokenizer=tokenizer,
callbacks=[EarlyStoppingCallback(early_stopping_patience=3)], # 3 eval’de iyileşme yoksa dur
)
# 👇 WandB init (opsiyonel ama önerilir)
wandb.init(project="qlora-llama2", name=training_args.run_name, config=training_args.to_dict())
Ne sağlıyor?
EarlyStoppingCallback → overfit önler, zaman kazandırır ⏱wandb.init → hyperparameter’lar, loss grafikleri, model checkpoint’ları tek panelde 🎛trainer.train() # 🚀 Eğitim başlar
trainer.save_model("./qlora-llama2-7b-final") # LoRA adapter + config
tokenizer.save_pretrained("./qlora-llama2-7b-final")
wandb.finish()
Sonuç:
./qlora-llama2-7b-final/ klasöründe sadece LoRA ağırlıkları ve tokenizer bulunur.PeftModel.from_pretrained(base_model, "./qlora-llama2-7b-final") ile birleştirip inference yaparsın 🔁| Adım | Ne yaptık? |
|---|---|
| Quantization | 4‑bit BitsAndBytesConfig ile modeli küçülttük |
| LoRA | LoraConfig + get_peft_model → sadece adapter eğitildi |
| Data | Alpaca → prompt → tokenize → labels kopyalama |
| TrainingArgs | bf16, grad_accum, lr=2e-4, early_stop, wandb |
| Trainer | Trainer + EarlyStoppingCallback |
| Kaydet | LoRA adapter + tokenizer → inference için hazır |
Artık elinde production‑ready bir QLoRA eğitim scripti var.
İstersen deepspeed config ekleyip multi‑GPU’ya ölçeklendirebilir, ya da bitsandbytes 8‑bit deneyerek hız/performans dengeyi test edebilirsin 🛠✨
Kolay gelsin, keyifli eğitimler! 🚀
Modeli eğittikten sonra nasıl performans gösterdiğini anlamak için birden fazla metrik ve insan geri bildirimi kombine ediyorum. İşte benim sık kullandığım stratejiler 🎯:
validation kümesinden 20‑30 rastgele örnek al, modelin ürettiği metni ve hedefi yan yana koy.İpucu: Hata analizini bir tabloya döküp, her iterasyonda "bu kategori %X azaldı" diye takip et. Böylece ilerleme somutlaşır ✅.
Aşağıda evaluate kütüphanesiyle ROUGE skorlarını nasıl topladığımı gösteriyorum. Kodun hemen altında ne yaptığımı anlatıyorum.
from evaluate import load
# ROUGE metriğini yükle
rouge = load("rouge")
def compute_rouge(predictions, references):
"""
predictions: modelin ürettiği metin listesi
references : hedef (ground‑truth) metin listesi
"""
# ROUGE‑1, ROUGE‑2, ROUGE‑L skorlarını hesapla
results = rouge.compute(predictions=predictions, references=references, use_stemmer=True)
return results
# Örnek kullanım
preds = ["model bu cümleyi özetledi", "ikinci tahmin örneği"]
refs = ["bu cümle model tarafından özetlendi", "ikinci referans örneği"]
scores = compute_rouge(preds, refs)
print(scores)
# Çıktı örneği:
# {'rouge1': 0.78, 'rouge2': 0.55, 'rougeL': 0.73, 'rougeLsum': 0.73}
Ne oluyor burada?
load("rouge") ile HF’in hazır metrik nesnesini alırız.compute_rouge fonksiyonu tahmin ve referans listelerini alır, use_stemmer=True ile kökleri eşleştirir.| Kök Neden | Aksiyon |
|---|---|
| Veri kalitesi | Etiket temizliği, veri artırma (back‑translation) ekle. |
| Rank / LoRA boyutu | Rank’ı 8 → 16 ya da 32’ye çıkar, GPU belleği uygun mu kontrol et. |
| Learning rate | 1e‑4 → 5e‑5 dene; warmup step sayısını artır. |
| Araç çağırma başarısı | Few‑shot örneklerle tool prompt’unu zenginleştir, tool_use_accuracy hedef %90 üstüne çek. |
Bu döngüyü her eğitim çalışmasında tekrar ediyorum: metrik → hata analizi → kök neden → hiperparametre/veri güncelleme → yeniden eğitim. Böylece modelin her versiyonu bir öncekisinden ölçülebilir derecede iyileşir 🚀.
Hazırsan bu son bölümü bir kadeh çayla beraber hızlıca geçelim ☕️. Modeli canlıya almak sadece “deploy et” demek değil; ölçeklenebilirlik, güvenilirlik ve sürekli öğrenme bir arada düşünülmeli.
| Aşama | Ne Yapılır? | Neden? |
|---|---|---|
| Canary %5 | Yeni modeli %5 trafiğe yönlendir | Riski minimize et |
| Metrics İzle | Latency, hata oranı, kullanıcı geri bildirimi | Anında rollback kararı ver |
| Gradual Ramp | %10 → %25 → %50 → %100 | Güven artınca yaygınlaştır |
| Feature Flag | model_version=v2 flag’i ile kontrol |
Kod değişikliği olmadan geçiş |
Küçük başla, ölç, büyüt 🎯 — bu mottosunu canlıya almak için Argo Rollouts veya Flagger gibi araçları kullanabilirsin.
model_version tag’ini güncelle, canary’a sok.Son söz: Prod’a çıkmak bir maraton, sprint değil. Küçük başla, ölç, büyüt prensibiyle her adımda veri topla, modelini iyileştir ve kullanıcıya değer kat.
İyi kodlamalar! 🚀
Bu içerik tamamen yapay zeka destekli otomasyon sistemi ile üretilmiştir.
All rights reserved