SlayerLab/fabryka-track-polish-mix

Fabryka Track Polish training mix (100 MB/source pack)

This dataset is the verified corpus pack used by track.fabryka.ai for training-pipeline tests.

It contains UTF-8 text samples plus one JSON metadata file per source and catalog.json. The bounded sources were materialized from fixed Hugging Face revisions. bytes in the catalog is the exact UTF-8 byte size; the current Track byte-token trainer counts one byte as one training token.

This is a reproducible workflow pack, not a claim that each source is fully represented. HPLT and FineWeb2 are 100-document viewer samples; the other sources are bounded to approximately 100 MB each.

Sources

See catalog.json for revisions, upstream URLs, document counts, hashes, and sampling details.

Files

• <source>.txt: concatenated UTF-8 text
• <source>.json: source metadata and exact SHA-256
• catalog.json: complete manifest

Training table schema

data/train.jsonl has one approximately 1 MB chunk per row and these columns:

• source_key, source_name, category
• source_repo, source_revision, source_url
• source_documents, source_bytes
• chunk_index, chunk_bytes
• text

Use source_key or category to build a weighted mixture. chunk_bytes is the exact UTF-8 size of the row and can be summed for accounting.

Build your own mix

Load the table, group by source_key, and sample rows with weights. This example gives Wikipedia 40%, EUR-Lex 30%, and literature 30%:

from datasets import load_dataset
from collections import defaultdict
import random

ds = load_dataset("SlayerLab/fabryka-track-polish-mix", split="train", streaming=True)
weights = {"wikipedia": .40, "eurlex": .30, "wolne_lektury": .15, "wikisource": .15}
rows = ((r["text"], r["source_key"]) for r in ds if r["source_key"] in weights)
by_source = defaultdict(list)
for text, source in rows:
    by_source[source].append(text)
mix = []
for source, weight in weights.items():
    n = round(1000 * weight)
    mix.extend(random.choices(by_source[source], k=n))
random.shuffle(mix)

For a streaming pipeline, keep a per-source iterator and draw the next source with random.choices(..., weights=...); this avoids materializing the full corpus. Use chunk_bytes to stop at an exact byte-token budget.

What can this corpus train?

The canonical expanded sources contain 655.4M UTF-8 byte tokens. With the current byte-token trainer, a useful planning rule is:

Model size	20:1 budget	Fit in this corpus?
8M	160M tokens	Yes
16M	320M tokens	Yes
32M	640M tokens	Barely; only ~2.4% remains
50M	1B tokens	No
100M	2B tokens	No

The 20:1 line is a Chinchilla-style planning heuristic, not a guarantee of model quality. This dataset uses bytes rather than a subword tokenizer, so the equivalent BPE-token count and the best training ratio will differ.

For a robust 32M run, target at least 800M–1B fresh tokens or allow a documented repeat factor. Larger models require more source text or a larger mix.