| |
| |
| |
| |
| |
| |
| |
| |
| |
| """ |
| Fine-tune a Kev decision model on your own labelled questions, on one HF Jobs GPU. |
| |
| Kev (https://github.com/jaredpalmer/kev) answers yes/no, multiple-choice and rating questions |
| about a text, with a probability for each answer. This script is a thin launcher around Kev's |
| own commands. It pins one Kev commit and one set of released weights, installs Kev, and then runs: |
| |
| 1. `kev.train`: a LoRA + pointer-head delta from the released Kev-4B, on your training records. |
| 2. `kev.benchmark`: the fine-tuned model and the released model, on your development records. |
| 3. `kev.calibrate`: a calibration report for the fine-tuned model (report only, nothing changes). |
| |
| All training and evaluation code is Kev's. Kev's own recipes run on Modal (the `kev-finetune` |
| skill) or on a GPU you have; this script is for people whose data and credit are on the Hub. |
| |
| Input: a folder with `train.jsonl` and `development.jsonl` in Kev's record format (see the README). |
| Output: an empty or new folder on a mounted bucket. Each result is copied there as soon as it is |
| written: the checkpoint, both benchmark reports, the calibration report and `run.json`. |
| |
| Example, with input and output in a bucket: |
| |
| hf jobs uv run --flavor a100-large --timeout 1h --secrets HF_TOKEN \\ |
| -v hf://buckets/<you>/kev-data:/mnt/kev \\ |
| https://huggingface.co/datasets/uv-scripts/classification/raw/main/train-kev.py \\ |
| /mnt/kev/newsgroups /mnt/kev/runs/newsgroups-v1 |
| |
| Tested on 2026-10-30 (a100-large, 31 min, about $1.29): 20 Newsgroups, 846 training and 426 test |
| posts after Kev's length limit. Accuracy 72.3% fine-tuned vs 62.4% for the released Kev-4B. One seed. |
| """ |
|
|
| import argparse |
| import json |
| import os |
| import subprocess |
| import sys |
| import time |
| from pathlib import Path |
|
|
| KEV_REPO = "https://github.com/jaredpalmer/kev" |
| KEV_TAG = "kev-1.0" |
| KEV_COMMIT = "6b719c3c3f367295f6ef336f4f751cf5ff970abc" |
| |
| |
| INIT_MODEL = "jaredpalmer/kev-4b@6cfce5c2fa4b4bd64026336ab649c5ca78857d52" |
| BASE_MODEL = "Qwen/Qwen3.5-4B-Base" |
| BASE_REVISION = "1001bb4d826a52d1f399e183466143f4da7b741b" |
| QUESTION_TYPES = ("noul", "choice", "score") |
| MAX_OPTIONS = 255 |
| WORK_DIR = Path("/tmp/kev") |
| SCRATCH = Path("/tmp/out") |
|
|
|
|
| def run(command, cwd=WORK_DIR): |
| print(f"\n$ {' '.join(command)}", flush=True) |
| started = time.time() |
| subprocess.run(command, cwd=cwd, check=True) |
| print(f"[{time.time() - started:.0f}s]", flush=True) |
|
|
|
|
| def check_gpu(): |
| try: |
| listing = subprocess.run(["nvidia-smi", "-L"], capture_output=True, text=True) |
| except FileNotFoundError: |
| listing = None |
| if listing is None or listing.returncode != 0 or "GPU" not in listing.stdout: |
| sys.exit("No GPU found. Run this on a GPU flavor, for example --flavor a100-large.") |
| print(listing.stdout.strip(), flush=True) |
|
|
|
|
| def question_problem(question): |
| """Why a labelled question is not in Kev's format, or None. Rules from kev/api.py and Kev's README: |
| noul labels are true/false; choice criteria is an object of options and the label is one of them; |
| score criteria is a list of levels and the label is a level's position from 0.""" |
| if not isinstance(question, dict) or question.get("type") not in QUESTION_TYPES: |
| return f"needs a type: one of {', '.join(QUESTION_TYPES)}" |
| if "label" not in question: |
| return "needs a label" |
| kind, label, criteria = question["type"], question["label"], question.get("criteria") |
| if kind == "noul" and not isinstance(label, bool): |
| return "is a noul question, so its label must be true or false" |
| if kind == "choice": |
| if not isinstance(criteria, dict) or not 1 <= len(criteria) <= MAX_OPTIONS: |
| return f"is a choice question, so its criteria must be an object with 1 to {MAX_OPTIONS} options" |
| if label not in criteria: |
| return f"has label {label!r}, which is not one of its criteria" |
| if kind == "score": |
| if not isinstance(criteria, list) or not 1 <= len(criteria) <= MAX_OPTIONS: |
| return f"is a score question, so its criteria must be a list of 1 to {MAX_OPTIONS} levels" |
| if isinstance(label, bool) or not isinstance(label, int) or not 0 <= label < len(criteria): |
| return f"is a score question, so its label must be a level position from 0 to {len(criteria) - 1}" |
| return None |
|
|
|
|
| def check_records(path): |
| """Fail before any GPU time is spent if a record is not in Kev's labelled format.""" |
| if not path.is_file(): |
| sys.exit(f"{path} not found. The input folder needs train.jsonl and development.jsonl.") |
| count = 0 |
| with path.open() as f: |
| for line_number, line in enumerate(f, start=1): |
| if not line.strip(): |
| continue |
| where = f"{path.name} line {line_number}" |
| try: |
| record = json.loads(line) |
| except json.JSONDecodeError as error: |
| sys.exit(f"{where}: not valid JSON ({error}).") |
| if not isinstance(record, dict) or record.get("state") is None: |
| sys.exit(f'{where}: a record needs a "state" (text, or any JSON object or list).') |
| questions = record.get("questions") |
| if not isinstance(questions, dict) or not questions: |
| sys.exit(f'{where}: a record needs a non-empty "questions" object.') |
| for name, question in questions.items(): |
| problem = question_problem(question) |
| if problem: |
| sys.exit(f'{where}: question "{name}" {problem}.') |
| count += 1 |
| if count == 0: |
| sys.exit(f"{path} has no records.") |
| print(f"{path.name}: {count} records", flush=True) |
| return count |
|
|
|
|
| def mount_of(path, mounts_file=Path("/proc/self/mounts")): |
| """(mount point, filesystem type, device) of the mount that holds `path`.""" |
| best = ("", "", "") |
| for line in mounts_file.read_text().splitlines(): |
| device, mount_point, fstype = line.split()[:3] |
| holds_path = path == Path(mount_point) or Path(mount_point) in path.parents |
| if holds_path and len(mount_point) > len(best[0]): |
| best = (mount_point, fstype, device) |
| return best |
|
|
|
|
| def prepare_output(output_dir): |
| """Fail before any GPU time is spent if the results would be lost or mixed with an old run.""" |
| if os.environ.get("JOB_ID"): |
| |
| mount_point, fstype, device = mount_of(output_dir) |
| if device != "hf-mount": |
| sys.exit(f"{output_dir} is not on a mounted bucket (it is on {mount_point}, {fstype or 'unknown'}). " |
| "Mount one with -v hf://buckets/<you>/<bucket>:/mnt/kev and write under /mnt/kev.") |
| if output_dir.exists() and any(output_dir.iterdir()): |
| sys.exit(f"{output_dir} is not empty. Use a new folder for each run.") |
| output_dir.mkdir(parents=True, exist_ok=True) |
| (output_dir / "run.json").write_text(json.dumps({"status": "started"})) |
|
|
|
|
| def install_kev(): |
| run(["git", "clone", "-q", "--depth", "1", "--branch", KEV_TAG, KEV_REPO, str(WORK_DIR)], cwd="/tmp") |
| head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=WORK_DIR, check=True, capture_output=True, text=True) |
| if head.stdout.strip() != KEV_COMMIT: |
| sys.exit(f"{KEV_TAG} now points to {head.stdout.strip()}, not {KEV_COMMIT}. Check the Kev release notes.") |
| run(["uv", "sync", "--no-dev", "-q"]) |
| cuda = subprocess.run(["uv", "run", "python", "-c", "import torch; print(torch.cuda.is_available())"], |
| cwd=WORK_DIR, capture_output=True, text=True) |
| if cuda.stdout.strip() != "True": |
| sys.exit(f"PyTorch in Kev's environment cannot use the GPU.\n{cuda.stderr[-2000:]}") |
|
|
|
|
| def save(name, output_dir): |
| """Copy one finished result to the output folder, so a later failure cannot lose it.""" |
| destination = output_dir / name |
| destination.mkdir(parents=True, exist_ok=True) |
| subprocess.run(["cp", "-r", f"{SCRATCH / name}/.", str(destination)], check=True) |
| print(f"saved {destination}", flush=True) |
|
|
|
|
| def train(args): |
| command = [ |
| "uv", "run", "python", "-m", "kev.train", |
| "--data", str(args.input_dir / "train.jsonl"), |
| "--base", BASE_MODEL, |
| "--base_revision", BASE_REVISION, |
| "--init_from", args.init_from, |
| "--epochs", str(args.epochs), |
| "--lr", str(args.lr), |
| "--batch", "1", "--accum", "8", "--dtype", "bf16", "--checkpointing", "1", |
| "--device", "cuda", |
| "--out", str(SCRATCH / "checkpoint"), |
| ] |
| if args.max_steps: |
| command += ["--max_steps", str(args.max_steps)] |
| run(command) |
|
|
|
|
| def benchmark(model, data, name): |
| run(["uv", "run", "python", "-m", "kev.benchmark", "--run", str(model), "--data", str(data), "--out", str(SCRATCH / name)]) |
|
|
|
|
| def calibrate(): |
| """Kev's calibration report. It needs enough development records for its folds, so a failure |
| here is reported and the run goes on: the checkpoint and benchmarks are already saved.""" |
| try: |
| run(["uv", "run", "python", "-m", "kev.calibrate", "--rows", str(SCRATCH / "finetuned-development" / "rows.json")]) |
| report = json.loads((SCRATCH / "finetuned-development" / "calibration.json").read_text()) |
| except (subprocess.CalledProcessError, OSError, json.JSONDecodeError) as error: |
| print(f"kev.calibrate failed ({error}); see the messages above. The other results are saved.", flush=True) |
| return None |
| return report.get("workload_temperature") |
|
|
|
|
| def headline(name): |
| clean = json.loads((SCRATCH / name / "report.json").read_text())["clean"] |
| return {"n": clean["n"], "acc": round(clean["acc"], 4), "ece": round(clean["ece"], 4)} |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("input_dir", type=Path, help="Folder with train.jsonl and development.jsonl in Kev's format") |
| parser.add_argument("output_dir", type=Path, help="New or empty folder for the results, on a mounted bucket") |
| parser.add_argument("--init-from", default=INIT_MODEL, help="Released Kev model to start from (repo@revision)") |
| parser.add_argument("--epochs", type=int, default=2) |
| parser.add_argument("--lr", type=float, default=2e-5) |
| parser.add_argument("--max-steps", type=int, default=0, help="Stop after this many optimizer steps, for a smoke test") |
| args = parser.parse_args() |
| |
| args.input_dir = args.input_dir.resolve() |
| args.output_dir = args.output_dir.resolve() |
|
|
| check_gpu() |
| check_records(args.input_dir / "train.jsonl") |
| check_records(args.input_dir / "development.jsonl") |
| prepare_output(args.output_dir) |
| started = time.time() |
| install_kev() |
|
|
| development = args.input_dir / "development.jsonl" |
| train(args) |
| save("checkpoint", args.output_dir) |
| benchmark(SCRATCH / "checkpoint", development, "finetuned-development") |
| save("finetuned-development", args.output_dir) |
| benchmark(args.init_from, development, "baseline-development") |
| save("baseline-development", args.output_dir) |
| temperature = calibrate() |
| if temperature is not None: |
| |
| calibration = SCRATCH / "finetuned-development" / "calibration.json" |
| subprocess.run(["cp", str(calibration), str(args.output_dir / "finetuned-development")], check=True) |
| print(f"saved {args.output_dir / 'finetuned-development' / 'calibration.json'}", flush=True) |
|
|
| summary = { |
| "status": "completed", |
| "kev_commit": KEV_COMMIT, |
| "init_from": args.init_from, |
| "base_revision": BASE_REVISION, |
| "finetuned": headline("finetuned-development"), |
| "released": headline("baseline-development"), |
| "workload_temperature": temperature, |
| "seconds": round(time.time() - started), |
| } |
| (args.output_dir / "run.json").write_text(json.dumps(summary, indent=2)) |
| print(json.dumps(summary), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
