| |
| """Kaggle GPU usage ledger. |
| |
| Kaggle gives each account ~30 GPU-hours per week, 2 concurrent sessions. The |
| number that matters is not "did it finish" but "how many GPU seconds did it |
| cost", and nobody was tracking it. |
| |
| # record a finished run by hand |
| python scripts/kaggle_usage.py log --kernel yamahei21python/uzu-eval-4b-rtn-probe \ |
| --account owner --seconds 5420 --gpu T4x2 --note "4B RTN eval v3" |
| |
| # or track it until it stops |
| python scripts/kaggle_usage.py track --kernel yamahei21python/uzu-emb8-08b-gpu --account owner |
| |
| # weekly report against the quota |
| python scripts/kaggle_usage.py report --week 2026-W45 --quota-hours 30 |
| |
| The ledger is JSON Lines so a crashed run cannot corrupt it. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import subprocess |
| import time |
| from datetime import date, datetime |
| from pathlib import Path |
| from typing import Any |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| LEDGER = ROOT / "logs" / "kaggle_usage.jsonl" |
| TERMINAL = ("COMPLETE", "ERROR", "FAILED", "CANCEL", "CANCELLED") |
|
|
|
|
| def week_key(value: date) -> str: |
| year, week, _ = value.isocalendar() |
| return f"{year}-W{week:02d}" |
|
|
|
|
| def is_terminal(status: str) -> bool: |
| upper = status.upper() |
| return any(marker in upper for marker in TERMINAL) |
|
|
|
|
| def append_entry(ledger: Path, entry: dict[str, Any]) -> None: |
| ledger.parent.mkdir(parents=True, exist_ok=True) |
| with ledger.open("a", encoding="utf-8") as handle: |
| handle.write(json.dumps(entry, ensure_ascii=False) + "\n") |
|
|
|
|
| def read_entries(ledger: Path) -> list[dict[str, Any]]: |
| if not ledger.exists(): |
| return [] |
| entries = [] |
| for line in ledger.read_text(encoding="utf-8").splitlines(): |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| entries.append(json.loads(line)) |
| except json.JSONDecodeError: |
| continue |
| return entries |
|
|
|
|
| def summarize(entries: list[dict[str, Any]], week: str, quota_hours: float) -> dict[str, Any]: |
| filtered = [entry for entry in entries if entry.get("week") == week] |
| by_account: dict[str, dict[str, Any]] = {} |
| for entry in filtered: |
| account = entry.get("account", "unknown") |
| bucket = by_account.setdefault(account, {"runs": 0, "seconds": 0.0, "kernels": []}) |
| bucket["runs"] += 1 |
| bucket["seconds"] += float(entry.get("seconds", 0)) |
| bucket["kernels"].append(entry.get("kernel")) |
| quota_seconds = quota_hours * 3600 |
| for account, bucket in by_account.items(): |
| bucket["hours"] = round(bucket["seconds"] / 3600, 2) |
| bucket["remaining_hours"] = round((quota_seconds - bucket["seconds"]) / 3600, 2) |
| bucket["used_pct"] = round(100 * bucket["seconds"] / quota_seconds, 1) if quota_seconds else None |
| total_seconds = sum(bucket["seconds"] for bucket in by_account.values()) |
| return { |
| "week": week, |
| "quota_hours_per_account": quota_hours, |
| "accounts": by_account, |
| "total_hours": round(total_seconds / 3600, 2), |
| "runs": len(filtered), |
| } |
|
|
|
|
| def format_report(summary: dict[str, Any]) -> str: |
| lines = [ |
| f"week {summary['week']} quota {summary['quota_hours_per_account']}h/account runs {summary['runs']}", |
| f"{'account':10s} {'hours':>8s} {'left':>8s} {'used':>7s} kernels", |
| "-" * 72, |
| ] |
| for account, bucket in sorted(summary["accounts"].items()): |
| kernels = ", ".join(str(name) for name in bucket["kernels"][-3:]) |
| lines.append( |
| f"{account:10s} {bucket['hours']:8.2f} {bucket['remaining_hours']:8.2f} " |
| f"{(bucket['used_pct'] or 0):6.1f}% {kernels}" |
| ) |
| return "\n".join(lines) |
|
|
|
|
| def kernel_status(kernel: str) -> str: |
| result = subprocess.run( |
| ["kaggle", "kernels", "status", kernel], text=True, capture_output=True, check=False |
| ) |
| text = (result.stdout or "") + (result.stderr or "") |
| for line in text.splitlines(): |
| if "status" in line.lower(): |
| return line.strip() |
| return text.strip() |
|
|
|
|
| def track(kernel: str, account: str, interval: float, ledger: Path) -> dict[str, Any]: |
| started = time.time() |
| status = "" |
| while True: |
| status = kernel_status(kernel) |
| if is_terminal(status): |
| break |
| print(f"{time.strftime('%H:%M:%S')} {status}", flush=True) |
| time.sleep(interval) |
| entry = { |
| "kernel": kernel, |
| "account": account, |
| "seconds": round(time.time() - started, 1), |
| "status": status, |
| "week": week_key(date.today()), |
| "finished": datetime.now().isoformat(timespec="seconds"), |
| "note": "tracked", |
| } |
| append_entry(ledger, entry) |
| return entry |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--ledger", type=Path, default=LEDGER) |
| sub = parser.add_subparsers(dest="command", required=True) |
|
|
| log = sub.add_parser("log") |
| log.add_argument("--kernel", required=True) |
| log.add_argument("--account", default="owner") |
| log.add_argument("--seconds", type=float, required=True) |
| log.add_argument("--gpu", default="T4x2") |
| log.add_argument("--week", default=None) |
| log.add_argument("--note", default="") |
|
|
| track_cmd = sub.add_parser("track") |
| track_cmd.add_argument("--kernel", required=True) |
| track_cmd.add_argument("--account", default="owner") |
| track_cmd.add_argument("--interval", type=float, default=60.0) |
|
|
| report = sub.add_parser("report") |
| report.add_argument("--week", default=None) |
| report.add_argument("--quota-hours", type=float, default=30.0) |
| report.add_argument("--json", type=Path, default=None) |
|
|
| args = parser.parse_args() |
|
|
| if args.command == "log": |
| entry = { |
| "kernel": args.kernel, |
| "account": args.account, |
| "seconds": args.seconds, |
| "gpu": args.gpu, |
| "week": args.week or week_key(date.today()), |
| "logged": datetime.now().isoformat(timespec="seconds"), |
| "note": args.note, |
| } |
| append_entry(args.ledger, entry) |
| print(json.dumps(entry, ensure_ascii=False)) |
| elif args.command == "track": |
| entry = track(args.kernel, args.account, args.interval, args.ledger) |
| print(json.dumps(entry, ensure_ascii=False)) |
| else: |
| week = args.week or week_key(date.today()) |
| summary = summarize(read_entries(args.ledger), week, args.quota_hours) |
| print(format_report(summary)) |
| if args.json: |
| args.json.parent.mkdir(parents=True, exist_ok=True) |
| args.json.write_text(json.dumps(summary, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
| print(f"wrote {args.json}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
