TMaxxx/tmax-sc3-campaign-curves

tmax sc3 RL campaign — training curves

Per-step training curves for all 13 RL arms of the sc3 campaign, exported from oscaryin4422/tmax-sc3-campaign and stitched across restarts.

import pandas as pd
url = "https://huggingface.co/datasets/TMaxxx/tmax-sc3-campaign-curves/resolve/main"
df = pd.read_csv(f"{url}/by-arm/hardened-prefilter-dppo-4b.csv")
df.plot(x="training_step", y="scores")

all_arms = pd.read_csv(f"{url}/all_arms_wide.csv")   # every arm, `arm` column

Files

path	what
by-arm/<exp_name>.csv	one stitched curve per arm — the file to plot
by-run/<exp_name>/<wandb_id>.csv	raw per-wandb-run history, unmerged, to audit the stitch
all_arms_wide.csv	all arms concatenated, with an arm column
INDEX.md	which wandb runs compose each arm

Two traps

objective/verifiable_reward is identically ZERO on all 13 arms. It is a legacy key this recipe never populates. Plotting it gives thirteen flat lines that look like thirteen failed runs. The learning curve is scores (equivalently batch/percent_solved_mean).

global_step is the EPISODE counter, not the optimizer step — facet runs 320…556,864 across its 500 steps. Use the synthesised training_step column (1…N) as the x-axis.

How restarts were stitched

One arm is not one wandb run: every crash-and-resume starts a new one, so 13 arms span 60 runs (prefilter-27b alone has 17). A resumed trainer continues its global_step from its last checkpoint, so runs are concatenated on that key, with two corrections:

1. Truncation. When a run starts at step S, everything an earlier run logged at ≥ S was rolled back and is dropped. Exact-key dedupe is not enough — overlapping runs log at different episode values, which left prefilter-4b at 523 steps for a 500-step run.
2. Seam collapse. A resume does not re-enter at exactly the episode the last run left, so two rows a few dozen episodes apart can be the same optimizer step. Adjacent rows closer than 10% of the series' median spacing are collapsed. That threshold is measured: seta's duplicate sits at ratio 0.059 while prefilter-4b's tightest legitimate step is 0.188.

After both, all ten completed arms land on exactly 500 steps, which is the check that the stitch is right.

Caveats for cross-arm comparison

• prefilter-sft8b runs pack_length 40960 / response_length 38912 against the frozen recipe's 67584 / 65536, forced by its checkpoint (max_position_embeddings=40960). Episodes past ~39k tokens truncate on that arm and not the others.
• prefilter-sft8b needs --tool_parser_type vllm_hermes; the Qwen3.5/3.6 arms use vllm_qwen3_xml. Its runs before 2026-09-22 20:14Z used the wrong parser, recorded zero tool calls, and are not meaningful.
• POOL_SIZE varied 128→768. It affects throughput, not what is learned.
• prefilter-27b, prefilter-2b and prefilter-sft8b were still running at export time.

Model checkpoints for each arm are published separately under TMaxxx as branches step-0100…step-0500.

by-arm/hardened-prefilter-dppo-9b_turns.csv — assistant-turn accounting

Per training step, from 130,560 saved rollouts (500 steps, 0 unparseable). Answers "how long is an assistant turn" without the tool-output contamination in val/sequence_lengths.

column	meaning
assistant_tokens_per_turn	the headline: policy-generated tokens ÷ generation segments
assistant_tokens_total / _mean_per_rollout	policy-generated tokens only
assistant_segments_total / _mean_per_rollout	maximal spans of generated tokens between tool insertions
tool_output_tokens_total / _mean_per_rollout	inserted tool tokens
tool_token_fraction	inserted tokens ÷ all response tokens
tool_blocks_total, num_calls_total	recovered block count, and request_info.num_calls
n_rollouts, response_tokens_total	per-step denominators

training_step here is 0-indexed (0…499), taken from the rollout's own step. The wandb-derived files use a 1-indexed synthesised training_step (1…500). Offset by one when joining.

How the split is measured (not estimated)

There is no mask field on a rollout record. But inserted tool tokens were never sampled by the policy, so they carry a logprob of exactly 0.0, and they arrive in contiguous blocks. Generated tokens can also hit 0.0 when the model is near-certain, so the value alone is not a discriminator — the run length is. Counting contiguous runs of exactly-0.0 logprobs and comparing with request_info.num_calls over 4,000 rollouts:

min run length	rollouts where block count == num_calls
≥ 4	1.7%
≥ 8	92.5%
≥ 12	99.8%
≥ 16	100.0% ← used
≥ 24	78.0%

Across the full 130,560 rollouts the recovered block count totals 3,619,733 against 3,619,712 reported num_calls — a 0.0006% difference, with 23 of 500 steps differing at all and a worst case of 0.081% within a step. Both columns are shipped so this is checkable.

This deliberately avoids tokenising tool_outputs: that field is a concatenated raw string, while response_tokens holds the formatted and possibly truncated tool message, so the two do not correspond token for token.

What a "turn" means here

num_calls is rollout.step_count and increments per tool dispatch or per format-error feedback, so it is not simply the number of assistant generation turns. This file counts generation segments — maximal spans of policy-sampled tokens between inserted tool blocks — which is the correct denominator for average assistant-turn length. tool_blocks_total and num_calls_total are both present so either convention can be reconstructed.

Caveats

• Only hardened-prefilter-dppo-9b has saved rollouts of this kind. prefilter-2b/4b/27b/sft8b do not, so this is unavailable for the model-size comparison.
• A generated span shorter than 16 tokens sitting between two tool blocks would be merged into the adjacent tool block. Given the 100%/4,000 agreement this is rare, but it is the failure mode to look for if a step looks odd.
• These are training rollouts, unrelated to any fixed-harness benchmark evaluation.

---

turns CSV — v2 (restart-overlap corrected + tool-call split)

Corrected 2026-09-23. v1 double-counted 0-indexed steps 360–369 (512 rollouts instead of 256) because the rollback/stitch rule applied to the wandb export was never applied to the rollout scan. Caught by hamishivi against val/sequence_lengths. Run __42__1789453662 covers steps 0–369 and __42__1789548075 restarts at 360, so the earlier run's rollouts at step >= 360 are discarded work. v2 drops them: 128,000 rollouts kept = 500 x 256 exactly, 2,560 dropped. Every step now has n_rollouts == 256.

Assistant-token split (new)

assistant_tool_call_tokens_total + assistant_non_tool_call_tokens_total = assistant_tokens_total, exactly, at every step (0 violations across 500 steps).

Span boundaries are token-exact, not regex on detokenised text: <tool_call> and </tool_call> are SINGLE tokens in this tokenizer (248058 / 248059), verified by round-trip. A span runs from open to close inclusive and covers the whole <function=…><parameter=…>… invocation the model authored. Inserted tool OUTPUT is excluded upstream by the zero-logprob rule and lives in tool_output_tokens_total.

New columns: assistant_tool_call_tokens_total, assistant_non_tool_call_tokens_total, assistant_tool_call_spans_total, mean_tool_call_length_tokens, malformed_tool_call_rollouts.

⚠️ Unterminated tool calls rise sharply over training

A rollout whose generated text ends with an open <tool_call> and no close is counted to the end and flagged in malformed_tool_call_rollouts. The rate is not uniform:

training steps	rollouts ending mid-call
0–49	4.7%
100–149	4.8%
200–249	5.5%
350–399	51.3%
400–449	88.7%
450–499	83.6%

first 25 steps 2.8% → last 25 steps 85.7%, tracking the rise in assistant_tokens_per_turn (285 → 517). On an early shard, finish_reason was stop (not length) for 96% of these, so the model is emitting an opening marker and stopping rather than being cut off by the token budget. Treat mean_tool_call_length_tokens in the later half of training with caution — a truncated span is measured to end-of-text and inflates it. The flag column is shipped so these can be excluded.

assistant_tool_call_spans_total (2,837,165) is ~0.80 x num_calls_total (3,553,376), consistent with hamishivi's note that num_calls also increments on format-error feedback.