Thor-T-bench

Paper (PDF) · Fucina (the forge) · llama.cpp branch thor-t-v1 · Bench data and logs

Everything needed to recompute the numbers of the evaluation of the Thor-T ternary models (XS, S, M and the root) reported in the paper A Ternarization Toolchain for Mixture-of-Experts Models That Run on a Consumer APU: Three Sizes of a 35B Model, a Ternary MTP Head, and llama.cpp Kernels (PDF), and to re-measure them: the raw logs of every run, the bench files with their converters, the run scripts, the statistics script, and the Q8_0 teacher used as the reference of every percentage.

Contents

part	what it is
teacher Q8_0	Ornith-1.5-35B-A3B-Q8_0.gguf, 37,802,149,216 bytes, sha256 e1425b9cba1c7514989cefe944fa9f4a68c34f480bcded2eec3549f75eea0fe0. Quantized by us with llama-quantize Q8_0 from the bf16 GGUF conversion of bartowski/Ornith-1.5-35B-A3B-GGUF at revision 64b0493d (two shards, sha256 b50ba22a501bb2cb03c48bcc4b84d72f5d82c949afa13047369931d62e5522e9 and 626fc796b98a4fd64da2d48d3b0bc3ee4ccc1acc45072de5531a1dc5722330ec). Redistributed under the base model's MIT licence. The upstream model later replaced its MTP tensors, so converting today's upstream weights does not give this file.
raw logs	every run of the final bench and of the development history: per-question llama-perplexity records (one MCLP line per question: choice, log-probabilities, answer lengths in tokens), llama-bench outputs, LM Evaluation Harness results_*.json and samples_*.jsonl, server logs of the generative runs.
bench files	the multiple-choice files of MMLU (eight blocks of the full test), HellaSwag, ARC-Challenge, ARC-easy, BoolQ, TruthfulQA-MC1 and MMLU-Pro, with their sha256 and the converters that produced them from the public datasets; the MMLU development subset (first 2,000 test questions) in stored and in mixed order. Three inputs whose sources declare no licence (Winogrande, PIQA, OpenBookQA) are listed with their sha256 but not shipped: scripts/ricostruisci_banchi.py OUT [--cache DIR] fetches each from a pinned revision or URL, rebuilds it and checks the sha256 (it also runs offline from cached downloads).
run scripts	the shell scripts of every bench (full MMLU in blocks, likelihood suite, generative suite, speed sessions).
statistics	genera_numeri.py, which regenerates every number of the final bench as LaTeX macros, and its file manifest (sizes, sha256 and per-tensor sha256 lists of the model files).
run register	scripts/cicli_extract.tsv: only the rows of our run register cicli.tsv that the script reads, with their line numbers (the whole register is not shipped). Three groups of values are read from it because their raw output was not kept (see below).
calibration and training data of the replay	the calibration selection index list (MMLU validation/dev questions); the teacher-distillation corpus (2,229 documents, 1.69 M tokens, generated by the MIT teacher from our own prompts seeded only by the 57 MMLU subject names, decontaminated); calib_auto2_pulito.txt (attention calibration text, generated by the teacher); corpus_cot.txt (chain-of-thought corpus: questions from MetaMathQA, MIT, and nvidia/OpenCodeInstruct, CC BY 4.0, see Attribution; reasoning and answers generated by the teacher); the 80 dense Hessians (1.3 GB) in place of the large calibration text calib_grande_2026_09_20.txt, which is not released (about 82 % private text); the recorded per-question MMLU-2000 log of C in stored order (logs/chain/mmlu_C_stored_order.log, sha256 89d95c99…) used by the replay's McNemar check.
MMLU source	the cais/mmlu parquet at revision c30699e8, in the Hugging Face cache layout (hub/datasets--cais--mmlu/snapshots/<revision>/all/).
checksums	SHA256SUMS for every file of this dataset.

The development subset has sha256 af987cc3369c15f90df9f390def043fd9fa4787e075b3b2170ff697a9dabbc6a.

Not in this dataset:

• the per-expert input statistics read by the expert folds of the chain: they are a separate dataset, Anjielon/Thor-T-fold-stats (32 files with their sha256 list);
• the model files (in their own repositories) and the engine (tag thor-t-v1 of Anjielon/llama.cpp);
• the standard baselines: Q2_K, Q4_K_M and IQ2_XXS are public files of the same bartowski repository and revision (their full sha256 are in the manifest and equal the repository's LFS hashes); IQ1_M, the IQ2_XXS mix and the naive TQ1_0 file were built by us and are not released, so only their recipe, not their bytes, can be reproduced;
• the replay recipe and the research code of the chain, which are in the forge Fucina.

Regenerating every number

genera_numeri.py runs on CPU only (Python 3.10 or later with NumPy and PyArrow; ricostruisci_banchi.py also needs the datasets package, and winogrande_ramo.py, contaminazione_mmlupro.py and microbatch_shares.py the tokenizers package; we ran Python 3.14.4, NumPy 2.4.6 and PyArrow 24.0.0; SciPy is not needed, the exact McNemar test is computed in the script; the gguf package of the release engine only for a run that re-reads GGUF headers). The full file list of this dataset, with sha256, size and licence, is BENCH_FILES.tsv. It reads its data from configurable roots. With --bundle it needs no model file: sizes and sha256 are read from the manifest that a full run on our machine wrote, and the tensor-by-tensor identities (released against measured S and M, XS against C) are re-checked from the per-tensor sha256 lists stored in the same manifest.

The micro-batch shares of likelihood scoring (scripts/microbatch_shares.json) are rebuilt on CPU with THOR_BENCH_INPUT=$PWD/bench THOR_TOKENIZER=$PWD/hf/tokenizer/tokenizer.json python3 scripts/microbatch_shares.py scripts/microbatch_shares.json (OpenBookQA and PIQA first rebuilt by scripts/ricostruisci_banchi.py). ricostruisci_banchi.py reads BENCH_FILES.tsv from the dataset root (or from scripts/), so run it from a full copy of the dataset.

The S/M trainer construction_SM/code/cardan_codice/cardan_kd.py defaults to the student code folder recupero_7dabd6f/thor_v2, which is not shipped; set E2E_KERNEL_NUOVI=1, as the shipped run commands do, to use thor_v2_kqat. That folder is tied to the runs by file dates, listed with sizes and sha256 in scripts/KQAT_FILE_DATES.tsv; its producer applica_kqat.py and the bit-exactness check confronta_cardan.py ship in construction_SM/code/. For every shipped answer log that has one, the raw stderr of its scoring run ships next to it as .mesc (all 30 on disk; 15 other .mesc files belong to logs that are not shipped). Reading dates come from the run register row that names each log (scripts/date_letture_fonte.json gives the source; file times only where no row names the log), and scripts/esiti_1108_PRODUCERS.tsv maps the runs in esiti_sicuro_1108/ and esiti_rip_1108/ to the scripts and manifests that produced them.

hf download Anjielon/Thor-T-bench --repo-type dataset --local-dir thor-t-bench
cd thor-t-bench
export THOR_BENCH_ROOT=$PWD/logs/bench          # per-question logs of the benches
export THOR_GGUF_ROOT=$PWD/logs/gguf            # development logs (no model file is needed with --bundle)
export THOR_FORGE_ROOT=$PWD/logs/forge          # CUDA logs and bench outputs
export THOR_RELEASE_ROOT=$PWD/release           # may be empty with --bundle
export HF_HOME_CACHE=$PWD/hf                    # contains hub/datasets--cais--mmlu/...
export THOR_FILE_MANIFEST=$PWD/scripts/manifest_file.json
export THOR_CICLI_EXTRACT=$PWD/scripts/cicli_extract.tsv   # the register rows the script reads, with line numbers
export THOR_LATEX_DIR=$PWD/out                  # numbers_final.tex and the per-subject table are written here
export THOR_BUNDLE_DIR=$PWD                     # --bundle verifies SHA256SUMS against this directory
export THOR_PAPER_DIR=$PWD/paper                # frozen copy of the paper sources: --bundle fails on any macro they use that it does not emit
OMP_NUM_THREADS=1 python3 scripts/genera_numeri.py --bundle --no-hash
# The two model files (teacher/ and stats/, 50.4 GB) are inputs of the replay only: --bundle neither reads them nor
# checks them; their sha256 are in SHA256SUMS.models (check with: sha256sum -c SHA256SUMS.models).
# REPLAY_STATUS (dataset root) is written by the replay's verification step V; the paper reports the replay as verified
# only if it contains the line "REPLAY VERIFIED <date> <commit>" with the cited forge commit.

Redacted copies. Code (.py, .sh, .bat, ...) ships byte-identical and was scanned for secrets. Logs and text outputs under logs/, scripts/, stats/ and construction_SM/ are copies in which machine-specific paths and user names are replaced by placeholders such as $THOR_LAB and $USER (the map, which is not invertible, is in REDACTION.md); the originals were not modified. SHA256SUMS hashes the redacted copies, BENCH_FILES.tsv records both hashes, and no parser of genera_numeri.py depends on the redacted paths (the bundle self-test regenerates every macro from them).

Compiling the paper. paper/ holds the LaTeX sources frozen at release, with the numbers_final.tex of our run. To compile the paper with the numbers of your run, copy the generated out/numbers_final.tex and out/sections/* (the per-subject table; the readings tables of the paper are built only on our machine, from the full register, and ship as scripts/letture.json) over the files of the same name in paper/ and paper/sections/, then run tectonic main.tex (or latexmk -pdf main.tex) inside paper/. The sources need no file outside paper/ (no figures; the diagrams are TikZ); tectonic fetches the TeX packages on first use.

The output is one \newcommand per number (numbers_final.tex) and the per-subject MMLU table. The script also prints % WARNING lines for every number that is cross-build or still pending (for example: rival suites and the root's likelihood suite still running); those warnings are part of the expected output. We checked that a run on a copy of the logs alone, with every model directory empty, reproduces every macro and table of the full run.

What the script computes, as in the paper: exact two-sided McNemar tests on discordant pairs; paired bootstrap intervals of student/teacher ratios (10,000 resamples of the questions, seeds 20261102 + k, the same indices for every model); cluster bootstrap over the 57 MMLU subjects; per-token and summed normalizations recomputed from the logged means and token counts. It checks that the gold answers of the concatenated MMLU blocks coincide with the answer column of the public split.

What is recomputed, and what is only transcribed

• Recomputed from per-question records or raw llama-bench outputs: every number of the final bench, and the development-subset scores and paired tests of the chain and of its internal reproduction.
• Read from the run register (cicli.tsv), not recomputable, because the raw output of those sessions was not kept: the one-session Vulkan and ROCm comparison with Q4_K_M, the same-session comparison of the launch and release builds, and the earlier-build CUDA MTP speeds. The launch-engine MTP speeds of the paper (S +16.8 %, M +13.2 %, XS +4.5 %) are recomputed by genera_numeri.py from the 30 raw response JSON files listed in BENCH_FILES.tsv (timings.predicted_per_second, mean of five completions per configuration).
• Literals in the paper, not produced by the script: the full-test scores of two intermediate checkpoints and the Holm values of the chain (computed from the same logs by an earlier statistics script), the captured fractions and fold comparisons, the Wikipedia top-1 agreements, and the root's earlier full-test score (run register). The C4 agreements of the released files (and of Q2_K and IQ2_XXS) are recomputed by the script from the shipped outputs (logs/forge/stato/c4_rilasciati_1110/): one session on the RTX 4060 laptop, CUDA build 49fa8a71e, experts on the CPU (--n-cpu-moe 99), teacher reference computed on Vulkan; the five files measured on the laptop are byte-identical to those on our main machine (sha256_aragorn.txt and sha256_corsair.txt in that folder). The earlier measurement of the hosts before their last step (top1_c4_1031/, commit not recorded) is kept as history.

What can be re-measured, not only recomputed

With the released model files, the engine tag thor-t-v1, this dataset and the commands of the paper's protocol, every accuracy and speed number measured on the launch engine can be re-run: XS, S, M, the root, the same-engine baselines whose files are public (Q2_K, Q4_K_M, IQ2_XXS) and the teacher, whose references are all on the launch engine. For example, one block of the full MMLU test:

GGML_VK_TQ1R_Q8=0 GGML_VK_DISABLE_GRAPH_OPTIMIZE=1 \
  llama-perplexity -m Thor-T-35B-A3B-XS.gguf -ngl 999 -dev Vulkan0 -c 4096 -np 4 -ub 512 \
  --multiple-choice --multiple-choice-tasks 100000 -f mmlu_00000.bin
# GGML_VK_TQ1R_Q8=1 for S, M and the root; the teacher and the standard files are unaffected by it

Expect small differences: batched evaluation is not bit-deterministic on this engine (the order in which sequences share a batch changes the accumulation order), and served generation is not reproducible run to run even with greedy decoding (two runs of S with bit-identical main-network weights gave 90.67 and 92.12 on GSM8K strict). The teacher's earlier-build runs (the drift comparison between builds), the development history and the baselines whose files are not released can only be recomputed from the logs here, not re-run.

Engines and builds behind the logs

commit	what it produced
49fa8a71e (CUDA, RTX 4060 laptop, experts on the CPU)	the C4 agreements of the released XS, S, M and of Q2_K and IQ2_XXS (logs/forge/stato/c4_rilasciati_1110/), against the teacher reference computed on Vulkan with 0b81365fc
0b81365fc (Vulkan, APU)	the teacher's C4 reference basec4.kld (31 Oct; teacher perplexity 12.055413 in every run)
4ed3ec488 (launch engine, Vulkan)	every accuracy number of the released models, the same-engine baselines, every teacher reference (including the teacher's GSM8K/IFEval generated-token counts, from one shared server log split by request: the first 1,319 requests GSM8K, the next 541 IFEval), the final-bench speeds
49fa8a71e (ancestor of thor-t-v1; its CUDA binaries report the stale build string 978ed9ce4)	the CUDA cross-check and the CUDA speeds
359f96cc0, 9f57abbb2 (ancestors of thor-t-v1)	the ROCm speeds; the CUDA full-test comparisons with standard quantizations
94ec619b7, 05589d47f (earlier Vulkan builds, not released)	the development history and the teacher's earlier-build runs (drift between builds)
5d2e382a9 (ancestor of the launch engine)	the one-session speeds of 7 November

The Vulkan backend of the release tag thor-t-v1 is byte-identical to that of the launch engine.

Datasets used by the benches

MMLU, GSM8K, IFEval and MATH-500 are read from Hugging Face snapshots pinned by revision (cais/mmlu c30699e8, openai/gsm8k 740312ad, google/IFEval 966cd895, HuggingFaceH4/MATH-500 6e4ed1a2). The multiple-choice files of ARC, BoolQ, OpenBookQA, TruthfulQA and MMLU-Pro were converted from the Hugging Face datasets at the revisions recovered from our cache (allenai/ai2_arc 210d026f, google/boolq 35b264d0, allenai/openbookqa 388097ea, truthfulqa/truthful_qa 741b8276, TIGER-Lab/MMLU-Pro b189ec76) and are pinned by the sha256 of the converted files. HellaSwag and Winogrande are the text files read by llama-perplexity. PIQA was rebuilt from the official raw files.

Attribution

corpus_cot.txt contains questions from the dataset nvidia/OpenCodeInstruct (https://huggingface.co/datasets/nvidia/OpenCodeInstruct), licensed under CC BY 4.0, and questions from MetaMathQA (MIT). The reasoning and answers that follow the questions were generated by Ornith-1.5. Changes were made: 1,024 entries of the input column of the first parquet file of OpenCodeInstruct were sampled at random (seed 20260921); their text is unchanged, but each one was wrapped in a template as "Domanda: \n\nRagionamento: \n\nRisposta: ", concatenated with the generated reasoning and answer, and dropped when generation failed or returned an empty answer.

Licence

Our own files (logs, scripts, statistics, manifest, converters) are released under CC BY 4.0. Third-party components keep their own licences: the teacher Q8_0 is a conversion of Ornith-1.5-35B-A3B and is redistributed under its MIT licence (notice in LICENSE.base-model); every benchmark file, converted dataset and corpus keeps the licence of its source dataset, listed per file in BENCH_FILES.tsv and per source in THIRD_PARTY.md (including the lm-eval samples, which contain text of their datasets). Because some files are share-alike (ARC CC BY-SA 4.0, BoolQ CC BY-SA 3.0), the dataset as a whole is declared "mixed": each file carries its own licence.

Citation

@misc{mogavero2026thort,
  title         = {A Ternarization Toolchain for Mixture-of-Experts Models That Run on a Consumer APU: Three Sizes of a 35B Model, a Ternary MTP Head, and llama.cpp Kernels},
  author        = {Mogavero, Angelo},
  year          = {2026},
  howpublished  = {\url{https://huggingface.co/Anjielon/Thor-T-35B-A3B/blob/main/Thor-T-35B-A3B-paper.pdf}},
  note          = {Preprint}
}

Replay code

The replay recipe of C lives in the forge Anjielon/fucina (tag thor-recipe-c-v1, commit 2b57db4 of the paper; replay from thor-recipe-c-v1.1 or master, which add the two cache files the bundle manifest lists); its code bundle ships inside that repository (bundles/thor_recipe_c/, pinned by its BUNDLE.json), and the recipe's bundle_src defaults to it, so a fresh clone of the forge needs no separate download. scripts/fucina_split.tsv records the public commit of the tag (2b57db4): the public forge is a git subtree split of the private tree followed by a filter-branch rewrite of the example paths (fucina_depriv.sed), so its commits differ from the private ones. REPLAY_STATUS is a self-report written by the replay's verification step on the machine that ran it; the script accepts it only if it names that commit, and the check covers the format and the commit, not that the replay was actually run. Scripts called by the run scripts but not shipped (sonda_corsair.sh, lucchetto.sh, sandbox_codice.py, statistiche.py) handle locking, a smoke probe and development statistics; they are not shipped, and every number of the paper is recomputed by genera_numeri.py from the shipped logs rather than read from their output.