Battam's picture
Release [run release-20261111T153845Z]
82d0b24 verified
|
Raw History Blame
35.9 kB
metadata
license: cc0-1.0
size_categories:
  - 1B<n<10B
pretty_name: Training Data Foundation
tags:
  - data-catalog
  - manifest
  - urls
  - provenance
configs:
  - config_name: catalog
    default: true
    data_files:
      - split: train
        path:
          - meta/catalog.parquet
  - config_name: preview
    data_files:
      - split: train
        path:
          - meta/preview.parquet
Public web, in two layers (task material in collections; corpora), one row per file (address, size, SHA-256, license), your selection, fetched and verified

This dataset is the public index of the Training Data Foundation: find public files to build agent tasks and environments from, and fetch them with one command.

English | 简体中文 · Data page · Usage video

1,805 material sets with 4,190 units in 14 collections; 139 corpora with 1,216,362,128 rows; 4.45 PB pointed to, as the index holds addresses, not copies; 99.6% of the 34,707 rows compared match their recorded size.

Get data in one command

uv run https://huggingface.co/datasets/Battam/training-data-foundation/resolve/release-2026-11-11.14/tools/fetch.py --form spreadsheets --sample 3 --out ./data

This fetches 3 units of every spreadsheet material set into ./data, one folder per unit, and checks each file against the size and hashes its row records. Change --form and --sample, or add --limit, to take other material; the same command takes the same units of this release.

What the command takes, and in which order

The command and the queries below are pinned to the release tag release-2026-11-11.14. uv reads the script's dependencies, at the versions published before the day of this release.

The command returns units: 3 units from each material set whose form is spreadsheets, each in a folder of its own named after its unit_id. They are the first 3 of each material set that pass the default profile, in a fixed order: by the sha256 of the path of the data file that holds the unit, then by the unit's key; --limit N takes N units of the whole selection from its sources in turn, each source's units in the same order: the first unit of each source, then the second of each, and so on, the sources of one turn in the order of the sha256 of their names. The script reads the data files in that order (with --limit, the first file of each source, then the second of each) and stops once the files read hold the units, so the same command takes the same units of this release.

What the default profile leaves out

The default profile is the rules tools/fetch.py applies unless an option relaxes them. It leaves out duplicate copies, rows that matched a benchmark or were not compared with the benchmark list yet, files whose license does not let them be shipped, rows in a language other than English, personal data and files above 20 MB. Each rule has its own option, and every run says how many units each rule removed. Every rule and its option, and what to keep out of an agent's environment: docs/for-agents.md.

Choose with SQL

Choose material sets from the catalog with DuckDB:

SELECT source, collection, title, units, files, top_types, license.tier AS license_tier, needs_auth
FROM 'hf://datasets/Battam/training-data-foundation@release-2026-11-11.14/meta/catalog.parquet'
WHERE kind = 'material_set' AND needs_auth = 'no' AND license.tier IN ('permissive', 'share-alike')
ORDER BY collection, units DESC;

This returns material sets, one row each with its collection, counted in units (units); with kind = 'corpus' it returns corpora instead, counted in rows (files).

Choose files in one corpus:

SET VARIABLE files = (SELECT list('hf://datasets/Battam/training-data-foundation@release-2026-11-11.14/' || f) FROM (SELECT unnest(data_files) AS f FROM 'hf://datasets/Battam/training-data-foundation@release-2026-11-11.14/meta/catalog.parquet' WHERE source = 'if-archive'));
SELECT uri, size_bytes, lower(hex(sha256)) AS sha256
FROM read_parquet(getvariable('files'))
WHERE source = 'if-archive' AND ext = 'pdf' AND size_bytes BETWEEN 100000 AND 5000000
ORDER BY size_bytes LIMIT 20;

This returns rows of the corpus if-archive, one per file. The first statement takes its data files from the catalog's column data_files, so the query reads exactly those files and lists no folder of data/. A data file may hold the rows of several sources, so the query keeps this one's by its column source.

What's inside

Task material Corpora
Material sets, each the files admitted from one site, repository or dataset for building tasks, grouped into units that you fetch whole. Counted in material sets and units, by collection. Whole upstreams read in bulk, such as package registries, bug trackers, mailing lists and web archives, to search when no material set fits. Counted in corpora and rows.

Task material: units by collection

Units by collection, longest bar first: Spreadsheets 536; Browser tests 439; Tests and exercises 425; Model serving configurations 397; Media and documents 391; Science reference data 342; Rule calculations 329; Security detection 328; Hardware design (EDA) tests 258; Issue trackers 258; Solver instances 193; Disk images 179; Reproduction packages and runs 106; In no collection 9; SEC filing reviews 0.

1,805 material sets with 4,190 units, in 14 collections (1 of them with no material set yet); 1 of the material sets are in no collection.

Task material by collection, as a table
Collection Material sets Units Files Upstreams Recorded size Deduplicated size
Spreadsheets 67 536 670 55 250 MB 248 MB
Disk images 52 179 324 40 272 MB 272 MB
Reproduction packages and runs 88 106 870 88 120 MB 120 MB
SEC filing reviews 0 0 0 0 0 B 0 B
Solver instances 69 193 367 66 127 MB 127 MB
Browser tests 123 439 852 88 32.0 MB 31.9 MB
Hardware design (EDA) tests 81 258 651 75 80.8 MB 80.8 MB
Issue trackers 212 258 682 212 196 MB 196 MB
Media and documents 276 391 1,088 269 569 MB 569 MB
Model serving configurations 102 397 1,165 82 250 MB 221 MB
Rule calculations 177 329 727 154 196 MB 186 MB
Security detection 110 328 983 77 684 MB 652 MB
Science reference data 161 342 671 157 63.8 MB 63.8 MB
Tests and exercises 286 425 2,544 265 42.6 MB 42.2 MB
In no collection 1 9 19 1 78.5 KB 78.5 KB

Upstreams are the upstream works the material sets of a collection come from.

Corpora: rows by main domain

Corpus rows by main domain, longest bar first: Data science 750,815,212; System administration 185,826,217; Many domains 109,262,742; Software engineering 45,267,701; Science 44,633,675; Operations 39,404,642; Media 12,751,612; Machine learning 9,636,889; Hardware 8,716,520; Unclassified 5,284,162; Security 4,521,631; Misc 241,125.

139 corpora with 1,216,362,128 rows.

Corpora by main domain, as a table
Domain Corpora Rows Recorded size Deduplicated size
Data science 23 750,815,212 634 TB 600 TB
System administration 29 185,826,217 280 TB 187 TB
Many domains 16 109,262,742 234 TB 224 TB
Software engineering 12 45,267,701 116 TB 87.3 TB
Science 15 44,633,675 251 TB 251 TB
Operations 6 39,404,642 1.78 TB 1.78 TB
Media 9 12,751,612 874 TB 874 TB
Machine learning 7 9,636,889 2.04 PB 1.86 PB
Hardware 5 8,716,520 1.67 TB 1.67 TB
Unclassified 4 5,284,162 1.02 TB 997 GB
Security 10 4,521,631 11.9 TB 11.9 TB
Misc 3 241,125 2.87 TB 2.87 TB

Each corpus is counted under its main domain.

Browse task material by collection, or corpora, on the data page, and build a fetch command there. Every material set and every corpus, with its counts, size, license tier and login, is in docs/sources.md.

How it is made

How the index is made, in four steps. 1, collect: collectors read whole upstreams into corpora, one row per file or record. 2, admit: works the search found upstream and groups of corpus rows become material sets. 3, check: licenses, personal data, overlap with benchmarks and sizes are checked before release. 4, release: one commit with its own tag, release-2026-11-11.14.

The terms, each step and how every number is made are folded below.

Glossary
  • Row: one pointer, a row of the data files under data/: where to download one file or record, its size, its hashes and its license. Corpora are counted in rows.
  • Unit: a group of files that its upstream publishes as one thing (a test case, one workbook, one package), delivered whole. Its key unit_id is the unit_group its rows share in the row column extra (extra.source_meta.unit_group), unique within its material set. Material sets are counted in units. A unit is material, not a task: one unit may give several tasks, and one task may use several units.
  • Material set: the units admitted from one source (a site, a repository or a dataset) for building tasks, with the README.md and LICENSE the index writes for it, which belong to no unit. It is counted in units; its files are the files of its units and those two.
  • Corpus (plural corpora): one whole upstream that a collector keeps reading in bulk, such as a package registry, a bug tracker, a mailing list or a web archive. It is counted in rows.
  • Collection: the material sets of one task family, such as spreadsheets or disk images; a corpus that holds a collection's kind of material is listed under it and stays a corpus.
  • Form: the shape of a source's material, one id such as spreadsheets or test-suites (the catalog column form, the option --form of tools/fetch.py).
  • Default profile: the rules tools/fetch.py applies unless an option relaxes them: it leaves out duplicate copies, rows that matched a benchmark or were not compared with the benchmark list yet, files whose license does not let them be shipped, rows in a language other than English, personal data and files above 20 MB (docs/for-agents.md).

Every row carries a unit_id: in a material set, the key of its unit; in a corpus, the row's own key (its uri, then @<range_offset> for a byte range, then !/<member_path> for an archive member), and tools/fetch.py puts the file of a corpus row in a folder named after it.

From corpora to material sets

Corpora are whole upstreams read in bulk and counted in rows; a material set is admitted for building tasks from works the search found upstream or from a group of corpus rows, its files checked and grouped into units, and it is counted in units, apart from any corpus its rows came from.

  • Corpora come from the collectors: each reads one whole upstream in bulk and records a row for every file or record it lists, with its address, size, hashes and license as the upstream gives them.
  • Admission makes the material sets. Its candidates are the works the search found upstream for the task family of a collection, and the units of a group of corpus rows chosen with tools/fetch.py (--where and --sample), which the fetch tool fetched and checked against their recorded size and sha256. It takes a candidate when its pointer facts hold: a download address, a recorded size and sha256, a recorded license, no legal block, no fact found wrong, and content not already in the index; every candidate it does not take is listed with its reason in meta/not_included.parquet (docs/access.md).
  • What admission adds: the candidate's files as one unit with its unit_id, the material set's README.md and LICENSE, its collection (the one of its task family), its form, and labels such as language, robots and terms. The collect step then fetches every file of every unit again and checks its sha256 before the material set is published.
  • A material set made from corpus rows is a source of its own, apart from the corpus: the same file is a row of the corpus and a file of a unit, so the two layers' counts are never added; the deduplicated size counts its content once.
How sizes are measured

The two layers are counted apart and never added together; only their sizes add up to the size of the whole index.

Level Recorded size Deduplicated size Rows read Rows compared Rows that match Rows read, not compared Rows without a recorded size Their estimated size
Whole index 4.45 PB 4.11 PB 35,586 34,707 34,578 (99.6%) 879: address unreachable 449, file gone 80, login needed 329, no size from the server 19, other error 2 312,300,338 202 TB, an estimate (95% range 171 TB to 245 TB), for 215,326,513 of them, from 14,161 rows read
Corpora 4.45 PB 4.11 PB 31,594 30,723 30,610 (99.6%) 871: address unreachable 449, file gone 80, login needed 322, no size from the server 19, other error 1 312,300,338 202 TB, an estimate (95% range 171 TB to 245 TB), for 215,326,513 of them, from 14,161 rows read
Task material 2.88 GB 2.81 GB 3,992 3,984 3,968 (99.6%) 8: login needed 7, other error 1 0 none

Rows read are the sample of rows the check reads in meta/sizes.parquet; a row compared matched its recorded size or did not, and a row read but not compared never reached its file. The estimate is for the rows without a recorded size, and says it is one; above one source its range is the sum of its sources' ranges, wider than a joint interval.

The recorded size is the sum of size_bytes over the rows that have one (catalog column bytes). The check reads a sample of rows of every data file (meta/sizes.parquet): 20 of its rows with a recorded size, and of its rows without one its share of its source's sample, sized for their mean size within 25% at 95% confidence by the spread of the sizes read so far (at most 400 rows per source per round, 20 for a source with none read yet); its share is the rows that match their recorded size out of the rows it compared (status match, size_mismatch or hash_mismatch), and the rows it could not compare, which never reached their file, are counted beside it by status (unreachable, gone, needs_auth, no_length, error; catalog column size_check). The estimate for a source's rows without a recorded size (catalog columns unsized_rows and unsized_estimate) is their number times the mean measured size of such rows read, with a 95% BCa bootstrap range (scipy.stats.bootstrap, its default resample count); a source with fewer than 10 such rows read has none. Above one source, the estimate is the sum of its sources' estimates and its range the sum of their ranges, which is wider than a joint interval. The figures of every level are in meta/size_figures.json.

Distinct content is the sum of size_bytes over the rows minus the sizes of the rows that repeat another row's content (the same sha256, else sha1, else md5 and size, within the same hash scope; one copy of each content is kept, in the first source by registry order), counted after each release over the data files it published, per source in the catalog column distinct_bytes; archive members whose archive the same source also lists whole have other hashes, so they are not subtracted. tools/fetch.py removes duplicates over your own selection when it reads it. The deduplicated sizes here were counted over the data files of release release-2026-11-11.10.

How the training-stage tables are counted

The stage table catalog/stages.yaml of the code repository gives each training stage a condition on fields the index already has: the kind, form and domain of a row's source, the file types of a unit, their training permits and, for some stages, rules of their own such as a size limit. The release records those fields for every unit of a material set and every row of a corpus, with how many of the rules every stage shares it passes, in this order: the benchmark rule (a row that matches a public benchmark task is left out), the rule on rows not compared with the benchmark list yet, the personal-data rule and deduplication (meta/stage_fields.parquet); each stage counts what meets its condition before those rules and after each of them, and its last count is what it can take. Each table below gives what a training stage can take, counted before the rules and after each of them, in their order; its last row is the stage's count.

The stage fields (meta/stage_fields.parquet) were counted over the data files of release release-2026-11-11.10, after it was published.

Post-training (in use)

Material set units for building tasks: every file of the unit allowed for training (conditional with its condition followed when the task is built), redistributable, in English or no natural language, and at most 20 MB.

Step Material sets Units Upstream sources
In the stage's condition, before the rules 1,426 3,479 1,350
After the benchmark rule 1,425 3,478 1,349
After the rule on rows not compared with the benchmark list 1,425 3,478 1,349
After the personal-data rule 1,267 3,084 1,201
After deduplication: the stage's count 1,244 2,989 1,183

Mid-training (provisional: conditions and counts only)

Corpus rows of code, documentation and the terminal side whose upstream states that training is allowed: conditions and counts only.

Step Rows Size
In the stage's condition, before the rules 5,236,376 1.23 TB
After the benchmark rule 5,228,453 1.23 TB
After the rule on rows not compared with the benchmark list 5,228,453 1.23 TB
After the personal-data rule 2,236,257 1.14 TB
After deduplication: the stage's count 2,127,316 1.13 TB

Pre-training (provisional: conditions and counts only)

Corpus rows of plain text whose upstream states that training is allowed, the mid-training types not counted here: conditions and counts only.

Step Rows Size
In the stage's condition, before the rules 116,630,859 29.9 TB
After the benchmark rule 116,630,083 29.9 TB
After the rule on rows not compared with the benchmark list 116,630,083 29.9 TB
After the personal-data rule 97,247,803 29.8 TB
After deduplication: the stage's count 96,995,442 29.7 TB
Collection, checks and release
  • Data collection: rows are collected from the public listings, APIs and archives of each source and checked when added: the address must answer, and size and hash are fetched again and compared. Material sets come from admission, which takes the works the search found upstream and groups of corpus rows (From corpora to material sets, above). Every material set and every corpus with its counts: docs/sources.md.
  • Checks before release: every source has its license recorded and grouped into a tier, personal information is read from sample files, and rows are compared with public benchmarks; rows that copy a public benchmark are removed, and units that do not meet a requirement are listed with the reason: docs/access.md.
  • Release: each release is one commit with its own tag; this card, its figures under docs/figures/, cards/*.md, meta/catalog.parquet, meta/croissant.json and meta/size_figures.json are generated from the same commit, so their numbers agree. Every count and size of this card is read from meta/size_figures.json, where each is computed once for this release, and the stage tables from meta/stage_figures.json. What each file of a release holds: docs/fields.md.
  • Chinese version: every name and description the Chinese card and its pages show is translated by a language model once per text and kept, by the sha256 of its English text, in meta/translations.parquet.

Reference

To Read
Read every field of a row and every column of the catalog docs/fields.md
See every material set and every corpus, with its counts, size, license tier and login docs/sources.md
See what was not included and why, and which sources need a login docs/access.md
Build tasks from the files, and keep what an agent must not see out of its environment docs/for-agents.md
See every release and what it changed CHANGELOG.md
Read the dataset as Croissant metadata Croissant generated by the Hub; meta/croissant.json describes the catalog and every source
Look through the catalog, one row per material set or corpus with its kind and collection The catalog subset in the Dataset Viewer
Query the catalog in the browser; it lists every source as published, without the default profile of tools/fetch.py, which the command applies SQL Console
Watch the index in use, in a video in Chinese and in English, each with its subtitles; the data page plays the video and the subtitles of its own language, in its Get the data section Usage video on the data page
Check every number of this card meta/size_figures.json and meta/stage_figures.json
Dataset structure: the fields used most

Each row of the data files under data/ points to one file or record (a row of the glossary); the catalog's column data_files names the files of each source, and one material set or corpus is read from exactly those files, as in the queries above and with tools/fetch.py. The Dataset Viewer has two subsets: catalog, one row per material set or corpus with its kind and collection, and preview, the first 10 rows of each. The fields used most:

Field Type Meaning
source text Name of the source; the same as its folder under data/.
uri text Where to download the item (https, s3, git, rsync or hf).
size_bytes integer Size in bytes as delivered; empty when the source does not publish it.
sha256 32 bytes SHA-256 of the item, 32 bytes (hex-encode to compare); empty when not known.
ext text File extension from the upstream file name, lower case.
media_type text Media type of the item when known.
license_spdx text The row's own license (SPDX); empty when it takes its batch license.
batch text Batch the row was published in; its license is in meta/sources.json.
sensitive text health or minors when the item is about health or about minors.
extra text JSON with the row's other fields; in a material set, extra.source_meta.unit_group is the key of the row's unit.

Every row field and every column of the catalog: docs/fields.md.

License, privacy and limits

Topic What it means for you
License The catalog is released under CC0 1.0. Each file keeps the license of its source, given in its row.
Personal data The catalog holds no personal records of its own. Rows about health or minors carry health or minors in the row column sensitive, so you can filter them out.
Not a copy The index holds one row per public file or record: its address, size, hashes and license. The files stay at their sources; the index is not a copy of them, not a list of ready tasks or environments, and not a training corpus by itself.
Removal To have a source removed or an entry corrected, open a discussion in the Community tab of this repository.
License details
  • This catalog itself (addresses, sizes, hashes and descriptive text) is released under CC0 1.0; that dedication does not extend to the files it points to.
  • The files under media/ (the usage example video and its subtitles) and under examples/ (the worked examples) are released under CC0 1.0 as well.
  • Each file keeps the license of its source: see the license columns of each row (a row without its own license takes the license of its batch, batches[].license in meta/sources.json).
  • License tiers group each source's license by what it allows; the tier of every source and what each tier means: docs/sources.md.
  • License tiers and reason codes are computed from the license categories of ScanCode LicenseDB, licensed CC-BY-4.0; its attribution: NOTICE.
Personal and sensitive information
  • The catalog itself holds addresses, sizes, hashes and license information; it contains no personal records of its own.
  • Some sources point to material that names its authors, such as mailing lists, bug trackers and forums.
  • Rows that point to data about health or about minors carry health or minors in the row column sensitive, so they can be filtered out.
  • Personal information read from sample files, by level, as each source's card gives it (risk.pii and risk.pii_evidence in cards/<source>.yaml, with the sample files it rests on):
Level Corpora Task material
none_known 3 0
present 14 0
suspected 1 0
Not judged yet 121 1,805
Sample files read per judged source 9 to 30 none
Days the sample files were read 2026-10-04 and 2026-10-05 none
Known limits
Sources Corpora Task material
With a recorded size for every row 92 of 139 1,805 of 1,805
With a summary read from sample files 0 of 139 0 of 1,805
With personal information read from sample files 18 of 139 0 of 1,805
Still being collected 25 of 139 0 of 1,805
  • Rows whose size the source does not publish are shown as unknown and left out of the size totals, never counted as 0.
  • Fields not judged yet say so; the counts, types, sizes and licenses of every source come from the index itself.
  • A source still being collected grows with each release.
  • The Chinese names and descriptions are machine translations.
Uses
  • Who it is for: people and agents that choose material for building agent tasks and environments, and then fetch the files themselves.
  • Direct use: choose sources and files for building agent tasks and environments, then fetch each file from its source and check it against the size and hashes in its row.
  • Out-of-scope use: this dataset is not a copy of the files, and not a training corpus by itself: the files stay at their sources under their own licenses. What a task checks is decided when the task is built from the material; the index holds material only.
  • How to build tasks from the files, what the default profile of tools/fetch.py removes and what to keep out of an agent's environment: docs/for-agents.md.
Releases
  • Latest release: release-2026-11-11.14 (its newest CHANGELOG entry is dated 2026-11-11).
  • Releases are listed in CHANGELOG.md; each one is a commit with its own release tag (this one is release-2026-11-11.14), so any earlier state stays readable at its tag.
  • meta/projection.json records the release tag and the version of the program and templates that generated this card.
  • Croissant metadata: generated by the Hub; meta/croissant.json describes the catalog and every source.

Days with a release, from the commit history read for this card:

Window Days Days with a release
2026-10-13 to 2026-11-11 30 16
Removal requests

This index lists pointers to files hosted elsewhere (addresses, sizes, checksums and license information); it does not host the files themselves.

If you maintain a source listed here and would like it removed, or you find an entry that is wrong, please open a discussion in the Community tab of this repository. Name the source, and the files if the request covers only some of them.

We review new discussions regularly. Removal requests are honoured: the source's entries are taken out in the next update of the index, and the removal is recorded in CHANGELOG.md. Reports of wrong entries are checked and corrected the same way.

A removal covers the current version of this repository (the main branch) and the Parquet copy that Hugging Face makes automatically for the dataset viewer (the refs/convert/parquet branch). After a removal, we check that the removed entries are no longer in the Parquet copy; when a whole source is removed, we check that its folder is gone from it. Earlier versions of the files stay in the git history of this repository, which pinned commits rely on; if you also need them removed from the history, say so in your request.

Citation

@misc{training_data_foundation,
  title        = {training-data-foundation: an index of public materials for building agent environments},
  howpublished = {https://huggingface.co/datasets/Battam/training-data-foundation},
  note         = {Release release-2026-11-11.14},
  year         = {2026}
}