The dataset behind a measurement study of storage and download demand on the Hugging Face Hub. It describes every public model and dataset repository the Hub listed on 2026-09-01: how many bytes each stores, how often it is downloaded (daily, since 2025-02-28), and what it contains, with the semantic attributes the Hub does not record inferred from the repositories' own files by an LLM agent: a dataset's modality, provenance and lineage, and a model's derivation from other models.

Three files, two grains. A repository is one row in models.parquet or datasets.parquet; its daily download history is a run of rows in downloads.parquet. Join on hub_id, the Hub's immutable repository id, never on the name.

file	one row per	rows	size
`models.parquet`	model repository	3,034,516	179 MB
`datasets.parquet`	dataset repository	1,028,803	114 MB
`downloads.parquet`	repository x day its download counter moved	175,028,119	909 MB

All three are plain zstd-compressed Parquet, readable by DuckDB, pandas, polars, Spark and the datasets library. Nested columns (tags, file_formats, parquet_contents) are Parquet lists; DuckDB reads them natively, pandas gets Python lists.

-- DuckDB: bytes by modality for the labeled datasets
SELECT unnest(modalities) AS modality, sum(current_bytes) / 1e15 AS PB
FROM 'datasets.parquet' WHERE in_label_scope GROUP BY 1 ORDER BY 2 DESC;

-- daily downloads of one repository, rename-proof
SELECT date, downloads_delta FROM 'downloads.parquet'
WHERE hub_id = (SELECT hub_id FROM 'models.parquet' WHERE repo_id = 'openai/whisper-large-v3')
ORDER BY date;

Provenance and cut

Snapshot. Repository metadata comes from the public daily export of the Hub's listing, cfahlgren1/hub-stats, mirrored one snapshot per UTC day. The repository tables are the 2026-09-01 snapshot; the download ledger is cut at 2026-08-31, the last day that snapshot observes.
Downloads. The ledger diffs the Hub's cumulative downloadsAllTime counter between consecutive snapshots. That counter exists since 2025-02-27, so daily series start on 2025-02-28 (datasets a few days later, when the first non-stale export appeared) and run to 2026-08-31. A download is a file-resolve request, not a full repository transfer or a unique user.
Storage. retained_bytes and current_bytes for models come from one Hub API call per repository (2026-07-17 to 2026-09-09); the dataset current_bytes is the snapshot's own mainSize, and dataset retained_bytes comes from the same crawl. Retained size is the Hub's per-repository accounting and does not reflect backend deduplication.
Labels. Dataset modality, provenance and lineage are labeled for every dataset of at least 10 GB (in_label_scope), which hold 98.5% of dataset bytes; smaller datasets carry only the Hub's own tags and the Parquet-conversion schema. For each labeled dataset an LLM agent inspected the files directly (directory listings, format-header range reads, bounded samples); cheaper layers (the conversion schema, an LLM reading of the README) remain as fallbacks for gated repositories and the few the agent left undecided. Model lineage is inferred for every model by a cascade from declared metadata through file structure, configs and README reading to the same kind of agent. Every label keeps its deciding *_method, a *_confidence tier and the labeler's one-line *_reason. Validation against adjudicated reference sets and replays under other model families is reported in the paper.

`models.parquet`

column	type	meaning
`hub_id`	`VARCHAR`	Immutable Hub repository id. Stable across renames; the join key to `downloads.parquet`.
`repo_id`	`VARCHAR`	Repository name `owner/name` at the snapshot.
`author`	`VARCHAR`	Owner (user or organization) at the snapshot.
`created_at`	`DATE`	Repository creation date.
`last_modified`	`TIMESTAMP`	Last commit time at the snapshot.
`likes`	`BIGINT`	Hub likes at the snapshot.
`downloads_30d`	`BIGINT`	The Hub's rolling 30-day download counter at the snapshot.
`downloads_all_time`	`BIGINT`	The Hub's cumulative download counter at the snapshot (file-resolve requests).
`pipeline_tag`	`VARCHAR`	Declared task (`pipeline_tag`).
`library_name`	`VARCHAR`	Declared library.
`tags`	`VARCHAR[]`	The raw Hub tag array (`license:`, `base_model:`, `arxiv:`, `dataset:`, ...).
`licenses`	`VARCHAR[]`	The `license:` tag values.
`declared_relation`	`VARCHAR`	Relation the card declares to its base model(s) (Hub `baseModels`): finetune, adapter, quantized, merge.
`declared_bases`	`STRUCT(hub_id VARCHAR, repo_id VARCHAR)[]`	The declared base models as the Hub resolved them: `hub_id`, and the name at declaration, which a later rename can leave stale (join on `hub_id`).
`n_files`	`BIGINT`	Files at the tip of `main`.
`params`	`BIGINT`	Parameter count from the safetensors or GGUF header the Hub parsed; NULL for other formats.
`weight_format`	`VARCHAR`	Container of the shipped weights, first match: safetensors, gguf, bin, torch, legacy, none.
`is_adapter`	`BOOLEAN`	Ships a PEFT `adapter_model*` payload (a delta against a base model) rather than full weights.
`gguf_quant_types`	`VARCHAR[]`	Distinct quantization types in the repository's `.gguf` file names, lower-case and sorted (`q4_k_m`, `iq2_xs`, `f16`, ...); empty when no name carries one, NULL without `.gguf` files.
`retained_bytes`	`BIGINT`	Bytes the repository retains across all revisions and branches (Hub `usedStorage`; per-repository accounting, no cross-repository deduplication).
`current_bytes`	`BIGINT`	Sum of file sizes at the tip of `main`.
`storage_measured_at`	`DATE`	Date the two sizes were crawled.
`lineage_relation`	`VARCHAR`	Derivation relation after the inference cascade: finetune, adapter, quantized, merge, copy, derived, base, original, undocumented, placeholder, unknown.
`lineage_method`	`VARCHAR`	The cascade layer that decided the relation (see Class vocabularies).
`lineage_confidence`	`VARCHAR`	declared, deterministic, high, medium, low, declared-dangling; NULL when undecided.
`parent_repo_id`	`VARCHAR`	The parent (base) repository named.
`parent_hub_id`	`VARCHAR`	The parent's `hub_id` when it resolves to a repository in the snapshot.
`parent_resolved`	`BOOLEAN`	Whether the named parent exists in the snapshot.
`has_weights`	`BOOLEAN`	Ships at least one weight file.
`has_readme`	`BOOLEAN`	Has a model card.
`architecture`	`VARCHAR`	Model family (`model_type`, timm name, LeRobot policy type or diffusers pipeline class); NULL when no layer knew.
`architecture_method`	`VARCHAR`	Layer that decided it: config, gguf, crawled-config, crawled-arch, crawled-type, diffusers-tag, inherited, none.
`is_checkpoint_repo`	`BOOLEAN`	Verified checkpoint repository: retained >= 100x current bytes and direct evidence in its history (verified 2026-08-13 by name, matched here by `hub_id`, so renamed repositories keep the flag).
`checkpoint_evidence`	`VARCHAR`	Evidence that confirmed it: titles (step/epoch counters in commit titles), branches (one branch per checkpoint), weights and/or paths (weight files rewritten between commits).
`checkpoint_versions`	`INTEGER`	Checkpoint versions its history was grouped into.
`checkpoint_version_method`	`VARCHAR`	How commits were grouped into versions: counters, branches, bursts, commits.
`checkpoint_median_gap_s`	`DOUBLE`	Median seconds between consecutive versions.
`n_commits`	`INTEGER`	Commits on `main` (checkpoint repositories only).
`n_branches`	`INTEGER`	Branches (checkpoint repositories only).

`datasets.parquet`

column	type	meaning
`hub_id`	`VARCHAR`	Immutable Hub repository id. Stable across renames; the join key to `downloads.parquet`.
`repo_id`	`VARCHAR`	Repository name `owner/name` at the snapshot.
`author`	`VARCHAR`	Owner (user or organization) at the snapshot.
`created_at`	`DATE`	Repository creation date.
`last_modified`	`TIMESTAMP`	Last commit time at the snapshot.
`likes`	`BIGINT`	Hub likes at the snapshot.
`downloads_30d`	`BIGINT`	The Hub's rolling 30-day download counter at the snapshot.
`downloads_all_time`	`BIGINT`	The Hub's cumulative download counter at the snapshot (file-resolve requests).
`gated`	`VARCHAR`	Access gating: auto (accept terms), manual (owner approves), or false.
`tags`	`VARCHAR[]`	The raw Hub tag array (`task_categories:`, `modality:`, `size_categories:`, `license:`, `language:`, `library:`, `format:`, `arxiv:`, free-form tags, ...).
`licenses`	`VARCHAR[]`	The `license:` tag values.
`task_categories`	`VARCHAR[]`	Declared tasks (`task_categories:` tags).
`declared_modalities`	`VARCHAR[]`	The Hub's own `modality:` tags, as declared or auto-derived by the Hub. Not the labels this study uses; compare with `modalities`.
`declared_size_category`	`VARCHAR`	Declared row-count bucket (`size_categories:` tag), e.g. `10K<n<100K`.
`current_bytes`	`BIGINT`	Bytes at the tip of `main` as reported in the snapshot (`mainSize`); the study's dataset storage measure.
`retained_bytes`	`BIGINT`	Bytes retained across all revisions and branches (Hub `usedStorage`, from the storage crawl; per-repository accounting, no cross-repository deduplication).
`storage_measured_at`	`DATE`	Date `retained_bytes` was crawled.
`info_status`	`VARCHAR`	Outcome of the datasets-server `/info` call: success, no_info (no Parquet conversion), gone, failed.
`schema_json`	`VARCHAR`	Typed column schema of the Hub's automatic Parquet conversion, one entry per distinct config schema: `[{config, n_alike, columns: [[name, type], ...]}]`.
`n_configs`	`INTEGER`	Configs (subsets) the conversion exposes.
`schema_modalities`	`VARCHAR[]`	Modalities read off the schema alone (typed `Image`/`Audio`/`Video` features, media-named pointer columns; all-numeric schemas give `tabular`). One input to the labels below.
`in_label_scope`	`BOOLEAN`	`current_bytes` >= 10 GB: the scope the study labels. Label columns are NULL outside it.
`modalities`	`VARCHAR[]`	Modalities of the stored data: text, image, video, audio, 3d, document, tabular, geospatial. Empty for repositories that hold no dataset (`modality_method = not_dataset`).
`n_modalities`	`INTEGER`	Length of `modalities`.
`modality_method`	`VARCHAR`	Deciding layer: agent, schema, llm_readme, not_dataset, gated, empty, none.
`modality_confidence`	`VARCHAR`	high, medium, low; NULL when structural or undecided.
`modality_reason`	`VARCHAR`	The labeler's one-line justification.
`source_decision`	`VARCHAR`	Provenance outcome: labeled, not_dataset, unknown, undecided.
`sources`	`VARCHAR[]`	Every provenance class present: found, human, model, sensor, sim.
`primary_source`	`VARCHAR`	The bytes-dominant provenance class; the study's single-class provenance label.
`source_method`	`VARCHAR`	Deciding layer: agent, llm_readme, tags, empty, none.
`source_confidence`	`VARCHAR`	high, medium, low.
`source_reason`	`VARCHAR`	The labeler's one-line justification.
`lineage_relation`	`VARCHAR`	Relation to parent datasets: original, copy, filter, merge, reencode, derived, unclear.
`lineage_parents`	`VARCHAR[]`	Parent datasets named (Hub `owner/name` where the parent is on the Hub, otherwise a name).
`reconstructible`	`VARCHAR`	Whether the content could be rebuilt from its parents: full, full_compute, partial, none, unknown.
`lineage_method`	`VARCHAR`	Deciding layer: agent, llm_readme.
`lineage_confidence`	`VARCHAR`	high, medium, low.
`lineage_reason`	`VARCHAR`	The labeler's one-line justification.
`file_formats`	`STRUCT(ext VARCHAR, files BIGINT, bytes BIGINT)[]`	Bytes and file count at the tip of `main` per file extension (lower-case, no dot; `gitattributes` etc. for dotfiles), largest first.
`parquet_contents`	`STRUCT(cls VARCHAR, bytes BIGINT)[]`	For the Parquet files: bytes per column content class (text, numeric, image, audio, video, document, 3d, unclassified), from the column chunks of each file's footer, largest first.

`downloads.parquet`

Row semantics: a row means the repository's all-time counter moved. No row for a date means zero downloads that day (zero-delta rows are omitted); use a repository's first and last row to tell zero from "did not exist yet". A repository's first row has is_first_seen = true and a NULL delta, because its counter at that point cannot be attributed to days; repositories that already existed in the first usable snapshot (2025-02-27) have no first-seen row. span_days > 1 marks stretches where the upstream export was skipped or stale, or the repository was temporarily hidden; the delta covers the whole span. Negative deltas are Hub-side counter corrections kept as-is; they cancel against neighboring rows, so sums over a week or more are reliable. The ledger balances for every repository: first observed downloads_total plus all later deltas equals the last downloads_total. Rows are sorted by (kind, repo_id, date), so engines with row-group pruning answer single-repository queries by reading a few MB. The ledger keeps repositories that were deleted before the cut; those have no row in the repository tables. Conversely a repository whose counter never moved in the window (most of them never-downloaded placeholders created before it) has a row in the repository tables but none here.

column	type	meaning
`kind`	`VARCHAR`	`model` or `dataset`: which table the repository belongs to.
`hub_id`	`VARCHAR`	Immutable Hub repository id; join key to the repository tables.
`repo_id`	`VARCHAR`	Repository name as of that date; changes on rename, so group by `hub_id` for continuity.
`date`	`DATE`	UTC date of the snapshot the observation comes from.
`downloads_delta`	`BIGINT`	Downloads accumulated since the previous observation (NULL on a repository's first row).
`span_days`	`INTEGER`	Days since the previous observation, usually 1; the delta covers this whole span (NULL on the first row).
`is_first_seen`	`BOOLEAN`	True on a repository's first appearance in the snapshots.
`downloads_total`	`BIGINT`	The Hub's cumulative all-time counter on that date.
`downloads_30d`	`BIGINT`	The Hub's rolling 30-day counter on that date.
`created_at`	`DATE`	Repository creation date.

Class vocabularies

Model lineage_relation. finetune, adapter, quantized, merge are derivation relations to a parent; copy is a re-upload of another repository's weights; derived is a derivation whose kind could not be told; base is a repository other repositories derive from with no derivation evidence of its own; original was affirmatively judged trained from scratch (never a default); undocumented ships weights with no documentation, placeholder has no files and no card, and unknown is everything the cascade could not decide.

Model lineage_method, in cascade order (a repository exits at the first layer that decides it): declared (the Hub's baseModels), card-dangling (a base_model card entry the Hub could not resolve), file-structure (adapter_model* or *.gguf files), config-declared (adapter_config.json naming its base), config-quant (quantization_config in config.json), config-inferred (_name_or_path naming another repository), llm (README read by an LLM), reverse-ref (referenced as a base by others), name-pattern (conservative suffix rules), agent (file-evidence episodes: safetensors/GGUF header reads, config fingerprints, tree inspection), none (undecided; the relation is then placeholder, undocumented or unknown).

Dataset modalities. text, image, video, audio, 3d, document, tabular, geospatial: what the stored files hold, not what the task is. A dataset may have several. modality_method: agent (file inspection), schema (typed features of the Parquet conversion), llm_readme (README read by an LLM), not_dataset (the repository holds no dataset: model weights, software, personal file hosting; modalities is then empty), gated (unreadable and undecided), empty (no data files at all), none (undecided).

Dataset provenance. sources lists every class present and primary_source the bytes-dominant one: found (pre-existing content harvested from the web or archives), human (produced deliberately for a collection effort: annotation, crowdsourcing, purpose-recorded speech), model (emitted by a learned model: LLM text, synthetic media, MT/OCR/ASR output), sensor (an instrument observing the physical world: robot teleoperation, driving, medical imaging, satellite), sim (a non-learned computational process: physics or climate simulation, game-engine renders). Subsets, mirrors and conversions inherit their upstream's source. source_decision is labeled when a class was assigned, not_dataset as above, unknown when the labeler could not tell, and undecided when no layer answered.

Dataset lineage. lineage_relation: original (not derived from another dataset), copy (a re-upload), filter (a subset or cleaned version), merge (a union of several parents), reencode (the same content in another format or layout), derived (a derivation whose kind could not be told, such as new annotations over a parent's media), unclear. reconstructible: whether the bytes could be rebuilt from the named parents: full (a deterministic transformation), full_compute (rebuildable but expensive), partial (some of the content), none, unknown.

Model weight_format. The container of the shipped weights, first match: the Hub-parsed safetensors or gguf header, then filename patterns (.safetensors, .gguf, .bin, torch for .pt/.pth/.ckpt, legacy for .onnx/.h5/.msgpack/.zip), else none. Adapters are a separate axis (is_adapter), since a LoRA ships in one of these containers too.

Reproducing the paper's numbers

reproduce.py recomputes the paper's hub-wide numbers from these three files alone, in plain SQL (it needs only duckdb, and uv reads its dependencies from the header):

uv run reproduce.py --release . --out numbers.json

Keys are named as in the paper's source (m. model section, d. dataset section, meth. methodology). Numbers from sampled measurements (checkpoint redundancy, compressibility, parent overlap, label validation) are not in this release and not recomputed.

Limitations

Public repositories only, as listed on 2026-09-01. Repositories deleted before the cut appear in the ledger only; repositories deleted between the cut and the storage crawl have NULL storage and labels.
Storage sizes and labels are those of the July to September 2026 crawl, not of the cut day.
is_checkpoint_repo marks the study's checkpoint population: the 16,529 of the 16,577 repositories verified in August 2026 that the snapshot still lists. The other 48 were deleted or made private before it.
Labels are inferred and carry measured error; treat *_confidence and *_method as part of the label. Gated datasets whose files could not be read keep metadata-based labels or stay NULL.
Download counts follow the Hub's counter semantics (file-resolve requests).

Code, working set and experiments

The code that built these files, labels the repositories and draws the paper's figures is at https://github.com/harvardMadsys/hf-hub-characterization (Apache-2.0), with a step-by-step guide to recomputing every number, figure and table of the paper. Beside the three release files, this repository also holds, under working-set/, the frozen working tree those scripts read: the 2026-09-01 snapshot of the Hub listing, the per-repository enrichment tables and download ledgers cut at 2026-08-31, and the raw results of every sampled measurement (checkpoint, fine-tune and quantization redundancy, update workload, compressibility, Parquet usage, the format evaluation, label validation). MANIFEST.md lists every file with its size and SHA-256.

License

The three release tables and the working set are released under CC BY 4.0. They are derived from the public Hub listing export cfahlgren1/hub-stats (Apache-2.0) and from the Hugging Face Hub's public APIs; repository names, tags and declared metadata remain those of their authors, and the inferred labels and their justifications are ours.

Citation

Haoran Ni, Yunjia Zheng, Tingfeng Lan, Zirui Wang, Zhaoyuan Su, Yue Cheng and Juncheng Yang. Characterizing a Petabyte-Scale ML Artifact Hub: Storage, Access, and Lineage on Hugging Face. Under submission, 2026. A BibTeX entry will be added on publication.

Downloads last month: 102

Total file size:

6.43 GB