# Fraction Compressor

- **Event:** [Meta Global AI Developer Hackathon](https://cerebralvalley.ai/e/meta-ai-developer-hackathon)
- **When:** Oct 26, 12:00 PM – Nov 4, 9:00 PM (EST)
- **Where:** Online
- **Team:** [Vinay Ganji](https://cerebralvalley.ai/u/vinuhi5online)
- **GitHub:** https://github.com/ganjikrishna/fraction-compressor-v0.4
- **Demo video:** https://www.youtube.com/watch?v=V2twYpXC3zU
- **Gallery:** https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery
- **Page:** https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/479

What was here before, and what was built this week. This repository (fraction-compressor-v0.4) was created on October 26, 2026, the first day of the event, and it contains only work built during the event: the factored runtime, the end-to-end benchmark, the recipe search, and the verification harness. Pre-existing work is separate and is not part of this submission: Fraction Compressor v0.1 to v0.3 and the Signet delta-transfer experiments live in the earlier repository, github.com/ganjikrishna/fraction-compressor, where the compression method was first designed and validated. The demo video opens with the same separation in one line. To state the boundary in one line: everything in this repository (the factored runtime, the four-pair benchmark, the recipe search, the BitDelta and LoRA baselines, and the verification harness) was built during the event, October 26 to November 2; the compression method itself and the Signet delta-transfer experiments were inherited from v0.1 to v0.3 and are not claimed as event work.

What it is. Fraction Compressor is a training-free, lossy delta-distribution format: it takes a fine-tune's patch, the weight difference between a base model and its fine-tune, which is normally almost as big as the model itself, and squeezes it into a small factored file, with no training and no queries. To be clear about the name: this tool does not compress the model itself; the base model stays full size, and what is compressed is only the fine-tune's difference from it. Fraction Compressor squeezes an existing fine-tune's patch into a small factored file whose structure is stored as 1-bit signs, priced at about 0.31 bits per weight all in (signs, factors, and scales together). On the Qwen2.5-0.5B pair, the full patch is 988 MB and ours is 19 MB, about 51x smaller. That 19 MB patch is lossy: its first-token accuracy is 0.010, against the base model's own 0.031. At run time the patch is applied as two small multiplies and the full weight matrix is never rebuilt, so patches swap in and out of one running base model live, in about 0.1 seconds (file-load time on the demo machine; the two recorded swaps measured 0.104 s and 0.087 s). One base model can then carry many behaviors, one small file each.

Why it matters (Impact). Model updates today ship as whole new models: a new name, a full-size download, and the old version retired, which breaks everyone still depending on it. With patches, an update is a 19 MB file on a stable base. The patch is also lossy: on our main pair it closes 23.2% of the gap to the full fine-tune, and its first-token accuracy is 0.010, below the base model's own 0.031, which is why the format is offered for cases where training cannot happen and partial recovery is acceptable. Rollout is a small download, rollback is swapping the previous file back in about a tenth of a second (file-load time on the demo machine), and one base serves many behaviors at once instead of one full model per behavior. The limits are stated as plainly as the wins: a patch lives only as long as its base does, a base update can break the patches built on it, and capability leaps still need full model releases. Patches are the cheap layer for the steady stream of small updates, not a replacement for new models.

Results, with the honest parts up front. On 96 fresh questions the search never saw, the headline recipe closes 23.2% of the score gap between base and full fine-tune on the Qwen pair (gap closed means the share of that gap a patch recovers), against 2.1% for a plain uniform recipe at a slightly larger byte budget. On Meta's Llama 3.2 1B pair, recovery is weaker (15.9%) and the uniform recipe scored below the base model itself, worse than no patch at all. On the Qwen2.5-1.5B scale test, the winning recipe's patch is about 80x smaller than the full patch and beats the uniform recipe by 0.134 nats on the combined 96 questions (a nat is the score's unit, one nat of log-probability advantage), but the margin is narrow and does not hold on both halves of the question set: the uniform recipe wins the heldout24 subset and the winning recipe wins heldout72. Where a compressed patch outscores the full patch, the gap-closed figure goes above 1.0 and we never call it a recovery fraction; the raw score margin is the honest measure there. Two rivals bound the claim from the other side, both detailed below: a plain 1-bit delta beats our format at its own floor price, and a LoRA adapter distilled at matched bytes beats it outright where training is available.

The full table, one row per run (combined 96 held-out questions per pair; score is mean target log-probability in nats, higher is better; accuracy is first-token accuracy; the winner on each pair is the byte-fair Spark recipe):

| Pair | Run | Score | First-token acc. | Bytes |
|---|---|---|---|---|
| Qwen2.5-0.5B | base | -11.150 | 0.031 | (reference) |
| Qwen2.5-0.5B | full delta (fp16) | -8.542 | 0.167 | 987,922,432 |
| Qwen2.5-0.5B | uniform rank-32 | -11.096 | 0.010 | 19,434,496 |
| Qwen2.5-0.5B | winner: mlp_behemoth_lite | -10.545 | 0.010 | 19,358,176 |
| SmolLM2-360M | base | -12.879 | 0.010 | (reference) |
| SmolLM2-360M | full delta (fp16) | -8.432 | 0.094 | 723,517,440 |
| SmolLM2-360M | uniform rank-32 | -8.366 | 0.083 | 19,705,856 |
| SmolLM2-360M | winner: o-down-rebalanced | -8.073 | 0.083 | 19,683,328 |
| Llama 3.2 1B | base | -13.718 | 0.010 | (reference) |
| Llama 3.2 1B | full delta (fp16) | -7.387 | 0.219 | 2,471,493,632 |
| Llama 3.2 1B | uniform rank-32 | -14.201 | 0.000 | 25,143,296 |
| Llama 3.2 1B | winner: no_embed_mlp_spread_balanced | -12.714 | 0.021 | 24,515,584 |
| Qwen2.5-1.5B | base | -12.584 | 0.010 | (reference) |
| Qwen2.5-1.5B | full delta (fp16) | -7.810 | 0.333 | 3,087,138,816 |
| Qwen2.5-1.5B | uniform rank-32 | -6.478 | 0.323 | 39,046,144 |
| Qwen2.5-1.5B | winner: Down Dominator | -6.344 | 0.260 | 38,623,232 |

Flags on that table, stated plainly. On SmolLM2-360M and Qwen2.5-1.5B the factored patches outscore the full delta itself, so gap closed exceeds 1.0 there (SmolLM2: uniform 1.015, winner 1.081; 1.5B: uniform 1.279, winner 1.307) and is not a recovery fraction on those pairs; the raw score margin is the measure. On Llama, the uniform recipe scores below the base model itself (-14.201 against -13.718, gap closed -0.076) with zero first-token accuracy. On the 1.5B pair the winner takes the combined set but the split reverses: uniform wins the heldout24 subset (-3.845 against -3.996) and the winner wins heldout72 (-7.126 against -7.356), and uniform's first-token accuracy (0.323) beats the winner's (0.260).

Side by side, from the recorded demos. Asked for a strict JSON object (the title, year, and director of the film Arrival, and nothing else), the base model writes the object and then rambles on with stray text, so its answer fails parsing; with the mlp_behemoth_lite patch swapped in, the same base returns exactly the object, parseable with the exact keys and values (results/hotswap_demo.json). The failure case is just as plain: on a NuExtract extraction prompt (pull the product, price, weight, and maker out of a short product description), the full fine-tune gets 8 of 10 prompts clean (9 of 10 parseable: 8 clean / 1 partial / 1 failed) while the rank-32 patch gets only 1 of 10 prompts clean and the base gets none at all, because the behavior rarely gets past its first token (results/skill_demo.json).

Known limits, stated up front. First, skills gated by the first generated token transfer weakly. On a real JSON extraction fine-tune (NuExtract-1.5-tiny on the Qwen pair), the fine-tune starts correctly on 9 of 10 prompts, the base on 0 of 10, and our rank-32 patch on 1 clean of 10. A control test explains why: force the fine-tune's first token and the plain base completes 7 of 10 cleanly (2 failed), so most of that skill was already latent in the base and the fine-tune mainly installs the decision to start. Under the same forced start, the patch completes 8 clean, 1 partial, and 1 failed of 10, matching the full fine-tune's own unforced score (8 clean, 1 partial, 1 failed). Second, the simplest rival is strong at its own price. A plain 1-bit delta (the BitDelta initialization) cannot go below about 62 MB on the first pair, and at that floor it closes 43.6% of the gap against 38.5% for our factored format at a matched budget (61,258,816 B against the 61,745,828 B floor). At 19 MB (lossy: first-token accuracy 0.010 against the base's 0.031) our format fits below BitDelta's floor, where no plain 1-bit patch fits at all; superiority over other training-free low-rank formats was not established.

Prior art and what is actually new. One-bit and low-rank delta compression are published work, and this project builds on the ideas only, no code: BitDelta (arXiv:2402.10193), Delta-CoMe (arXiv:2406.08903), D-QRELO (arXiv:2604.16940), and LittleBit (arXiv:2506.13771). The 1-bit format itself is not claimed as ours. What is ours is narrower: Muse Spark designing the per-layer compression recipes (a recipe is a per-layer rank allocation: how much of each layer's patch is kept) inside the experiment loop and claim-checking afterward, with every verdict required to cite the result file it rests on; the forced-multiply runtime that never rebuilds the full matrix; the first-token gate diagnosis together with its force-start control; and the verification harness described in the Meta products section.

Technical depth. Every number above is produced by a script in the repository and can be rerun. Beyond reruns, Muse Spark checked each headline claim against the exact files it cites, and Muse Glimmer set the wording rules (which recipe may be called the leader, and how percentages above 100% may be described). One disclosure belongs next to that: the held-out questions were also generated by Spark (the probe file is heldout96_probes_spark.json), so the question author and the claim checker are the same model; the recipe search never saw the questions before scoring, and we state the shared authorship plainly. The independent recomputation checks and the quantum-sampled re-audit live in the repository rather than in this pitch (results/gemini_validation_day2.md and results/quantum_audit.json). Scope: the compressor is model-agnostic by design and was tested on four open base models up to 1.5B, including Meta's Llama 3.2 1B, all run on one CPU-only home machine, which bounded the size and number of pairs testable in the event week. Llama was the hardest case measured, and its weaker recovery is reported as plainly as the stronger results. We also ran the comparison a reviewer asked for: a LoRA adapter distilled from the same fine-tuned model to 18,696,192 bytes, just under the factored patch's 19,358,176 bytes (the adapter's first-token accuracy is 0.167 to 0.177, the full fine-tune's own 0.167; the factored patch's is 0.010, the base's 0.031). On the same 96 questions the adapter's gap closed is 1.362 on average across three seeds (it scores above the full fine-tune itself, so that is a ratio, not a share recovered), against the patch's 0.232 (23.2%), and it ties the full fine-tune on first-token accuracy. The two are not equal-cost, though: the adapter needed 1,500 teacher generations and about 8 hours of training, while the patch is a deterministic conversion of weights already on disk, with no training and no queries. Distilled on Gemini-authored prompts in a deliberately different style, the same 18.7 MB LoRA adapter still reaches a gap closed of 0.620 on the Spark-written 96 (against 1.395 in-style, again a ratio above 1.0 rather than a share, and 0.232, or 23.2%, for the factored patch) (first-token accuracy: out-of-style adapter 0.042, in-style 0.167, factored patch 0.010, base 0.031), so the adapter's matched-byte win is not only a style-match artifact, though training-style match still adds a large share on top.

Built by Vinay K Ganji Krishna, solo participant and author of record, with Ember, an AI agent powered by Muse Spark, carrying out implementation, benchmarking, and documentation under his direction.

## More from Meta Global AI Developer Hackathon

- [Unchained](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/476)
- [Dragon](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/477)
- [Kabuga](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/478)
- [MegastarAI](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/480)
- [Quantum Pixels](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/481)
- [KISKY TEAM](https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/482)

---

Markdown version of https://cerebralvalley.ai/e/meta-ai-developer-hackathon/hackathon/gallery/479. Site index for agents: https://cerebralvalley.ai/llms.txt · full text: https://cerebralvalley.ai/llms-full.txt