Upload 15_scugnizz_chat_gui_agent_v2_fixed.py with huggingface_hub

15_scugnizz_chat_gui_agent_v2_fixed.py

@@ -0,0 +1,883 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# /// script
+# dependencies = ["torch","datasets","transformers","huggingface_hub","numpy","hf_xet"]
+# ///
+# SFT ScugnizzLLM-1.3B PCS from 1B-token pretrain checkpoint.
+
+import argparse, json, math, random, time, sys, os, re
+from contextlib import nullcontext
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from datasets import load_dataset
+from huggingface_hub import HfApi, upload_folder, hf_hub_download
+from transformers import GPT2TokenizerFast
+
+
+# ==========================================================
+# MODEL
+# ==========================================================
+
+@dataclass
+class GPTConfig:
+    vocab_size: int
+    block_size: int
+    n_layer: int
+    n_head: int
+    n_embd: int
+    dropout: float = 0.1
+    bias: bool = False
+    pcs_a: float = 0.8309193524478643
+    pcs_b: float = 0.0
+
+
+class PCS(nn.Module):
+    def __init__(self, a=0.8309193524478643, b=0.0):
+        super().__init__()
+        self.a = float(a)
+        self.b = float(b)
+
+    def forward(self, x):
+        return x * torch.sin(self.a * x) + self.b * torch.cos(x)
+
+
+class Attn(nn.Module):
+    def __init__(self, c):
+        super().__init__()
+        assert c.n_embd % c.n_head == 0
+        self.n_head = c.n_head
+        self.head_dim = c.n_embd // c.n_head
+        self.dropout = c.dropout
+        self.qkv = nn.Linear(c.n_embd, 3 * c.n_embd, bias=c.bias)
+        self.proj = nn.Linear(c.n_embd, c.n_embd, bias=c.bias)
+        self.drop = nn.Dropout(c.dropout)
+
+    def forward(self, x):
+        B, T, C = x.shape
+        q, k, v = self.qkv(x).split(C, dim=2)
+        q = q.view(B, T, self.n_head, self.head_dim).transpose(1, 2)
+        k = k.view(B, T, self.n_head, self.head_dim).transpose(1, 2)
+        v = v.view(B, T, self.n_head, self.head_dim).transpose(1, 2)
+        y = F.scaled_dot_product_attention(
+            q, k, v,
+            dropout_p=self.dropout if self.training else 0.0,
+            is_causal=True,
+        )
+        y = y.transpose(1, 2).contiguous().view(B, T, C)
+        return self.drop(self.proj(y))
+
+
+class MLP(nn.Module):
+    def __init__(self, c):
+        super().__init__()
+        self.fc1 = nn.Linear(c.n_embd, 4 * c.n_embd, bias=c.bias)
+        self.act = PCS(c.pcs_a, c.pcs_b)
+        self.fc2 = nn.Linear(4 * c.n_embd, c.n_embd, bias=c.bias)
+        self.drop = nn.Dropout(c.dropout)
+
+    def forward(self, x):
+        return self.drop(self.fc2(self.act(self.fc1(x))))
+
+
+class Block(nn.Module):
+    def __init__(self, c):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(c.n_embd)
+        self.attn = Attn(c)
+        self.ln2 = nn.LayerNorm(c.n_embd)
+        self.mlp = MLP(c)
+
+    def forward(self, x):
+        x = x + self.attn(self.ln1(x))
+        x = x + self.mlp(self.ln2(x))
+        return x
+
+
+class GPT(nn.Module):
+    def __init__(self, c):
+        super().__init__()
+        self.cfg = c
+        self.tok_emb = nn.Embedding(c.vocab_size, c.n_embd)
+        self.pos_emb = nn.Embedding(c.block_size, c.n_embd)
+        self.drop = nn.Dropout(c.dropout)
+        self.blocks = nn.ModuleList([Block(c) for _ in range(c.n_layer)])
+        self.ln_f = nn.LayerNorm(c.n_embd)
+        self.lm_head = nn.Linear(c.n_embd, c.vocab_size, bias=False)
+        self.tok_emb.weight = self.lm_head.weight
+        self.apply(self._init)
+        for n, p in self.named_parameters():
+            if n.endswith("proj.weight") or n.endswith("fc2.weight"):
+                nn.init.normal_(p, mean=0.0, std=0.02 / math.sqrt(2 * c.n_layer))
+
+    def _init(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        elif isinstance(m, nn.Embedding):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+
+    def forward(self, idx, targets=None):
+        B, T = idx.shape
+        if T > self.cfg.block_size:
+            idx = idx[:, -self.cfg.block_size:]
+            if targets is not None:
+                targets = targets[:, -self.cfg.block_size:]
+            B, T = idx.shape
+
+        pos = torch.arange(T, device=idx.device)
+        x = self.drop(self.tok_emb(idx) + self.pos_emb(pos))
+        for b in self.blocks:
+            x = b(x)
+        logits = self.lm_head(self.ln_f(x))
+
+        loss = None
+        if targets is not None:
+            loss = F.cross_entropy(
+                logits.reshape(B * T, -1),
+                targets.reshape(B * T),
+                ignore_index=-100,
+            )
+        return logits, loss
+
+
+# ==========================================================
+# UTILS
+# ==========================================================
+
+def args():
+    p = argparse.ArgumentParser()
+
+    # Base pretrain checkpoint
+    p.add_argument("--base-repo-id", default="Daisuke675/scugnizz-1b")
+    p.add_argument("--base-ckpt", default="AUTO")
+
+    # Dataset
+    p.add_argument("--dataset", default="Daisuke675/scugnizz-instruct-pro-50k")
+    p.add_argument("--split", default="train")
+
+    # Training
+    p.add_argument("--block-size", type=int, default=1024)
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--grad-accum", type=int, default=16)
+    p.add_argument("--epochs", type=int, default=1)
+    p.add_argument("--max-steps", type=int, default=0)
+    p.add_argument("--lr", type=float, default=5e-6)
+    p.add_argument("--min-lr", type=float, default=1e-6)
+    p.add_argument("--warmup-steps", type=int, default=50)
+    p.add_argument("--weight-decay", type=float, default=0.05)
+    p.add_argument("--grad-clip", type=float, default=1.0)
+    p.add_argument("--dropout", type=float, default=0.05)
+    p.add_argument("--eval-interval", type=int, default=250)
+    p.add_argument("--save-interval", type=int, default=250)
+    p.add_argument("--log-interval", type=int, default=10)
+    p.add_argument("--eval-batches", type=int, default=30)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--dtype", choices=["auto", "bfloat16", "float16", "float32"], default="auto")
+
+    # Output
+    p.add_argument("--out-dir", default="runs/sft-1b-from-1b")
+    p.add_argument("--hub-repo-id", default="Daisuke675/scugnizz-1b")
+    p.add_argument("--hub-path", default="training-runs/sft-1b-pro-50k")
+    p.add_argument("--push", action="store_true", default=True)
+    p.add_argument("--push-every-save", action="store_true", default=True)
+
+    return p.parse_args()
+
+
+def seed_all(s):
+    random.seed(s)
+    np.random.seed(s)
+    torch.manual_seed(s)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(s)
+
+
+def dtype_of(d, dev):
+    if d != "auto":
+        return d
+    if dev == "cuda" and torch.cuda.is_bf16_supported():
+        return "bfloat16"
+    if dev == "cuda":
+        return "float16"
+    return "float32"
+
+
+def ac(dev, dt):
+    if dev != "cuda" or dt == "float32":
+        return nullcontext()
+    return torch.amp.autocast("cuda", dtype=torch.bfloat16 if dt == "bfloat16" else torch.float16)
+
+
+def lr_at(step, max_steps, a):
+    if step < a.warmup_steps:
+        return a.lr * (step + 1) / max(1, a.warmup_steps)
+    r = (step - a.warmup_steps) / max(1, max_steps - a.warmup_steps)
+    return a.min_lr + 0.5 * (1 + math.cos(math.pi * r)) * (a.lr - a.min_lr)
+
+
+def save(path, model, opt, step, best, a, cfg):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "step": int(step),
+        "model": model.state_dict(),
+        "optimizer": opt.state_dict(),
+        "best_val": float(best),
+        "args": vars(a),
+        "config": asdict(cfg),
+    }
+    torch.save(payload, path)
+    print("SAVED", path, flush=True)
+
+
+def upload(out, repo, path, msg):
+    api = HfApi()
+    api.create_repo(repo, repo_type="model", exist_ok=True)
+    upload_folder(
+        repo_id=repo,
+        repo_type="model",
+        folder_path=out,
+        path_in_repo=path,
+        commit_message=msg,
+    )
+    print("UPLOADED", repo, path, flush=True)
+
+
+def resolve_base_checkpoint(repo_id, base_ckpt):
+    if base_ckpt and base_ckpt != "AUTO":
+        return hf_hub_download(repo_id=repo_id, filename=base_ckpt, repo_type="model"), base_ckpt
+
+    candidates = [
+        "training-runs/pretrain-1b/checkpoint_last.pt",
+        "training-runs/pretrain-1b-pcs-1b/checkpoint_last.pt",
+        "training-runs/pretrain-1b-1b-tokens/checkpoint_last.pt",
+        "training-runs/pretrain-1b-h200x8/checkpoint_last.pt",
+        "training-runs/pretrain/checkpoint_last.pt",
+        "checkpoint_last.pt",
+    ]
+
+    errors = []
+    for c in candidates:
+        try:
+            p = hf_hub_download(repo_id=repo_id, filename=c, repo_type="model")
+            print("BASE CHECKPOINT FOUND:", c, flush=True)
+            return p, c
+        except Exception as e:
+            errors.append((c, repr(e)))
+
+    print("ERRORE: checkpoint base 1.3B non trovato automaticamente.", flush=True)
+    print("Percorsi provati:", flush=True)
+    for c, e in errors:
+        print(" -", c, "=>", e[:200], flush=True)
+    print("Rilancia passando il percorso esatto, esempio:", flush=True)
+    print("hf jobs uv run --flavor h200 --secrets HF_TOKEN 10_sft_1b_pro_50k.py --base-ckpt training-runs/TUO_PERCORSO/checkpoint_last.pt", flush=True)
+    raise FileNotFoundError("Base checkpoint not found")
+
+
+# ==========================================================
+# DATASET FORMAT
+# ==========================================================
+
+def pick(row, names):
+    for n in names:
+        if n in row and row[n] is not None:
+            v = row[n]
+            if isinstance(v, str) and v.strip():
+                return v.strip()
+    return ""
+
+
+def make_prompt_and_answer(row):
+    # Robust for common instruct schemas.
+    instruction = pick(row, ["instruction", "prompt", "question", "input", "query", "user"])
+    context = pick(row, ["context", "system", "source"])
+    answer = pick(row, ["output", "response", "answer", "completion", "assistant", "text"])
+
+    # If dataset has only text, split very lightly or train whole text.
+    if not answer and "text" in row and isinstance(row["text"], str):
+        txt = row["text"].strip()
+        return "", txt
+
+    if context:
+        prompt = f"### Instruction:\\n{instruction}\\n\\n### Context:\\n{context}\\n\\n### Response:\\n"
+    else:
+        prompt = f"### Instruction:\\n{instruction}\\n\\n### Response:\\n"
+
+    return prompt, answer
+
+
+def encode_example(tok, row, block_size):
+    prompt, answer = make_prompt_and_answer(row)
+
+    # Train only the answer where possible.
+    full = prompt + answer + tok.eos_token
+
+    full_ids = tok.encode(full)
+    prompt_ids = tok.encode(prompt)
+
+    if len(full_ids) > block_size + 1:
+        # Keep the end, but avoid losing all answer labels where possible.
+        full_ids = full_ids[-(block_size + 1):]
+        # If prompt got truncated, no prompt mask.
+        prompt_len = 0
+    else:
+        prompt_len = min(len(prompt_ids), len(full_ids))
+
+    x = full_ids[:-1]
+    y = full_ids[1:]
+
+    # Mask prompt labels. y position i predicts full_ids[i+1].
+    # If i+1 is still inside prompt, ignore.
+    labels = []
+    for i, target in enumerate(y):
+        if (i + 1) < prompt_len:
+            labels.append(-100)
+        else:
+            labels.append(target)
+
+    return x, labels
+
+
+class SFTDataset:
+    def __init__(self, rows, tok, block_size):
+        self.items = []
+        self.tok = tok
+        self.block_size = block_size
+
+        for row in rows:
+            x, y = encode_example(tok, row, block_size)
+            if len(x) >= 8 and any(t != -100 for t in y):
+                self.items.append((x, y))
+
+        if not self.items:
+            raise RuntimeError("No usable SFT examples found. Check dataset columns.")
+
+    def __len__(self):
+        return len(self.items)
+
+    def batch(self, batch_size, dev):
+        idxs = np.random.randint(0, len(self.items), size=(batch_size,))
+        xs, ys = [], []
+        max_len = 0
+        for i in idxs:
+            x, y = self.items[i]
+            max_len = max(max_len, len(x))
+            xs.append(x)
+            ys.append(y)
+
+        max_len = min(max_len, self.block_size)
+        pad_id = self.tok.eos_token_id
+
+        bx, by = [], []
+        for x, y in zip(xs, ys):
+            x = x[-max_len:]
+            y = y[-max_len:]
+            pad = max_len - len(x)
+            bx.append([pad_id] * pad + x)
+            by.append([-100] * pad + y)
+
+        return (
+            torch.tensor(bx, dtype=torch.long, device=dev),
+            torch.tensor(by, dtype=torch.long, device=dev),
+        )
+
+
+@torch.no_grad()
+def eval_model(model, data, a, dev, dt):
+    model.eval()
+    losses = []
+    for _ in range(a.eval_batches):
+        x, y = data.batch(a.batch_size, dev)
+        with ac(dev, dt):
+            _, loss = model(x, y)
+        losses.append(float(loss.item()))
+    model.train()
+    return float(np.mean(losses))
+
+
+@torch.no_grad()
+def quick_generate(model, tok, prompt, dev, dt, max_new=120):
+    model.eval()
+    ids = torch.tensor([tok.encode(prompt)], dtype=torch.long, device=dev)
+    for _ in range(max_new):
+        x = ids[:, -model.cfg.block_size:]
+        with ac(dev, dt):
+            logits, _ = model(x)
+        logits = logits[:, -1, :].float() / 0.8
+        probs = torch.softmax(logits, dim=-1)
+        sorted_probs, sorted_idx = torch.sort(probs, descending=True)
+        cum = torch.cumsum(sorted_probs, dim=-1)
+        mask = cum > 0.9
+        mask[..., 1:] = mask[..., :-1].clone()
+        mask[..., 0] = False
+        sorted_probs[mask] = 0
+        sorted_probs = sorted_probs / sorted_probs.sum(dim=-1, keepdim=True)
+        sample = torch.multinomial(sorted_probs, 1)
+        nxt = sorted_idx.gather(-1, sample)
+        ids = torch.cat([ids, nxt], dim=1)
+        if int(nxt.item()) == tok.eos_token_id:
+            break
+    return tok.decode(ids[0].tolist(), skip_special_tokens=True)
+
+
+
+
+# ==========================================================
+# SCUGNIZZ AGENT MODE - ROUTER + MOCK TOOLS
+# ==========================================================
+
+AGENT_CITIES = [
+    "Udine","Trieste","Genova","Roma","Milano","Napoli","Torino","Bologna","Palermo","Cagliari",
+    "Verona","Bari","Lecce","Ancona","Aosta","Trento","Pordenone","Gorizia","Firenze","Padova"
+]
+AGENT_STOCKS = ["TSLA","AAPL","MSFT","NVDA","AMD","VWCE","SPY","ENI","ISP","GOOGL","AMZN","META","BTC","ETH"]
+
+def agent_json(obj):
+    return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
+
+def normalize_text(s):
+    return re.sub(r"\s+", " ", (s or "").strip())
+
+def find_city(text):
+    low = text.lower()
+    for c in AGENT_CITIES:
+        if c.lower() in low:
+            return c
+    m = re.search(r"\b(?:a|di|per|in)\s+([A-ZÀ-Ü][a-zà-ü]+)", text)
+    return m.group(1) if m else None
+
+def find_stock(text):
+    upper = text.upper()
+    for s in AGENT_STOCKS:
+        if re.search(rf"\b{re.escape(s)}\b", upper):
+            return s
+    m = re.search(r"\b([A-Z]{2,5})\b", upper)
+    return m.group(1) if m else None
+
+def find_domain(text):
+    m = re.search(r"\b((?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,})\b", text)
+    return m.group(1).lower() if m else None
+
+def find_ip(text):
+    m = re.search(r"\b(?:\d{1,3}\.){3}\d{1,3}\b", text)
+    return m.group(0) if m else None
+
+def find_url(text):
+    m = re.search(r"https?://[^\s]+", text)
+    return m.group(0).rstrip(".,)") if m else None
+
+def find_hash(text):
+    m = re.search(r"\b[a-fA-F0-9]{32}\b|\b[a-fA-F0-9]{40}\b|\b[a-fA-F0-9]{64}\b", text)
+    return m.group(0) if m else None
+
+def route_user_to_tool(text):
+    t = normalize_text(text)
+    low = t.lower()
+
+    if any(k in low for k in ["meteo", "tempo fa", "weather", "prevision"]):
+        city = find_city(t)
+        if city:
+            return {"name": "weather.forecast", "arguments": {"city": city}}
+        return {"error": "Mi serve la città per usare il tool meteo."}
+
+    if any(k in low for k in ["quota", "quotazione", "prezzo", "stock", "azioni", "etf", "quote"]):
+        sym = find_stock(t)
+        if sym:
+            return {"name": "finance.quote", "arguments": {"symbol": sym}}
+        return {"error": "Mi serve il simbolo del titolo/ETF per usare il tool finanza."}
+
+    if any(k in low for k in ["canzone", "brano", "sto ascoltando", "current song", "musica"]):
+        return {"name": "spotify.current_song", "arguments": {}}
+
+    if any(k in low for k in ["appuntamento", "calendario", "agenda", "evento", "meeting"]):
+        return {"name": "calendar.next_event", "arguments": {}}
+
+    if any(k in low for k in ["email non lette", "mail non lette", "unread", "posta non letta"]):
+        return {"name": "unread_mail_count", "arguments": {}}
+
+    if any(k in low for k in ["dns", "record"]):
+        d = find_domain(t)
+        record = "A"
+        for rtype in ["AAAA", "TXT", "MX", "NS", "A"]:
+            if re.search(rf"\b{rtype}\b", t.upper()):
+                record = rtype
+                break
+        if d:
+            return {"name": "dns.lookup", "arguments": {"domain": d, "record_type": record}}
+        return {"error": "Mi serve il dominio per il lookup DNS."}
+
+    if any(k in low for k in ["dominio", "domain", "whois", "osint"]):
+        d = find_domain(t)
+        if d:
+            return {"name": "osint.domain_lookup", "arguments": {"domain": d}}
+        return {"error": "Mi serve il dominio da analizzare."}
+
+    if any(k in low for k in ["indirizzo ip", "lookup ip", "ip "]):
+        ip = find_ip(t)
+        if ip:
+            return {"name": "ip.lookup", "arguments": {"ip": ip}}
+        return {"error": "Mi serve un indirizzo IP valido."}
+
+    if any(k in low for k in ["url", "link", "scansiona", "reputazione"]):
+        u = find_url(t)
+        if u:
+            return {"name": "url.scan", "arguments": {"url": u}}
+        return {"error": "Mi serve un URL completo da scansionare."}
+
+    if any(k in low for k in ["hash", "sha256", "md5", "sha1"]):
+        h = find_hash(t)
+        if h:
+            return {"name": "hash.lookup", "arguments": {"hash": h}}
+        return {"error": "Mi serve un hash valido."}
+
+    if any(k in low for k in ["sensore", "porta", "garage", "luce", "termostato", "telecamera"]):
+        room = None
+        device = None
+        for r in ["garage", "cucina", "salotto", "camera", "studio", "ingresso", "cantina", "terrazzo"]:
+            if r in low:
+                room = r
+                break
+        for d in ["sensore porta", "porta ingresso", "luce", "termostato", "telecamera", "sirena", "presa smart"]:
+            if d in low:
+                device = d
+                break
+        if device:
+            args = {"device": device}
+            if room:
+                args["room"] = room
+            return {"name": "home.sensor", "arguments": args}
+
+    return None
+
+def execute_mock_tool(call):
+    name = call.get("name")
+    args = call.get("arguments") or {}
+
+    if name == "weather.forecast":
+        city = args.get("city", "Genova")
+        table = {
+            "Genova": ("pioggia", 24, 18),
+            "Udine": ("nuvoloso", 23, 9),
+            "Roma": ("sereno", 31, 8),
+            "Milano": ("caldo", 30, 7),
+            "Trento": ("neve", -2, 18),
+        }
+        cond, temp, wind = table.get(city, ("sereno", 25, 10))
+        return {"tool": name, "result": {"city": city, "condition": cond, "temperature_c": temp, "wind_kmh": wind}}
+
+    if name == "finance.quote":
+        sym = args.get("symbol", "TSLA")
+        prices = {"TSLA": 312.45, "MSFT": 512.34, "AMD": 165.77, "NVDA": 142.10, "VWCE": 127.45}
+        return {"tool": name, "result": {"symbol": sym, "price": prices.get(sym, 100.00), "currency": "USD" if sym != "VWCE" else "EUR", "change_percent": 0.8}}
+
+    if name == "spotify.current_song":
+        return {"tool": name, "result": {"artist": "Muse", "title": "Uprising", "album": "The Resistance"}}
+
+    if name == "calendar.next_event":
+        return {"tool": name, "result": {"title": "Manutenzione", "date": "domani", "time": "15:45"}}
+
+    if name == "unread_mail_count":
+        return {"tool": name, "result": {"unread": 7, "important": 2, "latest_sender": "Anna"}}
+
+    if name == "osint.domain_lookup":
+        domain = args.get("domain", "example.com")
+        return {"tool": name, "result": {"domain": domain, "status": "mock", "risk": "unknown", "note": "Risultato dimostrativo locale"}}
+
+    if name == "dns.lookup":
+        return {"tool": name, "result": {"domain": args.get("domain"), "record_type": args.get("record_type", "A"), "answers": ["93.184.216.34"]}}
+
+    if name == "ip.lookup":
+        return {"tool": name, "result": {"ip": args.get("ip"), "asn": "AS15169", "country": "US", "provider": "mock"}}
+
+    if name == "url.scan":
+        return {"tool": name, "result": {"url": args.get("url"), "verdict": "unknown", "risk_score": 0, "note": "Mock scan locale"}}
+
+    if name == "hash.lookup":
+        return {"tool": name, "result": {"hash": args.get("hash"), "verdict": "unknown", "engines_detected": 0}}
+
+    if name == "home.sensor":
+        return {"tool": name, "result": {"device": args.get("device", "sensore"), "room": args.get("room", "ingresso"), "state": "aperta"}}
+
+    return {"tool": name or "unknown", "error": "Tool non implementato", "arguments": args}
+
+def build_tool_result_prompt(tool_result):
+    return (
+        "### Instruction:\n"
+        "TOOL_RESULT:\n"
+        + agent_json(tool_result)
+        + "\n\nScrivi una risposta naturale in italiano usando solo i dati utili. Non inventare nulla.\n\n"
+        "### Response:\n"
+    )
+
+# ==========================================================
+# SCUGNIZZLLM CHAT GUI
+# ==========================================================
+import threading
+import tkinter as tk
+from tkinter import ttk, scrolledtext, messagebox, filedialog
+
+CHECKPOINTS = {
+    "Toolcalling only best": "training-runs/sft-toolcalling-only/checkpoint_best.pt",
+    "Toolcalling only last": "training-runs/sft-toolcalling-only/checkpoint_last.pt",
+    "V3 agentic smart mix best": "training-runs/sft-universal-tool-renderer-1b-v3-agentic-smart-mix/checkpoint_best.pt",
+    "SFT 1.32B best": "training-runs/sft-1b-pro-50k-1320m/checkpoint_best.pt",
+    "SFT 1.32B last": "training-runs/sft-1b-pro-50k-1320m/checkpoint_last.pt",
+    "SFT 1B best": "training-runs/sft-1b-pro-50k/checkpoint_best.pt",
+    "SFT 1B last": "training-runs/sft-1b-pro-50k/checkpoint_last.pt",
+    "Pretrain 1.32B last": "training-runs/pretrain-1b/checkpoint_last.pt",
+}
+REPO_ID = "ProjectScugnizz/scugnizz-1b"
+
+@torch.no_grad()
+def sample_next_token(logits, temperature=0.7, top_p=0.9, top_k=50, repetition_penalty=1.10, recent_tokens=None):
+    logits = logits.float()
+    if recent_tokens and repetition_penalty and repetition_penalty > 1.0:
+        for t in set(recent_tokens[-128:]):
+            logits[:, t] /= repetition_penalty
+    if temperature <= 0:
+        return torch.argmax(logits, dim=-1, keepdim=True)
+    logits = logits / max(temperature, 1e-6)
+    if top_k and top_k > 0:
+        vals, idx = torch.topk(logits, min(top_k, logits.size(-1)))
+        mask = torch.full_like(logits, float("-inf"))
+        logits = mask.scatter(-1, idx, vals)
+    probs = torch.softmax(logits, dim=-1)
+    if top_p and top_p < 1.0:
+        sorted_probs, sorted_idx = torch.sort(probs, descending=True)
+        cum = torch.cumsum(sorted_probs, dim=-1)
+        mask = cum > top_p
+        mask[..., 1:] = mask[..., :-1].clone()
+        mask[..., 0] = False
+        sorted_probs[mask] = 0
+        sorted_probs = sorted_probs / sorted_probs.sum(dim=-1, keepdim=True)
+        sample = torch.multinomial(sorted_probs, 1)
+        return sorted_idx.gather(-1, sample)
+    return torch.multinomial(probs, 1)
+
+class ScugnizzEngine:
+    def __init__(self):
+        self.model = None
+        self.tok = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.dt = dtype_of("auto", "cuda" if torch.cuda.is_available() else "cpu")
+        self.loaded_name = None
+    def load(self, checkpoint_name):
+        ckpt_file = CHECKPOINTS[checkpoint_name]
+        self.tok = GPT2TokenizerFast.from_pretrained("gpt2")
+        self.tok.pad_token = self.tok.eos_token
+        path = hf_hub_download(repo_id=REPO_ID, filename=ckpt_file, repo_type="model")
+        ck = torch.load(path, map_location="cpu")
+        if isinstance(ck, dict) and "config" in ck:
+            cfg = GPTConfig(**ck["config"])
+        else:
+            cfg = GPTConfig(vocab_size=self.tok.vocab_size, block_size=1024, n_layer=24, n_head=16, n_embd=2048, dropout=0.0, bias=False, pcs_a=0.8309193524478643, pcs_b=0.0)
+        cfg.dropout = 0.0
+        model = GPT(cfg)
+        sd = ck["model"] if isinstance(ck, dict) and "model" in ck else ck
+        if any(k.startswith("module.") for k in sd.keys()):
+            sd = {k.replace("module.", "", 1): v for k, v in sd.items()}
+        model.load_state_dict(sd, strict=True)
+        model.to(self.device)
+        model.eval()
+        self.model = model
+        self.loaded_name = checkpoint_name
+    def build_prompt(self, history, user_msg):
+        text = ""
+        for role, msg in history[-8:]:
+            if role == "user":
+                text += f"### Instruction:\n{msg}\n\n### Response:\n"
+            else:
+                text += f"{msg}\n\n"
+        text += f"### Instruction:\n{user_msg}\n\n### Response:\n"
+        return text
+    @torch.no_grad()
+    def generate_stream(self, prompt, max_new=256, temperature=0.7, top_p=0.9, top_k=50, repetition_penalty=1.10, stop_flag=None):
+        if self.model is None:
+            raise RuntimeError("Modello non caricato.")
+        ids = torch.tensor([self.tok.encode(prompt)], dtype=torch.long, device=self.device)
+        generated = []
+        recent = ids[0].tolist()[-128:]
+        for _ in range(max_new):
+            if stop_flag and stop_flag():
+                break
+            x = ids[:, -self.model.cfg.block_size:]
+            with ac("cuda" if torch.cuda.is_available() else "cpu", self.dt):
+                logits, _ = self.model(x)
+            nxt = sample_next_token(logits[:, -1, :], temperature=temperature, top_p=top_p, top_k=top_k, repetition_penalty=repetition_penalty, recent_tokens=recent)
+            token_id = int(nxt.item())
+            if token_id == self.tok.eos_token_id:
+                break
+            ids = torch.cat([ids, nxt], dim=1)
+            recent.append(token_id)
+            generated.append(token_id)
+            piece = self.tok.decode([token_id], skip_special_tokens=True)
+            yield piece
+            current = self.tok.decode(generated, skip_special_tokens=True)
+            if "\n### Instruction:" in current or "\n### Response:" in current:
+                break
+
+class ChatApp:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("ScugnizzLLM Chat")
+        self.root.geometry("1100x760")
+        self.root.configure(bg="#151515")
+        self.engine = ScugnizzEngine()
+        self.history = []
+        self.stop = False
+        self.generating = False
+        self.setup_style()
+        self.build_ui()
+    def setup_style(self):
+        style = ttk.Style()
+        try: style.theme_use("clam")
+        except Exception: pass
+        style.configure("TFrame", background="#151515")
+        style.configure("TLabel", background="#151515", foreground="#e8e8e8")
+        style.configure("TButton", padding=6)
+    def build_ui(self):
+        top = ttk.Frame(self.root); top.pack(fill="x", padx=10, pady=8)
+        ttk.Label(top, text="Checkpoint:").pack(side="left")
+        self.ckpt_var = tk.StringVar(value="V3 agentic smart mix best")
+        ttk.Combobox(top, textvariable=self.ckpt_var, values=list(CHECKPOINTS.keys()), width=32, state="readonly").pack(side="left", padx=6)
+        self.load_btn = ttk.Button(top, text="Carica modello", command=self.load_model); self.load_btn.pack(side="left", padx=4)
+        ttk.Button(top, text="Nuova chat", command=self.new_chat).pack(side="left", padx=4)
+        ttk.Button(top, text="Salva chat", command=self.save_chat).pack(side="left", padx=4)
+        self.status = ttk.Label(top, text=f"Device: {self.engine.device}"); self.status.pack(side="right")
+        params = ttk.Frame(self.root); params.pack(fill="x", padx=10, pady=4)
+        self.temp=tk.DoubleVar(value=0.7); self.topp=tk.DoubleVar(value=0.9); self.topk=tk.IntVar(value=50); self.maxnew=tk.IntVar(value=256); self.rep=tk.DoubleVar(value=1.10); self.agent_mode=tk.BooleanVar(value=True); self.show_tool_log=tk.BooleanVar(value=True)
+        for label,var in [("Temp",self.temp),("Top-p",self.topp),("Top-k",self.topk),("Max token",self.maxnew),("Repetition",self.rep)]:
+            f=ttk.Frame(params); f.pack(side="left", padx=8); ttk.Label(f,text=label).pack(); ttk.Entry(f,textvariable=var,width=8).pack()
+        ttk.Checkbutton(params, text="Agent mode", variable=self.agent_mode).pack(side="left", padx=10)
+        ttk.Checkbutton(params, text="Tool log", variable=self.show_tool_log).pack(side="left", padx=10)
+        self.chat = scrolledtext.ScrolledText(self.root, wrap="word", bg="#101010", fg="#eeeeee", insertbackground="#ffffff", font=("Consolas", 11), padx=12, pady=12)
+        self.chat.pack(fill="both", expand=True, padx=10, pady=8)
+        self.chat.tag_config("user", foreground="#8fd3ff"); self.chat.tag_config("bot", foreground="#b6ffb6"); self.chat.tag_config("sys", foreground="#ffdf80"); self.chat.tag_config("tool", foreground="#ff9bd5")
+        self.append("ScugnizzLLM Chat pronto. Carica un checkpoint e scrivi una domanda.\n", "sys")
+        bottom = ttk.Frame(self.root); bottom.pack(fill="x", padx=10, pady=8)
+        self.input = tk.Text(bottom, height=4, bg="#202020", fg="#ffffff", insertbackground="#ffffff", font=("Consolas", 11)); self.input.pack(side="left", fill="x", expand=True)
+        self.input.bind("<Control-Return>", lambda e: self.send())
+        btns=ttk.Frame(bottom); btns.pack(side="right", padx=8)
+        self.send_btn=ttk.Button(btns, text="Invia\nCtrl+Invio", command=self.send); self.send_btn.pack(fill="x", pady=2)
+        ttk.Button(btns, text="Stop", command=self.stop_generation).pack(fill="x", pady=2)
+    def append(self, text, tag=None):
+        self.chat.insert("end", text, tag); self.chat.see("end"); self.root.update_idletasks()
+    def load_model(self):
+        name=self.ckpt_var.get(); self.status.config(text=f"Carico {name}..."); self.load_btn.config(state="disabled")
+        def worker():
+            try:
+                self.engine.load(name)
+                self.root.after(0, lambda: self.append(f"\n[OK] Modello caricato: {name}\n", "sys"))
+                self.root.after(0, lambda: self.status.config(text=f"Caricato: {name} | {self.engine.device}"))
+            except Exception as e:
+                self.root.after(0, lambda: messagebox.showerror("Errore caricamento", str(e)))
+                self.root.after(0, lambda: self.status.config(text="Errore caricamento"))
+            finally:
+                self.root.after(0, lambda: self.load_btn.config(state="normal"))
+        threading.Thread(target=worker, daemon=True).start()
+
+    def generate_text_blocking(self, prompt, max_new=None, temperature=None):
+        answer = ""
+        for piece in self.engine.generate_stream(
+            prompt,
+            max_new=int(max_new if max_new is not None else self.maxnew.get()),
+            temperature=float(temperature if temperature is not None else self.temp.get()),
+            top_p=float(self.topp.get()),
+            top_k=int(self.topk.get()),
+            repetition_penalty=float(self.rep.get()),
+            stop_flag=lambda: self.stop,
+        ):
+            answer += piece
+        return answer.strip()
+
+    def run_agent_mode(self, user_msg):
+        routed = route_user_to_tool(user_msg)
+
+        if isinstance(routed, dict) and "error" in routed:
+            return routed["error"], "[router] " + routed["error"]
+
+        if isinstance(routed, dict) and "name" in routed:
+            tool_result = execute_mock_tool(routed)
+            tool_log = (
+                "[router] TOOL_CALL "
+                + json.dumps(routed, ensure_ascii=False)
+                + "\nTOOL_RESULT "
+                + json.dumps(tool_result, ensure_ascii=False)
+            )
+            final_prompt = build_tool_result_prompt(tool_result)
+            final_answer = self.generate_text_blocking(final_prompt, max_new=int(self.maxnew.get()), temperature=0.05)
+            if not final_answer:
+                final_answer = json.dumps(tool_result, ensure_ascii=False)
+            return final_answer, tool_log
+
+        # Nessun tool: normale chat col modello
+        normal_prompt = self.engine.build_prompt(self.history, user_msg)
+        final_answer = self.generate_text_blocking(normal_prompt)
+        return final_answer, "[agent] Nessun tool necessario."
+
+    def send(self):
+        if self.generating:
+            return
+        msg = self.input.get("1.0", "end").strip()
+        if not msg:
+            return
+        if self.engine.model is None:
+            messagebox.showwarning("Modello non caricato", "Prima carica un checkpoint.")
+            return
+
+        self.input.delete("1.0", "end")
+        self.append(f"\nTu: {msg}\n", "user")
+        self.append("Scugnizz: ", "bot")
+
+        self.stop = False
+        self.generating = True
+        self.send_btn.config(state="disabled")
+
+        def worker():
+            answer = ""
+            try:
+                if self.agent_mode.get():
+                    answer, tool_log = self.run_agent_mode(msg)
+                    if self.show_tool_log.get() and tool_log:
+                        self.root.after(0, lambda tl=tool_log: self.append("\n[TOOL LOG]\n" + tl + "\n\n", "tool"))
+                    self.root.after(0, lambda a=answer: self.append(a, "bot"))
+                else:
+                    prompt = self.engine.build_prompt(self.history, msg)
+                    for piece in self.engine.generate_stream(
+                        prompt,
+                        max_new=int(self.maxnew.get()),
+                        temperature=float(self.temp.get()),
+                        top_p=float(self.topp.get()),
+                        top_k=int(self.topk.get()),
+                        repetition_penalty=float(self.rep.get()),
+                        stop_flag=lambda: self.stop,
+                    ):
+                        answer += piece
+                        self.root.after(0, lambda p=piece: self.append(p, "bot"))
+
+                self.history.append(("user", msg))
+                self.history.append(("assistant", answer.strip()))
+                self.root.after(0, lambda: self.append("\n", "bot"))
+
+            except Exception as e:
+                self.root.after(0, lambda e=e: self.append(f"\n[ERRORE] {e}\n", "sys"))
+            finally:
+                self.generating = False
+                self.root.after(0, lambda: self.send_btn.config(state="normal"))
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def stop_generation(self): self.stop=True
+    def new_chat(self): self.history.clear(); self.chat.delete("1.0", "end"); self.append("Nuova chat.\n", "sys")
+    def save_chat(self):
+        path=filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text", "*.txt"), ("Markdown", "*.md")])
+        if path:
+            Path(path).write_text(self.chat.get("1.0", "end"), encoding="utf-8"); self.append(f"\n[OK] Chat salvata: {path}\n", "sys")
+
+if __name__ == "__main__":
+    root = tk.Tk(); app = ChatApp(root); root.mainloop()