Qwen3.5 GGUF-compatible source — f32: a tiny toolchain fixture

A floating-point format control for the Qwen35 GGUF reader/converter path—not a lossy quantization result. F32 is an exact-control case and F16 a near-control case on the recorded panel.

These weights are untrained, not an assistant, and not a language-quality benchmark. Generated text has no useful semantic quality. No upstream trained weights or training data are implied by an architecture name.

Weight lineage

This is a floating-point format-conversion control derived from shared native weights, not a fine-tune. It is not independently initialized. Generic HF fine-tune/quantization relation metadata is deliberately omitted where it would misdescribe the control; the QFS artifact record retains derived_from_artifact_ref.

Exact construction source: malaiwah/qwen3-5-gguf-tiny-random-bf16@490767e58441a55c5a9f6375ea0e31e2cdc9da76.

All 4 derivatives in this family were measured against the same complete source checkpoint identity:

320527902d412346d533fd1ac62066bd4cd278016a44f8cfd071318dc3b36a4b

That identity binds config and weight bytes; equal architecture names or random seeds are not used as a substitute. Quantized storage cases use round-to-nearest packing and do not claim GPTQ/AWQ/ModelOpt optimization or calibration.

Browse the Matched-Weight Quantization Families collection.

At a glance

Size is serialized artifact size, not runtime RAM or a capacity/performance guarantee. Packed-array element counts are not model parameter counts.

What is actually included

A separate complete native Qwen3_5ForConditionalGeneration random source, sized for the canonical Qwen35 GGUF conversion geometry. Contains real small vision weights, but GGUF children export and measure only its language-model/head view. It is not the same checkpoint as qwen3-5-tiny-random-bf16; do not interchange their panels or source identities.

Storage intervention: canonical dense Qwen35 GGUF f32.

• Canonical dense Qwen35 split-QKV/Z; key heads 2/value heads 6; text-only view with own head; no Qwen35-MoE, Qwen4-Exp, historical fused layout, vision or MTP
• Output-head policy: native. The comparison replays each side through its own sealed head, including any head error; the reference head is not substituted.
• Native BF16 forward; no llama.cpp serving-kernel or activation quantization validation

The GGUF payload contains the text/language model and head view, not the source vision tower. Original wrapper config and qwen35-layout.json are retained; QFS records the explicit derived text view. No missing vision weights are borrowed or synthesized. Canonical converter/layout provenance is required; Qwen4-Exp, Qwen35-MoE, and historical fused-QKVZ layouts are outside this bridge.

The repository file inventory includes config.json, generation_config.json, tokenizer.json, tokenizer_config.json, scope.json, qwen35-layout.json, build.json. Exact build/runtime/license inventories are linked below. A file may describe historical provenance without being an executable entry point.

Good community uses—and boundaries

• Learn how to download pinned artifacts, seal a small synthetic token panel, capture hidden states and replay a full vocabulary head.
• Debug model-family adapters, strict tensor loading, storage decoders, or reproducibility tooling without downloading a production-sized checkpoint.
• Reproduce a narrowly scoped result, report an adapter/reader regression, and retain the source, panel and runtime identities needed to explain it.

Not established: trained-model accuracy; useful instruction following; quantizer optimization quality; original production-weight compatibility; GPU/NPU/serving-kernel parity; cross-hardware determinism; long-context behavior outside the recorded panel; throughput or paid-compute admission.

RTN is round-to-nearest packing, not optimization. These cases do not run GPTQ, AWQ or AutoRound optimization, calibrated ModelOpt/CT/QAT training, or activation-aware tuning. CPU reconstruction does not execute the original packed GEMM or serving activation arithmetic.

Model family, root dataset and evidence

Exact construction source: malaiwah/qwen3-5-gguf-tiny-random-bf16@490767e58441a55c5a9f6375ea0e31e2cdc9da76. This is the actual source pin; later documentation commits do not rewrite that history. Family fidelity-root dataset repository and storage evidence bundle. The root model is separate; this child must not be registered or represented as the base model. Canonical roots and their evidence are published; registry links distinguish native bases from child/control artifacts.

Recorded own-head result

Full comparison receipt includes per-context/tokenwise evidence, comparison gates and disclosures. Receipt self-digest: 9b865598a65885c37a9706290a4edc84f756baae128e7257ae87fb100d43b2ea. No threshold or usable determinism floor is invented here.

Control classification: exact-control, not a lossy-quantizer ranking. The original capture protocol uses --role quant / gguf-k-quant as a storage-path metadata convention even for F32/F16. This does not make the floating-point control a BF16 root or an optimized quantization.

Material disclosures from the observed receipt:

• HEAD-1d: each side replayed through its own sealed head (reference b734800ed651, candidate b734800ed651); head error is inside the measurement, as under HEAD-2, and nothing is substituted. The heads are content-identical.
• candidate was captured from a WEIGHTS-ONLY RECONSTRUCTION (gguf-dequant-to-bf16, output bfloat16). The stored weights were decoded before the model forward; native quantized GEMM and serving activation arithmetic are not measured. Decoder provenance is in the sealed runtime receipt. The comparison is advisory.

Runtime requirements and safe local reproduction

Replay the published evidence without loading a model

This uses QFS's existing NumPy FP64 comparator in a Torch-free environment. It reads the stored hidden states and each side's own head. No model forward, remote model code, GPU, upload or registry mutation is involved. Runtime receipts name the actual backend; last-bit differences from another FP64 implementation are not a new quality claim. Synthetic exact controls remain zero.

Set QFS to a reviewed Quant Fidelity Suite checkout and use Bash:

: "${QFS:?Set QFS to your reviewed QFS checkout}"
WORK=$(mktemp -d)
export OMP_NUM_THREADS=2 MKL_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2
python3.12 -m venv "$WORK/replay-env"
"$WORK/replay-env/bin/pip" install 'numpy==2.5.3' 'huggingface-hub==1.30.0'
"$WORK/replay-env/bin/hf" download malaiwah/qfs-qwen-gguf-tiny-cpu-format-v1 --repo-type dataset \
  --revision 7cb03a8be6ae3ebb1791c11b625718435308ddc5 --include 'raw/candidates/f32/evidence/**' --local-dir "$WORK/evidence"
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" verify \
  "$WORK/evidence/raw/candidates/f32/evidence/reference" --verify-tensors
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" verify \
  "$WORK/evidence/raw/candidates/f32/evidence/f32" --verify-tensors
"$WORK/replay-env/bin/python" "$QFS/bin/fidelity_dataset.py" compare \
  --reference "$WORK/evidence/raw/candidates/f32/evidence/reference" \
  --candidate "$WORK/evidence/raw/candidates/f32/evidence/f32" \
  --out "$WORK/replayed" --device cpu --replay-device numpy --replay-dtype float32 \
  --vocab-chunk 8192 --verify-tensors --own-heads --force-compute

Reconstructed format comparisons are intentionally advisory and normally return exit code 2 while writing a valid receipt. Inspect that receipt; do not silence refusals or interpret an advisory result as a production-quality ranking.

Capture the actual checkpoint

Capture uses a separate pinned Torch CPU environment. The input below is the original token-panel format, not a sealed capture's internal panel/ folder. The native source, tokenizer and model revisions remain explicit. Set AUTHOR to your own HF handle; the dataset repository argument is attribution only and nothing is uploaded by these commands.

: "${AUTHOR:?Set AUTHOR to your Hugging Face handle}"
"$WORK/replay-env/bin/hf" download malaiwah/qwen3-5-tiny-random-gguf-f32-format --revision 27678e2b2c3a95235e4dad9a2ac9a24d2b257408 --local-dir "$WORK/model"
"$WORK/replay-env/bin/hf" download malaiwah/qwen3-5-gguf-tiny-random-bf16 --revision 490767e58441a55c5a9f6375ea0e31e2cdc9da76 --local-dir "$WORK/source"
"$WORK/replay-env/bin/hf" download malaiwah/qfs-fixture-root-captures-v1 --repo-type dataset \
  --revision f53b204091c988ce4a2161af81886f3018745559 --include 'requirements-capture.txt' --include 'roots/qwen35-gguf/input-panel/**' \
  --local-dir "$WORK/inputs"
python3.12 -m venv "$WORK/capture-env"
"$WORK/capture-env/bin/pip" install -r "$WORK/inputs/requirements-capture.txt"
"$WORK/capture-env/bin/python" "$QFS/bin/fidelity_dataset.py" architectures prepare \
  --architecture qwen3_5 --model-dir "$WORK/model" \
  --model-repository malaiwah/qwen3-5-tiny-random-gguf-f32-format --model-revision 27678e2b2c3a95235e4dad9a2ac9a24d2b257408 \
  --panel "$WORK/inputs/roots/qwen35-gguf/input-panel" --tokenizer-root "$WORK/source" \
  --author "$AUTHOR" --dataset-repository "$AUTHOR/qwen3-5-tiny-random-gguf-f32-format-capture" \
  --dataset-id "fidelity--$AUTHOR.qwen3-5-tiny-random-gguf-f32-format" --out "$WORK/workflow" \
  --role quant --scope-file "$WORK/model/scope.json" --codec gguf-k-quant --bits 32.0 \
  --reference hf://malaiwah/qwen3-5-gguf-tiny-fidelity-root-v1@af1922b4fb5c619e0bf2e92c1bfcd68d8a83cb32

Inspect workflow.json. This launcher executes its exact capture/verification commands and selects the Torch-free interpreter only for the final comparison:

export OMP_NUM_THREADS=2 MKL_NUM_THREADS=2 OPENBLAS_NUM_THREADS=2
"$WORK/replay-env/bin/python" - "$WORK/workflow/workflow.json" <<'PY'
import json, subprocess, sys
workflow = json.load(open(sys.argv[1]))
for step in workflow["commands"]:
    argv = list(step["argv"])
    if step["step"] == "compare":
        argv[0] = sys.executable
    result = subprocess.run(argv)
    if result.returncode:
        raise SystemExit(result.returncode)
PY

Use the actual root at malaiwah/qwen3-5-gguf-tiny-fidelity-root-v1@af1922b4fb5c619e0bf2e92c1bfcd68d8a83cb32. The community collection groups models and captures. Custom code, where required above, is explicitly pinned and executed only after your consent; hash verification is provenance, not a sandbox.

Licensing and detailed provenance

The fixture repository retains its mit license in LICENSE. This covers the fixture only according to that exact text; architecture inspiration is not relicensing of upstream weights, cards, code, or configuration. Dependencies retain their own licenses (native Transformers implementation: Apache-2.0). No upstream trained tensors are claimed to be copied.

The exact source license is retained, unchanged, from malaiwah/qwen3-5-gguf-tiny-random-bf16. The storage conversion does not grant new upstream rights.

Immutable provenance, historical cards, source inventories and full caveats

• build.json.
• scope.json.
• qwen35-layout.json.
• Retained reproduction tools/dependencies and source-inventory.json. Source paths in recorded argv are historical execution locations; restore the dataset’s raw trees and map them to your own workspace. Do not substitute moving upstream branches or an unreviewed publisher workflow.

Selected original provenance fields (full tensor/component evidence remains in the linked inventories):

{
  "source": {
    "repository": "malaiwah/qwen3-5-gguf-tiny-random-bf16",
    "revision": "490767e58441a55c5a9f6375ea0e31e2cdc9da76"
  },
  "format": "canonical dense Qwen35 GGUF f32",
  "classification": "exact-control",
  "architecture_restrictions": [
    "Canonical dense Qwen35 split-QKV/Z; key heads 2/value heads 6; text-only view with own head; no Qwen35-MoE, Qwen4-Exp, historical fused layout, vision or MTP"
  ],
  "activation_omissions": [
    "Native BF16 forward; no llama.cpp serving-kernel or activation quantization validation"
  ],
  "head_policy": "native"
}

Additional original storage-build provenance (tensor entries remain in build.json):

{
  "claim": "FORMAT fixture, random own weights, no optimizer quality ranking; text-only language view",
  "converter_revision": "9a7570587ce908b0073a0458877205b80627f393",
  "format": "F32",
  "golden_file": "f32-upstream-goldens.safetensors",
  "schema": "qfs.qwen35-gguf-build.v1",
  "source_checkpoint_sha256": "170f6305c16e5dc1704bae7735fe46d9fa64b7988adf43542eaacf85ef53d7f6",
  "source_config_sha256": "af379f490737e9834a34adbf85c995fc8b834a675b9d90494c58fd17afa62ebd"
}