What Are GSQ and RCO Quantization? 2-Bit GGUF Explained
GSQ learns how to round each weight and RCO decides how many bits each layer gets. See how the two shrink a huge MoE model to about 2 bits in a standard GGUF.
What are GSQ and RCO quantization?
GSQ and RCO are two quantization methods that work at different levels. RCO works across the whole model. It sets a total size budget and decides how many bits each tensor gets, giving more to sensitive parts and fewer to tolerant ones. GSQ works on a single weight. It learns how to round that weight onto the allowed grid using Gumbel-Softmax. Together they produced 2-bit GGUF files of a very large DeepSeek V4.1 Flash model that reportedly match the original's benchmark scores.
TL;DR
- RCO decides where the bits go. It fixes a size budget first, then assigns precision per tensor so the total hits the target exactly.
- GSQ decides how each weight is rounded. It starts from a GPTQ guess and learns the rounding instead of snapping to the nearest value.
- The name comes from Gumbel-Softmax, a trick that turns a hard discrete choice into something a training loop can optimize.
- The pipeline is sequential. GSQ quantizes every tensor at every candidate type, RCO searches that database and picks one type per tensor, and the result is stitched into one standard GGUF.
- MoE models compress well because most of their size sits in the experts, which tolerate heavy compression.
- The released builds sit at roughly 1.75, 2, and 2.25 bits per weight, and the 2-bit build is reported to match the original on AIME 25, GPQA Diamond, and LiveCodeBench.
Why does quantization lose accuracy in the first place?
A model is billions of numbers called weights. In a typical model each one is stored in 16 bits. That gives high accuracy and a huge file. Quantization stores each number in far fewer bits, here in the range of two to four. The file shrinks, but every number is now an approximation, so some accuracy goes missing.
The DeepSeek release this article uses as its example already ships smaller than 16-bit: 8-bit for the dense parts and 4-bit for the experts. The GGUF builds push that down to around two bits. GGUF is just the file format that holds the compressed numbers, and it is what llama.cpp reads.
Why is this model such a good target for compression?
The original is a mixture-of-experts (MoE) model. Every layer has 384 experts, and only six are used for each token. The context window is a million tokens. Most of the parameters live inside those experts, and since only a few fire per token, they tolerate being squeezed harder than the dense layers do.
That asymmetry is what a budgeted method can exploit. If most of the bytes sit in a part of the model that handles error well, you can cut deeply there and protect the parts that cannot afford it.
How does RCO allocate a bit budget?
Giving every weight the same number of bits treats every part of the model as equally important. It is not. Some layers are sensitive, and a small error there damages the output. Others are tolerant, and you can crush them with little visible effect.
RCO starts from the other end. It sets a total size budget, then decides who gets what:
- Sensitive tensors get more bits.
- Tolerant tensors get fewer.
- Everything adds up to exactly the target size.
In this model, the dense part chooses from higher-precision types, while the experts choose from types between roughly one and three bits. Two properties matter here. RCO hits the budget exactly, and it makes its choices by looking at the model's real loss rather than by guessing which layers matter.
How does GSQ round each weight?
Once a weight has its bit count, you still have to round it to one of a few allowed values. For a 2-bit grid, the options in the example are -2, -1, 0, and 1. The simple approach snaps to the nearest value. That is not always the best choice for the model's output, because errors in neighboring weights interact.
GSQ does something different:
- It starts from a solid GPTQ solution as the initial guess.
- It keeps all the rounding options open at once and scores each by how well it fits.
- As training proceeds, it sharpens that distribution, like turning a dial, until one option wins.
That gradual sharpening is the Gumbel-Softmax idea in the name. A hard choice (which grid value?) is not differentiable, so you cannot normally train it. Gumbel-Softmax relaxes the choice into a soft mixture you can optimize, then tightens it into a single pick. The payoff is better accuracy at the same bit width.
How do GSQ and RCO work together?
They solve separate problems, so they chain cleanly.
| Method | Scope | Question it answers |
|---|---|---|
| RCO | Whole model, across layers | Where should the bits be spent? |
| GSQ | A single weight | How should this value be rounded? |
The order of operations:
- GSQ quantizes every tensor at every candidate type, building a database of options.
- RCO searches that database and picks one type per tensor to hit the size budget.
- The chosen tensors are stitched into one standard GGUF file.
Because the output is a normal GGUF, you do not need a special runtime. The creator who demonstrated the model ran it with llama.cpp and showed VRAM use staying under 12 GB.
What do the released builds look like?
The lab behind the release, based in Austria, published three bit levels, all as standard GGUF files.
| Build | Approx. bits per weight |
|---|---|
| Smallest | 1.75 |
| Middle | 2 |
| Largest | 2.25 |
The benchmark table on the model card, as shown in the demonstration, lists AIME 25, GPQA Diamond, and LiveCodeBench. On those, the 2-bit build matches the original model's score. Treat that as a vendor-reported result on three benchmarks. It does not guarantee parity on your workload.
Does a 2-bit model really behave like the original?
Not everywhere, and the demonstrations hint at where the gaps are. A single-prompt test produced a complete animated HTML canvas scene of a whirling dervish with no libraries, which is a demanding code-generation task. A separate multilingual test asked for TV channel names in more than 80 languages. The tester judged most outputs strong, with slight misses in low-resource languages.
That pattern is plausible for any heavily quantized model. Benchmarks with short, verifiable answers can hold up well, while long-tail knowledge such as rare languages is where small losses tend to show first. If your use case lives in that tail, test it directly before committing.
Frequently Asked Questions
What does GSQ stand for?
The source material does not expand the acronym. The "G" refers to Gumbel-Softmax, the technique used to make the rounding choice learnable. The method starts from a GPTQ result and refines it.
Is RCO a rounding method or an allocation method?
RCO is an allocation method. It decides which quantization type each tensor receives so the whole model lands on an exact size budget. It does not round individual weights. GSQ handles that part.
Do I need special software to run these models?
No. The output is a standard GGUF file, which llama.cpp can load. The demonstration used llama.cpp and reported VRAM use under 12 GB, though your results will depend on your hardware and settings.
Why not just use the same bit width everywhere?
Layers differ in sensitivity. A uniform width wastes bits on tolerant layers and starves sensitive ones. Budgeted allocation moves bits from the first group to the second at the same total size, which is how a 2-bit average can still protect the parts that matter.
Does this approach only work on MoE models?
The sources only describe it on a MoE model, where the experts hold most of the weight and compress well. The underlying ideas, budgeted allocation and learned rounding, are not tied to MoE in principle. This source does not show results elsewhere.
How we source, write, and correct our articles. Editorial standards
