Bizuayeu/GLM-5.3-Flash-XSFP4

GLM-5.3-Flash XSFP4

A derived checkpoint of nvidia/GLM-5.3-Flash-FP4-Local (revision 76348ddb2be2e35e39ecfc00e75dc07703f4f3d5). The routed experts of layers 3 to 44 and the MTP draft layer's experts are requantized from the BF16 weights of zai-org/GLM-5.3-Flash as XSFP4, which computes as standard NVFP4 with no runtime smoothing; every other tensor is FP4-Local's, byte for byte. It is not an NVIDIA or Z.AI release. It is the default checkpoint, from 3.4.0, of the 3.x line of GLM-5.3-Flash BIZ (TensorFold's native engine) on GB10 (DGX Spark class) systems.

A step-by-step explanation of the three formats, in English and Japanese: NVFP4, OSFP4, XSFP4.

At a glance

Source	nvidia/GLM-5.3-Flash-FP4-Local, revision 76348ddb2be2e35e39ecfc00e75dc07703f4f3d5 (NVIDIA Open Model Agreement)
Upstream	zai-org/GLM-5.3-Flash (MIT, Copyright (c) 2026 Z.AI Co., Ltd)
Requantized	Routed experts of layers 3 to 44 and the MTP layer's experts: XSFP4 (below), NVFP4 weights with FP8 E4M3 block scales of 16, from the BF16 weights
As shipped by FP4-Local	KDA projections, dense MLP, lm_head, and the MTP layer's attention and shared expert (MXFP8); MLA and the shared experts of layers 3 to 44 (FP8, per block); router; norms (BF16 and F32); embeddings; the vision tower
Calibration	512 rows of 2,048 tokens: Japanese 35% (Nemotron-Post-Training-Dataset-v2 Japanese, LLM-jp), local work logs 25%, math 15%, STEM 10%, English conversation 15%; rendered with the chat template at reasoning effort high; routing-only (each expert sees only the tokens routed to it)
Files	178 GB in 39 safetensors files (below)
License	NVIDIA Open Model Agreement (this derivative; LICENSE, NOTICE); the upstream model is MIT

Files

• 32 shards of the routed experts (model-xsfp4experts-*) and one of the MTP layer's experts (model-mtp-xsfp4experts.safetensors)
• FP4-Local's other tensors in model-0000{1..5}-of-00040.safetensors and tensors/native-QB.safetensors, and the index
• The source's config.json, hf_quant_config.json, generation_config.json, processor_config.json, tokenizer and chat template; NVIDIA's model card kept as README.nvidia.md
• As in FP4-Local, the routed experts' block scales of layers 3 to 44 are compressed losslessly in csf_32x2_v1 (the weight_scale.csf32_* tensors, 10.8 GB instead of 19.0 GB), and a loader restores them; the MTP layer's stay plain. The tensors are 0.45 GB larger than FP4-Local's, all of it in those scales, which compress a little less

FP4-Local, and what this checkpoint changes

FP4-Local is NVIDIA's mixed-precision GLM-5.3-Flash, made by quantization-aware distillation: trained against the BF16 model with the routed experts quantized to NVFP4. In its language model only the routed experts are 4-bit:

Part	FP4-Local	This checkpoint
Routed experts, layers 3 to 44	NVFP4, block scales compressed	XSFP4: NVFP4 requantized from the BF16 weights, block scales compressed the same way
The MTP layer's experts	NVFP4, block scales plain	XSFP4, requantized the same way; its block scales stay plain, as FP4-Local's do
KDA projections, dense MLP, lm_head	MXFP8 (KDA's small projections BF16)	FP4-Local's
MLA and the shared experts of layers 3 to 44	FP8 in 128×128 blocks (MLA's kv_b and indexer BF16)	FP4-Local's
The MTP layer's attention and shared expert	MXFP8	FP4-Local's
Router, embeddings, norms	BF16, F32	FP4-Local's
Vision tower	MXFP8 attention, NVFP4 MLP and merger	FP4-Local's

The experts are where the error and the bytes are. Measured part by part on FP4-Local, nearly all of its gap to the BF16 model came from the routed experts and their router, while its 8-bit attention, shared experts and head cost little; and the routed experts, the MTP layer's included, are 94% of the checkpoint, so they stay at 4 bits and a better 4-bit recipe is what gains accuracy. The new experts are plain NVFP4, served by the same kernels as FP4-Local's.

XSFP4

XSFP4 keeps the NVFP4 format and chooses its numbers with the method of OSFP4: Joint Optimization of Diagonal Smoothing and Block Scales for NVFP4 Quantization (Ben David, Meir and Ordentlich, 2026), which fits a smoothing and the block scales together so that each layer's output comes out closest, each input channel counted by the mean square of its activations. OSFP4 applies its smoothing at run time; XSFP4 removes that step from the routed experts. For each expert, the smoothing of the down projection's input is multiplied into the rows of the up projection, and the gate and up projections take no smoothing of their own. The block scales are fitted with OSFP4's method, so the weights compute as ordinary NVFP4 that any NVFP4 kernel reads, with nothing to apply at run time; as for FP4-Local, a loader restores the compressed block scales first.

Measured

Each checkpoint's next-token distributions over the same 128 documents (144,285 positions) against those of the BF16 weights. XSFP4 was measured on the revision with plain block scales; this revision restores them to the same bytes at load and gave the same decode-check hashes and NLL at both TP sizes.

On the engine that serves it: TensorFold's native engine as GLM-5.3-Flash BIZ 3.3.0 builds it, upstream 1.1.2 with upstream pull request #1050, which loads FP4-Local's formats as stored, and the patch of pull request #1179, on GB10 systems (NVIDIA's NVFP4 at TP=3 on the engine commit before, without #1179's patch, which lets an index name a shard in a folder; the release engine gave it the same decode-check hashes and NLL). Each document went to the engine as token ids with prompt_logprobs of 20. The KL bound counts one by one the tokens whose probability both sides report (the engine's best 20, BF16's best 20 and the text's token) and the rest as one bucket: it is exact from these numbers and lower than the KL over the whole vocabulary.

At TP=2 (two systems):

Checkpoint	Top-1 agreement	NLL above BF16	KL, lower bound
This checkpoint	93.26%	+0.85%	0.0431
nvidia/GLM-5.3-Flash-FP4-Local	92.82%	+1.11%	0.0510
nvidia/GLM-5.3-Flash-NVFP4	92.68%	+1.37%	0.0510

This checkpoint is closer to BF16 than each of the other two by all three measures, the per-document 95% intervals of the differences holding no zero (against FP4-Local's NLL narrowly: +0.01 to +0.55 points). FP4-Local and NVIDIA's NVFP4 are not told apart by the KL bound or the NLL.

At TP=3 (three systems; the engine splits each layer three ways, and its sums round differently):

Checkpoint	Top-1 agreement	NLL above BF16	KL, lower bound
This checkpoint	93.30%	+0.85%	0.0436
nvidia/GLM-5.3-Flash-FP4-Local	92.75%	+1.07%	0.0514
nvidia/GLM-5.3-Flash-NVFP4	92.71%	+1.38%	0.0511

This checkpoint is again closer than both by top-1 agreement and the KL bound, and closer than NVIDIA's NVFP4 by the NLL (+0.26 to +0.81 points); against FP4-Local's NLL the interval holds zero (−0.06 to +0.51 points).

Outside the engine, the same documents through the model in PyTorch with each checkpoint's weights dequantized and 16-bit activations (W4A16), over the whole vocabulary (these KL values do not compare with the bound above):

Checkpoint	KL	Top-1 agreement	NLL above BF16
This checkpoint (the MTP layer does not enter the next token)	0.0410	93.90%	+1.23%
nvidia/GLM-5.3-Flash-FP4-Local	0.0528	93.17%	+1.58%
nvidia/GLM-5.3-Flash-NVFP4	0.0512	93.22%	+1.99%

The MTP layer, which drafts tokens, was compared on the same 128 documents (144,157 positions) with FP4-Local's own MTP layer, teacher-forced at depth 1: its draft agreed with the main model's greedy token at 80.273% against 80.295%, a difference of −0.022 points with a per-document 95% interval of [−0.082, +0.036], and with the text's token two ahead at 68.607% against 68.636% ([−0.078, +0.022]). Both intervals hold zero, so the two cannot be told apart there, and the requantized layer ships.

Speed

Measured for GLM-5.3-Flash BIZ 3.3.0 on its engine and reference systems (MSI EdgeXpert, GB10, the GPU clock capped), at its serving defaults: one request at a time, a 245,760-token window at TP=2 and 1,048,576 at TP=3, the vision tower loaded. The runs read the revision with plain block scales, as in Measured. The setup's README keeps every release's figures and how they were taken.

	TP=2 (two systems)	TP=3 (three systems)
Decode, bench --kinds decode (tok/s, median)	54.15	66.23
An edit reply, bench --kinds edit (tok/s, median)	82.76	106.43
Prefill of 38,960 tokens (tok/s, median of three)	1,415.1	1,717.3
A 199,307-token prompt (s)	151.9	127.9
A 1,035,295-token prompt, first token (s)	—	1,015.7
tool-eval-bench, through the setup's tool-argument gate	93	93

Decode and the edit reply include the MTP layer's drafts, whose acceptance depends on the text, so they compare only with runs of the same prompts, not with other checkpoints' figures.

Known behaviours

Seen on GLM-5.3-Flash BIZ 3.3.0's engine, at temperature 0:

• A long count with a stop string. Asked for the numbers 1 to 1,000, one a line, with the stop string \n300\n, this checkpoint at TP=3 falls into a loop before 300, and the reply runs to its limit without the stop string; at TP=2 it reaches 300 and stops there, as NVIDIA's NVFP4 does at both sizes. FP4-Local does the opposite: it falls into a loop at TP=2 and stops at TP=3. The engine on upstream 1.1.1 gave the same results.
• A number written twice. When such a count is generated token by token, it sometimes writes one number twice, with NVIDIA's NVFP4 and FP4-Local as well as this checkpoint, at a place that moves with the checkpoint, the TP size, the build and where generation starts; NVIDIA's NVFP4, generated from the start at TP=2 on TensorFold's native engine, writes 152 twice, and upstream TensorFold 1.1.1's own binary gives the same tokens. The places belong to the checkpoint rather than to the engine: for NVIDIA's NVFP4, computed in fp32 from the same weights, the model itself picks 152 again there, and vLLM on it leaves the count at the same places about as often. Which start leaves where changes with the arithmetic (the TP size, the build, the engine), and neither generation nor the prompt path always keeps the count. No single wrong value has been found; the measurements are in TensorFold #1214, and the setup's README keeps the account.
• Short greedy replies can differ from NVIDIA's NVFP4. "The capital of France is", continued for 8 tokens, ends "Paris is spelled" at TP=3 where NVIDIA's NVFP4 ends "Paris is pronounced"; at TP=2 the two agree.

License

This checkpoint is a Derivative Work of nvidia/GLM-5.3-Flash-FP4-Local and is distributed under the NVIDIA Open Model Agreement, a copy of which is in LICENSE. Licensed by NVIDIA Corporation under the NVIDIA Open Model Agreement. The GLM-5.3-Flash base model is governed by the MIT License (Copyright (c) 2026 Z.AI Co., Ltd). The calibration data's Nemotron-Post-Training-Dataset-v2 rows are CC-BY-4.0 (NVIDIA); the data itself is not distributed.