Glossary

Definitions

bytes¶

File space, in binary units — 1 KiB is 1024 B, because a byte offset in a file is literally what this is. Model cards usually quote decimal GB, about 7% larger at that scale, which is enough to make two correct numbers look like they disagree. Bytes × 8 ÷ parameters is the real cost per weight.

changed weights¶

Share of compared pairs where B differs from A at all — exact inequality, not "differs by more than ε". A threshold would need a scale and the right scale differs per tensor, so the honest question is the plain one. Expect it well below 100% on real lineage: a quantize/dequantize round trip leaves many weights bit-identical, and a merged LoRA leaves most of the tensor untouched.

column norm p99 ÷ p50¶

Row norm p99 ÷ p50 read down the other axis, and worth having both because a scale convention has to choose one. It is omitted entirely when only part of a large tensor was read, rather than estimated: a column norm needs every row, so from a sample it would be a confident-looking guess.

comparable¶

Tensors that both sides reduce to the same logical shape — the only sense in which "the same tensor" has two versions, and therefore the only rows you can open. It is the count that decides how much of this comparison is actually available, which is why it is stated rather than left to be inferred from the others.

cosine¶

Which way B points relative to A: ⟨A,B⟩ ÷ (‖A‖·‖B‖). 1.0 is exactly the same direction, 0 is unrelated, −1 is opposite. It is scale-invariant on purpose, and that is what makes it worth reading beside σ(A) and σ(B): a cosine of 1.0 next to a large relF means somebody multiplied the tensor and changed nothing at all about what it points at. A finetune that only rescaled has learned nothing; a quantization round trip that rescaled has a scale-convention bug. Cosine cannot see size, by design — the two σ are what see it.

delta participation¶

How much of the tensor did the moving, as a fraction of it. 1.0 means every weight shifted by about the same amount. ⅓ is what an ordinary Gaussian change gives. 0.02 means the movement's mass sits in roughly 2% of the weights and the other 98% barely stirred — and that last case is the common one for a finetune, which is a genuinely odd fact about how finetuning works: a model can be meaningfully changed by moving almost none of it. Arithmetically it is (Σd²)² ÷ (n·Σd⁴), the normalized participation ratio borrowed from localization physics, and it is scale-invariant — so it is independent of relF rather than a restatement of it. relF says how far; this says how much of the tensor went along.

dequantized¶

A tensor present in both repos, where A was packed and B is plain floats — the reverse of quantized. Rarer, and more interesting when it turns up, because unpacking cannot recover what packing discarded: the file grew back and the information did not.

dtype¶

How each number is written in the file. F32 is a 32-bit float; BF16 is 16 bits with the same exponent range and fewer significant digits; U8 is a single unsigned byte. It fixes the file's size and the precision the file can hold — but it is not the model's precision. A quantized repo stores packed integers in a U8 or U32 tensor and rebuilds the weights from separate scale and bias planes, so U8 there means "packed", not "8-bit weights".

dtype changed¶

A tensor present in both repos, with the same shape, but stored as a different numeric type — an F32 checkpoint republished as BF16, say. The values may be identical to within the narrower type's precision, or not. This counts the re-encoding, not its effect.

effective bits per weight¶

Bytes × 8 ÷ parameters — what one weight actually costs, all overhead included. A "4-bit" model is never 4 bits. Every group of weights also stores a scale and a bias, each a 16-bit number. Spread across a group of 32 that is half a bit per weight apiece, so 4-bit at group 32 costs 5.00 — and at the group 64 most repos actually use, 4.50. This is the number to compare across repos, because it is the one whose definition nobody gets to choose.

How TensorLens treats the Hub¶

This tool is a reader. It never downloads a model, never walks a repo looking for more, and never fetches a tensor you did not click — a whole inventory is a couple of small reads of the file's index, and opening one tensor fetches only that tensor's bytes. That restraint is the deal: Hugging Face serves these files to everyone for free, and a viewer that hammered them would deserve to be blocked. Everything runs in this browser tab and talks only to Hugging Face — there is nowhere else for it to send anything. Public repos only. What a model is made of is also kept in this browser after the first look, so returning to a model you have already opened costs the Hub nothing at all. Only the index is kept, never the weights, and it is keyed to an exact commit so it can never show you a stale one. Best effort: if the browser will not store it, everything simply works as it did before.

identical¶

A tensor with the same name, the same dtype and the same shape in both repos. That is a statement about headers only: the weights inside can differ completely and this count will not notice. Open the tensor to compare the actual numbers.

kurtosis¶

How heavy the tails are: E[w⁴] ÷ E[w²]², about zero. A normal distribution sits at 3. Higher means the same total is concentrated in fewer, larger values — a compact way of saying "this tensor has outliers", and the exact condition under which min/max ranging and a single per-tensor scale fail.

largest single edit¶

max |B − A|: the biggest change made to any one weight. Beside the delta's σ it separates a change built from many small edits from one dominated by a few large ones. When only part of a large tensor was read it is a floor rather than a maximum — and for a comparison whose subject is often a handful of edited weights, that understatement is the one most worth knowing about.

max |w|¶

The single largest magnitude present. It matters out of all proportion to being one number: any per-tensor scale has to stretch far enough to represent it, so one extreme value decides how many usable levels the other million get. That is the mechanism behind most quantization damage. When a tensor is too large to read whole and only some of its rows were fetched, this is a floor, not a maximum — the largest value in a sample can only understate the largest value in the tensor.

mean¶

The plain average, sign kept. Near zero is the expected reading for weights, and for the delta between two versions of a tensor it is the more interesting one — a clearly non-zero mean is a systematic push in one direction, which an about-zero σ cannot see.

mean |change|¶

The average size of an edit, ignoring sign. Held against the mean change it says whether the edits pushed one way or cancelled out: much larger than |mean change| means the movement was two-sided.

mean |w|¶

The average distance of a weight from zero, ignoring sign. On its own it is unremarkable; against σ it is a free tail detector. A Gaussian gives mean |w| ≈ 0.8σ. Much below that and most weights sit near zero while a handful of large ones own the total — the condition under which one scale cannot serve both groups.

mean change¶

The average of B − A, sign kept. Near zero means the edits pushed both ways and cancelled. A clearly non-zero value is a systematic bias in the change — an added offset, or a rescale — and it is invisible to an about-zero σ, which is why it gets its own line.

non-finite values¶

Elements that were NaN or ±Infinity. They are excluded from every statistic here and counted rather than quietly dropped, because the count is the finding: a released checkpoint carrying non-finite weights has something wrong upstream — a diverged run, a bad conversion — and no statistic computed over the rest of the tensor would ever mention it.

only in A¶

A tensor name present in the first repo and absent from the second — a dropped bias, a fused pair of projections, a different naming convention for the same thing. A handful is ordinary. Hundreds means these two are not versions of each other.

only in B¶

A tensor name the second repo has and the first does not — an added adapter, a newly split projection, or the packing metadata a quantization brings with it. As with only in A, a handful is ordinary and hundreds is a verdict.

p₀¶

The share of weights a ternary code sends to exactly zero. Always read it beside relF: relF is norm-relative, so a scale that reproduces one big outlier faithfully can score a better relF than a sensible one while deleting most of the tensor. A p₀ near 90% next to a flattering relF is that failure, caught in the act.

parameters¶

How many individual numbers this holds — the product of its dimensions. These are the values the model learned; every other statistic here is a description of them. It is also the denominator of bits-per-weight, which is how a repo can shed two thirds of its bytes without losing a single parameter.

quantized¶

A tensor present in both repos, where B stores in packed form what A stored as plain floats. This is the count that says "B is a compression of A" rather than "B is a different model" — and it is the reason a repo pair can lose most of its bytes while keeping every parameter.

relF¶

Relative Frobenius change: ‖B − A‖ ÷ ‖A‖ — the size of the change as a fraction of what was there before. (The Frobenius norm is the square root of the sum of every element squared: a matrix's version of a vector's length.) One number, and that is exactly its limit — it cannot tell a change spread thinly over every weight from one concentrated in a handful, because both score the same whenever the totals match. It is never shown alone here. Its companion is delta participation when comparing two repos, and p₀ in the ternary what-if table; without one of those, relF will happily rate a setting that reproduced an outlier and deleted everything else as the better one.

row norm p99 ÷ p50¶

The 99th-percentile row length divided by the median row length. In an evenly balanced matrix this is near 1. In real transformer weights it is routinely 8, often 50, sometimes far more — a handful of rows thousands of times larger than their neighbours. This is why naive quantization destroys models. A scale wide enough for the hot rows rounds every median row to zero; a scale that fits the median clips the hot ones. There is no single number that serves both, which is why finer granularity — per-group or per-row scales — is the first fix, before any argument about conventions.

shape¶

The tensor's dimensions. A 4096 × 11008 weight matrix is 4096 rows of 11008 numbers each. Shape is also what decides whether two tensors can be compared at all: a matching name with a different shape is a lineage mismatch, not two versions of one weight, so it is reported rather than truncated to fit.

shape changed¶

A tensor with the same name in both repos and different dimensions — a resized vocabulary, a different hidden size, a merge that altered the architecture. There is no honest way to compare the numbers across a shape change, so those rows are listed but not openable.

share of bytes¶

What fraction of a repo's weight bytes one dtype accounts for. It is how a "4-bit" repo admits how much of itself is not 4-bit: embeddings, norms and the output head are routinely left at full precision, and on a small model the embedding alone can be a quarter of the file.

sparsity¶

Share of values that are exactly 0.0 — exact comparison, not "close to zero". A densely trained tensor is usually near 0%. A large number here means something deliberately zeroed weights: pruning, a structured mask, or a quantization that collapsed a whole range onto zero. Which of the three it was, the weight distribution will tell you.

status¶

Which way a tensor's header differs between the two repos being compared, where A is the first repo and B the second. Always spelled out in words and never carried by colour alone — and always about the header: two tensors can agree on name, dtype and shape and still hold entirely different numbers.

tensors¶

How many separate arrays the repo stores. It is not a measure of size, and it can move the wrong way: a quantized repo has more tensors than the model it came from, because every packed weight travels with its own scale and bias planes. Those triples are folded back into one logical tensor before anything here is counted or diffed — otherwise a 4-bit version of a 24-layer model reads as hundreds of unrelated additions.

ternary scale¶

The single multiplier a ternary code uses: every weight becomes −s, 0 or +s. All three conventions produce those same three levels and differ only in how they pick s — so the choice of scale, not the code, is where the error comes from.

unchanged weights¶

Share of compared pairs where B is bit-identical to A — the complement of changed weights, counted rather than subtracted from 1. A high number is not evidence that nothing happened: delta participation and the delta's own distribution are where you find out whether the weights that did move were the ones that mattered.

σ (RMS)¶

The typical size of a value in the tensor: the square root of the mean of the squares, taken about zero rather than about the mean. Weight tensors sit almost exactly on zero by construction, and every quantization scale is derived in the about-zero convention, so this σ is directly comparable to the scale a quantizer would pick. Read it beside mean |w|: a bell curve gives mean |w| ≈ 0.8σ, and a much smaller ratio means the total is being carried by a few large values rather than by the bulk.

σ of the change¶

The typical size of one weight's edit, in the same units as the weights themselves. Where relF is relative, this is absolute — which is the reading that survives when ‖A‖ is zero and relF cannot be defined at all.

σ(B) ÷ σ(A)¶

How much bigger or smaller B is than A overall; 1.0 means the same size, whatever else changed. This is the half of the reading that cosine deliberately cannot supply — together they separate "B points somewhere else" from "B is A, doubled".