experiment-pipeline

What this skill does

# Experiment Pipeline

A structured 4-stage framework for executing research experiments from initial implementation through ablation study, with attempt budgets and gate conditions that prevent wasted effort. This follows the Experiment Tree Search design from the EvoScientist paper, where the engineer agent iteratively generates executable code, runs experiments, and records structured execution results at each stage.

## When to Use This Skill

- User has a planned experiment and needs to organize the execution workflow
- User wants to systematically validate a novel method against baselines
- User asks about experiment stages, attempt budgets, or when to move on
- User needs to reproduce baseline results before testing their method
- User mentions "experiment pipeline", "baseline first", "ablation study", "stage budget", "experiment execution"

## The Pipeline Mindset

**Experiments fail for two reasons: wrong order and no stopping criteria.** Most researchers jump straight to testing their novel method without verifying their baseline setup, then wonder why results don't make sense. Others spend weeks tuning hyperparameters without a budget, hoping the next run will work.

The 4-stage pipeline solves both problems. It enforces a strict order (each stage validates assumptions the next stage depends on) and assigns attempt budgets (forcing systematic thinking over brute-force iteration).

## Before Starting: Load Prior Knowledge

If coming from `research-ideation`, your research proposal (Step 7) provides the experiment plan — datasets, baselines, metrics, and ablation design — that maps directly to Stages 1-4 below.

Before entering the pipeline, load Experimentation Memory (M_E) from prior cycles:

1. Refer to the **evo-memory** skill → Read M_E at `/memory/experiment-memory.md`
2. Select the top-1 entry (k_E=1) most relevant to the current experiment domain by comparing each entry's Context and Category against the current problem
3. The selected strategy informs hyperparameter ranges (Stage 2), debugging approaches (Stages 1-3), and training configurations across all stages
4. If M_E doesn't exist yet (first cycle), skip this step and proceed — your results will seed M_E via ESE after pipeline completion

## 4-Stage Pipeline Overview

Each stage follows a **generate → execute → record → diagnose → revise** loop:

| Stage | Goal | Budget (N_E^s) | Gate Condition |
|-------|------|--------|----------------|
| 1. Initial Implementation | Get baseline code running and reproduce known results | ≤20 attempts | Metrics within 2% of reported values (or within reported variance) |
| 2. Hyperparameter Tuning | Optimize config for your setup | ≤12 attempts | Stable config, variance < 5% across 3 runs |
| 3. Proposed Method | Implement & validate novel method | ≤12 attempts | Outperforms tuned baseline on primary metric, consistent across 3 runs |
| 4. Ablation Study | Prove each component's contribution | ≤18 attempts | All claims evidenced with controlled experiments |

Each stage saves artifacts to `/experiments/stageN_name/`.

### The Stage Loop

Within every stage, repeat this cycle for each attempt:

1. **Generate**: Form a hypothesis or plan for this attempt. What specifically will you try? What do you expect to happen?
2. **Execute**: Run the experiment. Record exact configuration, code changes, and runtime.
3. **Record**: Log results immediately using the stage log template. Include both metrics and observations.
4. **Diagnose**: Compare results to expectations. If they match, assess the gate condition. If they don't, load `experiment-craft` for the 5-step diagnostic flow.
5. **Revise**: Based on diagnosis, either advance to the next stage (gate met) or plan the next attempt (gate not met).

## Stage 1: Initial Implementation

**Goal**: Find or generate executable baseline code and verify it reproduces published results. This stage corresponds to the paper's "initial implementation" — the engineer agent searches for working code, runs it, and records structured execution results.

**Why this matters**: If you can't get the baseline running and reproducing known results, every subsequent comparison is meaningless. Initial implementation validates your data pipeline, evaluation code, training infrastructure, and understanding of prior work.

**Budget**: ≤20 attempts (N_E^1=20). Baselines can be tricky — missing details in papers, version mismatches, unreported preprocessing steps. 20 attempts gives enough room to debug without allowing infinite tinkering.

**Gate**: Primary metrics within 2% of reported values (or within the reported variance if provided).

**Process**:
1. Find the original baseline code (official repo, re-implementations, or write from paper description)
2. Get the code running in your environment — resolve dependencies, fix compatibility issues
3. Match the exact training configuration from the paper (dataset splits, preprocessing, hyperparameters)
4. Run and compare metrics. If off by >2%, diagnose the gap
5. Common pitfalls: different random seeds, different data splits, unreported data augmentation, framework version differences

**When to load `experiment-craft`**: If attempts 1-5 all fail significantly (>10% gap), switch to the 5-step diagnostic flow to isolate the cause before burning more attempts.

**Output**: `/experiments/stage1_baseline/` containing results, config, and verified baseline code.

See [references/stage-protocols.md](references/stage-protocols.md) for detailed initial implementation checklists.

## Stage 2: Hyperparameter Tuning

**Goal**: Find the optimal hyperparameter configuration for YOUR specific setup.

**Why this matters**: Published hyperparameters are tuned for the authors' setup. Your hardware, data version, framework version, or subtle implementation differences mean their config may not be optimal for you. Tuning now prevents confounding your novel method's results with suboptimal baselines.

**Budget**: ≤12 attempts. Hyperparameter tuning has diminishing returns. If 12 structured attempts don't find a stable config, the problem is likely deeper than hyperparameters.

**Gate**: Stable configuration found — variance < 5% across 3 independent runs with different random seeds.

**Process**:
1. Identify the most sensitive hyperparameters (usually: learning rate, batch size, loss weights)
2. Start with coarse search on the most sensitive parameter
3. Narrow the range based on results, then move to the next parameter
4. Validate final config with 3 independent runs

**Priority order for tuning**: Learning rate → batch size → loss weights → regularization → architecture-specific params. This order reflects typical sensitivity.

**When to load `experiment-craft`**: If results are highly unstable (variance > 20%) across runs, there's likely a training instability issue. Use diagnostic flow.

**Output**: `/experiments/stage2_tuning/` containing tuning logs, final config, and stability verification.

See [references/attempt-budget-guide.md](references/attempt-budget-guide.md) for budget rationale and adjustment rules.

## Stage 3: Proposed Method

**Goal**: Implement and validate your novel method, demonstrating improvement over the tuned baseline.

**Why this matters**: This is the core contribution. But because you've verified the baseline (Stage 1) and optimized the config (Stage 2), any improvement you see is genuinely attributable to your method — not to a better-tuned setup or a broken baseline.

**Budget**: ≤12 attempts. Your method should work within a reasonable number of iterations if the underlying idea is sound. Excessive attempts suggest a fundamental problem, not a tuning issue.

**Gate**: Outperforms the tuned baseline on the primary metric. The improvement should be consistent across at least 3 runs.

**Process**:
1. Implement the core method incrementally — don't add everything at once
2. Test each component's integration with the baseline pipeline
3. Run full training and compare aga