auto-impl/src/posttrainbench/README.md

posttrainbench

Portable runner for PostTrainBench: a CLI agent (e.g. Codex driven by an OpenAI model) gets a base LLM, a benchmark and a time budget on one GPU, and must post-train the model. The score is the benchmark result of the model it leaves behind.

Upstream only runs on its authors' HTCondor cluster. This package replaces that launcher (src/run_task.sh + src/commit_utils/) and nothing else: prompt, agents, tasks, evaluation scripts and the container definition are used unmodified from the pinned submodule third_party/PostTrainBench, so results stay comparable with the official leaderboard.

Requirements

• Linux with an NVIDIA GPU (official setting: one H100 80 GB per run) and internet access
• Apptainer >= 1.1; unprivileged installs work, no root or Docker needed
• Python >= 3.10, no packages needed (everything else lives in the container); uv is optional
• ~100 GB on a fast local disk for PTB_DATA_DIR: image 12 GB, ~4-8 GB per base model, and the agent's checkpoints during a run

Setup

All commands run from the repository root (auto-impl/).

git clone --recurse-submodules <this repo> && cd auto-impl   # or, in an existing clone:
git submodule update --init                    # fetch upstream PostTrainBench
cp .env.example .env                           # then set HF_TOKEN and PTB_DATA_DIR
uv run ptb setup --full-cache --models Qwen/Qwen3-1.7B-Base --tasks gsm8k

setup is idempotent: it builds the container images (12 GB and ~25 min each, once per machine), prefills the shared HF cache and fetches the benchmark test sets for the agent's decontamination checker. Without uv, use PYTHONPATH=src python -m posttrainbench instead of uv run ptb.

By default it builds the two images upstream uses for a claude-opus-5 cell: opus_5 for the agent and vllm_debug for evaluation. --containers picks others from upstream containers/*.def.

--full-cache downloads upstream's working set -- 14 models and 382 dataset splits, a few hundred GB over several hours. It is what lets the agent sandbox run with no network at all, so it is not optional here. Each image build downloads ~20 GB; if either fails on a network error, rerun the same command. google/gemma-3-4b-pt, google/gemma-3-4b-it, Idavidrein/gpqa and the gpqamain test data are gated on HuggingFace and need HF_TOKEN.

Run

# Sanity check of image + GPU + evaluation, no credentials needed (~10 min):
uv run ptb eval --task gsm8k --model Qwen/Qwen3-1.7B-Base --limit 20 --out-dir data/baselines/gsm8k_qwen3-1.7b

# Official setting: 10 h agent run followed by the full evaluation.
uv run ptb run --task gsm8k --model Qwen/Qwen3-1.7B-Base --agent-model claude-opus-5

# Cheap end-to-end smoke test.
uv run ptb run --task gsm8k --model Qwen/Qwen3-1.7B-Base --agent-model claude-opus-5 --hours 1

One ptb run is one (task, base model) cell and needs one GPU, selected via CUDA_VISIBLE_DEVICES if the machine has several. Sweeps are left to whatever the machine offers, e.g. sbatch --gres=gpu:1 --time=12:00:00 --wrap "uv run ptb run ..." or a shell loop.

Tasks: aime2025 arenahardwriting bfcl gpqamain gsm8k healthbench humaneval. Base models: Qwen/Qwen3-1.7B-Base Qwen/Qwen3-4B-Base HuggingFaceTB/SmolLM3-3B-Base google/gemma-3-4b-pt. --agent selects any scaffold in upstream agents/ (default claude_non_api; claude_non_api_max raises the reasoning effort), and --container the image it runs in.

The local codex_sdk scaffold drives Codex through the TypeScript SDK instead of invoking the CLI directly. scripts/ptb_codex_sdk_setup.sh installs the pinned SDK on shared storage, scripts/ptb_codex_sdk_probe.sbatch verifies its gateway path, and scripts/ptb_codex_sdk_sweep.sh submits the separate 28-cell run1 sweep. That sweep sets PTB_RESULTS_DIR to a Codex-specific root, so it cannot overwrite Claude results.

Output

$PTB_DATA_DIR/results/<agent>_<agent-model>_<hours>h/<task>_<model>_<timestamp>/ (upstream's layout, so upstream's scripts/ for aggregation work on it):

File	Content
metrics.json	final benchmark score
final_model/	the model the agent submitted
task/	the agent's workspace (code, data, logs; checkpoints removed)
prompt.txt	the exact prompt given to the agent
solve_out.txt	raw trajectory: the agent CLI's timestamped JSON event stream, written live
solve_parsed.txt	human-readable rendering of the trajectory
agent_home/	rest of the agent's home, incl. the CLI's own session records (.codex/sessions/)
time_taken.txt, final_eval_<n>.txt	agent wall-clock time, evaluation logs

Trajectories are written to the run directory while the agent runs, so a crash or a killed job loses nothing: whatever was not yet post-processed is still in <run dir>/sandbox/home/ben/. *_sanitized.* copies have the API keys redacted; share those, not the raw files.

Before spending a 10 h budget on a new machine or agent model, do the 1 h smoke test and look at solve_out.txt and agent_home/. If PTB_DATA_DIR is node-local or gets purged, copy results/ to persistent storage after each run (checkpoints are already removed, so it is small apart from final_model/).

Code

Module	Role
config.py	paths and .env; all machine-specific settings
sandbox.py	isolated container execution; the only place that knows Apptainer
provision.py	ptb setup
solve.py	agent phase
evaluate.py	evaluation phase, with upstream's retry protocol
cli.py	ptb command

Differences from upstream

Identical: prompt (except the internet line below), agent scaffold and CLI flags, container recipes and package versions, which container each phase uses, the prefilled HF cache, sandbox isolation, which credentials the agent sees, time limit (+5 min grace), evaluate.py with its arguments, the evaluation retry protocol, checkpoint cleanup, results layout. Different:

• No internet in the agent sandbox. Upstream's prompt promises unrestricted access; this runner gives the agent an empty network namespace and rewrites that one prompt line to describe what it actually has (solve.py:OFFLINE_LINE). The point is a controlled, reproducible environment: everything the agent should need is in the image (trl, peft, accelerate, datasets, lm-eval, ...) and in the prefilled cache. The cost is that upstream's rule 7, which lets the agent install extra packages, cannot be honoured.
• The agent CLI reaches its model through a local shim rather than the vendor's endpoint (scripts/x2p_anthropic_shim.py), and CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS / CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC are set because that gateway rejects the beta headers. The *_non_api scaffolds get a placeholder oauth_token, since the gateway, not the token, authenticates the request.
• The reward-hacking judges (src/judges/) are not run; they need a ChatGPT-subscription login rather than an API key. metrics.json is therefore the raw score: upstream replaces the score of runs its judges flag (contamination, disallowed models or API use). Traces and workspaces are kept, so runs can be judged later.
• Upstream's H100 check is skipped (only "a GPU is visible" is asserted), while the prompt still tells the agent it has an H100. No difference on an H100.
• Upstream kills all GPU processes on the node before evaluating; this runner does not. It expects the scheduler to hand it a dedicated GPU instead.
• Images are built with apptainer build --fakeroot --ignore-subuid (PTB_BUILD_FLAGS overrides), which unprivileged builds inside a containerized job need. The definitions are unmodified.