| """Assemble a size: python assemble.py 10M |
| |
| Shuffles documents with a fixed seed, holds out 0.5% per genre as validation, |
| writes out/<size>/train.txt (docs separated by <|endoftext|>) and valid_<genre>.txt. |
| """ |
| import json |
| import random |
| import sys |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| EOT = "<|endoftext|>" |
|
|
|
|
| |
| QUOTAS_1M = {"tinystories": 0.19, "simplestories": 0.19, "tinydialogues": 0.12, "soda": 0.10, |
| "tinyhelen": 0.15, "simplewiki": 0.10, "cosmo_v2": 0.10, "cosmo_v01": 0.05} |
|
|
|
|
| def load(size): |
| docs = [] |
| if size == "1M": |
| for name, q in QUOTAS_1M.items(): |
| n = 0 |
| for l in (ROOT / "work" / "10M" / f"{name}.jsonl").open(encoding="utf-8"): |
| d = json.loads(l) |
| if n >= q * 1e6: |
| break |
| n += len(d["text"].split()) |
| docs.append(d) |
| return docs |
| for p in sorted((ROOT / "work" / size).glob("*.jsonl")): |
| docs += [json.loads(l) for l in p.open(encoding="utf-8")] |
| return docs |
|
|
|
|
| def main_big(size): |
| """Same result as main() in the same shuffled order, without holding the documents in RAM (1000M).""" |
| import numpy as np |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| files = sorted((ROOT / "work" / size).glob("*.jsonl")) |
| idx_f, idx_o, n_genre = [], [], defaultdict(int) |
| for i, p in enumerate(files): |
| pos = 0 |
| with p.open("rb") as f: |
| for line in f: |
| idx_f.append(i) |
| idx_o.append(pos) |
| pos += len(line) |
| n_genre[json.loads(line)["genre"]] += 1 |
| idx_f, idx_o = np.array(idx_f, np.int32), np.array(idx_o, np.int64) |
| order = list(range(len(idx_f))) |
| random.Random(0).shuffle(order) |
| out = ROOT / "out" / size |
| pq_dir = out / "parquet" |
| pq_dir.mkdir(parents=True, exist_ok=True) |
| handles = [p.open("rb") for p in files] |
| schema = pa.schema([("text", pa.string()), ("source", pa.string()), ("genre", pa.string())]) |
| sep = f"\n{EOT}\n" |
| held, valid = defaultdict(int), defaultdict(list) |
| words, n_train, by_genre, by_source = 0, 0, defaultdict(int), defaultdict(int) |
| batch, shard, shard_words = [], 0, 0 |
|
|
| def flush(): |
| nonlocal batch, shard, shard_words |
| if batch: |
| pq.write_table(pa.table({"text": [d["text"] for d in batch], |
| "source": [d["src"].split(".")[0] for d in batch], |
| "genre": [d["genre"] for d in batch]}, schema=schema), |
| pq_dir / f"train-{shard:05d}.parquet", compression="zstd") |
| batch, shard, shard_words = [], shard + 1, 0 |
|
|
| with (out / "train.txt").open("w", encoding="utf-8") as tf: |
| for k in order: |
| f = handles[idx_f[k]] |
| f.seek(idx_o[k]) |
| d = json.loads(f.readline()) |
| g = d["genre"] |
| if held[g] < max(1, n_genre[g] // 200): |
| held[g] += 1 |
| valid[g].append(d) |
| continue |
| n = len(d["text"].split()) |
| tf.write(d["text"] + sep) |
| batch.append(d) |
| shard_words += n |
| n_train += 1 |
| words += n |
| by_genre[g] += n |
| by_source[d["src"].split(".")[0]] += n |
| if shard_words >= 50_000_000: |
| flush() |
| flush() |
| for h in handles: |
| h.close() |
| for g, ds in valid.items(): |
| (out / f"valid_{g}.txt").write_text(sep.join(d["text"] for d in ds) + sep, encoding="utf-8") |
| pq.write_table(pa.table({"text": [d["text"] for d in ds], "source": [d["src"].split(".")[0] for d in ds], |
| "genre": [d["genre"] for d in ds]}), pq_dir / f"validation_{g}.parquet", |
| compression="zstd") |
| summary = {"size": size, "train_docs": n_train, "train_words_M": round(words / 1e6, 2), |
| "genre_share_%": {g: round(100 * w / words, 1) for g, w in by_genre.items()}, |
| "source_words_M": {s: round(w / 1e6, 3) for s, w in sorted(by_source.items())}} |
| (out / "summary.json").write_text(json.dumps(summary, indent=1)) |
| print(json.dumps(summary, indent=1)) |
|
|
|
|
| def main(): |
| size = sys.argv[1] |
| if size == "1000M": |
| return main_big(size) |
| docs = load(size) |
| random.Random(0).shuffle(docs) |
| out = ROOT / "out" / size |
| out.mkdir(parents=True, exist_ok=True) |
| valid, held = defaultdict(list), defaultdict(int) |
| n_genre = defaultdict(int) |
| for d in docs: |
| n_genre[d["genre"]] += 1 |
| train, words, by_genre, by_source = [], 0, defaultdict(int), defaultdict(int) |
| valid_docs = defaultdict(list) |
| for d in docs: |
| g = d["genre"] |
| if held[g] < max(1, n_genre[g] // 200): |
| held[g] += 1 |
| valid[g].append(d["text"]) |
| valid_docs[g].append(d) |
| else: |
| train.append(d) |
| n = len(d["text"].split()) |
| by_genre[g] += n |
| by_source[d["src"].split(".")[0]] += n |
| words += n |
| sep = f"\n{EOT}\n" |
| (out / "train.txt").write_text(sep.join(d["text"] for d in train) + sep, encoding="utf-8") |
| for g, ts in valid.items(): |
| (out / f"valid_{g}.txt").write_text(sep.join(ts) + sep, encoding="utf-8") |
| |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| pq_dir = out / "parquet" |
| pq_dir.mkdir(exist_ok=True) |
|
|
| def write(name, ds): |
| pq.write_table(pa.table({"text": [d["text"] for d in ds], "source": [d["src"].split(".")[0] for d in ds], |
| "genre": [d["genre"] for d in ds]}), pq_dir / f"{name}.parquet", compression="zstd") |
|
|
| write("train", train) |
| for g, ds in valid_docs.items(): |
| write(f"validation_{g}", ds) |
| summary = {"size": size, "train_docs": len(train), "train_words_M": round(words / 1e6, 2), |
| "genre_share_%": {g: round(100 * w / words, 1) for g, w in by_genre.items()}, |
| "source_words_M": {s: round(w / 1e6, 3) for s, w in sorted(by_source.items())}} |
| (out / "summary.json").write_text(json.dumps(summary, indent=1)) |
| print(json.dumps(summary, indent=1)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
