File size: 4,568 Bytes
e2bb045
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
eb49041
 
e2bb045
 
 
 
 
 
0289347
e2bb045
 
eb49041
 
 
 
e2bb045
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
---
license: apache-2.0
base_model: sensenova/SenseNova-Loop-9B
base_model_relation: quantized
pipeline_tag: image-text-to-text
library_name: gguf
language: [en, zh]
tags: [gguf, rocmfpx, amd, vulkan, strix-halo, quantized, looped-transformer, mhc, vision-language, reasoning]
---

# SenseNova-Loop-9B, ROCmFPX GGUF

Quantized files of [SenseNova-Loop-9B](https://huggingface.co/sensenova/SenseNova-Loop-9B), a 9B vision-language model
from SenseNova. It runs 24 of its 32 decoder layers twice (56 layer passes per token) and mixes two residual streams
inside the looped part (mHC). It takes text and images and writes text.

> **These files need [HarshaVardhan3002/ROCmFPX](https://github.com/HarshaVardhan3002/ROCmFPX), built from 18 November
> 2026 or later.** The `sensenova_loop` architecture is new. Stock llama.cpp, LM Studio, Ollama and older ROCmFPX builds
> will not load any file here, the 6-bit one included.
>
> **Not tested on AMD hardware yet.** Please report speed and quality in the Community tab.
>
> Not an official release. All credit for the model goes to the SenseNova team.

## Files

| File | Size | KL to BF16 | Same top token | |
|---|---:|---:|---:|---|
| `SenseNova-Loop-9B-Q8_0_ROCMFPX.gguf` | 9.3 GB | 0.0012 | 98.7% | 8-bit, start here |
| `SenseNova-Loop-9B-Q6_K_ROCMFPX.gguf` | 7.4 GB | 0.013 | 95.5% | 6-bit ROCmFPX (`Q6_0_ROCMFPX`), added 20 November |
| `SenseNova-Loop-9B-Q4_0_ROCMFP4_STRIX_O8.gguf` | 6.6 GB | not measured yet | | 4-bit for AMD Strix Halo: ROCmFP4-FAST, attention and output 8-bit, added 20 November |
| `mmproj-SenseNova-Loop-9B-F16.gguf` | 0.9 GB | | | vision encoder, needed for images |

For comparison, measured the same way:

| Not published | Size | KL to BF16 | Same top token |
|---|---:|---:|---:|
| Stock Q6_K | 7.4 GB | 0.012 | 95.9% |
| Stock Q8_0 | 9.5 GB | 0.0023 | 98.5% |

The ROCmFPX 8-bit file is smaller than a stock Q8_0 and about half as far from BF16. At 6-bit, the stock Q6_K is slightly
closer (0.012 against 0.013); the ROCmFPX 6-bit runs on the fork's AMD kernels. Given how sensitive this model is, the
4-bit Strix file is for speed and memory on Strix Halo, not for the closest match; it passed a short answer test
("The capital of France is Paris."), and its numbers will be added.

This model reacts more strongly to quantization than a plain 9B model with the same layer layout: the same recipes on
a Qwen3.5-9B fine-tune drifted about seven to ten times less. A likely reason is the loop, where rounding errors in the shared layers pass
through them twice. If you need the closest match to the original, use the 8-bit file.

**How this was measured:** llama.cpp `llama-perplexity --kl-divergence` against a BF16 GGUF converted from SenseNova's
weights (perplexity 14.46), 40 chunks of 512 tokens of English Wikipedia text (wikitext-2), on an NVIDIA GB10 GPU after
expanding each file to F16. KL is how far the file's next-token probabilities drift from BF16, averaged over every
token; lower is better. This is general English text, not reasoning, coding or agent tasks, so it says nothing direct
about the benchmarks on the original card.

**Port check:** the new architecture in the fork was compared with SenseNova's own PyTorch code on the full model. On a
37-token chat prompt, the F32 GGUF gives the same next-token probabilities as PyTorch in FP32 (cosine 0.9999998, largest
KL 0.0000012, same top token at every position). A small random model with the same layout also matched token by token
with the cache.

Short checks on the published files, on CPU with greedy decoding:

- Text: both answered "What is the capital of France?" with "The capital of France is Paris."
- Vision: the 8-bit file correctly described a test image as a red circle in the upper left and a blue square in the
  lower right on a white background.

Notes:

- The multi-token prediction (MTP) head is not included.
- The model card's chat template, with its thinking block, is in the files. To answer without thinking, start the
  answer with an empty `<think>\n\n</think>\n\n` block.
- The loop and the stream mixing turn each token into many small GPU operations, so generation is slower than a plain
  9B model of the same size.

## Credits and license

- Original model: [sensenova/SenseNova-Loop-9B](https://huggingface.co/sensenova/SenseNova-Loop-9B), Apache-2.0,
  code at [OpenSenseNova/SenseNova-Loop](https://github.com/OpenSenseNova/SenseNova-Loop).
- The fork's support reuses llama.cpp's Qwen3.5 code, since the decoder uses the same hybrid layer layout.

Apache-2.0. See `LICENSE`.