Tue Sep 22 2026
Hadi kafa yormadan başlayalım 🚀
Makine öğrenimi dünyasında "overfitting" (aşırı uyum) kavramı neredeyse herkesin burnunu acıtan bir baş ağrısıdır. Model eğitim verisine ezber yapar, test verisinde ise tamamen çöker. Klasik denetimli öğrenmede bu durum neredeyse kaçınılmazdır — model, gördüğü her örnekten "ders çıkarır" sanır ama aslında sadece ezberler.
Peki ajanlar (agents) neden farklı? 🤔
İşte burada sihir başlıyor. Ajanlar sadece veri ile değil, ortam (environment) ile etkileşim kurarak öğrenirler. Bu küçük bir detay gibi görünse de, aslında oyun değiştiren bir farktır.
Keşif vs. Sömürü Dengesı 🎯
Ajan sürekli "Bunu deneyeyim, belki daha iyi bir sonuç çıkar" der (exploration). Sadece bildiği yolu tekrar etmez. Bu doğal olarak ezberlemeyi engeller.
Ödül Sinyali Gecikmelidir ⏳
Eğitim verisinde "doğru cevap" hemen verilmez. Ajan bir eylem yapar, belki 10 adım sonra bir ödül (veya ceza) alır. Bu gecikme, modelin yüzeysel kalıplara kilitlenmesini zorlaştırır.
Dağıtım Değişimi (Distribution Shift) Doğaldır 🔁
Ajan kendi verisini kendi üretir. Her yeni politika (policy) ile veri dağılımı değişir. Model sürekli değişen bir hedefe nişan alır — ezberleme imkansız hale gelir.
Dışarıdan Denetim Yok 🛠
Etiketli veri seti yoktur. "Doğru cevap" bir oracle'dan gelmez, ortamdan gelir. Model kendi hatasından öğrenir, verilen etiketlerden değil.
| Klasik ML | Ajan (RL) |
|---|---|
| Sabit veri seti | Kendi verisini üretir |
| Etiketli örnekler | Ödül sinyali (gecikmeli) |
| Ezberleme riski yüksek | Keşif zorunluluğu ezberi bozar |
| Dağıtım sabit | Dağıtım sürekli değişir |
Bu sayede ne oluyor?
Ajanlar, eğitim verisine "aşırı uymak" yerine strateji öğrenir. Ortamın dinamiklerine uyum sağlar, sadece gördüğü örneklere değil. Bu da onları gerçek dünyada çok daha dayanıklı (robust) kılar ✅
Hazırsan bir sonraki bölümde bunu somut bir örnek üzerinde görelim — kod ile birlikte 🛠
Mükemmel bir model, "her şeyi bilirmiş" gibi davranmak yerine sağduyulu davranan bir arkadaşa benzer. Araştırma ajanlarının da aşırı uyum göstermemesini sağlayan birkaç temel mekanizma var. Hadi bunlara bakalım ve her birini basit bir örnek üzerinden anlayalım. 🎯
Eğer bir ajan sürekli aynı veri kümesine dayanırsa, aynı perspektife sahip olur ve düşüncesi daralır. Tam da bu nedenle çeşitlilik odaklı örneklem çok önemlidir.
# Çeşitlilik odaklı örneklem (basitleştirilmiş özet)
import random
def rastgele_orneklem(veri_seti, adet):
"""Her öğenin önyargı içermemesini sağlayan örneklem fonksiyonu"""
return random.sample(veri_seti, min(adet, len(veri_seti)))
veri = ["rapor", "grafik", "yorum", "listeleme", "yorum"]
seçili = rastgele_orneklem(veri, 2) # Her defasında farklı öğeler
print(seçili)
Ne oluyor? Her çağrıda random.sample(), ajanın çok nadiren gördüğü yönlere açık bir ağı providır. Bir sonraki makinede "yorum" seçilirse, raporlama tarzı çok farklı olabilir. 🔁
Örneklem, varyasyonlu verilere erişimi varsa gerçekten işe yarar. Bu değişkenler arasında şunlar bulunur:
Ajanınıza, her çağrıda en az bir yeni kaynakla beslediğinizde, çoklu bakış açılarını öğrenir ve en sevdiği şablonla kilitlenmez.
Hızlandırılmış eğitimden aşırı eşleştirme eğilimine duyulan ihtiyaç vardır. Eğer ajan, türlerin evrimini takip edemeyecek kadar hızlı öğrenirse, sabit bir perspektife sahip olur.
Bir modelin cevabı, sürekli doğrulanmadığında, model yanlışlyapılar kurmaya başlar. Güçlü bir geri bildirim döngüsü şunları içerir:
Ajanına kontrol mekanizmaları sağladığında, iyi sonuçlar verdiği zaman sadece cezalandırılmasının ardından farklı perspektiflere göz atmaya başlar.
Birkaç faktörü bir araya getirdiğimizde (örneğin, çok çeşitli örnekler, stabil eğitim hızları, çeşitli kaynaklar, düzenli geri bildirim döngüleri), aşırı uyuma karşı dirençli bir ajan elde ederiz. Sonuç olarak, daha gerçekçi, daha esnek, daha güvenilir bir sistem elde ederiz.
Bunlar, bir ajanın yalnızca bir trendi tekrarlamak yerine, bir resmin çoklu yanını görmesini sağlayan temel ayarlar. 📸
Hazırsan başlayalım? 🎯
Birden fazla ajanın bir ortamda birden fazla görevde birlikte öğrenirken nasıl denge kurduğunu anlatacağım. İpuçları çoğunlukla insan beyninin hem yeni bilgiler öğrenirken hem de eski bilgileri koruduğu şekilde uyum sağlamasından geliyor.
for bölümü in bölümler:
bölümü tamamla → birleştirilmiş öngörüler ve deneyimler elde et
deneyimleri tekrar önbelleğine ekle
yeni bir batch örnekle → eski deneyimleri harmanlayarak dengeli bir batch oluştur
kaybı hesapla → RL + düzenleme
politikayı güncelle → ters çevrilmiş gradyan uygulayın
uyumluluk ölçümünü izleyin → değiştirin, örnekleme veya düzenleme oranlarını ayarlayın
Bu kadar!️⃣ Tek bir bölümde uyum düzenleme mekanizmalarını temel alarak her ajanın yeni bir şeyler öğrenirken eskisini unutmamayı nasıl başardığını anlattık. Bir şeyi daha derinlemesine incelemek isterseniz söyleyin, size rehberlik ederim.
Hazırsan başlayalım 🚀
Model düzenleme (model editing), eğitilmiş bir ağı daha küçük, daha hızlı ve daha dağıtıma uygun hale getirmek için kullandığımız bir dizi pratiktir. Öğretmen/araştırmacı olarak sınıfta veya laboratuvarda şu adımları sırayla uygulayabilirsin:
torch.nn.utils.prune ile sarmalayıcı (wrapper) bir katman yazarsın; bu sayede JIT/ONNX export sırasında pruning maskesi de modelin içine gömülür ⛔️➡️✅.# 1️⃣ Pruning maskesini tanımla
prune.l1_unstructured(module.weight, name='weight', amount=0.3)
# 2️⃣ Maskesi modelin state_dict'ine kaydet (JIT/ONNX için)
module.register_buffer('weight_mask', module.weight_mask)
Ne oluyor burada?
l1_unstructured → ağırlıkların %30’unu sıfırlar.register_buffer → maskeyi modelin bir parçası yapar; torch.jit.trace ederken kaybolmaz 🛡.import torch
import torch.nn as nn
import torch.nn.utils.prune as prune
def apply_pruning(model: nn.Module, amount: float = 0.3) -> nn.Module:
"""
Modeldeki tüm Linear ve Conv2d katmanlarına
global L1 unstructured pruning uygular ve maskeleri buffer olarak kaydeder.
"""
for name, module in model.named_modules():
if isinstance(module, (nn.Linear, nn.Conv2d)):
# 1️⃣ Prune
prune.l1_unstructured(module, name='weight', amount=amount)
# 2️⃣ Maskeyi kalıcı hale getir (JIT/ONNX dostu)
prune.remove(module, 'weight') # parametreleri sıkıştır
module.register_buffer('weight_mask', # maski buffer olarak sakla
module.weight_mask)
return model
def fine_tune(model: nn.Module,
dataloader: torch.utils.data.DataLoader,
epochs: int = 3,
lr: float = 1e-4) -> None:
"""Kısaltılmış modeli hızlıca fine-tune eder."""
model.train()
optimizer = torch.optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=lr)
criterion = nn.CrossEntropyLoss()
for epoch in range(epochs):
for x, y in dataloader:
optimizer.zero_grad()
loss = criterion(model(x), y)
loss.backward()
optimizer.step()
print(f"Epoch {epoch+1}/{epochs} – loss: {loss.item():.4f}")
# -------------------- KULLANIM --------------------
if __name__ == "__main__":
# Basit bir toy model
class TinyNet(nn.Module):
def __init__(self):
super().__init__()
self.fc1 = nn.Linear(784, 256)
self.fc2 = nn.Linear(256, 10)
def forward(self, x):
return self.fc2(torch.relu(self.fc1(x)))
model = TinyNet()
print("🔧 Pruning öncesi parametre sayısı:",
sum(p.numel() for p in model.parameters()))
# 1️⃣ Pruning uygula
model = apply_pruning(model, amount=0.4)
print("✂️ Pruning sonrası parametre sayısı:",
sum(p.numel() for p in model.parameters() if p.requires_grad))
# 2️⃣ Dummy dataloader ile fine-tune
dummy_loader = torch.utils.data.DataLoader(
torch.utils.data.TensorDataset(torch.randn(64, 784), torch.randint(0, 10, (64,))),
batch_size=16, shuffle=True)
fine_tune(model, dummy_loader, epochs=2)
# 3️⃣ JIT export testi (maskeler dahil)
scripted = torch.jit.trace(model, torch.randn(1, 784))
scripted.save("tiny_pruned.pt")
print("💾 JIT model kaydedildi → tiny_pruned.pt")
Bu sayede ne oluyor?
apply_pruning → tek fonksiyonla tüm uygun katmanları kısaltır ve maskeleri modelin içine gömer.prune.remove → sıfırlanan ağırlıkları gerçekten siler, model boyutunu düşürür.fine_tune → birkaç epoch ile doğruluk geri kazanılır.torch.jit.trace → maskeler de dahil tam dağıtıma hazır bir .pt dosyası üretir 📦.apply_pruning(model, amount=0.3) çağırfine_tune(model, loader, epochs=3) koşturtorch.jit.trace / torch.onnx.export ile production artifact üretHadi şimdi kendi modeline dene ve sonuçları paylaşalım! 🤝
Hazırsan başlayalım 🎯. Ajanlarımızı eğitirken aşırı uyum (overfitting) büyük bir engel olabilir. Bunu azaltmak için veri setini akıllıca örnekleyip her epoch'ta farklı bir bakış açısı sunabiliriz. İşte sık kullanılan üç strateji:
Bu yöntemler birleştirildiğinde, ajan genelleme yeteneği artar ve üretimdeki sürprizler minimuma iner 🛠.
Aşağıdaki script, data/ klasöründeki tüm .csv dosyalarından her epoch'ta %20 lik rastgele bir örneklem çeker ve train.py’i çağırır. Terminalde doğrudan çalıştırabilirsiniz 🚀.
#!/usr/bin/env bash
# dynamic_training.sh – Her epoch rastgele %20 veri ile eğitim
set -euo pipefail
DATA_DIR="data"
EPOCHS=10
SAMPLE_RATIO=0.2 # %20
TRAIN_SCRIPT="train.py"
# Veri dosyalarını topla
mapfile -t FILES < <(find "$DATA_DIR" -name "*.csv" -type f)
if [[ ${#FILES[@]} -eq 0 ]]; then
echo "❌ Hiç veri dosyası bulunamadı: $DATA_DIR"
exit 1
fi
for ((epoch=1; epoch<=EPOCHS; epoch++)); do
echo "🔁 Epoch $epoch başlıyor..."
# Rastgele dosya seç ve içinden %20 satır çek
SELECTED_FILE="${FILES[$RANDOM % ${#FILES[@]}]}"
TOTAL_LINES=$(wc -l < "$SELECTED_FILE")
SAMPLE_LINES=$(awk -v total="$TOTAL_LINES" -v ratio="$SAMPLE_RATIO" 'BEGIN{print int(total*ratio)}')
# Geçici örneklem dosyası oluştur
SAMPLE_FILE=$(mktemp --suffix=.csv)
shuf -n "$SAMPLE_LINES" "$SELECTED_FILE" > "$SAMPLE_FILE"
# Eğitimi başlat
python "$TRAIN_SCRIPT" --input "$SAMPLE_FILE" --epoch "$epoch"
# Geçici dosyayı temizle
rm -f "$SAMPLE_FILE"
echo "✅ Epoch $epoch tamamlandı."
done
echo "🎉 Tüm epoch'lar bitti."
Ne oluyor burada?
find ile veri dosyalarını listeleriz.shuf komutu sayesinde rastgele satırlar çekeriz — bu da dinamik örneklemi simüle eder.train.py’e veririz; script bittiğinde temizleriz.Bu basit döngü, modelin her seferinde farklı bir bakış açısı kazanmasını sağlar ve overfitting riskini ciddi oranda düşürür 🛡️.
İpucu: SAMPLE_RATIO veya EPOCHS değerlerini projenizin büyüklüğüne göre ayarlayın. Küçük veri setlerinde %30‑%40, büyüklerde %10‑%15 genellikle iyi işler 🎯.
# MemoryMonitor — Basit bir not defteri stili taslak
# -------------------------------------------------
# Görev: Kaybolan örnekleri izle ve hızla uyumla
# -------------------------------------------------
class MemoryMonitor:
def __init__(self, gamma=0.9):
self.kayip = {} # {örnek_id: değerler}
self.hız = 0.0 # yavaşlama katsayısı
self.uyum_bayrağı = True
def kayıp_ekle(self, örnek_id, değer):
if örnek_id not in self.kayip:
self.kayip[örnek_id] = []
self.kayip[örnek_id].append(değer)
def hız_hesapla(self):
toplam_kayip = sum(len(v) for v in self.kayip.values())
if toplam_kayip == 0:
return 0.0
# Basit kayıp oranı: en son iki kayıp arasındaki fark
son_döngü = {k: v[-1] if v else 0 for k, v in self.kayip.items()}
eski = {k: v[-2] if len(v) > 1 else v[-1] for k, v in self.kayip.items()}
fark = sum(abs(son - eski) for son, eski in zip(son_döngü.values(), eski.values()))
self.hız = gamma * self.hız + (1 - gamma) * fark
return self.hız
def uyum_kontrolü(self):
# Basit kural: hız çok yüksekse uyum bayrağını devre dışı bırak
if self.hız > 0.5:
self.uyum_bayrağı = False
return self.uyum_bayrağı
Ne oluyor burada? Sınıf, kayıp değerleri için küçük bir bellek tutar, zaman içindeki kayıp değişimlerine dayalı basit bir öğrenme hızı hesaplar ve öğrenme “çok hızlı” ve dengesizleşmeye başlarsa uygunluk bayrağını devre dışı bırakır.
class MemoryMonitor:
def __init__(self, gamma=0.9):
self.kayip = {}
self.hız = 0.0
self.uyum_bayrağı = True
def kayıp_ekle(self, örnek_id, değer):
if örnek_id not in self.kayip:
self.kayip[örnek_id] = []
self.kayip[örnek_id].append(değer)
def hız_hesapla(self):
toplam_kayip = sum(len(v) for v in self.kayip.values())
if toplam_kayip == 0:
return 0.0
son_döngü = {k: v[-1] for k, v in self.kayip.items()}
eski = {k: v[-2] if len(v) > 1 else v[-1] for k, v in self.kayip.items()}
fark = sum(abs(son - eski) for son, eski in zip(son_döngü.values(), eski.values()))
self.hız = 0.9 * self.hız + 0.1 * fark
return self.hız
def uyum_kontrolü(self):
if self.hız > 0.5:
self.uyum_bayrağı = False
return self.uyum_bayrağı
Nasıl çalışıyor?
Eğer hız değerinde ani bir artış görürseniz (yani kaybedilen örnekler arasında büyük bir değişim olursa), uyum_bayrağı otomatik olarak devre dışı kalır. Böylece ajan, hızı çok yüksek bir düzeye sürükleyebilecek durumdan kaçınır, ve bu da onu hataya karşı daha dayanıklı hale getirir.
Hazırsan tek bir dosyada model düzenleme, akıllı örnekleme ve hafıza/kayma kontrolü birleşen küçük bir eğitim döngüsü yazalım.
Aşağıdaki kod Jupyter hücresi mantığında kısaltılmış — kopyala, bir .py dosyasına yapıştır ya da notebook'ta çalıştır, hemen deneyebilirsin 🎯
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset, Subset
import random
import numpy as np
from collections import deque
Not: Gerçek projede
transformers,accelerate,wandbvb. de ekleriz; burada minimal bağımlılık tutuyoruz.
class ToyDataset(Dataset):
"""Basit sentetik veri: (input_id, target_id) çiftleri."""
def __init__(self, size=10_000, vocab_size=1000, seq_len=32):
self.data = torch.randint(0, vocab_size, (size, seq_len))
self.targets = torch.randint(0, vocab_size, (size, seq_len))
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return self.data[idx], self.targets[idx]
def get_dynamic_loader(dataset, batch_size, step, base_ratio=0.1, max_ratio=0.5):
"""
Eğitim ilerledikçe **daha zor** örnekleri (ör. loss'u yüksek olanları)
daha sık görmek için alt küme oranını artırır.
"""
ratio = min(base_ratio + step * 0.0002, max_ratio) # lineer büyür
subset_size = int(len(dataset) * ratio)
indices = torch.randperm(len(dataset))[:subset_size]
return DataLoader(Subset(dataset, indices), batch_size=batch_size, shuffle=True)
Ne oluyor burada?
ToyDataset → hızlı deneme için rasgele token dizileri üretir.get_dynamic_loader → her step'de önekleme oranını (ratio) biraz artırır; model "kolay" örneklerden sıkılmaz 🔁class TinyModel(nn.Module):
def __init__(self, vocab_size=1000, dim=256, n_layers=4):
super().__init__()
self.emb = nn.Embedding(vocab_size, dim)
self.blocks = nn.ModuleList([
nn.TransformerEncoderLayer(d_model=dim, nhead=4, dim_feedforward=dim*4, batch_first=True)
for _ in range(n_layers)
])
self.head = nn.Linear(dim, vocab_size)
# ---- LoRA benzeri düşük-rank adaptörler (sadece eğitilecek) ----
self.lora_A = nn.ParameterList([nn.Parameter(torch.randn(dim, 8) * 0.01) for _ in range(n_layers)])
self.lora_B = nn.ParameterList([nn.Parameter(torch.zeros(8, dim)) for _ in range(n_layers)])
# freeze ana ağırlıklar
for p in self.emb.parameters(): p.requires_grad = False
for blk in self.blocks:
for p in blk.parameters(): p.requires_grad = False
for p in self.head.parameters(): p.requires_grad = False
def forward(self, x):
x = self.emb(x)
for i, blk in enumerate(self.blocks):
# LoRA enjeksiyonu: x + x @ A @ B
lora_update = x @ self.lora_A[i] @ self.lora_B[i]
x = blk(x + lora_update)
return self.head(x)
✅ Neden bu yapı?
peft kütüphanesini kullanırsın; burası şeffaf öğretici versiyon.class DriftMonitor:
"""Basit EMA tabanlı kayma takibi + örnek hafıza tamponu."""
def __init__(self, window=100, drift_thresh=0.15):
self.loss_ema = None
self.window = window
self.drift_thresh = drift_thresh
self.buffer = deque(maxlen=5000) # replay buffer
def update(self, loss_val, batch_x, batch_y):
# EMA güncelle
if self.loss_ema is None:
self.loss_ema = loss_val
else:
self.loss_ema = 0.99 * self.loss_ema + 0.01 * loss_val
# Örnekleri buffer'a at (loss yüksekse öncelikli)
for x, y, l in zip(batch_x, batch_y, loss_val if isinstance(loss_val, list) else [loss_val]*len(batch_x)):
self.buffer.append((x.clone(), y.clone(), float(l)))
def check_drift(self, current_loss):
"""EMA'dan sapma büyükse True döner."""
if self.loss_ema is None:
return False
return abs(current_loss - self.loss_ema) / (self.loss_ema + 1e-8) > self.drift_thresh
def sample_replay(self, k=32):
"""Yüksek loss'lu örneklerden küçük bir replay batch'i."""
if len(self.buffer) < k:
return None
# loss'a göre ağırlıklı örnekle
losses = np.array([item[2] for item in self.buffer])
probs = losses / losses.sum()
idx = np.random.choice(len(self.buffer), k, p=probs, replace=False)
xs, ys, _ = zip(*[self.buffer[i] for i in idx])
return torch.stack(xs), torch.stack(ys)
Özet:
loss_ema → ani düşüş/artışları yumuşatır.buffer → modelin unuttuğu zor örnekleri replay eder (catastrophic forgetting'e karşı) 🛡check_drift → kayma tespit edilirse öğrenme oranını düşürebilir veya düzenlemeyi tetikleyebilirsin.device = "cuda" if torch.cuda.is_available() else "cpu"
model = TinyModel().to(device)
opt = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=3e-4)
dataset = ToyDataset()
monitor = DriftMonitor()
MAX_STEPS = 5000
EVAL_EVERY = 500
BATCH_SIZE = 64
for step in range(1, MAX_STEPS + 1):
# 1️⃣ Dinamik veri yükleyici
loader = get_dynamic_loader(dataset, BATCH_SIZE, step)
x, y = next(iter(loader))
x, y = x.to(device), y.to(device)
# 2️⃣ Forward + loss
logits = model(x)
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), y.view(-1), reduction="none")
loss_per_sample = loss.view(x.size(0), -1).mean(dim=1) # [B]
batch_loss = loss_per_sample.mean()
# 3️⃣ Backward + step
opt.zero_grad()
batch_loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
opt.step()
# 4️⃣ İzleme ve replay
monitor.update(loss_per_sample.detach().cpu().numpy(), x.detach().cpu(), y.detach().cpu())
# 5️⃣ Kayma kontrolü → replay batch ile ekstra step
if monitor.check_drift(batch_loss.item()):
replay = monitor.sample_replay(k=32)
if replay:
rx, ry = replay[0].to(device), replay[1].to(device)
r_logits = model(rx)
r_loss = F.cross_entropy(r_logits.view(-1, r_logits.size(-1)), ry.view(-1))
opt.zero_grad()
r_loss.backward()
opt.step()
print(f"⚠️ Step {step}: Drift tespit edildi → replay step yapıldı (loss={r_loss.item():.4f})")
# 6️⃣ Log
if step % EVAL_EVERY == 0:
print(f"Step {step:5d} | loss={batch_loss.item():.4f} | ema={monitor.loss_ema:.4f} | buffer={len(monitor.buffer)}")
print("✅ Eğitim bitti.")
| Ne değiştirmek istersin? | Nereden müdahale edersin? |
|---|---|
| Farklı model mimarisi | TinyModel sınıfını değiştir (ör. LlamaForCausalLM + peft.LoraConfig) |
| Daha karmaşık örnekleme | get_dynamic_loader içine loss-temelli priority sampling ekle |
| Daha akıllı kayma takibi | DriftMonitor → river.drift.ADWIN veya skmultiflow entegre et |
| Çoklu GPU / FSDP | accelerate wrapper + DistributedSampler ekle |
| Gerçek veri | ToyDataset yerine datasets.load_dataset("wiki_text") + tokenizer |
get_dynamic_loader eğitim ilerledikçe zor örnekleri öne çekiyor.DriftMonitor EMA + replay buffer ile unutmayı engelliyor.Bir sonraki bölümde bu scripti GPU kümesinde nasıl ölçeklendireceğimize (DeepSpeed / FSDP) bakacağız. Görüşmek üzere! 👋
Eğitmenler olarak ajanslarımızın bir günlük hava durumu kadar değişmediğini düşünmemeliyiz. En iyi modeller bile, veriler ve görevler zaman içinde değiştiğinde performansını kaybeder. İşte tam da bu noktada sürekli izleme ve adaptif öğrenme devreye giriyor.
Aşağıda, eğitmenin zaman içinde temel metrikleri (örn. ödül, doğruluk, kayıp) yakalamasına olanak tanıyan minimalist bir simülasyon var. Pratik, anlaşılır ve hemen çalışmaya başlayabilirsiniz.
# log_simulation.py
import json
from datetime import datetime, timedelta
def simulate_training(episodes=30, initial_reward=0.0, initial_accuracy=0.6):
logs = []
current_reward = initial_reward
current_accuracy = initial_accuracy
for episode in range(1, episodes + 1):
# Her bölümde metriklerde küçük, gerçekçi değişiklikler simüle et
current_reward += 0.05 + (0.02 * (episode % 5))
current_accuracy += 0.01 * (episode % 4)
if current_accuracy > 0.99:
current_accuracy = 0.99
log_entry = {
"episode": episode,
"timestamp": (datetime.utcnow() + timedelta(hours=3)).isoformat(),
"reward": round(current_reward, 4),
"accuracy": round(current_accuracy, 4),
"notes": "✅ İlerleme" if episode % 7 != 0 else "⚠️ Sıkıntı"
}
logs.append(log_entry)
# Belki sadece son birkaç günlüğü istediğinizde faydalı olur
return logs[-5:]
# Örnek kullanım
if __name__ == "__main__":
recent_logs = simulate_training(episodes=30)
print(json.dumps(recent_logs, indent=2))
Bu sayede ne oluyor?
notes alanı, beleşe indirmeleri veya ani düşüşleri işaretler.log_entry dosyası depolansın.matplotlib ile birkaç satırlık bir komut ile hızlıca bir çizim yapın.reward veya accuracy beklendiği gibi değişmiyorsa, basit bir uyarı (örn. e-posta veya Slack bildirimi) gönderin.Sürekli izleme ve adaptif öğrenme, yapay zeka eğitimini statik bir "defa çalıştır" sürecinden uzaklaştırıp sürekli gelişime doğru bir adım attırıyor. İlk günümüzdeki basit günlükler, ileride makine öğrenimi modellerini gerçek zamanlı olarak şekillendirecek, kendi kendini iyileştiren sistemlere dönüşecek.
Şimdi başlayın, her eğitim oturumunu bir öğrenme fırsatı olarak görün ve günlükler size hikayeyi anlatmasına izin verin. 🚀
Arkadaş, gelin durumu özetleyelim. Uzun vadede dayanıklı bir ajan inşa etmek, tek bir "sihirli" teknikten değil, dört temel piedra birleşiminden doğuyor 🎯
Bu dörtlü izole çalışırsa zayıf kalır. Birleştirildiklerinde ise ajanınız "sadece cevap veren" bir chatbot'tan çıkıp, plan yapan, hataından ders alan, bağlamı koruyan bir ortak haline gelir 🛠
Unutmayın: Mükemmel ajan gün içinde inşa edilmez. Küçük, sürekli, bilinçli adımlarla şekillenir. Bugün attığınız bir adım, yarın ajanınızı "dayanıklı" kılan temel olabilir.
Sen yapabilirsin — hadi geliştirelim! 💪✨
Bu içerik tamamen yapay zeka destekli otomasyon sistemi ile üretilmiştir.
All rights reserved