feat: add quant field — (name, type, quant) is the composite target key

With the LEM-Eval schema settling, the next axis we need to benchmark
is quantization: does Q4 give the same LEK delta as BF16? Q8_0 vs Q4_K_M?
These are first-class variants that need their own canons so per-round
stats don't blend across precision levels.

targets.yaml now carries a 'quant' field on each row. Lemer expands to
four working entries:

lemer / mlx / Q4 → LetheanNetwork/lemer-mlx vs lthn/lemer-mlx
lemer / mlx / 8bit → LetheanNetwork/lemer-mlx-8bit vs lthn/lemer-mlx-8bit
lemer / mlx / BF16 → LetheanNetwork/lemer-mlx-bf16 vs lthn/lemer-mlx-bf16
lemer / gguf / Q4_K_M → hf.co/LetheanNetwork/lemer:Q4_K_M vs lthn/lemer

Q8_0 / BF16 gguf entries pending LetheanNetwork/lemer having the matching
base gguf quants uploaded (llama-quantize + HfApi follow-up).

eval.py changes:

resolve_target()
takes quant_filter; (name, type, quant) is now the unique key.
Multiple matches → error asks for --type / --quant.

--quant CLI flag
optional. Auto-pick when only one match exists for (name, type),
required when multiple quants share a (name, type).

_canon_stem(task, type, quant) helper
builds the filename stem consistently. Examples:
mmlu_pro.mlx.Q4.parquet
mmlu_pro.mlx.BF16.parquet
mmlu_pro.gguf.Q4_K_M.parquet
The quant suffix is mandatory on the gguf side (all quants share one
repo), kept on mlx for uniformity.

_compute_next_offset, append_to_canon
both thread target_quant through to _canon_stem, so each (type, quant)
combo has its own progression and its own yaml+md views.

_run_once, main()
propagate target_quant; the run banner shows target/quant together.

derive_repo_id() helper strips 'hf.co/' and ':<tag>' from a this: field to
yield the canonical HF repo id — used later by lem-eval.sh / install.sh
for workspace clone deduplication (gguf quants share a repo).

_print_target_table gains a quant column.

Smoke verified locally on all three mlx quants (Q4, 8bit, BF16) —
each cleared end-to-end with its own canon file:
/tmp/lemer_Q4/mmlu_pro.mlx.Q4.parquet
/tmp/lemer_8bit/mmlu_pro.mlx.8bit.parquet
/tmp/lemer_BF16/mmlu_pro.mlx.BF16.parquet

Each returned different stochastic answers, proving each separate HF
repo was really loaded rather than a shared cache.

Co-Authored-By: Virgil <virgil@lethean.io>

eval.py

@@ -92,16 +92,16 @@ def load_targets():
     return _yaml.safe_load(TARGETS_YAML_PATH.read_text())
 
 
-def resolve_target(name, cfg=None, type_filter=None):
-    """Look up a target by (name, type) in targets.yaml.
+def resolve_target(name, cfg=None, type_filter=None, quant_filter=None):
+    """Look up a target by (name, type, quant) in targets.yaml.
 
-    Multiple entries can share a name if they have different types — e.g.
-    the same model family evaluated via mlx and via gguf. `type_filter`
-    disambiguates:
+    Multiple entries can share a name if they differ by type or quant — e.g.
+    the same model family evaluated via mlx at Q4, 8bit, and BF16. Filters
+    narrow the candidate set:
       - None and one match → return the match
-      - None and multiple matches → error, ask for --type
-      - set/iterable and one matching entry → return it
-      - set/iterable and zero/multiple → error
+      - None and multiple matches → error, ask for --type / --quant
+      - filter matches zero → error
+      - filter matches one → return it
     """
     if cfg is None:
         cfg = load_targets()
@@ -113,20 +113,45 @@ def resolve_target(name, cfg=None, type_filter=None):
     if type_filter is not None:
         allowed = set(type_filter) if not isinstance(type_filter, str) else {type_filter}
         candidates = [t for t in candidates if t.get("type") in allowed]
-
     if not candidates:
         raise KeyError(
             f"target {name!r} has no entry matching type filter {type_filter!r}. "
             f"Use --type to pick one."
         )
+
+    if quant_filter is not None:
+        candidates = [t for t in candidates if t.get("quant") == quant_filter]
+        if not candidates:
+            raise KeyError(
+                f"target {name!r} has no entry matching quant {quant_filter!r}. "
+                f"Check targets.yaml or use --list-targets to see what exists."
+            )
+
     if len(candidates) > 1:
-        types = [t.get("type", "?") for t in candidates]
+        combos = [(t.get("type", "?"), t.get("quant", "?")) for t in candidates]
         raise KeyError(
-            f"target {name!r} has multiple entries ({types}). Pass --type to disambiguate."
+            f"target {name!r} has multiple entries {combos}. "
+            f"Pass --type and/or --quant to disambiguate."
         )
     return candidates[0]
 
 
+def derive_repo_id(this_ref):
+    """Strip Ollama / transport prefixes from a `this:` reference to yield
+    the underlying HF repo id.
+
+    Examples:
+      lthn/lemer-mlx               → lthn/lemer-mlx
+      hf.co/lthn/lemer:Q4_K_M      → lthn/lemer
+    """
+    if this_ref.startswith("hf.co/"):
+        base = this_ref[len("hf.co/"):]
+        if ":" in base:
+            base = base.split(":", 1)[0]
+        return base
+    return this_ref
+
+
 # --- Wrapper routing --------------------------------------------------------
 #
 # Lighteval's custom-model loader wants to be pointed at a single file that
@@ -575,17 +600,36 @@ def _render_canon_md(stats, task, dataset_id="TIGER-Lab/MMLU-Pro"):
     return "\n".join(lines)
 
 
-def append_to_canon(task, eval_results_dir, new_rows, target_type=None):
-    """Append new rows to .eval_results/<task>[.<type>].parquet (the canon).
-
-    When target_type is given, the canon filename is task-and-type-scoped
-    (e.g. mmlu_pro.mlx.parquet, mmlu_pro.gguf.parquet) so runs on the same
-    model family via different inference backends live in disjoint canons
-    and their stats don't conflate.
+def _canon_stem(task, target_type=None, target_quant=None):
+    """Canon filename stem — task, then optional type, then optional quant.
 
-    Reads the existing canon (if any), concatenates the new rows, dedupes on
-    the composite key, writes back the parquet, and regenerates the yaml + md
-    views. Returns the merged DataFrame.
+    Examples:
+        mmlu_pro                      (neither type nor quant)
+        mmlu_pro.mlx                  (type only)
+        mmlu_pro.mlx.BF16             (type + quant)
+        mmlu_pro.gguf.Q4_K_M          (gguf case — quant required because
+                                       multiple quants share the same repo)
+    """
+    parts = [task]
+    if target_type:
+        parts.append(target_type)
+    if target_quant:
+        parts.append(target_quant)
+    return ".".join(parts)
+
+
+def append_to_canon(task, eval_results_dir, new_rows, target_type=None, target_quant=None):
+    """Append new rows to .eval_results/<task>[.<type>[.<quant>]].parquet (the canon).
+
+    Type and quant scope the canon filename so variants of the same model
+    family don't conflate — different mlx quants live in different HF repos
+    already, but gguf variants share one repo and NEED the quant suffix to
+    stay separate. Uniform naming across both backends keeps the filesystem
+    layout predictable.
+
+    Reads the existing canon (if any), concatenates new rows, dedupes on the
+    composite key, writes back the parquet, regenerates the yaml + md views.
+    Returns the merged DataFrame.
     """
     import io
     import pandas as pd
@@ -594,7 +638,7 @@ def append_to_canon(task, eval_results_dir, new_rows, target_type=None):
     eval_results_dir = Path(eval_results_dir).resolve()
     eval_results_dir.mkdir(parents=True, exist_ok=True)
 
-    stem = f"{task}.{target_type}" if target_type else task
+    stem = _canon_stem(task, target_type, target_quant)
     canon_path = eval_results_dir / f"{stem}.parquet"
 
     new_df = pd.DataFrame(new_rows)
@@ -637,7 +681,7 @@ def append_to_canon(task, eval_results_dir, new_rows, target_type=None):
 
 # --- Main -------------------------------------------------------------------
 
-def _compute_next_offset(task, eval_results_dir, target_type=None):
+def _compute_next_offset(task, eval_results_dir, target_type=None, target_quant=None):
     """Derive the next samples_start offset from the existing canonical parquet.
 
     Returns max(canon.question_index) + 1 if the canon exists and has rows,
@@ -645,11 +689,11 @@ def _compute_next_offset(task, eval_results_dir, target_type=None):
     run picks up where the last one finished without the caller tracking
     state externally.
 
-    When target_type is given, reads the type-scoped canon so mlx runs
-    progress independently from gguf runs on the same model family.
+    Type + quant scoping means each (type, quant) combination has its own
+    progression, so the mlx-BF16 canon advances independently from gguf-Q4_K_M.
     """
     import pandas as pd
-    stem = f"{task}.{target_type}" if target_type else task
+    stem = _canon_stem(task, target_type, target_quant)
     canon_path = Path(eval_results_dir) / f"{stem}.parquet"
     if not canon_path.exists():
         return 0
@@ -670,6 +714,7 @@ def _run_once(
     eval_results_dir,
     tmp_dir,
     target_name=None,
+    target_quant=None,
     lem_benchmarks_dir=None,
     wrapper_file=None,
 ):
@@ -689,7 +734,7 @@ def _run_once(
     dedup against its own existing state).
     """
     print(f"\n{'='*78}")
-    print(f"  LEM-Eval 8-PAC run — target: {target_name}")
+    print(f"  LEM-Eval 8-PAC run — target: {target_name} ({target_quant or '?'})")
     print(f"  this model:     {THIS_MODEL}")
     print(f"  base model:     {BASE_MODEL}")
     print(f"  task:           {task}")
@@ -725,12 +770,12 @@ def _run_once(
 
     print(f"\n[4/4] appending {len(rows)} rows to canon(s)...")
     print("  primary (model repo):")
-    append_to_canon(task, eval_results_dir, rows, target_type=target_type)
+    append_to_canon(task, eval_results_dir, rows, target_type=target_type, target_quant=target_quant)
 
     if lem_benchmarks_dir and target_name:
         agg_dir = lem_benchmarks_dir / "results" / target_name
         print(f"  aggregator (lthn/LEM-benchmarks):")
-        append_to_canon(task, agg_dir, rows, target_type=target_type)
+        append_to_canon(task, agg_dir, rows, target_type=target_type, target_quant=target_quant)
 
     # Clean up per-run lighteval scratch — the canons now have everything we need
     shutil.rmtree(tmp_dir, ignore_errors=True)
@@ -780,11 +825,17 @@ def detect_default_types():
 
 def _print_target_table(targets, highlight_types=None):
     highlight_types = set(highlight_types or [])
-    print(f"{'name':<18} {'type':<6} {'base':<42} {'this':<24}")
-    print("-" * 94)
+    print(f"{'name':<14} {'type':<6} {'quant':<8} {'base':<42} {'this':<28}")
+    print("-" * 106)
     for t in targets:
         mark = " *" if (t.get("type") in highlight_types) else ""
-        print(f"{t['name']:<18} {t.get('type', '?'):<6} {t['base']:<42} {t['this']:<24}{mark}")
+        print(
+            f"{t['name']:<14} "
+            f"{t.get('type', '?'):<6} "
+            f"{t.get('quant', '?'):<8} "
+            f"{t['base']:<42} "
+            f"{t['this']:<28}{mark}"
+        )
 
 
 def main():
@@ -798,6 +849,10 @@ def main():
     parser.add_argument("--type", default=None,
                         help="Restrict to targets of this type (mlx|gguf). "
                              "Defaults to capability detection (mlx on Apple Silicon).")
+    parser.add_argument("--quant", default=None,
+                        help="Disambiguate targets by quant identifier "
+                             "(e.g. Q4, 8bit, BF16, Q4_K_M, Q8_0). Required when "
+                             "a (name, type) pair has multiple quant variants.")
     parser.add_argument("--n-questions", type=int, default=DEFAULT_N_QUESTIONS)
     parser.add_argument("--rounds", type=int, default=DEFAULT_ROUNDS)
     parser.add_argument("--task", default=None,
@@ -852,13 +907,19 @@ def main():
     if not args.target:
         parser.error("--target is required (or use --list-targets / --my-targets)")
 
-    # Let --type / LEM_TYPES / capability detection disambiguate when the
-    # same target name exists with multiple types in targets.yaml.
+    # Let --type / LEM_TYPES / capability detection + --quant disambiguate
+    # when the same target name exists with multiple (type, quant) combos.
     try:
-        target = resolve_target(args.target, cfg, type_filter=allowed_types)
+        target = resolve_target(
+            args.target,
+            cfg,
+            type_filter=allowed_types,
+            quant_filter=args.quant,
+        )
     except KeyError as e:
         parser.error(str(e))
     target_type = target.get("type")
+    target_quant = target.get("quant")
     if target_type not in SUPPORTED_TYPES:
         parser.error(f"target {args.target!r} has unknown type {target_type!r}")
 
@@ -890,8 +951,14 @@ def main():
     lem_benchmarks_dir = Path(args.lem_benchmarks_dir).resolve() if args.lem_benchmarks_dir else None
 
     if args.samples_start == "auto":
-        samples_start = _compute_next_offset(task, eval_results_dir, target_type=target_type)
-        print(f"[auto] canon progression ({target_type}) → samples_start = {samples_start}", flush=True)
+        samples_start = _compute_next_offset(
+            task, eval_results_dir, target_type=target_type, target_quant=target_quant
+        )
+        print(
+            f"[auto] canon progression ({target_type}/{target_quant}) → "
+            f"samples_start = {samples_start}",
+            flush=True,
+        )
     else:
         try:
             samples_start = int(args.samples_start)
@@ -912,6 +979,7 @@ def main():
             eval_results_dir=eval_results_dir,
             tmp_dir=tmp_dir,
             target_name=args.target,
+            target_quant=target_quant,
             lem_benchmarks_dir=lem_benchmarks_dir,
             wrapper_file=wrapper_file,
         )

targets.yaml

@@ -23,32 +23,54 @@ defaults:
 
 targets:
 
+  # Lemer — Gemma 4 E2B. Three mlx quants + gguf Q4_K_M live and paired
+  # end-to-end. Q8_0 / BF16 gguf will be added once LetheanNetwork/lemer
+  # has the matching base quants (TODO: llama-quantize + upload).
+
   - name: lemer
     type: mlx
+    quant: Q4
     base: LetheanNetwork/lemer-mlx
-    this: lthn/lemer
-    notes: Gemma 4 E2B — paired mlx via LetheanNetwork/lemer-mlx (4bit, our own quant)
+    this: lthn/lemer-mlx
+
+  - name: lemer
+    type: mlx
+    quant: 8bit
+    base: LetheanNetwork/lemer-mlx-8bit
+    this: lthn/lemer-mlx-8bit
+
+  - name: lemer
+    type: mlx
+    quant: BF16
+    base: LetheanNetwork/lemer-mlx-bf16
+    this: lthn/lemer-mlx-bf16
 
   - name: lemer
     type: gguf
+    quant: Q4_K_M
     base: hf.co/LetheanNetwork/lemer:Q4_K_M
     this: hf.co/lthn/lemer:Q4_K_M
-    notes: Gemma 4 E2B — Q4_K_M via Ollama
+
+  # Lemma / Lemmy / Lemrd — pending the same treatment as lemer.
+  # (LetheanNetwork bases in matching formats, naming alignment, etc.)
 
   - name: lemma
     type: mlx
-    base: mlx-community/gemma-4-e4b-it-4bit
+    quant: Q4
+    base: mlx-community/gemma-4-e4b-it-4bit     # TODO: LetheanNetwork/lemma-mlx
     this: lthn/lemma
-    notes: Gemma 4 E4B
+    notes: Gemma 4 E4B — pending family rollout
 
   - name: lemmy
     type: gguf
-    base: mlx-community/gemma-4-26b-a4b-it-4bit
+    quant: Q4_K_M
+    base: mlx-community/gemma-4-26b-a4b-it-4bit # TODO: LetheanNetwork/lemmy gguf
     this: lthn/lemmy
-    notes: Gemma 4 26B A4B MoE — runs via GGUF on charon (Ollama endpoint)
+    notes: Gemma 4 26B A4B MoE — pending family rollout
 
   - name: lemrd
     type: gguf
-    base: mlx-community/gemma-4-31b-it-4bit
+    quant: Q4_K_M
+    base: mlx-community/gemma-4-31b-it-4bit     # TODO: LetheanNetwork/lemrd gguf
     this: lthn/lemrd
-    notes: Gemma 4 31B — runs via GGUF on charon (Ollama endpoint)
+    notes: Gemma 4 31B — pending family rollout