HANDOFF_COLLAB_TASK.md

# Handoff: Make COLLAB > INDEP at end-to-end EX (target ≥1pp, stretch ≥2pp)

## The problem in one line

Our paper-format ORPO **validator-internal reward-accuracy** strongly favors COLLAB over INDEP
(+10pp on val-sel, +17.7pp on val-cond), but **end-to-end selector EX is identical** (COLLAB 59.97% vs INDEP 60.31% — INDEP is actually 0.34pp ahead). The collab training signal isn't translating to pipeline gains.

**Your goal**: lift the COLLAB pipeline's selector EX so that it **beats INDEP by ≥1pp** (stretch goal: ≥2pp gap) on full BIRD-dev (1524 questions).

This must show in the **pipeline metric the paper cares about** (`compute_bestofn_with_selector.py` trained selector EX), not just the validator-internal `eval_rewards/accuracies`.

---

## 1. Current ground truth (full BIRD-dev, 1524 questions)

| Config | planner@1 (T=0) | pipeline@1 (T=0) | oracle pass@8 | **trained selector EX** |
|---|---|---|---|---|
| PLANNER-only | **51.54%** | 51.54% | 70.80% | — |
| SFT-VF (paper validators, no ORPO) | 51.48% | 52.20% | 71.65% | **59.91%** |
| **ORPO iter1 COLLAB** | 51.08% | 51.81% | 71.19% | **59.97%** |
| **ORPO iter1 INDEP** | 51.74% | 52.59% | 71.95% | **60.31%** |

Validator-internal reward accuracies (test_dpo split, what ORPO optimizes):

| Validator | eval_loss | eval_rewards/accuracies |
|---|---|---|
| **val-sel COLLAB** | 0.174 | **69.7%** |
| val-sel INDEP | 0.210 | 59.7% |
| **val-cond COLLAB** | 0.148 | **89.7%** |
| val-cond INDEP | 0.163 | 72.0% |

**Reading the gap**: COLLAB's chosen/rejected discrimination training succeeded, but at inference the chosen "correct" critiques don't lead to materially different fixer outputs (or different pipeline EX) than INDEP's.

---

## 2. Why collab SHOULD be better than indep (paper Alg. 2 intuition)

| Mode | What "chosen" means | What signal it carries |
|---|---|---|
| **INDEP** | critique whose `Conclude:` matches a HEURISTIC over planner-vs-gold correctness | Local: was the critique text consistent with whether planner was correct? Surface-level. |
| **COLLAB** | critique that, when fed to the fixer, produces a correct final SQL | End-to-end: did this critique HELP the downstream fixer produce correct SQL? |

If the fixer **actually uses critique content**, COLLAB's signal carries downstream-aware information INDEP doesn't have. If the fixer **ignores critique**, COLLAB signal collapses to noise + the fixer's intrinsic correctness, and INDEP wins on cleaner labels.

---

## 3. Diagnosis: why our collab signal is currently weak

Three structural issues identified in this session — partially mitigated, not fixed:

### 3.1 The fixer was trained on a FIXED critique template

[`build_orpo_data.py:245`](https://huggingface.co/datasets/thanhdath/mats-sql-bundle/blob/main/scripts/build_orpo_data.py) (in the snapshot uploaded to `thanhdath/mats-sql-bundle/scripts/`):

```python
val_critique = "<select>\nSELECT.\nINCORRECT\n</select>\n\n<condition>\nCONDITION.\nINCORRECT\n</condition>"
```

Every fixer SFT example uses this **identical** critique. The fixer never learned to condition its output on critique content. At collab data-gen time we feed K=4 *diverse* critiques per question, but the fixer's output is largely invariant to the critique — so chosen vs rejected critiques produce near-identical fixer SQLs → ORPO sees a low-information signal.

**Evidence**: collab pair-formation rate is 0.33 pairs/question (650 pairs from 2000 q) vs independent's 1.78 pairs/question (3565 pairs from 2000 q). The fixer judging step is collapsing — most critiques bucket identically.

### 3.2 Data-gen flow ≠ inference flow

At collab data-gen, the fixer runs for EVERY critique regardless of what the critique says. At inference, the fixer is gated by `planner_exec_ok=False`. This mismatch means the collab training distribution doesn't reflect how the validator actually contributes at inference (where it primarily votes "this candidate is good / bad" rather than steering a per-call fixer rewrite).

We added a `collab_v2` mode in `build_orpo_data.py` (`--mode collab_v2`) that simulates inference: critique-says-`Conclude:correct` → keep planner SQL; else → run fixer; chosen/rejected by end-to-end correctness. **It hasn't been used to retrain validators yet** — that's the obvious next experiment.

### 3.3 Small K + small dataset

`build_orpo_data.py` uses K=4 critiques per question in our runs. With paper-format validators that are already fairly calibrated, 4 critiques often land in the same bucket → 0 pairs for that question. Net pair yield is low for COLLAB.

---

## 4. Concrete experiments to flip the gap (ranked by ROI)

### E1. **Train a CRITIQUE-AWARE fixer** ⭐ highest ROI

The biggest single thing keeping COLLAB ≈ INDEP. Rebuild the fixer SFT data so each example has a DIFFERENT critique:

```
For each BIRD-train question with planner_exec_ok=False:
  Generate K=4 validator critiques (val-sel + val-cond, paper-format)
  For each critique:
    Run fixer at T=1.0, get fix_sql
    Score correctness
  Form (critique, fix) pairs:
    chosen   = (good_critique, correct_fix)
    rejected = (bad_critique, wrong_fix)
  Save with critique embedded in the prompt.
```

Then ORPO-train the fixer on this data. Now the fixer LEARNS to use critique content.

When the fixer becomes critique-aware, **collab's "fixer-judged chosen/rejected" signal becomes informative** (different critiques → different fix outputs → different correctness labels), so retraining COLLAB validators on iter2 data will discriminate better than INDEP.

Builder skeleton lives in [`scripts/build_orpo_data.py:build_fixer_data`](models/fixer-1B-orpo-iter1) — currently uses the fixed critique. Replace `val_critique = "<select>...INCORRECT..."` with per-row diverse critiques sampled from the SFT validators.

### E2. **Train iter2 COLLAB validators with the new fixer + `collab_v2` mode** ⭐ high ROI

Once E1 produces a critique-aware fixer (call it `fixer-1B-orpo-iter2`):

```bash
python scripts/build_orpo_data.py --agent validator_sel --mode collab_v2 \
    --planner_host ... --validator_host <SFT-paper> --fixer_host <fixer-iter2> \
    --K 8 --temperature 1.0 --max_questions 2000 \
    --out data/hf_orpo_val_sel_paper_iter2_collab
```

Note: **K=8 instead of K=4** for more pair-yield diversity. **`collab_v2`** for inference-aligned chosen/rejected.

Then ORPO iter2 on top of iter1 COLLAB. Expected gain: each ORPO iter typically lifts 0.3-0.8pp at pipeline level; with a working collab signal, iter2 should move COLLAB above INDEP.

### E3. **Joint K-rollout training (paper Alg. 2 in true form)**

The paper's joint training uses ONE rollout pool for ALL agents. We currently:

- Generate per-agent ORPO datasets independently (planner pool, val-sel pool, val-cond pool, fixer pool)
- Train each agent on its own pool

True Alg. 2: for each BIRD-train question, do K=8 FULL pipeline rollouts (planner→val-sel→val-cond→fixer→final SQL). Each rollout produces decisions at each agent. Then:

- planner chosen/rejected = the rollouts whose FINAL SQL was correct (vs not)
- val-sel chosen/rejected = the critiques that came from rollouts whose final was correct
- val-cond chosen/rejected = same
- fixer chosen/rejected = same

This couples the agents — each one is rewarded for decisions that helped the END-TO-END outcome. This is what COLLAB is supposed to be in the paper but our current `--mode collab` only does step-2 (fixer judges critique) not step-1 (final-outcome judges everything).

Build script doesn't exist; would need writing.

### E4. **Verify the fixer is gated correctly at inference**

[`scripts/run_pipeline_rollouts.py`](models/) wraps paper-format critique inside `<select>/<condition>` tags before sending to the fixer (since fixer was trained with wrapper tags). Inspect 5-10 fixer prompts in a `paper_COLLAB_par_passAt8_bird_dev.jsonl` row to confirm:
1. Critique content is reaching the fixer
2. Fixer's output actually responds to critique content (i.e., `fixed_sql != planner_sql` when critique says "INCORRECT")

If the fixer is ignoring critique content, E1 (critique-aware retraining) is mandatory.

### E5. **Tighten the comparison statistic**

Selector EX over n=1524 has ~1.2pp standard error at 60% — our COLLAB-INDEP gap of 0.34pp is well within noise. To call a ≥1pp gap "real":
- Report bootstrap CI over rollouts (resample questions with replacement, 1000 iters)
- Or report the gap on a fixed selector + fixed K=8 rollouts so the only variable is which validator was used

If the next iter shows COLLAB +1.2pp over INDEP, bootstrap will say whether it's statistically real or sampling.

---

## 5. Resources (all on `thanhdath/mats-sql-bundle` HF dataset + local)

### Pre-trained ckpts (already on HF, can re-download or use directly)

```
hf:thanhdath/mats-sql-bundle:models/planner-3B-sft/
hf:thanhdath/mats-sql-bundle:models/planner-3B-orpo-iter1/
hf:thanhdath/mats-sql-bundle:models/validator-sel-1B-sft-paper/
hf:thanhdath/mats-sql-bundle:models/validator-sel-1B-orpo-iter1-collab-paper/
hf:thanhdath/mats-sql-bundle:models/validator-sel-1B-orpo-iter1-indep-paper/
hf:thanhdath/mats-sql-bundle:models/validator-cond-1B-sft-paper/
hf:thanhdath/mats-sql-bundle:models/validator-cond-1B-orpo-iter1-collab-paper/
hf:thanhdath/mats-sql-bundle:models/validator-cond-1B-orpo-iter1-indep-paper/
hf:thanhdath/mats-sql-bundle:models/fixer-1B-sft/                          ← E1 retrains THIS
hf:thanhdath/mats-sql-bundle:models/fixer-1B-orpo-iter1/                   ← E1's alt input
hf:thanhdath/mats-sql-bundle:models/selector-3B-sft/                       ← keep frozen for fair compare
```

Local copies on weka (if you have the same compute):

```
/weka/s225250685/mats-tist/alignment-handbook/output/<same names>
```

### Pre-built ORPO iter1 paper datasets

```
data/hf_orpo_val_sel_paper_iter1_collab    617 train + 33 test pairs
data/hf_orpo_val_sel_paper_iter1_indep    3386 train + 179 test pairs
data/hf_orpo_val_cond_paper_iter1_collab   545 train + 29 test pairs
data/hf_orpo_val_cond_paper_iter1_indep   1553 train + 82 test pairs
```

### Scripts

```
scripts/build_orpo_data.py                  # has --mode {collab, collab_v2, independent}
scripts/run_pipeline_rollouts.py            # K=8 pipeline eval; emits *_passAt8_bird_dev.jsonl
scripts/compute_bestofn_with_selector.py    # runs trained selector, reports EX
scripts/gen_validator_sft_qwen72b.py        # Qwen-72B teacher for paper-format SFT (already ran)
scripts/train_sft_completion_only.py        # SFT trainer
```

### ORPO recipes

```
recipes/iter1-paper/orpo-val-sel-collab-paper.yaml
recipes/iter1-paper/orpo-val-sel-indep-paper.yaml
recipes/iter1-paper/orpo-val-cond-collab-paper.yaml
recipes/iter1-paper/orpo-val-cond-indep-paper.yaml
```

For an iter2, copy + change `model_name_or_path` to the iter1 ORPO ckpt, point `dataset_mixer` at the new iter2 dataset, output to `orpo-val-*-iter2-paper`.

### Reference rollouts (use these to eval without re-running the GPU pipeline)

```
eval_results/paper_SFT_VF_passAt8_bird_dev.jsonl       # K=8 SFT validators
eval_results/paper_COLLAB_par_passAt8_bird_dev.jsonl   # K=8 ORPO COLLAB
eval_results/paper_INDEP_par_passAt8_bird_dev.jsonl    # K=8 ORPO INDEP
eval_results/paper_greedy_*_passAt1_bird_dev.jsonl     # 4 greedy configs
```

---

## 6. Definition of done

A single command must produce a **passing** run:

```bash
python scripts/compute_bestofn_with_selector.py \
    eval_results/paper_COLLAB_iter2_passAt8_bird_dev.jsonl \
    paper_COLLAB_iter2_selectorEX \
    --selector_host http://localhost:8103 --row_preview
# Print: trained selector ≥ INDEP_iter2 + 1.0pp
```

Required to ship:

1. **K=8 BIRD-dev rollouts** for both new configs:
   - `paper_COLLAB_iter2_passAt8_bird_dev.jsonl` (new agents)
   - `paper_INDEP_iter2_passAt8_bird_dev.jsonl` (matched control)
2. **Selector EX from `compute_bestofn_with_selector.py`** on both.
3. **A bootstrap 95% CI** showing the COLLAB − INDEP gap is positive with lower bound ≥ 1pp.
4. **Updated `thanhdath/mats-sql-bundle` README** with the new numbers.
5. **The new iter2 ckpts pushed to HF** under `models/*-iter2-*-paper`.

---

## 7. Constraints (don't violate)

- **K = 8 is fixed** at inference rollout. Don't compare with K=16 etc.
- **Temperature = 1.0** for the K=8 rollouts.
- **Same selector for both configs** — use `selector-3B-sft` from the bundle, do NOT retrain the selector while making this comparison (otherwise you're conflating two changes).
- **Same planner and same fixer family across COLLAB vs INDEP at eval** — only the validators change (this is what isolates the COLLAB vs INDEP effect). If E1 retrains the fixer, evaluate COLLAB and INDEP both with the NEW fixer.
- **β = 0.1** for ORPO unless you have a specific reason to vary; β ≥ 0.5 collapsed val-sel in our runs.
- SLURM job name must be `vl` (lowercase). HF_TOKEN at `/weka/s225250685/mats-tist/.env`.
- `PYTHONNOUSERSITE=1` to avoid user-site contamination.

---

## 8. Suggested execution order

```
Day 0   E4: spot-check 10 fixer prompts on disk → confirm if fixer uses critique
Day 1   E1: build critique-aware fixer SFT data (~3h) → train fixer-1B-orpo-iter2 (~1h)
Day 2   E2: build iter2 COLLAB + INDEP datasets with new fixer + collab_v2 + K=8 (~6h each)
Day 2   E2: train iter2 COLLAB + INDEP validators (4 jobs in parallel, ~1h each)
Day 3   K=8 BIRD-dev rollouts × 2 configs (~3h each parallel) → selector EX
Day 3   Bootstrap CI, write up, push to HF
```

If E1 + E2 don't produce ≥1pp gap, drop to **E3 (joint Alg. 2)** which is the more aggressive rewrite.

## 9. What "good" looks like at the end

```
Selector EX
  paper_SFT_VF        : 59.91%   (baseline, unchanged)
  paper_INDEP_iter2   : 60.5±0.4%  (matched control)
  paper_COLLAB_iter2  : 62.0±0.4%  (target — gap ≥ 1pp, bootstrap-significant)
```

Then update the bundle README to show COLLAB ≠ INDEP, write a short summary of *why*
(critique-aware fixer + inference-aligned collab signal), and the paper claim "COLLAB > INDEP"
will be empirically supported on our reproduction.