skylar 0.1.0__py3-none-any.whl

skylar/__init__.py

@@ -0,0 +1,24 @@
+"""Skylar — local, sovereign, from-scratch LLMs (COBOL specialist & more)."""
+from .core import Skylar, load, DEFAULT_MODEL, COBOL_SYSTEM
+from .config import NanoTransformerConfig
+from .decoder import NanoTransformer
+from .chatml import encode_chatml
+
+__version__ = "0.1.0"
+__all__ = ["Skylar", "load", "NanoTransformer", "NanoTransformerConfig",
+           "encode_chatml", "DEFAULT_MODEL", "COBOL_SYSTEM", "__version__"]
+
+
+def _register_auto():
+    """Make AutoConfig/AutoModelForCausalLM aware of the custom arch, so
+    `AutoModelForCausalLM.from_pretrained(repo)` works after `import skylar`.
+    Best-effort: never break import if transformers internals change."""
+    try:
+        from transformers import AutoConfig, AutoModelForCausalLM
+        AutoConfig.register("nano-transformer", NanoTransformerConfig)
+        AutoModelForCausalLM.register(NanoTransformerConfig, NanoTransformer)
+    except Exception:
+        pass
+
+
+_register_auto()

skylar/chatml.py

@@ -0,0 +1,112 @@
+"""
+Chat dataset utilities for Supervised Fine-Tuning (SFT).
+
+Supports:
+  - ChatML format (same as Qwen, Mistral, OpenAI)
+The key insight: a "chat model" is just a base model fine-tuned on
+structured conversations. The structure is enforced by special tokens.
+"""
+
+import json
+
+
+# ─────────────────────────────────────────────────────────────
+# CHAT FORMAT (ChatML)
+# ─────────────────────────────────────────────────────────────
+#
+# ChatML is the standard used by Qwen, Mistral, OpenAI, etc.
+# It wraps each message in special tokens:
+#
+#   <|im_start|>system
+#   You are a helpful assistant.<|im_end|>
+#   <|im_start|>user
+#   What is 2+2?<|im_end|>
+#   <|im_start|>assistant
+#   2+2 equals 4.<|im_end|>
+#
+# During training, we only compute loss on the ASSISTANT tokens.
+# The model learns: "given this conversation so far, what should
+# the assistant say next?"
+# ─────────────────────────────────────────────────────────────
+
+def get_chatml_ids(tokenizer):
+    """Works with both special-token and sub-token tokenizers."""
+    ims_id = tokenizer.token_to_id("<|im_start|>")
+    if ims_id is not None:
+        return [ims_id], [tokenizer.token_to_id("<|im_end|>")]
+    else:
+        return (
+            tokenizer.encode("<|im_start|>", add_special_tokens=False).ids,
+            tokenizer.encode("<|im_end|>", add_special_tokens=False).ids,
+        )
+
+
+def create_loss_mask(messages, tokenizer):
+    """Loss mask for ChatML. Works with both special-token and sub-token tokenizers."""
+    ims_ids, ime_ids = get_chatml_ids(tokenizer)
+
+    all_token_ids = []
+    all_labels = []
+
+    for i, msg in enumerate(messages):
+        is_assistant = (msg["role"] == "assistant")
+
+        all_token_ids.extend(ims_ids)
+        all_labels.extend([-100] * len(ims_ids))
+
+        role_ids = tokenizer.encode(msg["role"] + "\n", add_special_tokens=False).ids
+        all_token_ids.extend(role_ids)
+        all_labels.extend([-100] * len(role_ids))
+
+        content_ids = tokenizer.encode(msg["content"], add_special_tokens=False).ids
+        all_token_ids.extend(content_ids)
+        if is_assistant:
+            all_labels.extend(list(content_ids))
+        else:
+            all_labels.extend([-100] * len(content_ids))
+
+        all_token_ids.extend(ime_ids)
+        if is_assistant:
+            all_labels.extend(list(ime_ids))
+        else:
+            all_labels.extend([-100] * len(ime_ids))
+
+        if i < len(messages) - 1:
+            sep_ids = tokenizer.encode("\n", add_special_tokens=False).ids
+            all_token_ids.extend(sep_ids)
+            all_labels.extend([-100] * len(sep_ids))
+
+    return all_token_ids, all_labels
+
+
+def encode_chatml(messages, tokenizer, add_generation_prompt=False):
+    """Encode ChatML. Works with both special-token and sub-token tokenizers."""
+    ims_ids, ime_ids = get_chatml_ids(tokenizer)
+
+    all_ids = []
+    for i, msg in enumerate(messages):
+        all_ids.extend(ims_ids)
+        all_ids.extend(tokenizer.encode(msg["role"] + "\n", add_special_tokens=False).ids)
+        all_ids.extend(tokenizer.encode(msg["content"], add_special_tokens=False).ids)
+        all_ids.extend(ime_ids)
+        if i < len(messages) - 1:
+            all_ids.extend(tokenizer.encode("\n", add_special_tokens=False).ids)
+
+    if add_generation_prompt:
+        all_ids.extend(tokenizer.encode("\n", add_special_tokens=False).ids)
+        all_ids.extend(ims_ids)
+        all_ids.extend(tokenizer.encode("assistant\n", add_special_tokens=False).ids)
+
+    return all_ids
+
+
+def load_dataset_jsonl(filepath):
+    """Load a JSONL dataset."""
+    examples = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                examples.append(json.loads(line))
+    print(f"  Loaded {len(examples)} examples from {filepath}")
+    return examples

skylar/cli.py

@@ -0,0 +1,171 @@
+"""`skylar` command-line interface: chat · generate · serve."""
+import argparse
+import sys
+
+DEFAULT_MODEL = "Sophia-AI/SkylarCobol-390M"
+
+
+def _add_common(sp):
+    sp.add_argument("--model", default=DEFAULT_MODEL,
+                    help="HF repo id (es. Sophia-AI/SkylarCobol-390M) o cartella locale")
+    sp.add_argument("--device", default=None, help="cuda | cpu (auto se omesso)")
+    sp.add_argument("--system", default=None, help="system prompt (default: esperto COBOL)")
+    sp.add_argument("--max-new", dest="max_new", type=int, default=512)
+    sp.add_argument("--temperature", type=float, default=0.0,
+                    help="0.0 = greedy deterministico (default)")
+
+
+def cmd_generate(args):
+    from .core import Skylar, COBOL_SYSTEM
+    sk = Skylar.load(args.model, device=args.device)
+    system = args.system if args.system is not None else COBOL_SYSTEM
+    print(sk.generate(args.prompt, system=system, max_new_tokens=args.max_new,
+                      temperature=args.temperature, seed=args.seed))
+
+
+def cmd_chat(args):
+    from .core import Skylar, COBOL_SYSTEM
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        console = Console()
+    except Exception:
+        console = None
+
+    print(f"Carico {args.model} ...", file=sys.stderr)
+    sk = Skylar.load(args.model, device=args.device)
+    system = args.system if args.system is not None else COBOL_SYSTEM
+    head = f"Skylar · {args.model}\ndevice: {sk.device} · system: {system!r}\n('exit' o Ctrl-D per uscire)"
+    if console:
+        console.print(Panel(head, title="skylar chat", border_style="cyan"))
+    else:
+        print(head)
+
+    while True:
+        try:
+            user = input("\n\033[1m›\033[0m ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if user.lower() in ("exit", "quit", ":q"):
+            break
+        if not user:
+            continue
+        for delta in sk.stream(user, system=system, max_new_tokens=args.max_new,
+                               temperature=args.temperature):
+            sys.stdout.write(delta)
+            sys.stdout.flush()
+        print()
+
+
+def cmd_cobol(args):
+    from .core import Skylar
+    from .cobol import EXAMPLE_STUB, complete_cobol, syntax_ok
+    if args.example:
+        stub = EXAMPLE_STUB
+    elif args.stub_file:
+        stub = open(args.stub_file).read()
+    else:
+        print("usa --example oppure --stub-file FILE", file=sys.stderr)
+        sys.exit(1)
+    print(f"Carico {args.model} ...", file=sys.stderr)
+    sk = Skylar.load(args.model, device=args.device)
+    prog = complete_cobol(sk, stub, max_new_tokens=args.max_new, temperature=args.temperature)
+    print(prog)
+    if args.compile:
+        ok = syntax_ok(prog)
+        if ok is None:
+            print("\n[cobc non installato — salto il check sintassi]", file=sys.stderr)
+        else:
+            print(f"\n[cobc -fsyntax-only: {'OK, compila ✓' if ok else 'errori di sintassi ✗'}]",
+                  file=sys.stderr)
+
+
+def cmd_serve(args):
+    try:
+        import uvicorn
+        from fastapi import FastAPI
+        from pydantic import BaseModel
+    except Exception:
+        print("`skylar serve` richiede gli extra: pip install 'skylar[serve]'", file=sys.stderr)
+        sys.exit(1)
+    from .core import Skylar, COBOL_SYSTEM
+
+    sk = Skylar.load(args.model, device=args.device)
+    app = FastAPI(title="Skylar", version="0.1.0")
+
+    class GenReq(BaseModel):
+        prompt: str
+        system: str = COBOL_SYSTEM
+        max_new_tokens: int = 512
+        temperature: float = 0.0
+
+    @app.get("/health")
+    def health():
+        return {"status": "ok", "model": args.model, "device": sk.device}
+
+    @app.post("/generate")
+    def generate(r: GenReq):
+        return {"completion": sk.generate(r.prompt, system=r.system,
+                                          max_new_tokens=r.max_new_tokens,
+                                          temperature=r.temperature)}
+
+    @app.post("/v1/chat/completions")
+    def chat_completions(body: dict):
+        msgs = body.get("messages", [])
+        system = next((m["content"] for m in msgs if m.get("role") == "system"), COBOL_SYSTEM)
+        user = next((m["content"] for m in reversed(msgs) if m.get("role") == "user"), "")
+        text = sk.generate(user, system=system,
+                           max_new_tokens=body.get("max_tokens", 512),
+                           temperature=body.get("temperature", 0.0))
+        return {"object": "chat.completion", "model": args.model,
+                "choices": [{"index": 0, "message": {"role": "assistant", "content": text},
+                             "finish_reason": "stop"}]}
+
+    print(f"Skylar serve su http://{args.host}:{args.port}  (POST /generate, /v1/chat/completions)")
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(
+        prog="skylar",
+        description="Skylar — LLM locali e sovrani, from-scratch (specialista COBOL & altri).")
+    p.add_argument("--version", action="store_true", help="stampa la versione ed esci")
+    sub = p.add_subparsers(dest="cmd")
+
+    g = sub.add_parser("generate", help="una risposta singola a un prompt")
+    _add_common(g)
+    g.add_argument("--prompt", required=True)
+    g.add_argument("--seed", type=int, default=None)
+    g.set_defaults(func=cmd_generate)
+
+    c = sub.add_parser("chat", help="REPL interattiva in streaming")
+    _add_common(c)
+    c.set_defaults(func=cmd_chat)
+
+    co = sub.add_parser("cobol", help="completa uno stub COBOL in un programma intero")
+    _add_common(co)
+    co.add_argument("--stub-file", default=None, help="file con uno stub COBOLEval-style")
+    co.add_argument("--example", action="store_true", help="usa lo stub d'esempio incluso")
+    co.add_argument("--compile", action="store_true", help="verifica la sintassi con GnuCOBOL")
+    co.set_defaults(func=cmd_cobol, max_new=900)
+
+    s = sub.add_parser("serve", help="server HTTP (OpenAI-compatibile) — extra [serve]")
+    _add_common(s)
+    s.add_argument("--host", default="127.0.0.1")
+    s.add_argument("--port", type=int, default=8000)
+    s.set_defaults(func=cmd_serve)
+
+    args = p.parse_args(argv)
+    if args.version:
+        from . import __version__
+        print(f"skylar {__version__}")
+        return
+    if not getattr(args, "func", None):
+        p.print_help()
+        return
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

skylar/cobol.py

@@ -0,0 +1,115 @@
+"""COBOL-aware helpers for the SkylarCobol model.
+
+The model is trained to *complete* a COBOLEval-style stub: given a fixed-format COBOL skeleton
+(IDENTIFICATION/ENVIRONMENT/DATA/LINKAGE divisions + the task as comments, ending at
+`WORKING-STORAGE SECTION.`), it emits the WORKING-STORAGE entries + PROCEDURE DIVISION as a
+fenced ```cobol block. `complete_cobol()` wraps the prompt exactly like the training/eval harness
+and reassembles a full, compilable program — so you get real COBOL, not a fragment.
+"""
+import re
+
+from .core import COBOL_SYSTEM
+
+_EVAL_USER = (
+    "Complete the following COBOL subprogram. Output ONLY the WORKING-STORAGE SECTION "
+    "entries and the PROCEDURE DIVISION USING LINKED-ITEMS (do NOT repeat IDENTIFICATION/"
+    "ENVIRONMENT/DATA/LINKAGE), storing the answer in RESULT, ending with END PROGRAM.\n"
+    "```cobol\n{stub}\n```"
+)
+
+
+def extract_code_block(src):
+    m = re.search(r"```(?:cobol)?\s*\n(.*?)```", src, re.DOTALL | re.IGNORECASE)
+    return m.group(1) if m else src
+
+
+def swap_sections(src):
+    ws, lk, proc, begin = [], [], [], []
+    cur = begin
+    for line in src.split("\n"):
+        s = line.strip().upper()
+        if s.startswith("WORKING-STORAGE SECTION."):
+            cur = ws
+        elif s.startswith("LINKAGE SECTION."):
+            cur = lk
+        elif s.startswith("PROCEDURE DIVISION"):
+            cur = proc
+            line = "       PROCEDURE DIVISION USING LINKED-ITEMS."
+        cur.append(line)
+    return "\n".join(begin + ws + lk + proc)
+
+
+def _program_id(stub):
+    m = re.search(r"(?im)^\s*PROGRAM-ID\.\s*([A-Za-z0-9-]+)", stub)
+    return m.group(1) if m else "SOLUTION"
+
+
+def construct(stub, completion, entry_point):
+    if "IDENTIFICATION DIVISION" in completion.upper():
+        prog = completion
+    else:
+        sol = completion
+        if sol.strip().startswith("WORKING-STORAGE SECTION."):
+            sol = sol.replace("WORKING-STORAGE SECTION.", "", 1)
+        prog = f"{stub}\n{sol}"
+    prog = swap_sections(prog)
+    name = entry_point.upper().replace("_", "-")
+    prog = re.sub(r"(?im)^[ \t]*END[ \t]+PROGRAM\b.*$", "", prog).rstrip()
+    prog += f"\n       END PROGRAM {name}.\n"
+    return prog
+
+
+def complete_cobol(sk, stub, entry_point=None, max_new_tokens=900, temperature=0.0):
+    """Return a full, reassembled COBOL program for a COBOLEval-style stub."""
+    name = entry_point or _program_id(stub)
+    raw = sk.generate(_EVAL_USER.format(stub=stub), system=COBOL_SYSTEM,
+                      max_new_tokens=max_new_tokens, temperature=temperature)
+    return construct(stub, extract_code_block(raw), name)
+
+
+def syntax_ok(program_text):
+    """Best-effort: does GnuCOBOL accept it syntactically? (None if cobc missing).
+
+    Uses fixed-format (COBOLEval programs are column-sensitive). Honors a COBC env var so a
+    non-PATH GnuCOBOL build can be pointed at explicitly."""
+    import shutil, subprocess, tempfile, os
+    cobc = os.environ.get("COBC", "cobc")
+    if not (os.path.isfile(cobc) or shutil.which(cobc)):
+        return None
+    with tempfile.TemporaryDirectory() as d:
+        f = os.path.join(d, "prog.cbl")
+        open(f, "w").write(program_text)
+        r = subprocess.run([cobc, "-fsyntax-only", "-fformat=fixed", "-w", f],
+                           capture_output=True, text=True)
+        return r.returncode == 0
+
+
+# sample stub for `skylar cobol --example` — a task the model handles well (increment a list).
+# (COBOLEval-style fixed format; the model emits WORKING-STORAGE + PROCEDURE, we reassemble.)
+EXAMPLE_STUB = """\
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. INCR-LIST.
+
+       ENVIRONMENT DIVISION.
+
+       INPUT-OUTPUT SECTION.
+
+       DATA DIVISION.
+
+       LINKAGE SECTION.
+
+       01 LINKED-ITEMS.
+           05 L-L OCCURS 3 TIMES INDEXED BY NI PIC S9(10).
+           05 RESULT OCCURS 100 TIMES INDEXED BY NJ PIC S9(10).
+
+      * Return list with elements incremented by 1.
+      * >>> incr_list([1, 2, 3])
+      * [2, 3, 4]
+      * >>> incr_list([5, 3, 5])
+      * [6, 4, 6]
+
+      * Complete the WORKING-STORAGE SECTION and the PROCEDURE DIVISION
+      * Store the result in the RESULT variable and mark the end of your program with END PROGRAM
+
+       WORKING-STORAGE SECTION.
+"""