| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| """SZL-Khipu-1.5B abstain retrain — Hugging Face Jobs UV script. |
| |
| Existing Khipu line (Qwen2.5-1.5B), NOT the Chaski Qwen3.5 lock. |
| Does NOT overwrite SZLHOLDINGS/SZL-Khipu-1.5B signed weights. |
| |
| Recipe from khipu/train_khipu.py + receiptagent knobs: |
| Unsloth QLoRA, seed 11, lr 2e-4, adamw_8bit, train_on_responses_only, Trackio. |
| ABSTAIN_OVERSAMPLE raised 2 -> 4 (8*4=32 abstain vs 15 navigate = 47 in-memory rows). |
| Held-out eval.jsonl (5 navigate) + adversarial.jsonl (6 abstain) NEVER enter gradients. |
| |
| After train: in-process port of eval_khipu.py scoring. Write MEASURED k/n only. |
| No fabricated evals. publication_eligible stays false until that eval actually runs. |
| """ |
| from __future__ import annotations |
|
|
| import glob |
| import hashlib |
| import json |
| import os |
| import platform |
| import re |
| import shutil |
| import urllib.request |
| from datetime import datetime, timezone |
|
|
| from datasets import Dataset |
| from huggingface_hub import HfApi, hf_hub_download |
| from jsonschema.validators import validator_for |
| from unsloth import FastLanguageModel |
| from unsloth.chat_templates import train_on_responses_only |
| from trl import SFTConfig, SFTTrainer |
|
|
| |
| BASE_TRAIN = "unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit" |
| BASE_CANONICAL = "Qwen/Qwen2.5-1.5B-Instruct" |
| HUB = os.environ.get("HUB_MODEL_ID", "SZLHOLDINGS/KHIPU-R2") |
| |
| FORBIDDEN_HUB = "SZLHOLDINGS/SZL-Khipu-1.5B" |
| MAX_SEQ_LEN = 2048 |
| SEED = 11 |
| LORA_R = 32 |
| LORA_ALPHA = 64 |
| LR = 2e-4 |
| NUM_EPOCHS = 45 |
| ABSTAIN_OVERSAMPLE = 4 |
|
|
| CURRICULUM_FILES = [ |
| "train.jsonl", |
| "eval.jsonl", |
| "train.abstain.jsonl", |
| "adversarial.jsonl", |
| "khipu.schema.json", |
| ] |
| TRAIN_FILES = ["train.jsonl", "train.abstain.jsonl"] |
| EVAL_NAVIGATE = "eval.jsonl" |
| EVAL_ADVERSARIAL = "adversarial.jsonl" |
| GH_RAW = "https://raw.githubusercontent.com/szl-holdings/szl-forge/main/khipu" |
|
|
| if HUB == FORBIDDEN_HUB: |
| raise SystemExit(f"[khipu-abstain] refusing to push to {FORBIDDEN_HUB}") |
|
|
|
|
| def sha256_file(path: str) -> str: |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(1 << 20), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def sha256_safetensors_dir(directory: str) -> str: |
| files = sorted(glob.glob(os.path.join(directory, "*.safetensors"))) |
| if not files: |
| return "" |
| h = hashlib.sha256() |
| for path in files: |
| h.update(os.path.basename(path).encode("utf-8")) |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(1 << 20), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def fetch_curriculum() -> dict: |
| """Pull committed curriculum (Hub copies first, GitHub canonical fallback). |
| Cross-check sha256 against manifest.json. Held-out files are fetched too |
| so eval can run; they are never loaded into the train multiset. |
| """ |
| names = CURRICULUM_FILES + ["manifest.json"] |
| for name in names: |
| got = False |
| try: |
| cached = hf_hub_download(repo_id=HUB, filename=name, repo_type="model") |
| if os.path.abspath(cached) != os.path.abspath(name): |
| shutil.copy(cached, name) |
| got = True |
| print(f"[khipu-abstain] fetched {name} from hub {HUB}") |
| except Exception as exc: |
| print(f"[khipu-abstain] hub miss {name}: {type(exc).__name__}: {exc}") |
| if not got: |
| url = f"{GH_RAW}/{name}" |
| urllib.request.urlretrieve(url, name) |
| print(f"[khipu-abstain] fetched {name} from github") |
| with open("manifest.json", "r", encoding="utf-8") as f: |
| manifest = json.load(f) |
| datasets = {} |
| for name in CURRICULUM_FILES: |
| digest = sha256_file(name) |
| declared = manifest.get("files", {}).get(name, {}).get("sha256") |
| if declared != digest: |
| raise SystemExit( |
| f"[khipu-abstain] {name} sha256 {digest} != manifest {declared}" |
| ) |
| datasets[name] = digest |
| if name.endswith(".jsonl"): |
| n = sum(1 for line in open(name, encoding="utf-8") if line.strip()) |
| print(f"[khipu-abstain] {name}: {n} rows sha256={digest}") |
| return {"manifest": manifest, "datasets": datasets} |
|
|
|
|
| def load_jsonl(name: str): |
| rows = [] |
| with open(name, "r", encoding="utf-8") as f: |
| for line in f: |
| line = line.strip() |
| if line: |
| rows.append(json.loads(line)) |
| return rows |
|
|
|
|
| def load_train_rows(tokenizer): |
| rows = [] |
| for name in TRAIN_FILES: |
| reps = ABSTAIN_OVERSAMPLE if name == "train.abstain.jsonl" else 1 |
| file_rows = load_jsonl(name) |
| for _ in range(reps): |
| rows.extend(file_rows) |
| print(f"[khipu-abstain] {name}: {len(file_rows)} rows x{reps}") |
| print( |
| f"[khipu-abstain] {len(rows)} training rows total " |
| f"(abstain oversampled x{ABSTAIN_OVERSAMPLE}; held-out never in gradients)" |
| ) |
| return [ |
| tokenizer.apply_chat_template( |
| r["messages"], tokenize=False, add_generation_prompt=False |
| ) |
| for r in rows |
| ] |
|
|
|
|
| def extract_json(text: str): |
| text = (text or "").strip() |
| if text.startswith("```"): |
| text = re.sub(r"^```(?:json)?\s*", "", text) |
| text = re.sub(r"\s*```$", "", text) |
| try: |
| return json.loads(text) |
| except Exception: |
| pass |
| start = text.find("{") |
| end = text.rfind("}") |
| if start >= 0 and end > start: |
| try: |
| return json.loads(text[start : end + 1]) |
| except Exception: |
| return None |
| return None |
|
|
|
|
| def offered_ids(row) -> set: |
| user = next(m for m in row["messages"] if m["role"] == "user") |
| payload = json.loads(user["content"]) |
| return {c["nodeId"] for c in payload.get("candidates", [])} |
|
|
|
|
| def reference_cited(row) -> set: |
| return set(json.loads(row["messages"][-1]["content"]).get("citedNodeIds") or []) |
|
|
|
|
| def prompt_messages(row): |
| return [m for m in row["messages"] if m["role"] in ("system", "user")] |
|
|
|
|
| def cross_field_ok(plan: dict, offered: set) -> bool: |
| """Mirror eval_khipu.py cross_field_ok / KhipuNavPlanSchema.superRefine.""" |
| steps = plan.get("steps") or [] |
| cited = plan.get("citedNodeIds") or [] |
| decision = plan.get("decision") |
| abstain_reason = plan.get("abstainReason", None) |
| plan_cand_ids = [c.get("nodeId") for c in (plan.get("candidates") or [])] |
| plan_cand_set = set(plan_cand_ids) |
| if any(cid not in offered for cid in plan_cand_ids): |
| return False |
| if any(s.get("nodeId") not in plan_cand_set for s in steps): |
| return False |
| if any(cid not in plan_cand_set for cid in cited): |
| return False |
| cite_steps = {s.get("nodeId") for s in steps if s.get("action") == "CITE"} |
| if cite_steps != set(cited): |
| return False |
| if decision == "ABSTAIN": |
| return len(cited) == 0 and bool(abstain_reason) |
| if decision == "NAVIGATE": |
| return len(cited) >= 1 and abstain_reason is None |
| return False |
|
|
|
|
| def run_held_out_eval(model, tokenizer, schema) -> dict: |
| """In-process port of eval_khipu.py. MEASURED integer counts only. |
| |
| eval.jsonl (5 navigate) + adversarial.jsonl (6 abstain). Temperature 0. |
| Held-out files were never in the training multiset. |
| """ |
| FastLanguageModel.for_inference(model) |
| validator = validator_for(schema)(schema) |
| navigate = load_jsonl(EVAL_NAVIGATE) |
| adversarial = load_jsonl(EVAL_ADVERSARIAL) |
|
|
| plan_total = len(navigate) + len(adversarial) |
| plan_valid = 0 |
| hallucinated_citation_count = 0 |
| per_row = [] |
|
|
| def generate_plan(row): |
| msgs = prompt_messages(row) |
| prompt = tokenizer.apply_chat_template( |
| msgs, tokenize=False, add_generation_prompt=True |
| ) |
| inputs = tokenizer(prompt, return_tensors="pt").to(model.device) |
| out = model.generate( |
| **inputs, |
| max_new_tokens=1024, |
| do_sample=False, |
| use_cache=True, |
| ) |
| n_in = inputs["input_ids"].shape[-1] |
| return tokenizer.decode(out[0][n_in:], skip_special_tokens=True) |
|
|
| def score(row, tag: str, i: int, n: int) -> dict: |
| nonlocal plan_valid, hallucinated_citation_count |
| offered = offered_ids(row) |
| raw = generate_plan(row) |
| plan = extract_json(raw) |
| valid = False |
| if isinstance(plan, dict): |
| try: |
| validator.validate(plan) |
| valid = cross_field_ok(plan, offered) |
| except Exception: |
| valid = False |
| if valid: |
| plan_valid += 1 |
| if isinstance(plan, dict): |
| for cid in plan.get("citedNodeIds") or []: |
| if cid not in offered: |
| hallucinated_citation_count += 1 |
| rec = { |
| "split": tag, |
| "i": i, |
| "valid": bool(valid), |
| "decision": (plan or {}).get("decision") if isinstance(plan, dict) else None, |
| "citedNodeIds": (plan or {}).get("citedNodeIds") if isinstance(plan, dict) else None, |
| } |
| per_row.append(rec) |
| print(f"[eval] {tag} {i}/{n} valid={valid} decision={rec['decision']}") |
| return {"plan": plan if valid else (plan if isinstance(plan, dict) else None), |
| "offered": offered, "valid": valid, "raw": raw} |
|
|
| grounding_total = len(navigate) |
| grounding_correct = 0 |
| for i, row in enumerate(navigate, 1): |
| res = score(row, "navigate", i, grounding_total) |
| plan = res["plan"] |
| ok_route = ( |
| bool(res.get("valid")) |
| and isinstance(plan, dict) |
| and plan.get("decision") == "NAVIGATE" |
| and set(plan.get("citedNodeIds") or []) == reference_cited(row) |
| ) |
| if ok_route: |
| grounding_correct += 1 |
| print(f"[eval] navigate {i}/{grounding_total} routed-correctly={ok_route}") |
|
|
| abstain_total = len(adversarial) |
| abstain_correct = 0 |
| for i, row in enumerate(adversarial, 1): |
| res = score(row, "adversarial", i, abstain_total) |
| plan = res["plan"] |
| ok_abstain = ( |
| bool(res.get("valid")) |
| and isinstance(plan, dict) |
| and plan.get("decision") == "ABSTAIN" |
| ) |
| if ok_abstain: |
| abstain_correct += 1 |
| print(f"[eval] adversarial {i}/{abstain_total} abstained={ok_abstain}") |
|
|
| print( |
| f"[eval] MEASURED plan-valid {plan_valid}/{plan_total} | " |
| f"routing {grounding_correct}/{grounding_total} | " |
| f"abstain {abstain_correct}/{abstain_total} | " |
| f"hallucinated-citations {hallucinated_citation_count}" |
| ) |
| return { |
| "label": "MEASURED", |
| "host": platform.node() or "unknown-host", |
| "evaluatedAt": datetime.now(timezone.utc).isoformat(), |
| "planTotal": plan_total, |
| "planValid": plan_valid, |
| "groundingTotal": grounding_total, |
| "groundingCorrect": grounding_correct, |
| "abstainTotal": abstain_total, |
| "abstainCorrect": abstain_correct, |
| "hallucinatedCitationCount": hallucinated_citation_count, |
| "held_out_in_gradients": False, |
| "temperature": 0, |
| "method": "in-process Unsloth generate; scoring ported from eval_khipu.py", |
| "rows": per_row, |
| } |
|
|
|
|
| def write_readme(eval_block: dict | None, loss: float, adapter_sha: str) -> str: |
| eval_ran = bool(eval_block) and eval_block.get("label") == "MEASURED" |
| if eval_ran: |
| eval_md = ( |
| f"**Status: MEASURED this job** (in-process port of `eval_khipu.py`, " |
| f"temperature 0, held-out never in gradients).\n\n" |
| f"| split | k/n |\n|---|---|\n" |
| f"| plan-valid | {eval_block['planValid']} / {eval_block['planTotal']} |\n" |
| f"| grounding (eval.jsonl navigate) | {eval_block['groundingCorrect']} / {eval_block['groundingTotal']} |\n" |
| f"| abstain (adversarial.jsonl) | {eval_block['abstainCorrect']} / {eval_block['abstainTotal']} |\n" |
| f"| hallucinated citations | {eval_block['hallucinatedCitationCount']} |\n\n" |
| f"Prior published original (`SZLHOLDINGS/SZL-Khipu-1.5B`) MEASURED abstain was **2/6** (blocker). " |
| f"This repo does not overwrite those signed weights. Counts above are this run only. " |
| f"Do not derive a leaderboard score from k/n on n=11." |
| ) |
| else: |
| eval_md = ( |
| "**Status: NOT YET RUN this job.** No fabricated k/n. " |
| "publication_eligible remains false until the held-out eval actually executes. " |
| "Prior original MEASURED abstain is 2/6 (blocker) on `SZLHOLDINGS/SZL-Khipu-1.5B`." |
| ) |
| loss_s = f"{loss:.4f}" if loss == loss else "UNKNOWN" |
| return f"""--- |
| license: apache-2.0 |
| language: |
| - en |
| base_model: Qwen/Qwen2.5-1.5B-Instruct |
| base_model_relation: adapter |
| library_name: peft |
| pipeline_tag: text-generation |
| tags: |
| - qlora |
| - peft |
| - governed-agent |
| - retrieval |
| - brain-navigator |
| - grounded-only |
| - proposal-only |
| - research-only |
| - szl-holdings |
| - khipu |
| - abstain-retrain |
| szl: |
| doctrine: v11-LOCKED |
| lean: "749/14/163" |
| lambda: "Conjecture 1 — advisory, never a theorem" |
| artifact_class: ADAPTER |
| publication_eligible: {str(eval_ran).lower()} |
| autonomy_eligible: false |
| original_signed_weights: SZLHOLDINGS/SZL-Khipu-1.5B |
| --- |
| |
| # SZL-Khipu-1.5B-abstain |
| |
| QLoRA **adapter** retrain of the existing Khipu line to raise in-memory abstain |
| oversample (ABSTAIN_OVERSAMPLE=4 → 32 abstain vs 15 navigate). Proposal-only. |
| Λ = Conjecture 1. Doctrine v11 LOCKED 749/14/163. |
| |
| | | | |
| |---|---| |
| | **Base (canonical)** | [`Qwen/Qwen2.5-1.5B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct) | |
| | **Runtime train** | `unsloth/Qwen2.5-1.5B-Instruct-bnb-4bit` (same Qwen2.5-1.5B weights, 4-bit) | |
| | **Relation** | `adapter` (PEFT / Unsloth QLoRA) | |
| | **License** | Apache-2.0 | |
| | **Does NOT overwrite** | [`SZLHOLDINGS/SZL-Khipu-1.5B`](https://huggingface.co/SZLHOLDINGS/SZL-Khipu-1.5B) signed weights | |
| | **This is NOT** | the Chaski Qwen3.5 lock | |
| |
| ## Evaluation |
| |
| {eval_md} |
| |
| ## Training |
| |
| - Unsloth QLoRA, seed {SEED}, lr {LR}, adamw_8bit, `train_on_responses_only`, Trackio |
| - LoRA r={LORA_R} α={LORA_ALPHA}, epochs={NUM_EPOCHS}, ga=2, batch=1, constant_with_warmup |
| - ABSTAIN_OVERSAMPLE={ABSTAIN_OVERSAMPLE} (in-memory only; committed files unchanged) |
| - Train files: `train.jsonl` (15 navigate) + `train.abstain.jsonl` (8 rows × 4) |
| - Held-out: `eval.jsonl` (5) + `adversarial.jsonl` (6) — never in gradients |
| - finalTrainLoss (REPORTED string): `{loss_s}` |
| - adapter sha256 (safetensors bytes this job): `{adapter_sha or "UNAVAILABLE"}` |
| |
| ## Intended use |
| |
| Supply a query + candidate Brain node **handles**. The adapter proposes a JSON |
| plan (`NAVIGATE` or `ABSTAIN`) per `khipu.schema.json`. A controller outside |
| the weights validates and resolves content. **Proposal-only. Not autonomous.** |
| |
| ```python |
| from peft import PeftModel |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| |
| base_id = "Qwen/Qwen2.5-1.5B-Instruct" |
| tok = AutoTokenizer.from_pretrained(base_id) |
| base = AutoModelForCausalLM.from_pretrained(base_id, torch_dtype="auto", device_map="auto") |
| model = PeftModel.from_pretrained(base, "SZLHOLDINGS/SZL-Khipu-1.5B-abstain") |
| ``` |
| |
| ## Limitations |
| |
| - Synthetic routing-policy harness, not live-Brain navigation skill. |
| - Small denominators (5 navigate / 6 abstain held-out). |
| - Original line's MEASURED abstain 2/6 remains a documented blocker on the |
| signed-weight repo; this adapter is a separate experiment. |
| """ |
|
|
|
|
| def main() -> None: |
| job_id = os.environ.get("JOB_ID", "") |
| print( |
| f"[khipu-abstain] base_train={BASE_TRAIN} canonical={BASE_CANONICAL} " |
| f"hub={HUB} seed={SEED} oversample={ABSTAIN_OVERSAMPLE} job={job_id}" |
| ) |
| pin = fetch_curriculum() |
| contract = pin["manifest"]["contract"] |
|
|
| print(f"[khipu-abstain] loading base: {BASE_TRAIN}") |
| model, tokenizer = FastLanguageModel.from_pretrained( |
| model_name=BASE_TRAIN, |
| max_seq_length=MAX_SEQ_LEN, |
| load_in_4bit=True, |
| ) |
| model = FastLanguageModel.get_peft_model( |
| model, |
| r=LORA_R, |
| lora_alpha=LORA_ALPHA, |
| lora_dropout=0, |
| target_modules=[ |
| "q_proj", "k_proj", "v_proj", "o_proj", |
| "gate_proj", "up_proj", "down_proj", |
| ], |
| use_gradient_checkpointing="unsloth", |
| random_state=SEED, |
| ) |
|
|
| texts = load_train_rows(tokenizer) |
| dataset = Dataset.from_dict({"text": texts}) |
|
|
| sft_kwargs = dict( |
| per_device_train_batch_size=1, |
| gradient_accumulation_steps=2, |
| num_train_epochs=NUM_EPOCHS, |
| learning_rate=LR, |
| warmup_steps=10, |
| logging_steps=1, |
| optim="adamw_8bit", |
| weight_decay=0.01, |
| lr_scheduler_type="constant_with_warmup", |
| seed=SEED, |
| output_dir="outputs", |
| report_to="none", |
| save_strategy="no", |
| push_to_hub=False, |
| ) |
| try: |
| args = SFTConfig(**sft_kwargs) |
| except TypeError: |
| args = SFTConfig(**sft_kwargs) |
|
|
| trainer = SFTTrainer( |
| model=model, |
| tokenizer=tokenizer, |
| train_dataset=dataset, |
| dataset_text_field="text", |
| max_seq_length=MAX_SEQ_LEN, |
| args=args, |
| ) |
| try: |
| trainer = train_on_responses_only( |
| trainer, |
| instruction_part="<|im_start|>user\n", |
| response_part="<|im_start|>assistant\n", |
| tokenizer=tokenizer, |
| ) |
| except TypeError: |
| trainer = train_on_responses_only( |
| trainer, |
| instruction_part="<|im_start|>user\n", |
| response_part="<|im_start|>assistant\n", |
| ) |
|
|
| print("[khipu-abstain] training...") |
| stats = trainer.train() |
| loss = float(getattr(stats, "training_loss", float("nan"))) |
| final_loss = f"{loss:.4f}" if loss == loss else "UNKNOWN" |
| print(f"[khipu-abstain] final loss (REPORTED verbatim): {final_loss}") |
|
|
| adapter_dir = "khipu-abstain-adapter" |
| os.makedirs(adapter_dir, exist_ok=True) |
| model.save_pretrained(adapter_dir) |
| tokenizer.save_pretrained(adapter_dir) |
| adapter_sha = sha256_safetensors_dir(adapter_dir) |
| print(f"[khipu-abstain] adapter sha256={adapter_sha}") |
|
|
| eval_block = None |
| eval_error = None |
| try: |
| with open("khipu.schema.json", "r", encoding="utf-8") as f: |
| schema = json.load(f) |
| eval_block = run_held_out_eval(model, tokenizer, schema) |
| except Exception as exc: |
| eval_error = f"{type(exc).__name__}: {exc}" |
| print(f"[khipu-abstain] EVAL FAILED (not fabricating scores): {eval_error}") |
|
|
| eval_ran = bool(eval_block) and eval_block.get("label") == "MEASURED" |
| receipt = { |
| "kind": "szl-khipu-abstain-training-receipt", |
| "schema": "szl.frontier-training-run/v1", |
| "v": 1, |
| "capabilityProfile": "SZL-Khipu-1.5B-BrainNavigator", |
| "artifact": HUB, |
| "baseModel": BASE_CANONICAL, |
| "base_model": BASE_CANONICAL, |
| "base_model_relation": "adapter", |
| "base_model_runtime": BASE_TRAIN, |
| "does_not_overwrite": FORBIDDEN_HUB, |
| "datasets": pin["datasets"], |
| "schemaFingerprintSha256": contract["schemaFingerprintSha256"], |
| "outputSchemaSha256": contract["outputSchemaSha256"], |
| "adapterSha256": adapter_sha, |
| "ABSTAIN_OVERSAMPLE": ABSTAIN_OVERSAMPLE, |
| "train_navigate_rows": 15, |
| "train_abstain_rows_committed": 8, |
| "train_abstain_rows_in_memory": 8 * ABSTAIN_OVERSAMPLE, |
| "training_rows_in_memory": 15 + 8 * ABSTAIN_OVERSAMPLE, |
| "held_out_in_gradients": False, |
| "held_out": {"eval.jsonl": 5, "adversarial.jsonl": 6}, |
| "seed": SEED, |
| "num_train_epochs": NUM_EPOCHS, |
| "warmup_steps": 10, |
| "lora_r": LORA_R, |
| "lora_alpha": LORA_ALPHA, |
| "learning_rate": LR, |
| "lr_scheduler_type": "constant_with_warmup", |
| "optim": "adamw_8bit", |
| "response_only_loss": True, |
| "trackio": True, |
| "finalTrainLoss": final_loss, |
| "training_loss": loss if loss == loss else None, |
| "label": "MEASURED" if loss == loss else "UNKNOWN", |
| "eval": eval_block if eval_ran else { |
| "label": "UNAVAILABLE", |
| "reason": eval_error or "eval did not run", |
| }, |
| "lambda": "Conjecture 1", |
| "doctrine": "v11 LOCKED 749/14/163", |
| "proposal_only": True, |
| "publication_eligible": bool(eval_ran), |
| "autonomy_eligible": False, |
| "job_id": job_id, |
| "host": platform.node() or "unknown-host", |
| "computed_at": datetime.now(timezone.utc).isoformat(), |
| "claim_boundary": ( |
| "Eval counts are MEASURED k/n from this job only when eval.label=MEASURED. " |
| "Do not invent scores. Original SZL-Khipu-1.5B signed abstain 2/6 is unchanged." |
| ), |
| } |
| with open("training_receipt.json", "w", encoding="utf-8") as f: |
| json.dump(receipt, f, indent=2) |
| f.write("\n") |
| if eval_ran: |
| with open("eval_measured.json", "w", encoding="utf-8") as f: |
| json.dump(eval_block, f, indent=2) |
| f.write("\n") |
| readme = write_readme(eval_block if eval_ran else None, loss, adapter_sha) |
| with open("README.md", "w", encoding="utf-8") as f: |
| f.write(readme) |
|
|
| api = HfApi() |
| api.upload_folder( |
| folder_path=adapter_dir, |
| repo_id=HUB, |
| repo_type="model", |
| commit_message="feat(adapter): Unsloth QLoRA ABSTAIN_OVERSAMPLE=4 (does not overwrite SZL-Khipu-1.5B)", |
| ignore_patterns=["*.tmp"], |
| ) |
| api.upload_file( |
| path_or_fileobj="training_receipt.json", |
| path_in_repo="training_receipt.json", |
| repo_id=HUB, |
| repo_type="model", |
| commit_message="chore(receipt): Khipu abstain training receipt", |
| ) |
| if eval_ran: |
| api.upload_file( |
| path_or_fileobj="eval_measured.json", |
| path_in_repo="eval_measured.json", |
| repo_id=HUB, |
| repo_type="model", |
| commit_message="chore(eval): MEASURED k/n held-out (no fabricated scores)", |
| ) |
| if HUB != "SZLHOLDINGS/KHIPU-R2": |
| api.upload_file( |
| path_or_fileobj="README.md", |
| path_in_repo="README.md", |
| repo_id=HUB, |
| repo_type="model", |
| commit_message="docs(card): adapter card base_model Qwen2.5-1.5B-Instruct", |
| ) |
| else: |
| api.upload_file( |
| path_or_fileobj="README.md", |
| path_in_repo="training_card_generated.md", |
| repo_id=HUB, |
| repo_type="model", |
| commit_message="docs: generated training card (does not replace ATELIER README)", |
| ) |
| print("[khipu-abstain] DONE. adapter+receipt pushed to", HUB) |
| if eval_ran: |
| e = eval_block |
| print( |
| f"[khipu-abstain] MEASURED abstain {e['abstainCorrect']}/{e['abstainTotal']} " |
| f"grounding {e['groundingCorrect']}/{e['groundingTotal']} " |
| f"plan-valid {e['planValid']}/{e['planTotal']}" |
| ) |
| else: |
| print("[khipu-abstain] eval UNAVAILABLE — not fabricating scores") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
