File size: 6,395 Bytes
fbe8d49 9cd89ed fbe8d49 9cd89ed fbe8d49 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | """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|>"
# 1M is a prefix slice of the 10M build (million words per source)
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")
# parquet with provenance, for the Hugging Face release
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()
|