# Handicate (self-refinement trainer)

A **self-improving training framework** for a text/code LLM: a policy model that gets
better over rounds via **reinforcement learning (GRPO)** with an AI **judge** as the
reward, a **data curator** that pulls web data and keeps only what the judge rates highly
(compressed into compact pairs, raw discarded), a **critique→revise** loop so it learns
from criticism, and **distill-into-weights + discard-raw** so knowledge lives in
parameters instead of a growing corpus on disk.

This is the realistic, buildable core of the "Handicate" vision. It synthesizes ideas
from [[refora]] (expert iteration + critic + streaming data), [[sofara]] (rating-gated
polish, differential weight purification, AutoLabeler), and [[intelejack]] (LLM-orchestrated
training).

## What it is NOT (honest scope)
- **Not** JARVIS, **not** AGI, **not** "beats Fable 5." A solo training run cannot reach
  frontier multimodal capability -- that's hundreds of millions of dollars and huge teams.
- It does **not** improve "exponentially." Self-training has hard diminishing returns and a
  real failure mode -- **model collapse** -- when a model trains on AI-rated/AI-generated
  data in a loop. This framework's whole point is to *manage* that, not pretend it away.

## How collapse is prevented (the load-bearing part)
Every round is kept ONLY if it does not regress on a **frozen, human-grounded eval set**
(`data/eval_heldout.jsonl`) that the AI never generates or rates. Regressions are reverted.
A small **replay buffer** of real high-quality pairs fights forgetting. Without these, the
loop spirals down; with them, only changes that help on real tasks survive.

## The loop (loop.py)
```
curate web -> judge rates+compresses (raw discarded)
critique -> revise (learn from criticism)
GRPO RL with judge reward (constant improvement)
distill curated+revised into weights -> discard raw
eval gate: keep round iff no regression on frozen held-out tasks
```

## Files
| File | Role |
|------|------|
| `config.py` | base model (Qwen2.5-3B-Instruct), judge, budgets, knobs |
| `rubric.md` | the judge's requirements + examples (+ your criticisms get appended) |
| `core/judge.py` | rater/critic: score 0..1 + written criticism; GRPO reward func |
| `core/curator.py` | web pull -> judge-filter -> compress to pairs -> discard raw |
| `core/critique_revise.py` | answer -> criticism -> revise -> keep better |
| `core/refine_rl.py` | GRPO (TRL) with the judge as reward |
| `core/distill.py` | fold accepted pairs into weights (LoRA), discard raw, replay |
| `core/evalgate.py` | frozen held-out eval; collapse guard |
| `loop.py` | orchestrates a round and repeats |
| `jobs/run_handicate.py` | HF Jobs runner |
| `test_run.py` | free local checks |
| `feedback/criticisms.jsonl` | your criticisms about responses -> raise the bar |

## You must provide (small, real, human-grounded)
- `data/seed_prompts.jsonl` — `{"prompt": "..."}` tasks to train on.
- `data/eval_heldout.jsonl` — `{"instruction": "...", "ideal?": "..."}` frozen eval (the
  collapse guard). Keep this real and never let the loop touch it.
- Wire `core/curator.web_pull()` to a real search+fetch (or a streamed HF dataset).

## Run
```
python test_run.py                      # free local checks
hf upload AmongTheCouch23/handicate-code . . --repo-type dataset
hf jobs uv run -d --flavor a100-large --timeout 12h --python 3.11 -s HF_TOKEN ./jobs/run_handicate.py
```

## Extending toward the bigger vision
Text/code core first. Each modality (3D, image, video, audio) plugs in as another
**generator + judge** pair behind the same loop -- e.g. ImageForge as generator + a vision
judge, Sculptron for 3D, Michiro for music. Handicate becomes the orchestrator (the
"manage scripts and systems" brain); [[handicate_sni_project]] could serve as its reasoning
core. Build and validate one modality at a time -- the loop is the same.