egitim/: v2 betikleri ve veri ozetleri

egitim/dogal_egitim32.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+"""Dogal-CPT (32B surumu): Erk-32B'ye (birlesik-075) DOGAL Turkce metinle (FineWeb-2 tur_Latn, gorulmemis parcalar) tam-parametre devam egitimi.
+
+NEDEN BU RECETE
+  Iki onceki recete (sozluk genisletme, sentetik kural-CPT) on-kayitli olcutleri gecemedi. Teshis: Erk'in
+  acigi istisna kovalarinda (unlu dusmesi, uyum kirici, ikizlesme, kisaltma, sayi) — bunlar SOZLUKSEL bilgi,
+  sablonla ogretilemez; dogal metinde dogal sikliklariyla gorulerek ogrenilir (2B Turkce-yerli modellerin yolu).
+  Sentetik veri tamami duzenli uyum ornegi oldugu icin uyum-kirici kovasini GERILETMISTI; dogal metinde bu
+  yanlilik yok.
+  Teknik duzeltme: onceki egitimler saf bf16 AdamW ile lr 1e-5 kullandi; bf16'da 1e-5'lik guncelleme cogu
+  agirlik icin yarim ulp'nin altinda kalir ve YUVARLANIR (agirlik_degisim.py teshisi). Burada fp32 ANA
+  AGIRLIK tutulur: ileri/geri bf16, optimizer fp32, her adimda bf16'ya kopyalanir.
+
+VERI
+  dogal_metin.txt (dogal_secim.py: %70 rastgele paragraf + %30 kesme-isaretli-cekim yogun paragraf; kiyas
+  maddesi/sablonu/govde listesi/TDK sozlugu KULLANILMADI; sozluk-maddesi gorunumlu satirlar atildi).
+  Sohbet yetenegini korumak icin ~her 12 paragrafta bir SFT konusmasi (sft_clean_v2, sohbet sablonuyla).
+
+ON-KAYITLI BASARI OLCUTLERI (sonuca bakilmadan yazildi; karar DEV kesitinde, cekirdek bir kez olculur)
+  A) TurkishMMLU, ayni betik, ayni 652 soru: dogal >= taban - 1,0 puan
+  B) DEV kesiti (2.000 cekirdek-disi madde, kova oranlari cekirdekle ayni): hucre-kumeli esli fark
+     anlamli pozitif VE >= +1,5 puan
+  C) DEV'de hicbir kovada anlamli gerileme yok
+  Ucu gecerse 3.6 cekirdegi BIR KEZ olculur ve tabloya o sayi girer; ayni recete 32B'ye uygulanir.
+  Gecmezse model yayimlanmaz, 32B'ye uygulanmaz. Kontrol noktasi secimi de yalniz DEV ile yapilir.
+"""
+import os, random, time, json, torch, torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+MODEL = os.environ.get("MODEL", "/ari/users/ytanis/erk32b-birlesik-075")
+GENEL = os.environ.get("GENEL", "/ari/users/ytanis/dogal_metin.txt")
+SFT = os.environ.get("SFT", "/ari/users/ytanis/erk/sft_clean_v2.jsonl")
+CIK = os.environ.get("CIK", "/ari/users/ytanis/erk32b-dogal")
+OPT = os.environ.get("OPT", "adafactor_sr")   # adafactor_sr: fp32 ana agirlik YOK, bf16 parametre + KARARLI (stokastik) YUVARLAMA   # 32B: Adam durumlari (256 GB) 4xA100'a sigmaz; Adafactor faktorlu durum, fp32 ana agirlik korunur
+KAYDET = os.environ.get("KAYDET", "1") == "1"
+UZUNLUK = int(os.environ.get("UZUNLUK", "1024"))
+ADIM = int(os.environ.get("ADIM", "9000"))
+YIGIN = int(os.environ.get("YIGIN", "2")); BIRIKIM = int(os.environ.get("BIRIKIM", "8"))
+LR = float(os.environ.get("LR", "1e-5"))
+SFT_HER = int(os.environ.get("SFT_HER", "12"))
+SENTETIK = os.environ.get("SENTETIK", "")                 # tur 2: kural cumleleri (kisaltma/sayi/cati), kiyas govdeleri DISLANMIS
+SENTETIK_ORAN = float(os.environ.get("SENTETIK_ORAN", "0.0"))
+SURE_DK = float(os.environ.get("SURE_DK", "1560")); KAYIT_HER = int(os.environ.get("KAYIT_HER", "3000"))
+yaz = lambda *a: print(*a, flush=True)
+t_bas = time.time()
+if not torch.cuda.is_available(): raise SystemExit("CUDA yok")
+tok = AutoTokenizer.from_pretrained(MODEL)
+model = AutoModelForCausalLM.from_pretrained(MODEL, dtype=torch.bfloat16, device_map="balanced")
+model.gradient_checkpointing_enable(); model.config.use_cache = False
+aygit = model.get_input_embeddings().weight.device
+yaz("model yerlesimi:", sorted({str(p.device) for p in model.parameters()}))
+
+class Karisim(Dataset):
+    def __init__(self, n_blok):
+        rng = random.Random(20260926)
+        sft_f = open(SFT, encoding="utf8"); self.blok, tampon, say, n_sft, n_sent = [], [], 0, 0, 0
+        sent = []
+        if SENTETIK:
+            sent = [l.strip() for l in open(SENTETIK, encoding="utf8", errors="ignore") if l.strip()]; rng.shuffle(sent)
+        with open(GENEL, encoding="utf8", errors="ignore") as f:
+            for satir in f:
+                say += 1
+                if sent and rng.random() < SENTETIK_ORAN:
+                    # bir paragraf yerine 3-6 kural cumlesi (tek satir), dogal metnin arasina serpistirilir
+                    k = rng.randint(3, 6); satir = " ".join(sent[n_sent % len(sent): n_sent % len(sent) + k]) + "\n"; n_sent += k
+                elif say % SFT_HER == 0:
+                    ln = sft_f.readline()
+                    if ln:
+                        try:
+                            msg = json.loads(ln)["messages"]
+                            satir = tok.apply_chat_template(msg, tokenize=False) + "\n"; n_sft += 1
+                        except Exception: pass
+                tampon += tok(satir, add_special_tokens=False).input_ids + [tok.eos_token_id]
+                while len(tampon) >= UZUNLUK + 1:
+                    self.blok.append(tampon[:UZUNLUK + 1]); tampon = tampon[UZUNLUK:]
+                    if len(self.blok) >= n_blok:
+                        yaz("veri: %d blok · %d paragraf · %d SFT konusmasi · %d sentetik cumle" % (len(self.blok), say, n_sft, n_sent)); return
+        yaz("veri: %d blok (dosya bitti) · %d paragraf · %d SFT · %d sentetik" % (len(self.blok), say, n_sft, n_sent))
+    def __len__(self): return len(self.blok)
+    def __getitem__(self, i):
+        b = torch.tensor(self.blok[i]); return b[:-1], b[1:]
+
+veri = Karisim(ADIM * YIGIN * BIRIKIM + 500)
+dl = DataLoader(veri, batch_size=YIGIN, shuffle=True, num_workers=4, drop_last=True)
+
+def ara_kayit(et):
+    y = CIK + "-" + et; os.makedirs(y, exist_ok=True)
+    model.save_pretrained(y, safe_serialization=True); tok.save_pretrained(y); yaz("  ara kayit:", y)
+
+for p in model.parameters(): p.requires_grad = True
+egitilen = [p for p in model.parameters()]
+ANA = OPT != "adafactor_sr"
+if ANA:
+    # fp32 ana agirliklar (ayni aygitta), optimizer bunlarin uzerinde
+    ana = [p.detach().to(torch.float32).clone() for p in egitilen]
+    for m in ana: m.requires_grad = True
+else:
+    ana = egitilen
+
+def sr_bf16(x32):
+    """fp32 -> bf16 KARARLI yuvarlama: alt 16 bite rastgele ekle, sonra kes. Kucuk guncellemeler
+    ortalamada korunur (deterministik yuvarlama 1e-5'lik guncellemeyi cogu agirlikta yutar)."""
+    b = x32.view(torch.int32)
+    b = b + torch.randint(0, 1 << 16, b.shape, device=b.device, dtype=torch.int32)
+    return (b & -65536).view(torch.float32).to(torch.bfloat16)
+
+if OPT == "adafactor_sr":
+    import math
+    from transformers.optimization import Adafactor
+    class AdafactorSR(Adafactor):
+        """transformers 5.13 Adafactor.step ile birebir; tek fark: bf16 parametreye geri yazarken sr_bf16."""
+        @torch.no_grad()
+        def step(self, closure=None):
+            for group in self.param_groups:
+                for p in group["params"]:
+                    if p.grad is None: continue
+                    grad = p.grad.float() if p.grad.dtype in (torch.float16, torch.bfloat16) else p.grad
+                    state = self.state[p]; grad_shape = grad.shape
+                    factored, use_first_moment = self._get_options(group, grad_shape)
+                    if len(state) == 0:
+                        state["step"] = 0
+                        if use_first_moment: state["exp_avg"] = torch.zeros_like(grad)
+                        if factored:
+                            state["exp_avg_sq_row"] = torch.zeros(grad_shape[:-1]).to(grad)
+                            state["exp_avg_sq_col"] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad)
+                        else: state["exp_avg_sq"] = torch.zeros_like(grad)
+                        state["RMS"] = 0
+                    p32 = p.float()
+                    state["step"] += 1; state["RMS"] = self._rms(p32); lr = self._get_lr(group, state)
+                    beta2t = 1.0 - math.pow(state["step"], group["decay_rate"])
+                    update = (grad ** 2) + group["eps"][0]
+                    if factored:
+                        r, c = state["exp_avg_sq_row"], state["exp_avg_sq_col"]
+                        r.mul_(beta2t).add_(update.mean(dim=-1), alpha=(1.0 - beta2t))
+                        c.mul_(beta2t).add_(update.mean(dim=-2), alpha=(1.0 - beta2t))
+                        update = self._approx_sq_grad(r, c); update.mul_(grad)
+                    else:
+                        v = state["exp_avg_sq"]; v.mul_(beta2t).add_(update, alpha=(1.0 - beta2t)); update = v.rsqrt().mul_(grad)
+                    update.div_((self._rms(update) / group["clip_threshold"]).clamp_(min=1.0)); update.mul_(lr)
+                    if use_first_moment:
+                        e = state["exp_avg"]; e.mul_(group["beta1"]).add_(update, alpha=(1 - group["beta1"])); update = e
+                    if group["weight_decay"] != 0: p32.add_(p32, alpha=(-group["weight_decay"] * lr))
+                    p32.add_(-update)
+                    p.copy_(sr_bf16(p32) if p.dtype == torch.bfloat16 else p32)
+                    del p32, update
+            return None
+    opt = AdafactorSR(ana, lr=LR, scale_parameter=False, relative_step=False, warmup_init=False, weight_decay=0.01, beta1=None)
+elif OPT == "adafactor":
+    from transformers.optimization import Adafactor
+    opt = Adafactor(ana, lr=LR, scale_parameter=False, relative_step=False, warmup_init=False, weight_decay=0.01, beta1=None)
+else:
+    opt = torch.optim.AdamW(ana, lr=LR, weight_decay=0.01, foreach=False)
+plan = torch.optim.lr_scheduler.OneCycleLR(opt, max_lr=LR, total_steps=ADIM, pct_start=0.05, cycle_momentum=(OPT not in ("adafactor", "adafactor_sr")))
+yaz("=== DOGAL-CPT-32B · optimizer %s" % OPT)
+yaz("=== DOGAL-CPT · %d adim · %d jeton/adim · lr %.1e · %s · %.2f B parametre"
+    % (ADIM, UZUNLUK * YIGIN * BIRIKIM, LR, "fp32 ana agirlik" if ANA else "bf16 + kararli yuvarlama", sum(p.numel() for p in egitilen) / 1e9))
+try:
+    for g in range(torch.cuda.device_count()):
+        yaz("   kart %d: %.1f / %.1f GB" % (g, torch.cuda.memory_allocated(g) / 2**30, torch.cuda.get_device_properties(g).total_memory / 2**30))
+except Exception as e: yaz("   (bellek raporu yok: %s)" % e)
+
+model.train(); i = biriken = 0; t0 = time.time(); kayip = None; degisen_ilk = None
+while i < ADIM:
+    for x, y in dl:
+        if i >= ADIM: break
+        lg = model(input_ids=x.to(aygit)).logits
+        kayip = F.cross_entropy(lg.float().view(-1, lg.size(-1)), y.to(lg.device).view(-1))
+        (kayip / BIRIKIM).backward(); biriken += 1
+        if biriken == BIRIKIM:
+            torch.nn.utils.clip_grad_norm_(egitilen, 1.0)
+            if ANA:
+                with torch.no_grad():
+                    for m, p in zip(ana, egitilen):
+                        m.grad = p.grad.to(torch.float32); p.grad = None
+            with torch.no_grad():
+                if i == 0: p0 = egitilen[len(egitilen)//2]; once = p0.detach().clone()
+            opt.step(); plan.step(); opt.zero_grad(set_to_none=True)
+            with torch.no_grad():
+                if ANA:
+                    for m, p in zip(ana, egitilen): p.copy_(m.to(p.dtype))
+                if i == 0:
+                    yaz("  ilk adimda bf16'da degisen agirlik orani (orta katman): %.4f" % (p0 != once).float().mean().item())
+            biriken = 0; i += 1
+            if i % 100 == 0:
+                yaz("  adim %5d/%d | kayip %.4f | %.1f dk | %.0f jeton/sn" % (i, ADIM, float(kayip), (time.time() - t0) / 60,
+                    i * UZUNLUK * YIGIN * BIRIKIM / (time.time() - t0)))
+            if i % KAYIT_HER == 0 and KAYDET: ara_kayit("adim%d" % i)
+            if i == 3 or i % 500 == 0:
+                try: yaz("   bellek zirve:", " ".join("%d:%.0fGB" % (g, torch.cuda.max_memory_allocated(g)/2**30) for g in range(torch.cuda.device_count())))
+                except Exception: pass
+            if (time.time() - t_bas) / 60 > SURE_DK:
+                yaz("  !! sure butcesi doldu, %d. adimda kesiliyor" % i); i = ADIM; break
+
+model.config.use_cache = True
+if KAYDET:
+    os.makedirs(CIK, exist_ok=True); model.save_pretrained(CIK, safe_serialization=True); tok.save_pretrained(CIK)
+yaz("yazildi: %s  (%.1f dk)" % (CIK, (time.time() - t_bas) / 60))