Update NEXT_AGENT.md: new target bronze=6062.44, need 2 more tasks

medal-solvers/NEXT_AGENT.md

@@ -2,165 +2,139 @@
 
 ## The Goal
 
-Build **`build_task319_onnx.py`** — a script that creates `optimized/task319.onnx`.
+**Bronze medal = 6062.44.** Current LB = 6053.51. Gap = **8.93 pts.**
 
-Then swap ALL optimized models into the submission:
+You need to optimize **2-3 more task models** to close the gap. Each optimization yields +3-6 pts.
 
-```bash
-cd medal-solvers
+## What's Already Done
 
-# Step 1: Build Task 255 (already done)
-python build_task255_onnx.py \
-    --neurogolf-utils neurogolf_utils.py \
-    --task-data-dir ../task-data
+```
+optimized/
+├── task255.onnx   ← 11.570 pts (was 6.64, gain +4.93)
+├── task285.onnx   ← 8.818 pts (was 5.98, gain +2.83)
+└── task319.onnx   ← 11.580 pts (was 7.92, gain +3.66)
+```
 
-# Step 2: Build Task 319 (YOU BUILD THIS)
-python build_task319_onnx.py \
-    --neurogolf-utils neurogolf_utils.py \
-    --task-data-dir ../task-data
+Total gain so far: +11.42 pts across 3 tasks.
 
-# Step 3: Swap ALL models from optimized/ into submission
-# swap_and_submit.py automatically finds ALL .onnx files in optimized/ folder
-python swap_and_submit.py \
-    --base /kaggle/working/neurogolf-solver/submission-6043.zip \
-    --task-data-dir task-data \
-    --output /kaggle/working/submission.zip
-```
+## How to Add a New Task
 
-**`swap_and_submit.py` auto-discovers ALL `taskNNN.onnx` files in `optimized/`** — no need to list them manually. It validates each model with neurogolf_utils before creating the zip.
+### Step 1: Choose a Target Task
 
-After running, `optimized/` should contain:
-```
-optimized/
-├── task255.onnx   ← built by build_task255_onnx.py (DONE, 11.570 pts)
-├── task285.onnx   ← built by build_task285_scatter.py (DONE, 8.818 pts)
-└── task319.onnx   ← built by build_task319_onnx.py (YOU BUILD THIS)
+Pick from the largest models in `submission-6043.zip` (most room to optimize):
+- **task209.onnx** (1.29MB) — likely scoring ~5-6 pts, room for +5-7
+- **task366.onnx** (1.27MB) — likely scoring ~5-6 pts, room for +5-7
+- **task084.onnx** (1.13MB) — likely scoring ~6-7 pts, room for +4-6
+- **task076.onnx** (949KB) — likely scoring ~6-7 pts, room for +4-5
+- **task233.onnx** (939KB) — likely scoring ~6-7 pts, room for +4-5
+
+### Step 2: Reverse-Engineer the Rule
+
+```bash
+# Extract task data
+unzip own-solver/neurogolf-2026.zip taskNNN.json -d task-data/
+
+# Analyze examples
+python -c "
+import json, numpy as np
+with open('task-data/taskNNN.json') as f:
+    data = json.load(f)
+# Look at input/output patterns, find the transformation rule
+"
 ```
 
-## Script Template
+### Step 3: Write Python Solver (100% pass required)
 
-Follow the same pattern as `build_task285_scatter.py`:
+Create `taskNNN_solver.py` — must pass ALL train+test+arc-gen examples.
+Use the approach from `task319_solver_267.py` as a template.
+
+### Step 4: Build ONNX Model
+
+Use the shared `onnx_builder.py`:
 
 ```python
-"""Build optimized ONNX model for Task 319."""
-import argparse
-import onnx
-from onnx import helper, TensorProto, numpy_helper
+"""Build optimized ONNX model for Task NNN."""
+from onnx import TensorProto
 import numpy as np
-import os, sys
-
-def build_task319():
-    """Build the ONNX graph. Returns onnx.ModelProto."""
-    nodes, inits, vis = [], [], []
-    # ... build graph ...
-    x = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 10, 30, 30])
-    y = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 10, 30, 30])
-    graph = helper.make_graph(nodes, 'task319', [x], [y], initializer=inits, value_info=vis)
-    model = helper.make_model(graph, ir_version=10, opset_imports=[helper.make_opsetid('', 18)])
-    return model
-
-def validate_with_official_utils(model_path, neurogolf_utils_path, task_data_dir):
-    """Run official neurogolf_utils.verify_network(). Must show 0 failures."""
-    # (see build_task285_scatter.py for the full validation function)
-    ...
+from onnx_builder import OnnxBuilder, build_and_validate
 
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--neurogolf-utils', default='neurogolf_utils.py')
-    parser.add_argument('--task-data-dir', default='../task-data')
-    parser.add_argument('--output', default='optimized/task319.onnx')
-    args = parser.parse_args()
-
-    model = build_task319()
-    os.makedirs(os.path.dirname(args.output) or '.', exist_ok=True)
-    onnx.save(model, args.output)
-    validate_with_official_utils(args.output, args.neurogolf_utils, args.task_data_dir)
-```
 
-## The Rule (267/267 verified — see `task319_solver_267.py`)
+def build_taskNNN():
+    b = OnnxBuilder()
+    const, nd = b.const, b.nd
+
+    # ... implement the rule in ONNX ops ...
 
-**CRITICAL**: Object binary = `(inp == color)` within bbox. NOT `(inp != bg)`!
-Objects can OVERLAP — a bbox may contain pixels of other colors that must be ignored.
+    return b.finish('taskNNN', last_tensor=final_output)
 
-### Algorithm:
 
+if __name__ == '__main__':
+    build_and_validate(build_taskNNN, task_num=NNN)
 ```
-Input: [1, 10, 30, 30] one-hot encoded grid
-Output: [1, 10, 30, 30] one-hot encoded grid (one of the input objects)
 
-PASS 1: Template = channel with MOST pixels (after background)
-  1. Find largest uniform block size (bs_r, bs_c) in template mask
-  2. Downsample: one value per block → pattern
-  3. Check if pattern is a sub-region of any other non-bg channel
-  4. If match → output = that channel
+### Step 5: Validate and Submit
 
-PASS 2 (if Pass 1 fails): Template = channel with 2ND MOST pixels
-  Same as Pass 1.
+```bash
+# Build and validate
+python build_taskNNN_onnx.py --task-data-dir ../task-data
 
-Result: 267/267 ✓
+# Must show: "N pass, 0 fail" and "IS READY for submission!"
+
+# Create submission with ALL optimized models
+python swap_and_submit.py \
+    --base ../submission-6043.zip \
+    --task-data-dir ../task-data \
+    --output ../submission.zip
 ```
 
-### Block Size Statistics:
-- **(2,2): 241/267** — handle this first, covers 90%!
-- (4,2): 4, (2,4): 3, (2,1): 2
-- Row/col grouping: 2 cases
-- Second template needed: 17 cases
+## Key Constraints
 
-### Memory Target:
-- Need memory+params < 282,000 → score ≥ 12.45 pts
-- Current model: 26M → 7.92 pts
-- Objects max 10×10, grid 30×30
-- Estimated with efficient impl: ~100-200KB → score 12-13
+- **Opset ≤ 18**
+- **Banned ops**: LOOP, SCAN, NONZERO, UNIQUE, SCRIPT, FUNCTION, COMPRESS, Sequence*
+- **File size < 1.44MB** per model
+- **All tensor shapes must be statically known**
+- **Input/output: [1, 10, 30, 30]** (one-hot encoded 30×30 grid with 10 colors)
+- **MUST pass ALL examples or score = 1.0!** (not partial credit)
 
-### ONNX Implementation for (2,2) blocks:
+## Scoring Formula
 
+```python
+score = max(1.0, 25.0 - math.log(max(1.0, memory + params)))
 ```
-1. ch_sums = ReduceSum(input, axes=[2,3])  → [1,10] pixel counts per channel
-2. bg_ch = ArgMax(ch_sums)
-3. Mask out bg, template_ch = ArgMax(remaining)
-4. Extract template mask via Gather on channel dim → [1,1,30,30]
-5. Reshape to [15,2,15,2], check ReduceMin==ReduceMax per 2×2 block
-6. If uniform: downsample = ReduceMax of blocks → [15,15] pattern
-7. For each candidate channel c ≠ bg, c ≠ template:
-   - Conv2D(candidate_mask, pattern_kernel) → correlation map
-   - Where correlation == sum(pattern) → match!
-8. Output = matched candidate in one-hot format
-```
 
-### Constraints:
-- Opset ≤ 18
-- Banned: LOOP, SCAN, NONZERO, UNIQUE, SCRIPT, FUNCTION, COMPRESS, Sequence*
-- File size < 1.44MB
-- All tensor shapes must be statically known
-- Input/output: exactly [1,10,30,30]
-- **MUST pass ALL 267 examples (0 failures) or score = 1.0!**
+Target: memory+params < 282,000 → score ≥ 12.45 pts
+Good: memory+params < 700,000 → score ≥ 11.5 pts
+
+## Memory Optimization Tips
+
+1. **Use Conv `pads` attribute** instead of separate Pad op (saves intermediate tensor)
+2. **Minimize intermediate tensor sizes** — each named tensor is counted by profiler
+3. **Reuse constants** — same initializer referenced by multiple nodes costs nothing extra
+4. **Avoid large MatMul intermediates** — [900×900] = 3.2MB!
+5. **MaxPool propagation** — 30 iterations × [1,1,30,30] = 108KB (acceptable)
 
 ## Key Reference Files
 
 | File | Purpose |
 |------|---------|
-| `task319_solver_267.py` | **Python reference (267/267) — MATCH THIS LOGIC** |
-| `build_task285_scatter.py` | **Script structure template** (args, build, validate) |
-| `build_task255_onnx.py` | Another ONNX builder reference (helpers, const/nd/vi pattern) |
-| `TASK319_ONNX_GUIDE.md` | Detailed implementation notes + memory analysis |
-| `neurogolf_utils.py` | Official scorer — final validation |
+| `onnx_builder.py` | **Shared OnnxBuilder DSL + validation** |
+| `build_task319_onnx.py` | **Best example of new-style build script** |
+| `build_task285_scatter.py` | Legacy style but good ONNX techniques |
+| `build_task255_onnx.py` | Complex ONNX (CumSum, sparse table, MaxPool propagation) |
+| `neurogolf_utils.py` | Official scorer — MUST USE for final validation |
+| `swap_and_submit.py` | Creates submission zip (auto-discovers optimized/*.onnx) |
+| `LEARNING.md` | All technical findings and what works/doesn't |
 
-## Validation Requirement
+## Workflow Summary
 
-The script MUST end with official validation that prints:
 ```
-Results on ARC-AGI examples: N pass, 0 fail
-Results on ARC-GEN examples: M pass, 0 fail
-Your network IS READY for submission!
-It appears to require XXXXX bytes + YYYY params, yielding ZZ.ZZZ points.
+1. Pick task (largest .onnx in submission)
+2. Extract task data from neurogolf-2026.zip
+3. Analyze input/output examples → find the rule
+4. Write Python solver → verify 100% pass
+5. Translate to ONNX using OnnxBuilder
+6. Validate with neurogolf_utils.py
+7. Add .onnx to optimized/ folder
+8. Submit via swap_and_submit.py
+9. Repeat until LB ≥ 6062.44
 ```
-
-If it shows ANY failures, the model is NOT ready and will score 1.0 on Kaggle.
-
-## Score Budget
-
-| Task | Current | After | Gain | Cumulative LB |
-|------|---------|-------|------|---------------|
-| 285 | 5.98 | 8.82 | +2.83 | 6045.68 |
-| 255 | 6.64 | 11.57 | +4.93 | ~6050.61 |
-| **319** | **7.92** | **~12.5** | **+4.5** | **~6055.1 (BRONZE!)** |