---

license: mit

base_model: orcarouter/GLM-5.3-Flash-Uncensored-FP8

base_model_relation: quantized

tags:

- gguf

- vector-quantization

- residual-vq

- glm5-next

- q4_k

- dgx-spark

- abliterated

- uncensored

- experimental

pipeline_tag: image-text-to-text

---

GLM-5.3-Flash Uncensored VQ GGUF (R13+8 experts, Q4_K nonexpert v3)

> Status, 2026-10-18: the files are the 19-layer R13+8 revision: the

> residual stage now covers routed layers 3–17, 22, 27, 41 and 44 (before:

> 3–16). Loading needs a ds4-dfm-rs build with GVQ1 container v2 support

> (main since PR #96,

> merge 34c46d18); the runtime binds the residual stage on any routed layer,

> so no runtime change is needed. Speed and memory of this revision on DGX

> Spark are not measured yet. Previous revisions are kept at the tags

> r13p8-l3-16

> (R13+8 on layers 3–16) and

> q4k-v3

> (all routed layers R13).

Experimental custom GVQ1 / GGUF v3 conversion of

orcarouter/GLM-5.3-Flash-Uncensored-FP8

(150bd5e3a957db747db1224cc4f8891bcfa7a7f0), the abliterated

(refusal-removed) build of Z.AI GLM-5.3-Flash in the official block-FP8

layout, for DGX Spark (GB10) with

ds4-dfm-rs. Standard

llama.cpp/Ollama/Transformers loading is not claimed.

It has the structure of

Baekpica/GLM-5.3-Flash-VQ-GGUF

at the same R13+8 revision: the same part names, tensors, types and payload

sizes. Only the source weights, and therefore the codebooks and indices,

differ. Keep the two releases in separate directories.

What this revision changes

• 19 of 42 routed layers are R13+8: layers 3–17, 22, 27, 41 and 44.

Layers 17, 22, 27, 41 and 44 are new; the parts of layers 3–16 are

byte-identical to the previous revision. Each R13+8 layer keeps the 13-bit

stage (K8192 E4M3 book, F16 row gain) and adds an 8-bit residual stage:

one K=256 E4M3 book per layer, trained on this model's residuals, and one

index byte per 8-weight vector, 2.625 bits per weight in total. Stage-1

and stage-2 indices are chosen jointly from the source weights.

• The other 23 routed layers stay R13 (1.625 bits per weight), with

their published bytes unchanged.

• Unchanged: the 316 Q4_K nonexpert matrices of v3, native-precision

tensors, vision and the MTP layer 45.

• Size: about 94.49 GB (88.0 GiB) of GGUF parts, against 89.96 GB with

14 R13+8 layers and 77.27 GB with none.

• Format: GVQ1 container v2 (FORMAT.md); only the 19

upgraded layer parts declare version 2.

How the layers were chosen

Measured end to end on the base model's weights; this release uses the

same layers. Upgrading one routed layer at a time (all others R13)

and measuring KL(original || model) on held-out text ranks the bottom

layers far ahead: layer 5 lowers KL by 0.066, 8 by 0.064, 6 by 0.064, 14 by

0.056, 3 by 0.045, and layers 3–16 take the first 14 places (68% of the

summed single-layer gains). The next five are 17 (0.021), 41 (0.017),

44 (0.015), 27 (0.013) and 22 (0.011); with them the 19 upgraded layers hold

77% of the summed gains. The middle and upper-middle layers are last

(26: 0.001).

A local screen that scored each layer by the routed-FFN output error per

extra GiB, normalized by that layer's FFN output energy, pointed the other

way and lost end to end; the FFN output energy differs by three orders of

magnitude between layers, so a normalized local error does not measure a

layer's effect on the model. Held-out comparison of the 14-layer choices

made for the previous revision, on the base model (5,435 tokens,

original-precision non-experts; R13+8 rows use the published stage 1 and a

greedy stage 2 unless marked):

| Routed layers upgraded | PPL | KL vs original |

|---|---:|---:|

| none (q4k-v3) | 4.858 | 0.607 |

| local-screen top 14 (4, 5, 9, 25–40) | 4.470 | 0.498 |

| bottom 7 + top 7 (3–9, 38–44) | 4.220 | 0.437 |

| local-screen bottom 14 (3, 6, 7, 10–14, 24, 34, 35, 42–44) | 4.058 | 0.390 |

| layers 3–16 | 3.987 | 0.354 |

| layers 3–16, the base release's parts (joint stages) | 3.969 | 0.342 |

| all 42 (reference, does not fit the budget) | 3.595 | 0.151 |

| original model | 3.538 | 0 |

Measured on this revision's parts

The base release's reference forward (Transformers 5.19.0 modules,

original-precision non-experts), run on this model's own FP8 weights and

this release's parts, on 5,195 held-out and fixture tokens. KL is against

this model's original weights.

| Routed layers R13+8 | PPL | KL vs original | top-1 agreement |

|---|---:|---:|---:|

| 3–16 (r13p8-l3-16) | 3.927 | 0.331 | 80.6% |

| 3–17, 22, 27, 41, 44 (this revision) | 3.780 | 0.282 | 82.0% |

| original model | 3.500 | 0 | 100% |

KL falls on 11 of the 12 cases: Korean prose 0.571 → 0.494, Korean chat

0.206 → 0.160, English prose 0.457 → 0.382, the runtime fixture's Korean

summary 0.149 → 0.096; the 23-token math fixture stays level (0.187 →

0.190). The all-R13 revision was not measured on this model. These isolate

the routed experts; they are not ds4 engine numbers, since the release

stores the non-experts as Q4_K.

Memory on DGX Spark

The base release's 14-layer revision quoted 112.0 GiB on GB10 at the native

1,048,576-token context with two MTP drafts, of 118.7 GiB available. This

revision adds the same 4.2 GiB of weights, about 116.2 GiB by that quote;

the five extra layers were sized for that headroom. The quote has not been

re-run on this revision.

Speed and quality

This release's 19 upgraded layers have the same weight error as the base

release's (relative MSE 0.1438 → about 0.041).

Decode reads about 7.98 GB of weights per token (7.85 GB with 14 R13+8

layers, 7.5 GB with none), so it is expected to be slightly slower than the

previous revision. DGX Spark measurements follow. This is not a

quality-equivalent replacement of the source model.

Disclaimer

The source model had its safety alignment substantially removed by

abliteration; see its card. It can comply with harmful requests that the

original model refuses. It is meant for research such as refusal-mechanism

study, red-teaming and robustness evaluation. You are responsible for how you

use it and for everything it generates; add your own safety and moderation

layers before any deployment.

Integrity and licensing

files.json and SHA256SUMS give file sizes and

hashes; tensor-manifest.json gives per-tensor

precision, shapes and payload hashes. Verify them before loading.

Weights and assets: MIT, see LICENSE. YoungAi algorithm

attribution: see LICENSE-YoungAi.