Upload folder using huggingface_hub

configs/verifier_v_7b.yaml

@@ -1,27 +1,33 @@
-# Model V on the 7B-Math base — tests whether raw capability lifts the
-# arithmetic-verification ceiling the 1.5B hit. Apache-2.0, fits an 80GB A100.
-# Run with --gpu-preset none so these (7B-sized) batch settings apply instead of
-# the 1.5B a100 preset:
-#   python -m mathcompose.train.train --task v --config configs/verifier_v_7b.yaml --gpu-preset none
+# Model V on the 7B-Math base — tuned to USE the 80GB A100 (fast).
+# Run with --gpu-preset none so these settings apply (not the 1.5B preset), and
+# --push so the adapter lands on the Hub (Colab storage is ephemeral):
+#   python -m mathcompose.train.train --task v --config configs/verifier_v_7b.yaml \
+#       --gpu-preset none --push --hub-model-id <you>/mathcompose-verifier-7b
 extends: "base.yaml"
 
 task: "v"
 output_dir: "runs/verifier_v_7b"
-hub_model_id: null            # e.g. "42e/mathcompose-verifier-7b"
+hub_model_id: null            # set via --hub-model-id, e.g. "42e/mathcompose-verifier-7b"
 
 model:
   base_id: "Qwen/Qwen2.5-Math-7B-Instruct"
   max_context: 4096
 
+quant:
+  load_in_4bit: false          # bf16 LoRA on the 80GB A100: faster than 4-bit (no dequant),
+                               # and actually uses the VRAM (14GB weights vs ~4.5GB in 4-bit)
+
 data:
-  train_path: "data/verifier/train.jsonl"   # same v2 genuine-detection data
+  train_path: "data/verifier/train.jsonl"   # v2 genuine-detection data
   val_path: "data/verifier/val.jsonl"
 
 train:
   max_length: 4096
-  per_device_train_batch_size: 4   # 7B: smaller batch than the 1.5B preset
-  gradient_accumulation_steps: 4   # eff batch 16
-  gradient_checkpointing: true
+  per_device_train_batch_size: 16   # up from 4: ~4x fewer forward passes -> much faster
+  gradient_accumulation_steps: 1    # eff batch 16
+  gradient_checkpointing: true      # keep on (no-ckpt @ seq 4096 OOMs even the 1.5B)
+  # ~35GB VRAM at these settings. To use more / go faster: raise batch to 24 or 32
+  # (fits 80GB). NOTE: training has no auto-OOM-recovery — if it OOMs, lower it.
 
 eval:
   processbench_splits: ["gsm8k", "math", "olympiadbench", "omnimath"]

src/mathcompose/train/train.py

@@ -78,6 +78,10 @@ def build_and_train(args) -> str:
     # reduce fragmentation OOMs (set before CUDA initializes)
     os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
     import torch
+
+    if torch.cuda.is_available():
+        torch.backends.cuda.matmul.allow_tf32 = True   # free ~1.3x matmul speedup on A100+
+        torch.backends.cudnn.allow_tf32 = True
     from datasets import load_dataset
     from transformers import AutoModelForCausalLM
     from trl import SFTConfig, SFTTrainer
@@ -214,8 +218,13 @@ def build_and_train(args) -> str:
 
     hub_id = args.hub_model_id or cfg.get("hub_model_id")
     if args.push and hub_id:
-        trainer.push_to_hub(hub_id)
+        from huggingface_hub import HfApi, create_repo
+
+        create_repo(hub_id, exist_ok=True)
+        HfApi().upload_folder(folder_path=output_dir, repo_id=hub_id, repo_type="model")
         print(f"Pushed adapter to https://huggingface.co/{hub_id}")
+    elif args.push and not hub_id:
+        print("[warn] --push given but no --hub-model-id; adapter saved locally only.")
 
     print(f"Saved adapter to {output_dir}")
     return output_dir

src/mathcompose/train/train_7b.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# mathcompose \u2014 train the **7B** verifier (Colab A100)\n",
+    "\n",
+    "Everything baked in: bf16 LoRA (uses the VRAM, faster than 4-bit), batch 16 + TF32,\n",
+    "**auto-push** so the adapter can't get lost, base-inferred eval, and the code-exec probe.\n",
+    "**Runtime \u2192 A100 GPU** first. Expect ~35 GB VRAM (vs <8 before); raise batch in the\n",
+    "config to 24/32 to use more."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# 1. GPU deps + drop Colab's incompatible torchao\n",
+    "!pip -q install \"transformers>=5.13,<6\" \"trl>=1.7,<2\" \"peft>=0.19,<0.20\" \\\n",
+    "    \"accelerate>=1.14\" \"datasets>=5.0\" \"huggingface_hub>=1.22\" sympy bitsandbytes\n",
+    "!pip -q uninstall -y torchao 2>/dev/null; echo done"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# 2. Token -> pull code+data -> install (cwd = the snapshot, which has data/verifier)\n",
+    "import os\n",
+    "from huggingface_hub import HfApi, snapshot_download, login\n",
+    "os.environ[\"HF_TOKEN\"] = \"hf_xxx\"   # paste, or Colab Secrets\n",
+    "login(os.environ[\"HF_TOKEN\"])\n",
+    "USER = HfApi().whoami()[\"name\"]\n",
+    "proj = snapshot_download(f\"{USER}/mathcompose\", repo_type=\"model\")\n",
+    "%cd {proj}\n",
+    "!pip -q install -e .\n",
+    "print(\"data:\", os.listdir(\"data/verifier\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# 3. Confirm A100\n",
+    "import torch; print(torch.cuda.get_device_name(0), f\"{torch.cuda.get_device_properties(0).total_memory/1e9:.0f}GB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Train the 7B verifier (bf16 LoRA, batch 16, TF32) with auto-push\n",
+    "~1\u20131.5 hr on the A100. You should see `[gpu] ... compute=bf16`, `[train] ... batch=16`,\n",
+    "and VRAM climb to ~35 GB. The adapter is pushed to `{USER}/mathcompose-verifier-7b`\n",
+    "at the end so it survives the session."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "!python -m mathcompose.train.train --task v --config configs/verifier_v_7b.yaml \\\n",
+    "    --gpu-preset none --push --hub-model-id {USER}/mathcompose-verifier-7b"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Want to use even more VRAM / go faster?\n",
+    "Add `--batch-size 24` (or `32`) to the command above \u2014 both fit 80 GB. Training has\n",
+    "no auto-OOM-recovery, so if it OOMs, drop it back down."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Eval: 7B base vs tuned (base auto-inferred from the adapter)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "!python -m mathcompose.eval.run --base-id Qwen/Qwen2.5-Math-7B-Instruct processbench --tag base_7b --maj-k 1 --limit 100\n",
+    "!python -m mathcompose.eval.run --adapter {USER}/mathcompose-verifier-7b --tag tuned_7b --maj-k 1 --limit 100\n",
+    "!python -m mathcompose.eval.run report"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. M1c probe \u2014 does code execution close the arithmetic gap?\n",
+    "Per-example tool loop (slower) \u2192 small limit. gsm8k is the arithmetic split where it helps most."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "!python -m mathcompose.eval.run --adapter {USER}/mathcompose-verifier-7b --tag tuned7b_codeexec --code-exec --limit 40 --splits gsm8k math\n",
+    "!python -m mathcompose.eval.run --base-id Qwen/Qwen2.5-Math-7B-Instruct processbench --tag base7b_codeexec --code-exec --limit 40 --splits gsm8k math"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}