Weightprint

Model cards on the Hugging Face Hub declare a parent: this model is a fine-tune, a quantization, a merge or an adapter of that one. Weightprint checks the claim against the weights. For 120,976 models whose declared parent could be read, it compared the two tensor by tensor and recorded what the child measures as, and which parts of it changed.

It also lists 155,769 repos whose weight files are byte-for-byte identical to another repo's.

Browse it at weightprint.ifsp.dev (also as a Space). Census of 2026-10-11 (Hub metadata and weights as of that day).

Quick start

from datasets import load_dataset

pairs = load_dataset("tardellirs/weightprint", "pairs", split="train")
copies = load_dataset("tardellirs/weightprint", "copies", split="train")

import duckdb

# declared fine-tunes, by what their weights show
duckdb.sql("""
    SELECT verdict, count(*) AS n
    FROM 'hf://datasets/tardellirs/weightprint/pairs.parquet'
    WHERE declared = 'finetune'
    GROUP BY 1 ORDER BY 2 DESC
""").show()

Tables

pairs: one row per model, measured against its declared parent

Column	Type	Meaning
model_id	string	The model (the child)
parent_id	string	The parent its card declares (base_model)
declared	string	What the card says it is: finetune, quantized, merge or adapter
verdict	string	What the weights measure as (below)
subset	bool	The two models share only part of their tensors (one holds a subset of the other's), and the verdict is about the shared part
tensors_changed	int	Tensors whose values changed
tensors_compared	int	Tensors compared
{part}_changed, {part}_tensors	int	The same two counts per part of the model: attention, mlp, norms, embeddings, lm_head, other
summary	string	The verdict in one or two sentences
downloads_30d	int	The child's downloads in the 30 days before the census

Verdicts

Verdict	Meaning	Models
identical	The same files, byte for byte	791
same_weights_repacked	The same weights, re-saved, re-sharded or with new metadata	1,031
same_weights_converted	The same weights in another dtype (BF16, F16, F32) or format	28,704
quantization	A quantization of the same weights (GGUF, MLX, bitsandbytes, FP8…), within that format's error	49,312
full_finetune	Nearly every tensor changed	19,322
partial_finetune	Some parts changed and others didn't, in a way that isn't LoRA-style	3,709
lora_merge	LoRA-style: only the attention and MLP matrices changed; norms, biases and embeddings didn't	8,385
abliterated	Only the matrices that write to the residual stream changed (attention output, MLP down projection, sometimes the embeddings): the signature of an abliteration	1,630
moe_from_dense	A mixture of experts whose experts are copies of dense models' MLPs	124
adapter	The child is an adapter (LoRA weights), not a full model	3,897
different_architecture	Tensor names or shapes don't line up, so the two can't be compared	2,013
not_compared	A format or repo layout the engine can't compare yet	2,058

copies: repos with byte-identical weight files

Column	Type	Meaning
model_id	string	A repo in a group
fingerprint	string	Hash of the group's weight files; repos with the same fingerprint hold the same bytes
group_size	int	Repos in the group
bytes	int	Size of one copy's weight files
group_most_downloaded	string	The group's most downloaded repo
group_downloads_30d	int	Downloads of the whole group in the 30 days before the census

Only repos whose fingerprint covers all of their top-level safetensors files, 10 MB or more, are included.

Methodology

Weightprint never downloads a model. For each weight file it reads the header (tensor names, shapes and types) and a 128-byte sample of every tensor, through HTTP range requests to the Hub's CDN: a few hundred kilobytes per model.

• Tensors are matched by name. GGUF and original checkpoints are renamed to the transformers layout first.
• Samples are compared as numbers, so the same weights stored as BF16, F16 or F32 count as the same. A quantized tensor counts as the same weights when it differs from its source by no more than that quantization's error.
• The verdict comes from which tensors changed: all of them is a full fine-tune; only the attention and MLP matrices, with norms, embeddings and biases untouched, is LoRA-style; only the attention output and MLP down projections (the matrices that write to the residual stream) is an abliteration.

How accurate it is. On declared quantizations whose name matches their parent's, where the right answer is "the same weights", the verdict agrees 96.5% of the time (59,203 of 61,362). Most misses are real differences: the parent was updated after the quant was made, or the card names a different parent. The other verdicts have no such ground truth.

Limits

• A sample per tensor can miss a change confined to rows it didn't read.
• "LoRA-style" fits a merged LoRA, and also a fine-tune with the norms and embeddings frozen. The two can't be told apart.
• Repos with several components (diffusion pipelines) are compared on their largest weight file; "the same weights" needs every file, so on those repos it becomes not_compared.
• GPTQ and AWQ quantizations aren't compared tensor by tensor. NVFP4, stacked GGUF experts and some MLX and FP8 layouts can't be compared yet (not_compared).
• "Declared" is what the model card says. A mismatch can be a card that names the base model instead of the model it was made from.
• It says what two sets of weights measure as, not which came first or who made them.

Source and license

• Source: the Hugging Face Hub (model metadata and weight files, read through the public API and CDN).
• License: Apache 2.0.
• Weightprint is an independent project and is not affiliated with Hugging Face.

Citation

@misc{stekel2026weightprint,
  author       = {Stekel, Tardelli},
  title        = {Weightprint: What Hugging Face Models Are, Measured from Their Weights},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/tardellirs/weightprint}}
}

Contact

Made by Tardelli Stekel (@tardellirs · stekel.ifsp.dev). If a verdict on a model you know looks wrong, say so in the Community tab: every report gets checked against the engine.