Datasets:

jncarlo
/

tinymix

"""Streaming adapters. Each yields dicts: {"text"} or {"turns": [(speaker, text)]}, optional "title"."""
import ast
import random
import re
import zlib

from datasets import load_dataset
from huggingface_hub import HfFileSystem

SEED = 0
EOT = "<|endoftext|>"
# (index, count): set by build_pool.py workers so each one streams a disjoint part of a dataset
SHARD = None
# adapter -> how many files `datasets` reads at once to fill a shuffle buffer (its default is 10).
# Set by build_pool.py; left empty, every build picks the same documents as before.
INPUT_SHARDS = {}


def _ds(*args, shuffle=False, buffer=20000, columns=None, input_shards=None, **kw):
    # read only the columns an adapter uses: Arrow batches and the shuffle buffer hold whole rows, and
    # Cosmopedia's long prompts nearly double a worker's memory (2.9 -> 1.5 GB). Parquet skips them on
    # read; a format without that option drops them after. Rows and their order do not change.
    try:
        ds = load_dataset(*args, streaming=True, **({"columns": columns} if columns else {}), **kw)
    except (TypeError, ValueError):
        ds = load_dataset(*args, streaming=True, **kw)
    if columns:
        ds = ds.select_columns(columns)
    if SHARD and SHARD[1] > 1:
        i, k = SHARD
        # whole files when there are enough of them, otherwise every k-th row (each worker
        # then downloads the full stream but only processes its rows)
        if ds.n_shards >= k:
            ds = ds.shard(num_shards=k, index=i)
        else:
            ds = ds.filter(lambda _, idx: idx % k == i, with_indices=True)
    if not shuffle:
        return ds
    if input_shards:
        return ds.shuffle(seed=SEED, buffer_size=buffer, max_buffer_input_shards=input_shards)
    return ds.shuffle(seed=SEED, buffer_size=buffer)


def _lines(path):
    with HfFileSystem().open(path, "r", encoding="utf-8", errors="replace") as f:
        yield from f


def tinystories(size):
    buf = []
    for line in _lines("datasets/roneneldan/TinyStories/TinyStoriesV2-GPT4-train.txt"):
        if EOT in line:
            text = " ".join(buf).strip()
            buf = []
            if text:
                # the source lost curly quotes as U+FFFD: between letters it was an apostrophe
                text = re.sub(r"(?<=\w)�(?=\w)", "'", text).replace("�", '"')
                yield {"text": text}
        else:
            buf.append(line.strip())


def simplestories(size):
    for r in _ds("SimpleStories/SimpleStories", split="train", shuffle=True, columns=["story"]):
        yield {"text": r["story"]}


def cosmo_stories(size):
    for r in _ds("HuggingFaceTB/cosmopedia", "stories", split="train", shuffle=True, columns=["text", "audience"]):
        yield {"text": r["text"], "audience": r.get("audience")}


def tinydialogues(size):
    for line in _lines("datasets/styfeng/TinyDialogues/tinydialogue_train_ordered.txt"):
        for doc in line.split(EOT):
            turns = []
            for t in doc.split("\\n\\n"):
                m = re.match(r'\s*\*\*(.+?)\*\*\s*:\s*(.+)', t.strip(), re.S)
                if m:
                    turns.append((m.group(1).strip(), m.group(2).strip().strip('"')))
            if turns:
                yield {"turns": turns}


def soda(size):
    for r in _ds("allenai/soda", split="train", shuffle=True, columns=["dialogue", "speakers"]):
        d, s = r["dialogue"], r["speakers"]
        d = ast.literal_eval(d) if isinstance(d, str) else d
        s = ast.literal_eval(s) if isinstance(s, str) else s
        if d and len(d) == len(s) and 4 <= len(d) <= 12:
            yield {"turns": list(zip(s, d))}


def _chat(msgs):
    names = {"user": "User", "assistant": "Assistant"}
    return [(names[m["role"]], m["content"]) for m in msgs if m["role"] in names]


def ultrachat(size):
    for r in _ds("HuggingFaceH4/ultrachat_200k", split="train_sft", shuffle=True, columns=["messages"]):
        yield {"turns": _chat(r["messages"])}


def smoltalk(size):
    # interleave the three configs so none is exhausted first
    its = [iter(_ds("HuggingFaceTB/smoltalk", c, split="train", shuffle=True, columns=["messages"]))
           for c in ("everyday-conversations", "smol-summarize", "smol-rewrite")]
    while its:
        for it in list(its):
            try:
                yield {"turns": _chat(next(it)["messages"])}
            except StopIteration:
                its.remove(it)


def tinyhelen(size):
    base = "hf://datasets/EmpathYang/TinyHelen/data/leaner/100M/train/"
    fs = HfFileSystem()
    files = sorted(p for p in fs.ls("datasets/EmpathYang/TinyHelen/data/leaner/100M/train", detail=False)
                   if any(k in p.split("/")[-1] for k in ("book", "conversation", "textbook", "web", "wiki")))
    streams = [iter(load_dataset("json", data_files=base + p.split("/")[-1], split="train", streaming=True))
               for p in files]
    # round-robin over the genre files so the mix is balanced
    while streams:
        for it in list(streams):
            try:
                yield {"text": next(it)["text"]}
            except StopIteration:
                streams.remove(it)


def simplewiki(size):
    for r in _ds("wikimedia/wikipedia", "20231101.simple", split="train", shuffle=True, columns=["text", "title"]):
        yield {"text": r["text"], "title": r["title"]}


def enwiki_intro(size):
    for r in _ds("wikimedia/wikipedia", "20231101.en", split="train", shuffle=True, columns=["text", "title"]):
        intro = r["text"].split("\n\n")[0]
        yield {"text": intro, "title": r["title"]}


def cosmo_v2(size):
    kids = {"young_children", "middle_school_students", "grade_school_students", "children"}
    for r in _ds("HuggingFaceTB/smollm-corpus", "cosmopedia-v2", split="train", shuffle=True,
                 columns=["text", "audience", "format"]):
        if size == "10M" and r["audience"] not in kids:
            continue
        yield {"text": r["text"], "audience": r["audience"], "format": r["format"]}


def cosmo_v01(size):
    its = [iter(_ds("HuggingFaceTB/cosmopedia", c, split="train", shuffle=True, columns=["text"]))
           for c in ("wikihow", "khanacademy", "openstax")]
    while its:
        for it in list(its):
            try:
                yield {"text": next(it)["text"]}
            except StopIteration:
                its.remove(it)


def tiny_textbooks(size):
    # `text` is raw web (RefinedWeb); `textbook` is the synthetic lesson we want
    for r in _ds("nampdn-ai/tiny-textbooks", split="train", shuffle=True, columns=["textbook"]):
        yield {"text": r["textbook"]}


def fineweb_edu(size):
    for r in _ds("HuggingFaceFW/fineweb-edu", "sample-10BT", split="train", columns=["text", "int_score"]):
        if r["int_score"] >= 4:
            yield {"text": r["text"]}


def gutenberg_books(size):
    # whole books per row: a 20k-row shuffle buffer overflows Arrow's 2 GB string offsets, and each
    # file decodes ~300 MB row groups, so reading 10 files at once peaks near 6 GB
    for r in _ds("manu/project_gutenberg", split="en", shuffle=True, buffer=8, columns=["text"],
                 input_shards=INPUT_SHARDS.get("gutenberg_books")):
        t = r["text"]
        a = re.search(r"\*\*\* ?START OF (THE|THIS) PROJECT GUTENBERG[^\n]*\n", t)
        b = re.search(r"\*\*\* ?END OF (THE|THIS) PROJECT GUTENBERG", t)
        if a:
            t = t[a.end():]
        if b:
            t = t[:t.rfind("*** END")] if "*** END" in t else t[:b.start()]
        paras = [re.sub(r"\s*\n\s*", " ", p).strip() for p in re.split(r"\n\s*\n", t)]
        paras = [p for p in paras if p and not (p.isupper() and len(p) < 80)]
        chunk, n = [], 0
        for p in paras:
            chunk.append(p)
            n += len(p.split())
            if n >= 300:
                yield {"text": "\n\n".join(chunk)}
                chunk, n = [], 0


def poetry(size):
    rng = random.Random(SEED)
    cur, lines, target = None, [], rng.randint(4, 20)
    for r in _ds("biglam/gutenberg-poetry-corpus", split="train", columns=["line", "gutenberg_id"]):
        if r["gutenberg_id"] != cur:
            cur, lines = r["gutenberg_id"], []
        lines.append(r["line"].strip())
        if len(lines) >= target:
            yield {"text": "\n".join(lines)}
            lines, target = [], rng.randint(4, 20)


def cnn(size):
    for r in _ds("abisee/cnn_dailymail", "3.0.0", split="train", shuffle=True, columns=["article", "highlights", "id"]):
        text = r["article"]
        if zlib.crc32(r["id"].encode()) % 10 < 3:
            text += "\n\nIn short: " + " ".join(r["highlights"].split("\n"))
        yield {"text": text}


REGISTRY = {f.__name__: f for f in (
    tinystories, simplestories, cosmo_stories, tinydialogues, soda, ultrachat, smoltalk,
    tinyhelen, simplewiki, enwiki_intro, cosmo_v2, cosmo_v01, tiny_textbooks, fineweb_edu,
    gutenberg_books, poetry, cnn)}

	"""Streaming adapters. Each yields dicts: {"text"} or {"turns": [(speaker, text)]}, optional "title"."""
	import ast
	import random
	import re
	import zlib

	from datasets import load_dataset
	from huggingface_hub import HfFileSystem

	SEED = 0
	EOT = "<\|endoftext\|>"
	# (index, count): set by build_pool.py workers so each one streams a disjoint part of a dataset
	SHARD = None
	# adapter -> how many files `datasets` reads at once to fill a shuffle buffer (its default is 10).
	# Set by build_pool.py; left empty, every build picks the same documents as before.
	INPUT_SHARDS = {}


	def _ds(args, shuffle=False, buffer=20000, columns=None, input_shards=None, *kw):
	# read only the columns an adapter uses: Arrow batches and the shuffle buffer hold whole rows, and
	# Cosmopedia's long prompts nearly double a worker's memory (2.9 -> 1.5 GB). Parquet skips them on
	# read; a format without that option drops them after. Rows and their order do not change.
	try:
	ds = load_dataset(args, streaming=True, ({"columns": columns} if columns else {}), *kw)
	except (TypeError, ValueError):
	ds = load_dataset(args, streaming=True, *kw)
	if columns:
	ds = ds.select_columns(columns)
	if SHARD and SHARD[1] > 1:
	i, k = SHARD
	# whole files when there are enough of them, otherwise every k-th row (each worker
	# then downloads the full stream but only processes its rows)
	if ds.n_shards >= k:
	ds = ds.shard(num_shards=k, index=i)
	else:
	ds = ds.filter(lambda _, idx: idx % k == i, with_indices=True)
	if not shuffle:
	return ds
	if input_shards:
	return ds.shuffle(seed=SEED, buffer_size=buffer, max_buffer_input_shards=input_shards)
	return ds.shuffle(seed=SEED, buffer_size=buffer)


	def _lines(path):
	with HfFileSystem().open(path, "r", encoding="utf-8", errors="replace") as f:
	yield from f


	def tinystories(size):
	buf = []
	for line in _lines("datasets/roneneldan/TinyStories/TinyStoriesV2-GPT4-train.txt"):
	if EOT in line:
	text = " ".join(buf).strip()
	buf = []
	if text:
	# the source lost curly quotes as U+FFFD: between letters it was an apostrophe
	text = re.sub(r"(?<=\w)�(?=\w)", "'", text).replace("�", '"')
	yield {"text": text}
	else:
	buf.append(line.strip())


	def simplestories(size):
	for r in _ds("SimpleStories/SimpleStories", split="train", shuffle=True, columns=["story"]):
	yield {"text": r["story"]}


	def cosmo_stories(size):
	for r in _ds("HuggingFaceTB/cosmopedia", "stories", split="train", shuffle=True, columns=["text", "audience"]):
	yield {"text": r["text"], "audience": r.get("audience")}


	def tinydialogues(size):
	for line in _lines("datasets/styfeng/TinyDialogues/tinydialogue_train_ordered.txt"):
	for doc in line.split(EOT):
	turns = []
	for t in doc.split("\\n\\n"):
	m = re.match(r'\s\\(.+?)\\\s:\s*(.+)', t.strip(), re.S)
	if m:
	turns.append((m.group(1).strip(), m.group(2).strip().strip('"')))
	if turns:
	yield {"turns": turns}


	def soda(size):
	for r in _ds("allenai/soda", split="train", shuffle=True, columns=["dialogue", "speakers"]):
	d, s = r["dialogue"], r["speakers"]
	d = ast.literal_eval(d) if isinstance(d, str) else d
	s = ast.literal_eval(s) if isinstance(s, str) else s
	if d and len(d) == len(s) and 4 <= len(d) <= 12:
	yield {"turns": list(zip(s, d))}


	def _chat(msgs):
	names = {"user": "User", "assistant": "Assistant"}
	return [(names[m["role"]], m["content"]) for m in msgs if m["role"] in names]


	def ultrachat(size):
	for r in _ds("HuggingFaceH4/ultrachat_200k", split="train_sft", shuffle=True, columns=["messages"]):
	yield {"turns": _chat(r["messages"])}


	def smoltalk(size):
	# interleave the three configs so none is exhausted first
	its = [iter(_ds("HuggingFaceTB/smoltalk", c, split="train", shuffle=True, columns=["messages"]))
	for c in ("everyday-conversations", "smol-summarize", "smol-rewrite")]
	while its:
	for it in list(its):
	try:
	yield {"turns": _chat(next(it)["messages"])}
	except StopIteration:
	its.remove(it)


	def tinyhelen(size):
	base = "hf://datasets/EmpathYang/TinyHelen/data/leaner/100M/train/"
	fs = HfFileSystem()
	files = sorted(p for p in fs.ls("datasets/EmpathYang/TinyHelen/data/leaner/100M/train", detail=False)
	if any(k in p.split("/")[-1] for k in ("book", "conversation", "textbook", "web", "wiki")))
	streams = [iter(load_dataset("json", data_files=base + p.split("/")[-1], split="train", streaming=True))
	for p in files]
	# round-robin over the genre files so the mix is balanced
	while streams:
	for it in list(streams):
	try:
	yield {"text": next(it)["text"]}
	except StopIteration:
	streams.remove(it)


	def simplewiki(size):
	for r in _ds("wikimedia/wikipedia", "20231101.simple", split="train", shuffle=True, columns=["text", "title"]):
	yield {"text": r["text"], "title": r["title"]}


	def enwiki_intro(size):
	for r in _ds("wikimedia/wikipedia", "20231101.en", split="train", shuffle=True, columns=["text", "title"]):
	intro = r["text"].split("\n\n")[0]
	yield {"text": intro, "title": r["title"]}


	def cosmo_v2(size):
	kids = {"young_children", "middle_school_students", "grade_school_students", "children"}
	for r in _ds("HuggingFaceTB/smollm-corpus", "cosmopedia-v2", split="train", shuffle=True,
	columns=["text", "audience", "format"]):
	if size == "10M" and r["audience"] not in kids:
	continue
	yield {"text": r["text"], "audience": r["audience"], "format": r["format"]}


	def cosmo_v01(size):
	its = [iter(_ds("HuggingFaceTB/cosmopedia", c, split="train", shuffle=True, columns=["text"]))
	for c in ("wikihow", "khanacademy", "openstax")]
	while its:
	for it in list(its):
	try:
	yield {"text": next(it)["text"]}
	except StopIteration:
	its.remove(it)


	def tiny_textbooks(size):
	# `text` is raw web (RefinedWeb); `textbook` is the synthetic lesson we want
	for r in _ds("nampdn-ai/tiny-textbooks", split="train", shuffle=True, columns=["textbook"]):
	yield {"text": r["textbook"]}


	def fineweb_edu(size):
	for r in _ds("HuggingFaceFW/fineweb-edu", "sample-10BT", split="train", columns=["text", "int_score"]):
	if r["int_score"] >= 4:
	yield {"text": r["text"]}


	def gutenberg_books(size):
	# whole books per row: a 20k-row shuffle buffer overflows Arrow's 2 GB string offsets, and each
	# file decodes ~300 MB row groups, so reading 10 files at once peaks near 6 GB
	for r in _ds("manu/project_gutenberg", split="en", shuffle=True, buffer=8, columns=["text"],
	input_shards=INPUT_SHARDS.get("gutenberg_books")):
	t = r["text"]
	a = re.search(r"\\\* ?START OF (THE\|THIS) PROJECT GUTENBERG[^\n]*\n", t)
	b = re.search(r"\\\* ?END OF (THE\|THIS) PROJECT GUTENBERG", t)
	if a:
	t = t[a.end():]
	if b:
	t = t[:t.rfind("* END")] if "* END" in t else t[:b.start()]
	paras = [re.sub(r"\s\n\s", " ", p).strip() for p in re.split(r"\n\s*\n", t)]
	paras = [p for p in paras if p and not (p.isupper() and len(p) < 80)]
	chunk, n = [], 0
	for p in paras:
	chunk.append(p)
	n += len(p.split())
	if n >= 300:
	yield {"text": "\n\n".join(chunk)}
	chunk, n = [], 0


	def poetry(size):
	rng = random.Random(SEED)
	cur, lines, target = None, [], rng.randint(4, 20)
	for r in _ds("biglam/gutenberg-poetry-corpus", split="train", columns=["line", "gutenberg_id"]):
	if r["gutenberg_id"] != cur:
	cur, lines = r["gutenberg_id"], []
	lines.append(r["line"].strip())
	if len(lines) >= target:
	yield {"text": "\n".join(lines)}
	lines, target = [], rng.randint(4, 20)


	def cnn(size):
	for r in _ds("abisee/cnn_dailymail", "3.0.0", split="train", shuffle=True, columns=["article", "highlights", "id"]):
	text = r["article"]
	if zlib.crc32(r["id"].encode()) % 10 < 3:
	text += "\n\nIn short: " + " ".join(r["highlights"].split("\n"))
	yield {"text": text}


	REGISTRY = {f.__name__: f for f in (
	tinystories, simplestories, cosmo_stories, tinydialogues, soda, ultrachat, smoltalk,
	tinyhelen, simplewiki, enwiki_intro, cosmo_v2, cosmo_v01, tiny_textbooks, fineweb_edu,
	gutenberg_books, poetry, cnn)}