cycle — the SLM teaching cycle

In each round, the SLM parses new school sentences, Haiku corrects the parse, the open parsers and treeagree check the correction, and the next SLM learns from the result. The teacher never sees a bare sentence: it always gets the SLM's parse with it, and the loop goes round.

cargo build --release
cycle run 2 10      # rounds 2..10, stops when the pool is used up
cycle round 4       # one round; steps already done are skipped (a broken round resumes)
cycle report        # cycle.tsv

The GPU draft (2026-10-15)

CYCLE_GPARSE_MODEL=<gparse model dir> makes the GPU parser re-parse the perceptron draft before the open parsers and treeagree. The tags, heads and relations come from gparse. LEMMA and FEATS stay where the tags did not change and are refilled from the agreed school where they did (GP_LEX).

Measured on round 6 (2 088 sentences). The referee is the 50 104 words where Stanza and Trankit give the same head and relation.

Caveat: treeagree votes with Stanza and Trankit, so part of its lead is agreement with the referee itself.

Fast learning (subsets, no full convergence)

• The GPU SLM learns every round. After each round, gparse train makes a warm start from the current model (GP_INIT). It runs 2 epochs over all of the round's trees (GP_ALWAYS) plus a fresh random 15% of the rest each epoch (GP_SAMPLE), at lr 5e-4. That takes about 30 s, versus 35 min from scratch. The result goes to models/round<k>, and the next round drafts with it. Measured on the held-out tests: school LAS 88.42 and EWT 85.62 after the fine-tune, against 88.48 and 85.75 for the 30-epoch model. Nothing is lost.
• The perceptron is not retrained. In the hybrid draft it only supplies tokens, lemmas and features, so CYCLE_EN_MODEL loads a saved en model (ANNOT_EN_MODEL). Drafting 2 200 sentences takes 2 s, against 3 min with retraining.

Pools

• new.tsv: 4 344 primary-school sentences that are not in the silver of 2026-10-11. Rounds 1–3 took 200 each; from round 6 (2026-10-15) a round takes 5% of the corpus, 2 200 sentences.
• pool-all.tsv: all 47 103 primary-school sentences (no dictionary, no middle school). Use it once new.tsv is used up, with CYCLE_LABEL=recheck. The SLM has already trained on these sentences, so how much of its draft Haiku keeps is flattered; such rows are marked pre/recheck.

Two flows

• CYCLE_FLOW=pre (the default; rounds 4 on). The SLM drafts the sentences. Stanza, Trankit and spaCy trf parse the same sentences on the GPU. treeagree agrees the draft with them, learning retag FEATS and lemmas from the agreed school. Only this agreed tree goes to Haiku as the draft (annot batch-prepare with ANNOT_DRAFTS). Haiku's corrected trees then train the next SLM, and treeagree check only reports gate violations.
• CYCLE_FLOW=post (rounds 1–3). The SLM drafts go straight to Haiku, and treeagree agrees Haiku's trees afterwards. The steps below describe this flow.

One round (post)

1. Drafts. annot batch-prepare retrains the SLM (en) on the base data (EWT, ESLSpok, the agreed school) plus everything the cycle has agreed so far. It then drafts N random pool sentences that are not yet in the cycle corpus.
2. Haiku. annot batch-run sends the drafts as patch requests through Message Batches (50% of the API price; 8 sentences per request; the fixed prompt is cached). annot batch-apply applies the patches, runs the UD gates and appends to school-cycle.conllu.
3. Witnesses. Stanza, Trankit and spaCy trf parse the round's trees on the GPU.
4. Agreement. treeagree agree produces the agreed trees and appends them to school-cycle-agreed.conllu, the corpus the next SLM trains on.
5. Row in cycle.tsv:
   • how much of the SLM draft Haiku kept (UAS/LAS). This is the number that should rise as the SLM learns;
   • how much treeagree still changed after Haiku;
   • the cost.

The defaults (cycle-2026-10-15, pool new.tsv: primary-school sentences that are not in the silver). Override them with CYCLE_ROOT, CYCLE_POOL, CYCLE_N, CYCLE_SEED, CYCLE_BASE, CYCLE_CORPUS and CYCLE_AGREED.

Why the draft goes in: the anchoring check (round 1, 2026-10-15)

annot batch-blind sends the same sentences again with no draft, so Haiku annotates them from scratch. The table covers 159 sentences that passed both runs. "Agrees with Stanza ∩ Trankit" means the share of words where Stanza and Trankit agree with each other and the tree takes the same head.

The draft does anchor Haiku. Without it, though, Haiku is worse by the open parsers' vote, refuses more gates and costs 2.2× more per sentence. So the draft stays, and treeagree after Haiku is mandatory.

The same comparison with an SLM trained on EWT only (2026-10-11): Haiku kept its draft at UAS 88.3 / LAS 84.0. The current SLM, trained on the agreed school, is kept at 96.3 / 94.1.

What it gives the SLM student (2026-10-15)

world knowledge course runs the student (PragStudent, reading through frames over the en tree) through all 25 primary courses: 26 992 test questions, four options each. The test questions are never in the parsers' training data (only explain: and fact: lines are). Only the parser model (WORLD_EN_MODEL) changes. Runs are deterministic: repeated runs are byte-identical. Logs are in mmm-school-2026-10-15.

That is +935 questions. The biggest gains are in chemistry (+10.2), physics (+8.9), myths (+7.7) and biology (+5.6 on 4 581 questions). Only english (−1.1) and euphemisms (−0.2) drop, where the questions are about words themselves. The Haiku rounds add nothing on top of the agreed school yet: they were mostly recheck rounds over sentences the parser already had.

Licence

Elamur Cosmic License (Elamur Cosmic License). Third-party data keeps its own terms, as noted where it is used.

This page in Markdown → https://md.mova.elamur.ai/free/en/docs/tools/cycle/