commonpool-256-ssl

A canonical, messy, naturally long-tailed, web-scale base image dataset for prototyping self-supervised-learning (SSL) data-curation techniques. This is not a cleaned/balanced academic benchmark (e.g. ImageNet) — it is closer in spirit to a Common-Crawl-style image pool, intentionally left uncurated so that curation techniques can be tested on top of it.

Provenance

Built from wusize/common_pool, which hosts a DataComp CommonPool (small-pool) crawl as WebDataset shards with real image bytes (~5.79M images surviving from ~12.8M candidate URLs). DataComp's CommonPool construction includes CSAM removal at the URL-collection stage. No additional safety filtering is applied here — "uncurated" describes the absence of any quality/dedup/balance/safety filtering beyond what upstream CommonPool already does.

License / use: non-commercial research only, consistent with the upstream DataComp / CommonPool terms.

Structure: data vs. manifest

Data and metadata are deliberately split so that small, predefined slices can be pulled without touching the rest of the pool:

• data/{train,val,test}/<split>-NNNNNN.tar — WebDataset shards. Each sample is only a processed image and its content hash:

  • <key>.jpg — 256x256 center-cropped, re-encoded JPEG (quality 95)
  • <key>.json — {"key": ..., "sha256": ...}

  No captions, URLs, or other metadata live in the data shards — keeping them minimal means a shard can be fetched and decoded with nothing but webdataset, and the heavy image bytes are never duplicated across metadata formats.

• manifest.parquet — one row per sample, with everything else: key, sha256, caption, url, orig_width, orig_height, source_raw_shard, split, shard_path (which tar the sample lives in), index_in_shard. Query/filter this file (pandas/DuckDB) to decide which shards you need, then fetch only those.

• scale_tiers.json — maps tier name (xs/s/m) to a list of train shard paths (nested prefixes of the shuffled train shard list: xs ⊂ s ⊂ m). Pulling a tier means downloading exactly those shard files — no row-level filtering needed.

Splits — defined at the shard level, not the sample level

Samples are randomized via a streaming shuffle (raw input shard order is shuffled, plus a 50,000-sample sliding shuffle buffer downstream — chosen so the full ~5.7M-image build never has to hold the whole pool in memory), then assigned to splits in whole shard-sized chunks (10,000 samples/shard): the first chunk becomes val, the next becomes test, everything after that is train. This means:

• Splits are disjoint sets of tar files, so pulling val or test (or a train scale tier) is just downloading those specific shards — no need to touch manifest.parquet or decode unrelated shards first.
• No fixed random seed is used — this artifact is meant to be used as-is, not regenerated bit-for-bit. The shuffle is good enough to avoid gross ordering bias but is not a uniform global permutation.

Note on val/test: this pool is unlabeled. val/test are held-out image sets for loss monitoring / leakage control during pretraining, not a labeled evaluation set. Downstream SSL quality should be judged with an external labeled probe (e.g. ImageNet-1k linear/kNN), not with labels from this dataset.

Processing pipeline

1. Stream raw/*.tar shards from wusize/common_pool.
2. Drop samples with a recorded fetch/decode error, or whose original min(width, height) < 64px.
3. Center-crop to square (min side) and resize to 256x256 (Lanczos), re-encode JPEG q95.
4. Shuffle all surviving samples; chunk into shard-sized groups; assign chunks to train/val/test.
5. Write data shards (image + hash only) and the parallel manifest (full metadata).

Versions

• v0.1 — pilot. 130 raw input shards -> 112,046 samples (1 val + 1 test + 10 train shards).
• v1.0 — full build. All 6,540 raw input shards, 5,799,314 raw samples seen -> 5,684,754 kept (1 val + 1 test + 567 train shards, ~151GB). Scale tiers: xs=570k/57 shards, s=2.84M/284 shards, m=5.67M/567 shards (all of train).