Battam's picture
Release release-2026-11-17.3, made by the table store from release-2026-11-17.2
779c00c verified
|
Raw History Blame Contribute Delete
15.4 kB
metadata
license: cc0-1.0
size_categories:
  - 1B<n<10B
pretty_name: Training Data Foundation
tags:
  - data-catalog
  - manifest
  - urls
  - provenance
  - training-data
  - pre-training
  - post-training
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

Training Data Foundation

Real public data for pre-training, mid-training and post-training, each file with its address, size, hashes and license, fetched with one command; this dataset is the foundation's public index.

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

What each training stage can use in this release. Pre-training (provisional): 30.7 TB deduplicated size, 151,161,846 rows, 30.0 TB allowed for training. Mid-training (provisional): 3.87 TB deduplicated size, 34,243,169 rows, 1.42 TB allowed for training. Post-training: 1,789 material sets, from 2,213 upstream sources, 1,406 allowed for training.

Get data in one command

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

This fetches every spreadsheet material set whole into ./data, one folder per unit, and checks each file against the size and hashes its row records. Change --kind and --form, or add --sample N (at most N units of each source) or --limit N (N units in all), to take other material; take a corpus, whose whole can be petabytes, with one of them; 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-17.3. uv reads the script's dependencies, at the versions published before the day of this release.

The command returns units: every unit that passes the default profile of each material set whose form is spreadsheets, each in a folder of its own named after its unit_id. --sample N takes the first N of each source (all of a source with fewer), 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, rows in a language other than English, files above 20 MB, and rows that the release's fetch check read and found refused by their site (HTTP 401 or 403, a login, or an empty or short body). Each rule has its own option, and every run says how many units each rule removed. The license and the personal-data mark are labels of every row, not rules of the default profile: every row comes whatever they say, and --training-only leaves out files whose license does not let them be shipped, --no-personal-data personal data. 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-17.3/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-17.3/' || f) FROM (SELECT unnest(data_files) AS f FROM 'hf://datasets/Battam/training-data-foundation@release-2026-11-17.3/meta/catalog.parquet' WHERE source = 'habs-haer-hals'));
SELECT uri, size_bytes, lower(hex(sha256)) AS sha256
FROM read_parquet(getvariable('files'))
WHERE source = 'habs-haer-hals' AND ext = 'pdf' AND size_bytes BETWEEN 100000 AND 5000000
ORDER BY size_bytes LIMIT 20;

This returns rows of the corpus habs-haer-hals, 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

The training stages by top-level domain, largest first. Pre-training (provisional), deduplicated size, by domain: Data science 29.9 TB; Science 531 GB; Machine learning 82.8 GB; Media 48.7 GB; Unclassified 47.0 GB; System administration 35.7 GB; Many domains 29.6 GB; Hardware 29.6 GB; Security 4.18 GB; Misc 376 MB; Software engineering 183 MB; Operations 4.08 KB. Mid-training (provisional), deduplicated size, by domain: System administration 1.27 TB; Many domains 1.00 TB; Machine learning 503 GB; Science 462 GB; Data science 429 GB; Hardware 177 GB; Security 13.9 GB; Unclassified 4.43 GB; Misc 3.45 GB; Software engineering 3.00 GB; Media 735 MB; Operations 13.9 MB. Post-training, material sets, by domain: Data science 353; Software engineering 286; Media 276; Operations 207; Machine learning 185; Science 179; Security 108; Hardware 87; System administration 71; Misc 37.
The training stages by top-level domain, as a table
Domain Pre-training: deduplicated size Pre-training: rows Mid-training: deduplicated size Mid-training: rows Post-training: material sets
Software engineering 183 MB 59,085 3.00 GB 256,404 286
System administration 35.7 GB 1,999,552 1.27 TB 11,396,233 71
Data science 29.9 TB 107,371,726 429 GB 270,472 353
Machine learning 82.8 GB 237,332 503 GB 230,420 185
Science 531 GB 13,352,882 462 GB 203,278 179
Operations 4.08 KB 18,884,152 13.9 MB 430 207
Hardware 29.6 GB 388,557 177 GB 4,945,550 87
Security 4.18 GB 80,781 13.9 GB 121,360 108
Media 48.7 GB 16,401 735 MB 35,708 276
Misc 376 MB 2,403 3.45 GB 102,989 37
Many domains 29.6 GB 8,274,002 1.00 TB 16,195,869 0
Unclassified 47.0 GB 494,973 4.43 GB 484,456 0

Each source is counted under its main domain, the top-level domain of its first domain code. Every size is deduplicated, and every count is what a stage keeps after the rules every stage shares (How it is made in the data page's manual).

Browse by domain and training stage 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 on the pages of its domain, which docs/sources.md lists.

How it is made

How the index is made, in four steps. 1, collect: collectors read whole public upstreams into corpora, one row per file or record, the material of pre-training and mid-training. 2, admit: works the search found upstream and groups of corpus rows become material sets, the material of post-training. 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-17.3.

Collectors read whole public upstreams into corpora, the material of pre-training and mid-training, and admission turns works found upstream and chosen corpus rows into material sets, the material of post-training. Before each release every source is checked for its license, personal data, overlap with benchmarks and sizes, and each release is one tagged commit whose card and figures are computed from its own files. Each step, and how sizes and the stage counts are measured: How it is made in the data page's manual; the glossary and the checks of this release: Words and numbers in the data page's manual.

Reference

Every page and file of this dataset, the fields used most, Croissant metadata, the Dataset Viewer and the SQL Console: Pages and files of the dataset in the data page's manual.

License, privacy and limits

Every row carries two labels: its file's training permit, license_training_ok (yes, conditional, no or unknown), and a personal-data mark when it has one: health or minors in its column sensitive, personal_data in its pool fields, or its source's pii.level in the catalog. They are labels, not rules: tools/fetch.py takes every row whatever they say, and filters on them only when asked, --training-only leaving out files whose license does not let them be shipped and --no-personal-data rows marked as carrying personal data. On the data page, the Training filter chooses rows by their permit, and each source's card says whether it holds personal data. Rows that copy a public benchmark task, and rows not compared with the benchmark list yet, are left out of every training stage and of the fetch tool's default; only --allow-benchmark and --allow-not-compared take them. The catalog itself is released under CC0 1.0, and each file keeps the license of its source. The full text, with the license details, personal information read from sample files, known limits, uses, releases and removal requests: License, privacy and limits in the data page's manual.

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-17.3},
  year         = {2026}
}