MiniCPM-V-4.7-35B-A3B EXL3 6.08 bpw

Summary

EXL3 (ExLlamaV3) quantisation of openbmb/MiniCPM-V-4.7-35B-A3B (revision 4c7623a9), the 35B-parameter, 3B-active mixture-of-experts vision-language model.

6.08 bits per weight on average over the quantised decoder weights (routed experts 6 bit, attention / gated-delta-net / shared expert 8 bit, output head 6 bit); 28.3 GB on disk in 8 safetensors shards.
The vision tower, window merger, projector and token embeddings are stored in bf16, byte-identical to the source (sha256 verified, 460 tensors).
Text KL divergence to the bf16 model, same implementation: 0.008622 mean on 14 x 1024 tokens and 0.004045 mean on 100 x 1024 tokens (97.5% / 98.0% top-1 agreement). Details and caveats are in Fidelity.
Companion draft for speculative decoding: r0b0tlab/MiniCPM-V-4.7-35B-A3B-DSpark-EXL3-6.00bpw.

What runs where. Text generation runs on the r0b0tlab ExLlamaV3 fork, exllamav3-r0b0t: plain decoding on its minicpm-v4.7 branch (commit 4d083d25c1a3, ExLlamaV3 v1.5.0 base), and DSpark drafting with the companion draft on its minicpm-v4.7-dspark branch (commit 5ddae7d12448). Stock ExLlamaV3 does not know this architecture until the shim in support/exllamav3/ is added. ExLlamaV3 runs the text path only: the vision tower is stored in bf16 and is not run, so image and video input are not supported or measured here. The vision tensors are kept in bf16 for a runtime that runs them.

Where the numbers on this card come from

Every figure on this card was measured with ExLlamaV3 on one NVIDIA GB10: the quantisation fidelity with the fork's own forward pass (on the equivalent development branch described under Limitations), and the text-generation figures with the fork's plain and DSpark-drafting branches named in How to load. The generation figures are reproducible with the public loader and with the serving repository at v2.1.1, which contains the commands, the evaluation kit and the evidence bundles evidence/exllamav3-plain-20261013 and evidence/exllamav3-drafted-20261014. The fidelity figures were measured when the pack was built; their primary records are in evidence/fidelity-20261013, but not every fidelity figure on this card is reproduced there yet.

Hard-reasoning verdicts (20 items per run) are AI-graded: the drafted run's by a blind AI subagent, the plain run's by the builder's AI assistant. Neither is an independent human review.
Drafted decoding is not bit-identical to plain decoding: 59 of 80 greedy prompts produce the same tokens with adaptive drafting. The rest differ at some point; the position and the cause were not measured.
One pass per lane on one GB10 at batch 1. A difference of one or two Q200v2 rows is not evidence of a difference in quality.

What is quantised and what is not

component	count	stored as	bits per weight	size	share
routed experts (gate, up, down)	30,720 matrices	EXL3 trellis, codebook mul1	6	24.317 GB	86.0%
vision tower, window merger, projector	459 tensors	bf16, byte-identical to the source	16	1.106 GB	3.9%
token embeddings	1 tensor	bf16, byte-identical to the source	16	1.016 GB	3.6%
gated-delta-net projections (in_proj_qkv, in_proj_z, out_proj)	90 matrices	EXL3 trellis, codebook mul1	8	1.008 GB	3.6%
output head (lm_head)	1 matrix	EXL3 trellis, codebook mul1	6	0.382 GB	1.3%
attention projections (q, k, v, o)	40 matrices	EXL3 trellis, codebook mul1	8	0.273 GB	1.0%
shared expert projections	120 matrices	EXL3 trellis, codebook mul1	8	0.126 GB	0.4%
router and shared-expert gate	80 tensors	f16, 0 byte-identical, 80 exact fp16 casts of the source bf16	16	0.042 GB	0.1%
gated-delta-net gates, conv, state parameters, norm	180 tensors	bf16/f16, 120 byte-identical, 60 exact fp16 casts of the source bf16	16	0.010 GB	0.0%
layer norms and final norm	81 tensors	bf16, byte-identical to the source	16	0.000 GB	0.0%
attention q/k norms	20 tensors	bf16, byte-identical to the source	16	0.000 GB	0.0%

Quantiser settings: -hq raises the attention, gated-delta-net and shared-expert groups by 2 bits over the routed experts; the output head is 6 bit (-hb 6); codebook mul1. The exact command is in CONVERT.md.
681 of the 821 plain (not trellis-coded) tensors are byte-identical to the source checkpoint (sha256 over the raw bytes): vision tower, window merger, projector (459), gated-delta-net gates, conv, state parameters, norm (120), layer norms and final norm (81), attention q/k norms (20), token embeddings (1).
140 small tensors (router and shared-expert gate (80), gated-delta-net gates, conv, state parameters, norm (60)) are stored as fp16 instead of bf16; every value equals the widened source value (exact cast, compared bit for bit).
The source checkpoint contains no multi-token-prediction (MTP) head, so none is included even though the config declares mtp_num_hidden_layers: 1.
Average over the quantised linears including scales: 6.12 bits per weight (quantization_config.json reports 6.08 for the decoder body).
The source checkpoint has 59,093 structurally dead expert channels (1.1% of 5,242,880; 41% of layer 0): every weight of such a channel is the same tiny constant (about 7.8e-38). They are quantised like all others; the weight-space scan below measures live channels only, because over all channels it would flag 392 matrices that are in fact fine.

Size and memory

item	size
weights in this repository (shards)	28.30 GB (26.35 GiB)
of which: vision tower, window merger, projector	1.11 GB
of which: token embeddings	1.02 GB
of which: output head (lm_head)	0.38 GB
KV cache (full-attention layers only, fp16)	20,480 B/token = 5.00 GiB at 262,144 tokens; 1.25 GiB at 65,536
gated-delta-net recurrent state	64.4 MB per sequence, independent of context length
DSpark draft (companion repository)	451 MB weights + 10,240 B/token draft KV cache

KV cache per token = full-attention layers x 2 (K and V) x KV heads x head dim x 2 bytes = 10 x 2 x 2 x 256 x 2 = 20,480 bytes. Gated-delta-net state per sequence = linear-attention layers x (value heads x key dim x value dim x 4 bytes + conv channels x (kernel - 1) x 2 bytes) = 30 x (32 x 128 x 128 x 4 + 8,192 x 3 x 2) = 64,389,120 bytes (64.4 MB); it does not grow with context length.

Fidelity (text)

Every number below is measured on text only. The reference is the bf16 checkpoint; "same implementation" means the bf16 weights and this pack are both run through ExLlamaV3 (fp16 activations), so the KL isolates the effect of quantisation. Divergences are over all next-token distributions in the rows (248,144-way vocabulary).

Set A: 14 rows x 1024 tokens (ids sha256 9c3477a78036); row kinds: doc 2, multilingual 2, chat 1, cuda 1, dialogue 1, javascript 1, json 1, math_logic 1, prose 1, python 1, rust 1, tables 1. The same 14 rows are used for the yardstick below.
Set B: 100 rows x 1024 tokens (ids sha256 70002c4a0efa); row kinds: self_sampled 40, image_text 15, multilingual 14, python 7, rust 6, cuda 5, prose 4, json 2, tables 2, doc 1, javascript 1, python_prose 1, shell 1, toml 1. A larger held-out set; self_sampled rows are text sampled from the model itself.

KL divergence to the bf16 model (same implementation)

set	rows x tokens	KL mean (ref → pack)	median	p95	p99	max	KL mean (pack → ref)	top-1 agree	top-5 overlap	ppl ratio
Set A	14 x 1024	0.008622	0.0005655	0.01975	0.0673	9.961	0.008825	97.50%	0.957	1.0041
Set B	100 x 1024	0.004045	0.000096	0.01265	0.04397	28.91	0.00405	97.97%	0.964	0.9998

KL(bf16 → pack) is the usual direction; KL(pack → bf16) is given for the mean. Top-5 overlap is the mean fraction of the reference top-5 tokens that are also in the pack's top-5; the perplexity ratio is pack / bf16 on the same tokens.

Without the single worst row

The mean is dominated by a few positions: the worst 1% of positions carry 49% of the total KL on the 100-row set.

On Set A the worst row is row 11 (chat_template, kind chat). That row is unstable for the unquantised implementations too. Their mean KL on it against an all-fp32 run of the same weights:
- HF transformers bf16: 0.08736 on that row (0.01064 over all rows)
- HF transformers bf16 + fp32 residual stream: 0.1023 on that row (0.01149 over all rows)
- ExLlamaV3 fp16 (the implementation used for the measurements): 0.06192 on that row (0.006943 over all rows)
On Set B the worst row is row 71 (image_text_scene_1, kind image_text).

set	excluded row (worst)	KL mean (bf16 → pack), all rows	KL mean (bf16 → pack), without it	KL mean (pack → bf16), without it	top-1, all rows	top-1, without it	top-5 overlap, without it
Set A	row 11 (chat_template, kind chat)	0.008622	0.004525	0.004508	97.50%	97.48%	0.958
Set B	row 71 (image_text_scene_1, kind image_text)	0.004045	0.003534	0.003655	97.97%	97.97%	0.964

Against HF transformers bf16, and the numerics floor

A second reference is the HF transformers bf16 forward pass of the same checkpoint. Two different bf16 implementations of the unquantised model already differ by the "floor" rows below, so differences between this pack and HF bf16 of that size are not quantisation error.

set	rows x tokens	KL mean (ref → pack)	median	p95	p99	max	KL mean (pack → ref)	top-1 agree	top-5 overlap	ppl ratio
Set A: this pack vs HF bf16	14 x 1024	0.01195	0.0007481	0.0269	0.09319	10.43	0.01141	96.88%	0.951	1.0037
Set A: floor (ExLlamaV3 bf16 vs HF bf16, no quantisation)	14 x 1024	0.01158	0.0005616	0.02211	0.08821	17.72	0.01046	97.20%	0.956	0.9996
Set B: this pack vs HF bf16	100 x 1024	0.005157	0.0001391	0.01796	0.05978	20.16	0.005381	97.72%	0.958	0.9990
Set B: floor (ExLlamaV3 bf16 vs HF bf16, no quantisation)	100 x 1024	0.004543	0.00009	0.01471	0.05108	15.41	0.004535	98.12%	0.963	0.9993

Against an all-fp32 run of the same bf16 weights (Set A), the unquantised implementations themselves differ by:

implementation (unquantised)	KL mean to fp32	without the worst row	top-1 agree
HF transformers bf16	0.01064	0.004735	97.2%
HF transformers bf16 + fp32 residual stream	0.01149	0.004497	97.4%
ExLlamaV3 fp16 (the implementation used for the measurements)	0.006943	0.002714	98.1%

Same-protocol yardstick

The same 14 x 1024 token set (identical ids), the same forward implementation and the same KL definition were run on a published 4.00 bpw EXL3 quantisation of Qwen3.5-35B-A3B. That model has the same text architecture (30 gated-delta-net + 10 attention layers, 256 experts, top-8) but different weights, and it was quantised with a different codebook (mcg; this pack uses mul1) and calibration set. This is a plausibility check, not a ranking.

model	bpw	format	KL mean	median	p99	mean without worst row	top-1 agree
this pack (MiniCPM-V-4.7-35B-A3B)	6.08	ExLlamaV3 EXL3, mul1	0.008622	0.0005655	0.0673	0.004525	97.5%
Qwen3.5-35B-A3B, published EXL3 (turboderp)	4.00	ExLlamaV3 EXL3, mcg	0.03673	0.004592	0.2825	0.01634	94.7%

Per-kind breakdown (100-row set, KL to the bf16 model, same implementation)

kind	rows	KL mean (bf16 → pack)	KL mean (pack → bf16)	top-1 agree
self_sampled	40	0.001614	0.001625	99.0%
image_text	15	0.009748	0.009676	97.3%
multilingual	14	0.006506	0.006569	96.9%
python	7	0.003632	0.003668	98.3%
rust	6	0.002677	0.002668	97.9%
cuda	5	0.002428	0.002427	98.5%
prose	4	0.005326	0.005299	96.5%
json	2	0.000943	0.0009158	96.7%
tables	2	0.002973	0.002966	96.9%
doc	1	0.004752	0.004661	96.0%
javascript	1	0.003353	0.003406	97.9%
python_prose	1	0.005898	0.006059	98.7%
shell	1	0.003361	0.003469	97.9%
toml	1	0.002472	0.002501	90.3%

Weight-space scan

All 30,971 quantised matrices (every routed-expert matrix, the attention, gated-delta-net and shared-expert projections and the head) were dequantised from the pack and compared with the bf16 source, relative L2 over live channels. 0 matrices flagged, 0 on the watch list (flag threshold: 3x the median of the (bits, kind) group). rel_l2_scan.json holds the summary and the worst 10 matrices per group.

bits	kind	matrices	median rel L2	p99	max
8	`linear_attn.in_proj_qkv`	30	0.005352	0.007341	0.007341
8	`linear_attn.in_proj_z`	30	0.00562	0.007147	0.007147
8	`linear_attn.out_proj`	30	0.005709	0.00647	0.00647
8	`mlp.shared_expert.down_proj`	40	0.005271	0.005883	0.005883
8	`mlp.shared_expert.gate_proj`	40	0.005242	0.005973	0.005973
8	`mlp.shared_expert.up_proj`	40	0.005249	0.005631	0.005631
8	`self_attn.k_proj`	10	0.005274	0.005383	0.005383
8	`self_attn.o_proj`	10	0.005902	0.006208	0.006208
8	`self_attn.q_proj`	10	0.006451	0.008873	0.008873
8	`self_attn.v_proj`	10	0.005282	0.005533	0.005533
6	`lm_head`	1	0.02004	0.02004	0.02004
6	`mlp.experts.*.down_proj`	10,240	0.0178	0.01968	0.0214
6	`mlp.experts.*.gate_proj`	10,240	0.01883	0.01941	0.02068
6	`mlp.experts.*.up_proj`	10,240	0.01885	0.01943	0.01975

Long context

The model's native context is 262,144 tokens. Needle retrieval uses one 261,001-token document with six seven-digit passcodes, 22 questions over prefixes of 4,096 to 261,000 tokens, token-exact:

run	exact answers
ExLlamaV3, plain decoding	19 / 22
ExLlamaV3, with DSpark drafting	19 / 22

The same three questions miss in both runs, at the cuts of 200,000 and 261,000 tokens; each miss returns another passcode from the same document.

Decode and prefill at depth, one stream, median of three cold repeats (tokens per second; cold time to first token in seconds):

context	decode, plain	decode, drafted	prefill, plain	prefill, drafted	cold TTFT, plain	cold TTFT, drafted
1,024	59.5	65.6	1,096	1,115	0.9	0.9
4,096	47.0	70.7	2,077	2,035	2.0	2.0
32,768	48.2	48.7	2,889	2,839	11.3	11.5
131,072	34.7	24.1	1,764	1,764	74.3	74.3
261,000	24.7	15.9	1,151	1,149	226.8	227.1

The 4,096-token plain figure is a first visit; warm plain decoding at that depth measured 55 to 57 tok/s, so the 4,096 comparison is not a clean speed-up. With the draft attached, decoding is slower than plain at 131,072 and 261,000 tokens; the cause is not established.

Throughput

One NVIDIA GB10, the 6.08 bpw EXL3 target, batch 1, one stream, ExLlamaV3 on the branches named in How to load.

Plain decoding, 80-prompt kit, greedy, tokens per second: GSM8K-style math 60.1, code 59.8, chat 59.4, all 59.9.
With DSpark drafting, adaptive verification (the default; up to 15 drafts per round): GSM8K-style math 177.8, code 220.5, chat 69.0, all 161.3.
With DSpark drafting, fixed 15 drafts per round: GSM8K-style math 162.1, code 207.3, chat 41.0, all 143.1. Chat is slower than plain at fixed 15, which is why adaptive verification is the default.
End to end on Q200v2 text-180, one request in flight: 58.7 tok/s plain, 109.8 tok/s with drafting.
GPU memory after load: 29.9 GiB allocated (plain), 33.8 GiB (with the draft attached).
Decode and prefill at depth: see Long context.

Task sanity

A frozen kit of 180 text prompts (Q200v2 text-180), run through ExLlamaV3 with the target alone and with the companion draft attached. Greedy decoding, thinking enabled, at most 8,192 tokens per answer.

family	rows	ExLlamaV3, plain	ExLlamaV3, with DSpark drafting
GSM8K-style math	80	74 (92.5%)	75 (93.8%)
HumanEval-style code	40	39 (97.5%)	39 (97.5%)
IFEval-style instruction following	40	35 (87.5%)	35 (87.5%)
Hard reasoning	20	19 (95.0%)	20 (100.0%)
all	180	167 (92.8%)	169 (93.9%)

Grading: GSM8K-style answers are an exact answer; HumanEval-style code is executed against its tests; IFEval-style instructions are checked by rule. Hard reasoning has no automatic grader: the 20 answers of each run were read against the reference answers by an AI assistant (the drafted run's by a blind AI subagent, the plain run's by the builder's assistant), not by an independent human reviewer. One HumanEval row (humaneval-032) fails in both runs; in the drafted run it reaches the 8,192-token ceiling without an answer.

Calibration

250 x 2048 tokens from the converter's bundled calibration corpus (general text, code, multilingual, technical, encyclopedic). Full description and the data hashes: calibration.md.

Calibration was text-only. The quantiser cannot run the vision tower, so no image tokens or vision features were seen during calibration; the expert routing seen by image tokens was not calibrated. The vision tower itself is not quantised. No image-prompt measurement is made on this runtime.

Limitations

Calibration was text-only (see above). Image input is not run or measured by this runtime; there is no multimodal calibration.
The vision tower, merger and projector are unquantised bf16, so they add 1.1 GB; the pack is not smaller for image input.
The source ships no MTP head, so there is no native multi-token prediction.
Stock ExLlamaV3 does not know the MiniCPMV4_7ForConditionalGeneration architecture. The shim in support/exllamav3/ subclasses the Qwen3.5 MoE classes of ExLlamaV3 v1.5.0. Against the stock ExLlamaV3 1.6.1 sources (PyPI wheel, sha256 e9bc4bb39d45) it was checked statically (shim_check.py): the base classes, constructor signatures, trim_padded_out handling and registration mechanism it relies on are present and compatible. Nothing was imported or run on 1.6.1, so that route is unverified in practice; the branch above is the supported route.
ExLlamaV3 runs the text path only: image and video input are not supported or measured by this runtime. The fidelity measurements on this card were taken on an equivalent development branch of the loader (library code identical apart from comments and one error-message string); the plain generation measurements on minicpm-v4.7 (commit 4d083d25c1a3) and the drafted ones on minicpm-v4.7-dspark (commit 5ddae7d12448).
The source checkpoint has structurally dead expert channels (see above); they are reproduced, not repaired.
KL and perplexity are proxies; no benchmark accuracy numbers are claimed here.

How to load

Use the minicpm-v4.7 branch of exllamav3-r0b0t (commit 4d083d25c1a3, ExLlamaV3 v1.5.0 base) for plain decoding, or its minicpm-v4.7-dspark branch (commit 5ddae7d12448) to attach the DSpark draft as well. Both add MiniCPM-V-4.7 text-path support (so the architecture is registered there), DSpark draft quantisation, and opt-in Hessian dump / outlier retry to convert.py. They load the text path only (Config.from_directory, Model.from_config, load, Generator; eval/ppl.py works); the vision tower is stored unquantised in bf16 and not run. The end-to-end serving setup (click-run, OpenAI-compatible server, drafted-versus-plain parity check) is in the serving repository at v2.1.1.

from exllamav3 import Config, Model, Cache, Tokenizer, Generator

config = Config.from_directory("<path-to-this-repository>")
model = Model.from_config(config)
cache = Cache(model, max_num_tokens = 16384)
model.load(progressbar = True)
tokenizer = Tokenizer.from_config(config)
generator = Generator(model = model, cache = cache, tokenizer = tokenizer)

# ChatML as rendered by the bundled chat_template.jinja; thinking is on by default (the prompt ends with "<think>\n")
prompt = "<|im_start|>user\nWhy is the sky blue?<|im_end|>\n<|im_start|>assistant\n<think>\n"
print(generator.generate(
    prompt = prompt,
    stop_conditions = [tokenizer.eos_token_id, "<|im_end|>"],
    max_new_tokens = 512,
    completion_only = True,
    add_bos = False,
))

To use another ExLlamaV3 checkout instead, add the shim: copy support/exllamav3/minicpmv4_7.py into exllamav3/architecture/ and register MiniCPMV4_7Model in exllamav3/architecture/architectures.py (3 steps, see support/exllamav3/README.md). Perplexity check with the branch: python eval/ppl.py -m <path-to-this-repository>.

The chat template is the upstream one (chat_template.jinja, unmodified; enable_thinking=false renders <think>\n\n</think>\n\n). Recommended sampling from the upstream generation_config.json: temperature 1.0, top-k 20, top-p 0.95.

Files

file	bytes	content
`model-00001-of-00008.safetensors`	4,242,152,212	EXL3 weights shard
`model-00002-of-00008.safetensors`	3,872,221,415	EXL3 weights shard
`model-00003-of-00008.safetensors`	3,865,616,258	EXL3 weights shard
`model-00004-of-00008.safetensors`	3,872,236,945	EXL3 weights shard
`model-00005-of-00008.safetensors`	3,865,616,258	EXL3 weights shard
`model-00006-of-00008.safetensors`	3,872,236,945	EXL3 weights shard
`model-00007-of-00008.safetensors`	4,292,015,100	EXL3 weights shard
`model-00008-of-00008.safetensors`	414,882,767	EXL3 weights shard
`CONVERT.md`	2,363	conversion command, settings, hardware, wall-clock
`LICENSE`	11,358	Apache License 2.0
`NOTICE`	2,461	attribution and statement of modifications
`calibration.json`	78	calibration composition (machine readable)
`calibration.md`	674	calibration data description
`chat_template.jinja`	7,250	chat template (upstream)
`config.json`	3,951	model configuration (upstream values plus the converter's quantization_config block)
`exl3_retry_log.json`	344	converter outlier-retry log (0 matrices re-encoded)
`generation_config.json`	186	default sampling settings (upstream)
`kl.json`	257,804	KL / top-k / perplexity measurements (machine readable)
`model.safetensors.index.json`	13,450,633	shard index
`preprocessor_config.json`	148	image preprocessor settings (upstream)
`processor_config.json`	2	processor settings (upstream)
`quantization_config.json`	40,377,713	EXL3 storage description of every tensor
`rel_l2_scan.json`	34,848	weight-space error scan summary
`support/exllamav3/README.md`	739	shim installation (3 steps)
`support/exllamav3/minicpmv4_7.py`	4,185	ExLlamaV3 architecture shim (MIT)
`tokenizer.json`	20,001,935	tokenizer (upstream)
`tokenizer_config.json`	8,976	tokenizer settings (upstream)
`README.md`	(this file)	this model card
`UPLOAD_MANIFEST.json`	-	every file with size and sha256

SHA-256

UPLOAD_MANIFEST.json lists every file with size and sha256. The same digests for the weight shards and metadata (verify with sha256sum -c after saving the block as a file):

26626068500d467023b97ec612c38ef947d2722af8e3922f6be955d18b2157e8  CONVERT.md
cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE
ed07481f528bf4c7684fb7b9ae2fbebe4d15bd569fb81887010a6f51057d36be  NOTICE
08d231bb0567634dc9c2e6a1a11a74a060813d5a898b5c7b6f1f0a9c63019999  calibration.json
acbf9851e6f0aee2d8dc5e029394832f3c27a5f8fc017c7ce920653ab7410231  calibration.md
c4531cacbf2a0ab65170433d7a4f371d11b7599cf96c04b192e6372432636c70  chat_template.jinja
b332cdb7ca068987fb6c74e42aef874cd9821b3ca89d3556b1e31a4469be72b0  config.json
9fb40e5040359991f6c75e6c48b3a294bf34b29569539c23029b758c11b13668  exl3_retry_log.json
7fa47217744f0e0918f6cf846e7541e4f322e6bc66917044cf2ad580699216c8  generation_config.json
bade72091336291f959d7ae65629ddec1d5c478a14165a6b236aa89614871b01  kl.json
e35037215430c76bbd841a5f39ebe6f5759b421909f29faa90f4dd3119a964b7  model-00001-of-00008.safetensors
165c85ab89c74950842728ca8122894301ffbc90d8155b1b3ebc915e93836674  model-00002-of-00008.safetensors
a1ba7fca2d96d71c4c82cd1db909caaf52eb9b9840eec9ab779e5f236e8459bc  model-00003-of-00008.safetensors
0c6743519751398d1088f7f501147760f04a9789162db017aa5429e4d77d867f  model-00004-of-00008.safetensors
eb197338fb6838cd8740174f804ccdd669cc68ddd2ba8d9e4dc878cd84c6d3b1  model-00005-of-00008.safetensors
aff890e36675821474595ad28b7e9d9556d2cf7f56e66746f2637fedf61b6767  model-00006-of-00008.safetensors
8bb73fb2bd4ce673695cb4bc889c6d2c948d0e69f5ff88c327295d7003fb880f  model-00007-of-00008.safetensors
8ef5f1cd7b36bbc4d428c7e700843fabbe1bfa72d724dd08427cfaa2e4926ce9  model-00008-of-00008.safetensors
a621148b7afc205069c98cdb9fb956363a49ed05dd519f40bf4865dd7acdc92c  model.safetensors.index.json
c64289d04f36e48d9d059e3a0069f54062b2ef6044a807adb448b98449cb54de  preprocessor_config.json
44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a  processor_config.json
5ea9d03ecdba23a7f9917c9e553d5737dda9cc32e553b6e437db005e87310941  quantization_config.json
05fa68ca0a0efd391af1d98b72200abad2fca0d49cf9511246a91cada38ec0f9  rel_l2_scan.json
e96742dbc5e4a82caf1ca0f4a210bfeee2daf54b7b55c08574c3a45584826342  support/exllamav3/README.md
6cc291bc2803cdcb4d29521f99811ff2913141c3aa9fb96f13c2d11aaf5eb81d  support/exllamav3/minicpmv4_7.py
e4608c5d7b3f4f30ba83be16a82cdac856b2e7191d40f0a08cbacc76c2a926ee  tokenizer.json
03c8faa31145d89c815b86dffc9aa7fa732ebebb5cb1a47b1663c17d0477eab9  tokenizer_config.json

License

Apache License 2.0, inherited from the base model (openbmb/MiniCPM-V-4.7-35B-A3B); see LICENSE and NOTICE for the attribution and the statement of modifications. support/exllamav3/minicpmv4_7.py is MIT licensed (derived from ExLlamaV3, Copyright (c) 2025 Turboderp).

Thanks to OpenBMB for the model, to turboderp for ExLlamaV3 and the EXL3 format, and to the Qwen team for the backbone architecture. The limitations and disclaimer of the upstream model card apply.

r0b0tlab/MiniCPM-V-4.7-35B-A3B-EXL3-6.08bpw