README: bank classifiers, held-out mouse accuracy, classify argument order

- rows and a size table for the four bank models; _full supersedes the
routing trees for new work
- mm10_brain_{full,lite} scored on 49,113 Liu 2021 cells outside the
training cap: 0.9660 / 0.9482 micro
- every classify example now reads model-first, matching the binary

README.md

@@ -25,7 +25,7 @@ runs directly — no separate annotation files.
 # fetch one model (or --local-dir models to grab all)
 hf download zhou-lab/methscope hg38_celltype.clfx --local-dir .
 
-methscope classify query.cg   hg38_celltype.clfx       # cell type / label
+methscope classify hg38_celltype.clfx  query.cg        # cell type / label
 methscope upscale -o out.cg   hg38_wg.updecx  query.cg # genome-wide CpG upscaling
 methscope inspect             hg38_sex.clfx            # framework, labels, features
 ```
@@ -55,9 +55,62 @@ upscale input + truth) live in the GitHub repo
 | `hg38_wg.updecx` | whole-genome CpG upscaling | `UPDEC2` | all 29,401,795 hg38 CpGs; v5 primary upscaler (2.8 GB). Its decoder upgrade is deferred to v9. |
 | `hg38_10k1.updecx` | CpG upscaling (single block) | MLP decoder | block 10k1 (10,000 CpGs); small demo model |
 | `hg38_celltype.clfx` | cell-type annotation (human) | xgboost, routing tree | 33 human cell types; 11-node tree + 3 satellites; cross-cohort accuracy **0.903** — see below |
+| `hg38_celltype_full.clfx` | cell-type annotation (human), **bank-full** | xgboost, pooled bank | 63 human cell types; a 1,981-set MRMP chain (LCA binstrings + a calibrated resolver for every class pair) scored by ONE pooled booster, no routing; **class-balanced 0.9544 / micro 0.9569** over 84,601 held-out cells, ten-fold CV. Supersedes `hg38_celltype.clfx` for new work |
+| `hg38_celltype_lite.clfx` | cell-type annotation (human), **bank-lite** | xgboost, pooled bank | the same 63 classes and the same architecture as `_full`, with resolvers only for the pairs no binstring separates: 233 sets / 208 resolvers against 1,981 / 1,953. **51 MB** |
+| `mm10_brain_full.clfx` | cell-type annotation (mouse **brain**), **bank-full** | xgboost, pooled bank | 41 mouse-brain classes; an 837-set MRMP chain (LCA binstrings + a calibrated resolver for every class pair) scored by ONE pooled booster, no routing; **class-balanced 0.9746 / micro 0.9720** over 54,447 held-out cells, ten-fold CV (the tree below: 0.969). Supersedes `mm10_celltype_brain.clfx` for new work. Brain only |
+| `mm10_brain_lite.clfx` | cell-type annotation (mouse **brain**), **bank-lite** | xgboost, pooled bank | 41 mouse-brain classes; 135 sets / 117 resolvers; **27 MB**. Brain only, like `mm10_celltype_brain.clfx` |
 | `mm10_celltype_brain.clfx` | cell-type annotation (mouse **brain**) | xgboost, routing tree | 41 mouse-brain cell types; 4-node tree + 134 satellites; **class-balanced accuracy 0.969 ± 0.001** at native coverage (10-fold CV). Brain only — a non-brain cell is forced onto the nearest brain type |
 | `hg38_sex.clfx` | sex prediction | logistic | Female, Male (XCI `Xa_hi`/`Xa_lo` markers) |
 
+### Bank classifiers: `_full` and `_lite`, and the tree they replace
+
+New in v9. A **bank** classifier does not route: its MRMP is a flat set of
+hierarchical LCA binstrings plus redrawn, LOO-calibrated *resolvers* for close
+class pairs, all scored by a single pooled booster. `_full` and `_lite` are the
+same build one flag apart — how many pairs get a resolver.
+
+| | sets | resolvers | size |
+| --- | --- | --- | --- |
+| `hg38_celltype_full.clfx` | 1,981 | 1,953 — every class pair | 154 MB |
+| `hg38_celltype_lite.clfx` | 233 | 208 — only pairs no binstring separates | 51 MB |
+| `mm10_brain_full.clfx` | 837 | 820 — every class pair | 68 MB |
+| `mm10_brain_lite.clfx` | 135 | 117 | 27 MB |
+
+**Accuracy.** Ten-fold CV of the recipe: human `_full` class-balanced 0.9544 /
+micro 0.9569 over 84,601 cells; mouse `_full` 0.9746 / 0.9720 over 54,447.
+The shipped mouse bytes were also scored on 49,113 Liu 2021 cells that never
+entered the model (the cells beyond the 2,000-per-class training cap, so 18 of
+the 41 classes, the large cortical ones included):
+
+| | micro | class-balanced (18) |
+| --- | --- | --- |
+| `mm10_brain_full.clfx` | 0.9660 | 0.9707 |
+| `mm10_brain_lite.clfx` | 0.9482 | 0.9595 |
+
+The lite model's cost is concentrated in the cortical IT layers (IT-L23
+0.946 → 0.924, IT-L5 0.951 → 0.915); elsewhere the two are within noise. The
+human `_lite` has no held-out number: the human bank used every labeled cell.
+Use `_full` when the number matters; use `_lite` when its size does, and
+validate on your own data before relying on it.
+
+**How these differ from `hg38_celltype.clfx`** is structure, not just training
+data. The tree *routes*: a query descends 11 nodes, each with its own booster
+over its own class subset, so a wrong turn high up cannot be recovered lower
+down. A bank has one node and no routing decision to get wrong, and covers 63
+classes against the tree's 33.
+
+The tree stays published — it is what earlier results were produced with, and
+nothing citing it needs to move. For mouse that tree is `mm10_celltype_brain.clfx`;
+`mm10_brain_full.clfx` and `mm10_brain_lite.clfx` are its bank counterparts.
+All three mouse models are **brain only**: a non-brain cell is forced onto the
+nearest brain type.
+
+All of them run the same way:
+
+```sh
+methscope classify hg38_celltype_lite.clfx query.cg
+```
+
 `methscope inspect <model>` prints the exact framework, full label list, and (for
 linear models) per-feature weights. Classifiers carry a required framework `kind`
 mark (`tree` / `violation` / `threshold` / `logistic`); `classify` rejects an
@@ -155,7 +208,7 @@ so a reference *is* a per-class prediction already. The rule just asks which
 class the query contradicts least, and there is nothing to fit:
 
 ```sh
-methscope classify --framework violation query.cg ref.mrmp
+methscope classify --framework violation ref.mrmp query.cg
 ```
 
 ```