Upload code/kod/test_smartcore.py with huggingface_hub

code/kod/test_smartcore.py

@@ -0,0 +1,242 @@
+"""
+SmartCore V1 — SIFIRDAN Colab test (standalone / kendine yeten).
+
+Final base modeli (kdirgul/smartcore-v1 son checkpoint) HF'den çeker, metin üretir.
+Model tanımı faz3_train.py ile BİREBİR aynı (içine gömülü) → state_dict tam oturar,
+faz3_train.py'ye bağımlılık YOK.
+
+Ortam: Colab GPU + mamba-og fork (Faz 3a kurulu). CUDA şart (Triton kernel).
+NOT: Bu bir BASE model (instruction yok) → soru-cevap DEĞİL, metin TAMAMLAMA yapar.
+
+Kullanım:
+  HF_TOKEN=hf_xxx python test_smartcore.py --prompt "Türkiye'nin başkenti"
+  HF_TOKEN=hf_xxx python test_smartcore.py                    # interaktif REPL
+  python test_smartcore.py --ckpt /content/ck/step_022887/ckpt.pt   # yerel .pt
+"""
+import os, sys, math, argparse
+import torch, torch.nn as nn, torch.nn.functional as F
+from functools import partial
+
+try:
+    from mamba_ssm.modules.block import Block
+    from mamba_ssm.modules.mamba3 import Mamba3
+    from mamba_ssm.modules.mlp import GatedMLP
+    from mamba_ssm.ops.triton.layer_norm import RMSNorm
+except Exception as e:
+    sys.exit(f"[hata] mamba-og fork import edilemedi ({e!r}). Önce Faz 3a kurulum hücresini çalıştır (CUDA gerekir).")
+
+
+# ───────────── model (faz3_train.py ile BİREBİR AYNI) ─────────────
+def _rms(x, w, eps=1e-5):
+    return (x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + eps)) * w
+
+
+def _rot_half(x):
+    a, b = x.chunk(2, -1)
+    return torch.cat((-b, a), -1)
+
+
+class GQAMixer(nn.Module):
+    def __init__(self, dim, n_heads=12, n_kv=3, base=10000.0, layer_idx=None, device=None, dtype=None):
+        super().__init__()
+        self.nh, self.nkv, self.hd = n_heads, n_kv, dim // n_heads
+        self.rep = n_heads // n_kv
+        fk = {"device": device, "dtype": dtype}
+        self.q_proj = nn.Linear(dim, n_heads * self.hd, bias=False, **fk)
+        self.k_proj = nn.Linear(dim, n_kv * self.hd, bias=False, **fk)
+        self.v_proj = nn.Linear(dim, n_kv * self.hd, bias=False, **fk)
+        self.out_proj = nn.Linear(n_heads * self.hd, dim, bias=False, **fk)
+        self.qn = nn.Parameter(torch.ones(self.hd, **fk))
+        self.kn = nn.Parameter(torch.ones(self.hd, **fk))
+        self.register_buffer(
+            "inv", 1.0 / (base ** (torch.arange(0, self.hd, 2, device=device).float() / self.hd)),
+            persistent=False)
+
+    def _rope(self, x, T):
+        f = torch.outer(torch.arange(T, device=x.device, dtype=torch.float32), self.inv)
+        e = torch.cat((f, f), -1)
+        return (x * e.cos()[None, None] + _rot_half(x) * e.sin()[None, None]).to(x.dtype)
+
+    def forward(self, x, **kw):
+        B, T, _ = x.shape
+        q = self.q_proj(x).view(B, T, self.nh, self.hd).transpose(1, 2)
+        k = self.k_proj(x).view(B, T, self.nkv, self.hd).transpose(1, 2)
+        v = self.v_proj(x).view(B, T, self.nkv, self.hd).transpose(1, 2)
+        q = _rms(q.float(), self.qn.float()).to(x.dtype)
+        k = _rms(k.float(), self.kn.float()).to(x.dtype)
+        q, k = self._rope(q, T), self._rope(k, T)
+        k = k.repeat_interleave(self.rep, 1)
+        v = v.repeat_interleave(self.rep, 1)
+        y = F.scaled_dot_product_attention(q, k, v, is_causal=True)
+        return self.out_proj(y.transpose(1, 2).contiguous().view(B, T, -1))
+
+
+class HybridLM(nn.Module):
+    def __init__(self, cfg, device=None, dtype=None):
+        super().__init__()
+        self.cfg = cfg
+        self.vocab = cfg["vocab_size"]
+        self.scaled_embed = cfg.get("scaled_embed", False)
+        d = cfg["d_model"]
+        self.embedding = nn.Embedding(self.vocab, d, device=device, dtype=dtype)
+        self.layers = nn.ModuleList()
+        self.attn_idx = []
+        for i in range(cfg["n_layers"]):
+            is_attn = ((i + 1) % cfg["attn_every"] == 0) and i != 0 and i != cfg["n_layers"] - 1
+            fk = {"device": device, "dtype": dtype}
+            if is_attn:
+                mixer_cls = partial(GQAMixer, n_heads=cfg["n_heads"], n_kv=cfg["n_kv_heads"],
+                                    layer_idx=i, **fk)
+                self.attn_idx.append(i)
+            else:
+                ssm = dict(d_state=cfg["d_state"], expand=cfg["expand"], headdim=cfg["head_dim"],
+                           ngroups=cfg["ngroups"], rope_fraction=cfg["rope_fraction"],
+                           is_outproj_norm=False, is_mimo=cfg["is_mimo"], mimo_rank=cfg["mimo_rank"],
+                           chunk_size=cfg["chunk_size"])
+                mixer_cls = partial(Mamba3, layer_idx=i, **ssm, **fk)
+            blk = Block(d, mixer_cls,
+                        partial(GatedMLP, hidden_features=cfg["d_intermediate"], out_features=d, **fk),
+                        norm_cls=partial(RMSNorm, eps=1e-5, **fk),
+                        fused_add_norm=True, residual_in_fp32=True)
+            blk.layer_idx = i
+            self.layers.append(blk)
+        self.norm_f = RMSNorm(d, eps=1e-5, device=device, dtype=dtype)
+        self.lm_head = nn.Linear(d, self.vocab, bias=False, device=device, dtype=dtype)
+        self.lm_head.weight = self.embedding.weight   # tied
+
+    def forward(self, ids):
+        h = self.embedding(ids)
+        if self.scaled_embed:
+            h = h * (self.cfg["d_model"] ** 0.5)
+        res = None
+        for l in self.layers:
+            h, res = l(h, res)
+        h = self.norm_f((h + res) if res is not None else h)
+        return self.lm_head(h.to(self.lm_head.weight.dtype))
+
+
+# ───────────── tokenizer + checkpoint ─────────────
+def load_tok(path, token):
+    import sentencepiece as spm
+    if not (path and os.path.exists(path)):
+        from huggingface_hub import hf_hub_download
+        path = hf_hub_download("kdirgul/smartcore-v1", "tokenizer/tokenizer.model",
+                               repo_type="model", token=token)
+    sp = spm.SentencePieceProcessor(model_file=path)
+    print(f"[tok] vocab={sp.get_piece_size()} eos={sp.eos_id()}", flush=True)
+    return sp
+
+
+def resolve_ckpt(spec, repo, token):
+    if spec and spec != "latest_hf":
+        return spec
+    from huggingface_hub import HfApi, hf_hub_download
+    api = HfApi(token=token)
+    files = [f for f in api.list_repo_files(repo, repo_type="model")
+             if f.startswith("checkpoints/step_") and f.endswith("ckpt.pt")]
+    if not files:
+        sys.exit("[hata] HF'de checkpoint yok.")
+    latest = max(files)
+    print(f"[ckpt] HF'den indiriliyor: {latest}", flush=True)
+    return hf_hub_download(repo, latest, repo_type="model", token=token)
+
+
+# ───────────── üretim ─────────────
+@torch.no_grad()
+def generate(model, sp, prompt, max_new=120, temperature=0.7, top_k=40, top_p=0.95,
+             rep_penalty=1.3, dev="cuda", seed=None):
+    if seed is not None:
+        torch.manual_seed(seed)
+    eos = sp.eos_id()
+    ids = sp.encode(prompt, out_type=int)
+    x = torch.tensor([ids], dtype=torch.long, device=dev)
+    out = list(ids)
+    for _ in range(max_new):
+        with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
+            logits = model(x)[0, -1].float()
+        if rep_penalty and rep_penalty != 1.0:
+            for t in set(out):
+                logits[t] = logits[t] / rep_penalty if logits[t] > 0 else logits[t] * rep_penalty
+        if temperature <= 0:
+            nxt = int(logits.argmax())
+        else:
+            logits = logits / temperature
+            if top_k:
+                kth = torch.topk(logits, min(top_k, logits.numel())).values[-1]
+                logits[logits < kth] = -float("inf")
+            probs = F.softmax(logits, dim=-1)
+            if top_p and top_p < 1.0:
+                sp_, si = torch.sort(probs, descending=True)
+                cut = torch.cumsum(sp_, dim=-1) > top_p
+                cut[1:] = cut[:-1].clone(); cut[0] = False
+                sp_[cut] = 0.0
+                probs = torch.zeros_like(probs).scatter_(0, si, sp_)
+                probs /= probs.sum()
+            nxt = int(torch.multinomial(probs, 1))
+        if nxt == eos:
+            break
+        out.append(nxt)
+        x = torch.cat([x, torch.tensor([[nxt]], device=dev)], dim=1)
+        if x.shape[1] >= 2048:
+            x = x[:, -2048:]
+    return sp.decode([t for t in out if t != eos])
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="latest_hf", help="latest_hf | yerel .pt yolu")
+    ap.add_argument("--ckpt_repo", default="kdirgul/smartcore-v1")
+    ap.add_argument("--tokenizer", default=None)
+    ap.add_argument("--prompt", default=None, help="boşsa interaktif REPL")
+    ap.add_argument("--max_new", type=int, default=120)
+    ap.add_argument("--temperature", type=float, default=0.7)
+    ap.add_argument("--top_k", type=int, default=40)
+    ap.add_argument("--top_p", type=float, default=0.95)
+    ap.add_argument("--rep_penalty", type=float, default=1.3)
+    ap.add_argument("--seed", type=int, default=None)
+    args = ap.parse_args()
+
+    if not torch.cuda.is_available():
+        sys.exit("[hata] CUDA yok — Colab GPU gerekir (Triton kernel).")
+    dev = "cuda"
+    torch.set_float32_matmul_precision("high")
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        try:
+            from huggingface_hub import get_token
+            token = get_token()
+        except Exception:
+            token = None
+
+    sp = load_tok(args.tokenizer, token)
+    path = resolve_ckpt(args.ckpt, args.ckpt_repo, token)
+    st = torch.load(path, map_location="cpu")
+    cfg = st["cfg"]
+    print(f"[model] step={st.get('step','?')} | {'MIMO' if cfg.get('is_mimo') else 'SISO'} | "
+          f"n_layers={cfg['n_layers']} | vocab={cfg['vocab_size']}", flush=True)
+
+    model = HybridLM(cfg, device=dev, dtype=torch.bfloat16)
+    miss, unexp = model.load_state_dict(st["model"], strict=False)
+    if miss or unexp:
+        print(f"[uyarı] eksik={len(miss)} beklenmeyen={len(unexp)} (persistent olmayan buffer normal)", flush=True)
+    model.eval()
+    print("[hazır] BASE model — metin TAMAMLAR (soru-cevap değil).\n", flush=True)
+
+    g = lambda p: generate(model, sp, p, args.max_new, args.temperature, args.top_k,
+                           args.top_p, args.rep_penalty, dev, args.seed)
+    if args.prompt is not None:
+        print(f"PROMPT: {args.prompt}\nÇIKTI : {g(args.prompt)}")
+    else:
+        print("İnteraktif — prompt yaz (boş/çık = quit).")
+        while True:
+            try:
+                p = input("\n> ").strip()
+            except (EOFError, KeyboardInterrupt):
+                break
+            if not p or p.lower() in ("quit", "exit", "çık"):
+                break
+            print(g(p))
+
+
+if __name__ == "__main__":
+    main()