Download code/scripts/charts.py from KeremTT/OPUS-5.5-DATABASE: direct link, hf CLI and curl.
- Browser
- Download file 16.2 kB
-
https://huggingface.co/datasets/KeremTT/OPUS-5.5-DATABASE/resolve/main/code/scripts/charts.py
- Command line
-
hf download hf://datasets/KeremTT/OPUS-5.5-DATABASE/code/scripts/charts.py
-
curl -L -o charts.py https://huggingface.co/datasets/KeremTT/OPUS-5.5-DATABASE/resolve/main/code/scripts/charts.py
16.2 kB
| """Render the dataset-card charts from out/stats/*.json into out/assets/*.png. | |
| Measured charts use real numbers produced by build.py / train/*.py. Projection charts | |
| are computed from published scaling laws and are labelled as projections. | |
| """ | |
| import json | |
| import math | |
| import os | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt # noqa: E402 | |
| import matplotlib.ticker # noqa: E402 | |
| import numpy as np # noqa: E402 | |
| OUT = os.environ.get("OPUSDB_OUT", "out") | |
| ST = os.path.join(OUT, "stats") | |
| AS = os.path.join(OUT, "assets") | |
| os.makedirs(AS, exist_ok=True) | |
| # Validated categorical palette (fixed order), light surface. | |
| C = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"] | |
| SURFACE, INK, INK2, GRID = "#fcfcfb", "#0b0b0b", "#52514e", "#e6e5e0" | |
| plt.rcParams.update({ | |
| "figure.facecolor": SURFACE, "axes.facecolor": SURFACE, "savefig.facecolor": SURFACE, | |
| "axes.edgecolor": GRID, "axes.labelcolor": INK2, "xtick.color": INK2, "ytick.color": INK2, | |
| "text.color": INK, "axes.grid": True, "grid.color": GRID, "grid.linewidth": 0.8, | |
| "axes.spines.top": False, "axes.spines.right": False, "font.size": 10.5, | |
| "axes.titlesize": 13, "axes.titleweight": "bold", "axes.titlelocation": "left", "figure.dpi": 150, | |
| }) | |
| def load(name): | |
| p = os.path.join(ST, name + ".json") | |
| return json.load(open(p)) if os.path.exists(p) else None | |
| def save(fig, name): | |
| fig.tight_layout() | |
| fig.savefig(os.path.join(AS, name), bbox_inches="tight") | |
| plt.close(fig) | |
| print("chart", name) | |
| def human(n): | |
| for unit, k in (("B", 1e9), ("M", 1e6), ("K", 1e3)): | |
| if n >= k: | |
| return f"{n / k:.1f}{unit}" if n / k < 100 else f"{n / k:.0f}{unit}" | |
| return str(int(n)) | |
| # ------------------------------------------------------------------ 1. token composition per config | |
| def composition(): | |
| sft, pref, pre = load("sft_sources"), load("preference_sources"), load("pretrain_tokens") | |
| tools = load("tools_sources") | |
| panels = [("pretrain", {k: {"tokens": v} for k, v in (pre or {}).items()}), ("sft", sft or {}), | |
| ("preference", pref or {}), ("tools", tools or {})] | |
| panels = [p for p in panels if p[1]] | |
| fig, axes = plt.subplots(2, 2, figsize=(15, 9.5)) | |
| axes = axes.flatten() | |
| for ax in axes[len(panels):]: | |
| ax.axis("off") | |
| for ax, (title, data) in zip(axes, panels): | |
| items = sorted(data.items(), key=lambda kv: -kv[1]["tokens"]) | |
| names = [k for k, _ in items] | |
| vals = [v["tokens"] for _, v in items] | |
| y = np.arange(len(names))[::-1] | |
| ax.barh(y, vals, color=C[0], height=0.62) | |
| for yi, v in zip(y, vals): | |
| ax.text(v, yi, " " + human(v), va="center", fontsize=9, color=INK2) | |
| ax.set_yticks(y, names) | |
| ax.set_title(f"{title}: {human(sum(vals))} tokens") | |
| ax.set_xlabel("tokens (SmolLM2 tokenizer)") | |
| ax.xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(lambda v, _: human(v) if v else "0")) | |
| ax.grid(axis="y", visible=False) | |
| ax.set_xlim(0, max(vals or [1]) * 1.25) | |
| fig.suptitle("OPUS-5.5-DATABASE — token composition by config and source (measured)", x=0.01, ha="left", | |
| fontweight="bold", fontsize=14) | |
| save(fig, "composition.png") | |
| # ------------------------------------------------------------------ 2. SFT domain + language mix | |
| def sft_mix(): | |
| sft = load("sft_sources") | |
| if not sft: | |
| return | |
| domains = {} | |
| from collections import Counter | |
| langs = Counter() | |
| dom_map = {"smol-magpie-ultra": "general chat", "smol-constraints": "instruction following", | |
| "smol-rewrite": "rewriting", "smol-summarize": "summarization", "oasst2": "human-written chat", | |
| "metamathqa": "math", "openmathinstruct2": "math", "gsm8k": "math", "magicoder-oss": "code", | |
| "codealpaca": "code", "opus-synth": "verified synthetic (EN/TR)"} | |
| for k, v in sft.items(): | |
| d = dom_map.get(k, k) | |
| domains[d] = domains.get(d, 0) + v["rows"] | |
| for kk, vv in v.items(): | |
| if kk.startswith("lang_"): | |
| langs[kk[5:]] += vv | |
| fig, (a1, a2) = plt.subplots(1, 2, figsize=(14, 4.8), gridspec_kw={"width_ratios": [1.5, 1]}) | |
| items = sorted(domains.items(), key=lambda kv: -kv[1]) | |
| y = np.arange(len(items))[::-1] | |
| tot = sum(v for _, v in items) | |
| a1.barh(y, [v for _, v in items], color=C[0], height=0.62) | |
| for yi, (_, v) in zip(y, items): | |
| a1.text(v, yi, f" {v:,} ({100 * v / tot:.1f}%)", va="center", fontsize=9, color=INK2) | |
| a1.set_yticks(y, [k for k, _ in items]) | |
| a1.set_xlim(0, items[0][1] * 1.35) | |
| a1.grid(axis="y", visible=False) | |
| a1.set_title(f"SFT conversations by capability ({tot:,} total)") | |
| top = langs.most_common(6) | |
| other = sum(langs.values()) - sum(v for _, v in top) | |
| labels = [k for k, _ in top] + (["all remaining"] if other else []) | |
| vals = [v for _, v in top] + ([other] if other else []) | |
| y2 = np.arange(len(labels))[::-1] | |
| a2.barh(y2, vals, color=C[2], height=0.62) | |
| for yi, v in zip(y2, vals): | |
| a2.text(v, yi, f" {v:,}", va="center", fontsize=9, color=INK2) | |
| a2.set_yticks(y2, labels) | |
| a2.set_xscale("log") | |
| a2.set_xlim(min(vals) / 2, max(vals) * 8) | |
| a2.grid(axis="y", visible=False) | |
| a2.set_title("SFT conversations by language (log scale)") | |
| save(fig, "sft_mix.png") | |
| # ------------------------------------------------------------------ 3. length distribution | |
| def lengths(): | |
| sl = load("sft_lengths") | |
| pl = load("pretrain_lengths") | |
| fig, (a1, a2) = plt.subplots(1, 2, figsize=(14, 4.6)) | |
| if sl: | |
| bins = np.logspace(1, math.log10(8192), 50) | |
| groups = {"chat & instruction": ("smol-magpie-ultra", "smol-constraints", "smol-rewrite", "smol-summarize", "oasst2"), | |
| "math": ("metamathqa", "openmathinstruct2", "gsm8k"), | |
| "code": ("magicoder-oss", "codealpaca"), "verified synthetic": ("opus-synth",)} | |
| arr, src = np.array(sl["num_tokens"]), np.array(sl["source"]) | |
| for i, (g, srcs) in enumerate(groups.items()): | |
| vals = arr[np.isin(src, srcs)] | |
| a1.hist(vals, bins=bins, histtype="step", linewidth=2, color=C[i], label=f"{g} (median {int(np.median(vals))})") | |
| a1.set_xscale("log") | |
| a1.set_xlabel("tokens per conversation") | |
| a1.set_ylabel("conversations") | |
| a1.set_title("SFT conversation length") | |
| a1.legend(frameon=False, fontsize=9) | |
| if pl: | |
| bins = np.logspace(1.5, 5, 50) | |
| for i, (k, v) in enumerate(pl.items()): | |
| a2.hist(v, bins=bins, histtype="step", linewidth=2, color=C[i], label=f"{k} (median {int(np.median(v))})") | |
| a2.set_xscale("log") | |
| a2.set_xlabel("tokens per document") | |
| a2.set_ylabel("documents (sample)") | |
| a2.set_title("Pretraining document length") | |
| a2.legend(frameon=False, fontsize=9) | |
| save(fig, "lengths.png") | |
| # ------------------------------------------------------------------ 4. filtering funnel | |
| def funnel(): | |
| parts = [("sft", load("sft_funnel")), ("preference", load("preference_funnel")), ("pretrain", load("pretrain_funnel"))] | |
| rows = [] | |
| for cfg, f in parts: | |
| if not f: | |
| continue | |
| for src, c in f.items(): | |
| if not isinstance(c, dict): | |
| continue | |
| read = c.get("read", 0) | |
| kept = c.get("kept", 0) | |
| q = sum(v for k, v in c.items() if k.startswith(("quality", "bad_", "empty", "boiler", "low_", "incomplete", | |
| "no_margin", "identical", "argilla"))) | |
| dup = c.get("exact_duplicate", 0) + c.get("near_duplicate", 0) | |
| con = c.get("benchmark_contaminated", 0) | |
| cap = c.get("over_cap", 0) | |
| rows.append((f"{cfg}/{src}", read, kept, q, dup, con, cap)) | |
| if not rows: | |
| return | |
| fig, ax = plt.subplots(figsize=(13, 0.42 * len(rows) + 1.6)) | |
| y = np.arange(len(rows))[::-1] | |
| labels = ["kept", "quality / format filter", "duplicate (exact + MinHash)", "benchmark-contaminated", "subsampled (cap)"] | |
| cols = [C[2], C[3], C[0], C[7], "#c9c8c2"] | |
| for yi, r in zip(y, rows): | |
| left = 0 | |
| read = max(1, r[1]) | |
| for j, v in enumerate([r[2], r[3], r[4], r[5], r[6]]): | |
| w = 100 * v / read | |
| ax.barh(yi, w, left=left, color=cols[j], height=0.62, edgecolor=SURFACE, linewidth=1.5, | |
| label=labels[j] if yi == y[0] else None) | |
| left += w | |
| ax.text(101, yi, f"{r[2]:,} / {r[1]:,}", va="center", fontsize=8.5, color=INK2) | |
| ax.set_yticks(y, [r[0] for r in rows], fontsize=9) | |
| ax.set_xlim(0, 125) | |
| ax.set_xticks([0, 20, 40, 60, 80, 100]) | |
| ax.set_xlabel("% of rows read") | |
| ax.grid(axis="y", visible=False) | |
| ax.legend(ncol=5, frameon=False, fontsize=9, loc="upper left", bbox_to_anchor=(0, -0.08)) | |
| ax.set_title("Filtering funnel per source (measured): kept rows / rows read") | |
| save(fig, "funnel.png") | |
| # ------------------------------------------------------------------ 5. measured scaling ladder | |
| def ladder(): | |
| lad = load("ladder") | |
| if not lad or not lad.get("runs"): | |
| return | |
| runs = sorted(lad["runs"], key=lambda r: r["total_params"]) | |
| fig, (a1, a2) = plt.subplots(1, 2, figsize=(14, 4.8)) | |
| for i, r in enumerate(runs): | |
| xs = [p["tokens"] for p in r["curve"]] | |
| ys = [p["val_loss"] for p in r["curve"]] | |
| a1.plot(xs, ys, color=C[i], linewidth=2, label=f"{human(r['total_params'])} params") | |
| a1.set_xscale("log") | |
| a1.set_xlabel("training tokens") | |
| a1.set_ylabel("validation loss (nats/token)") | |
| a1.set_title("Measured: validation loss during training") | |
| a1.legend(frameon=False, fontsize=9) | |
| N = np.array([r["total_params"] for r in runs], float) | |
| L = np.array([r["val_loss"] for r in runs]) | |
| a2.plot(N, L, "o", color=C[0], markersize=9, label="measured (final val loss)") | |
| fit = lad.get("fit") | |
| if fit: | |
| xs = np.logspace(math.log10(N.min() / 2), math.log10(N.max() * 30), 100) | |
| a2.plot(xs, fit["E"] + fit["A"] / xs ** fit["alpha"], "--", color=C[1], linewidth=2, | |
| label=f"fit L = {fit['E']:.2f} + {fit['A']:.3g}/N^{fit['alpha']:.2f}") | |
| for n, l in zip(N, L): | |
| a2.annotate(f"{l:.2f}", (n, l), textcoords="offset points", xytext=(6, 6), fontsize=9, color=INK2) | |
| a2.set_xscale("log") | |
| a2.set_xlabel("model parameters (N)") | |
| a2.set_ylabel("final validation loss") | |
| a2.set_title("Measured: loss vs model size on OPUS pretrain") | |
| a2.legend(frameon=False, fontsize=9) | |
| save(fig, "ladder.png") | |
| # ------------------------------------------------------------------ 6. projections (published scaling laws) | |
| SIZES = [0.135, 0.5, 1, 4, 8, 14, 27, 70] # billions | |
| def chinchilla(N, D, E=1.69, A=406.4, B=410.7, a=0.34, b=0.28): | |
| return E + A / N ** a + B / D ** b | |
| def effective_data(U, D, r_star=15.4): | |
| """Muennighoff et al. (2023) data-constrained scaling: value of repeated tokens decays.""" | |
| if D <= U: | |
| return D | |
| R = D / U - 1 | |
| return U + U * r_star * (1 - math.exp(-R / r_star)) | |
| def projections(): | |
| pre = load("pretrain_tokens") | |
| sft = load("sft_sources") | |
| tools = load("tools_sources") or {} | |
| if not pre: | |
| return | |
| U = sum(pre.values()) | |
| fig, (a1, a2) = plt.subplots(1, 2, figsize=(14, 5)) | |
| Ns = np.array(SIZES) * 1e9 | |
| ideal = [chinchilla(n, 20 * n) for n in Ns] | |
| opus = [chinchilla(n, effective_data(U, 20 * n)) for n in Ns] | |
| opus1 = [chinchilla(n, U) for n in Ns] | |
| a1.plot(Ns, ideal, "-o", color=C[0], lw=2, ms=6, label="unlimited unique data, 20 tok/param (Chinchilla optimum)") | |
| a1.plot(Ns, opus, "-o", color=C[1], lw=2, ms=6, label=f"OPUS pretrain only ({human(U)} unique), repeated to 20 tok/param") | |
| a1.plot(Ns, opus1, "--", color=C[6], lw=2, label="OPUS pretrain only, single epoch") | |
| a1.set_xscale("log") | |
| a1.set_xticks(Ns, [f"{s:g}B" for s in SIZES], rotation=45) | |
| a1.minorticks_off() | |
| a1.set_ylabel("projected loss (Chinchilla units, nats)") | |
| a1.set_title("PROJECTION: pretraining from scratch") | |
| a1.legend(frameon=False, fontsize=8.5) | |
| # compute to fine-tune on SFT config (2 epochs) — arithmetic, not a measurement | |
| if sft: | |
| T = sum(v["tokens"] for v in sft.values()) + sum(v["tokens"] for v in tools.values()) | |
| flops = 6 * Ns * T * 2 | |
| h100 = flops / (989e12 * 0.40) / 3600 | |
| lora = h100 / 3 # LoRA skips weight-gradient matmuls for frozen weights (~2/3 of backward) | |
| a2.plot(Ns, h100, "-o", color=C[0], lw=2, ms=6, label="full fine-tune") | |
| a2.plot(Ns, lora, "-o", color=C[2], lw=2, ms=6, label="LoRA (approx.)") | |
| for n, h in zip(Ns, h100): | |
| if n / 1e9 in (0.5, 4, 8, 14, 27, 70): | |
| a2.annotate(f"{h:,.1f} h", (n, h), textcoords="offset points", xytext=(-10, 8), fontsize=9, color=INK2) | |
| a2.set_xscale("log") | |
| a2.set_yscale("log") | |
| a2.set_xticks(Ns, [f"{s:g}B" for s in SIZES], rotation=45) | |
| a2.minorticks_off() | |
| a2.set_ylabel("H100 GPU-hours (40% MFU)") | |
| a2.set_title(f"ESTIMATE: 2 epochs on sft + tools ({human(T)} tokens)") | |
| a2.legend(frameon=False, fontsize=9) | |
| save(fig, "projections.png") | |
| out = {"unique_pretrain_tokens": U, | |
| "rows": [{"params_b": s, "chinchilla_optimal_tokens_b": 20 * s, "epochs_needed_on_opus": 20 * s * 1e9 / U, | |
| "loss_unlimited": ideal[i], "loss_opus_repeated": opus[i], "loss_opus_1epoch": opus1[i]} | |
| for i, s in enumerate(SIZES)]} | |
| json.dump(out, open(os.path.join(ST, "projections.json"), "w"), indent=2) | |
| # ------------------------------------------------------------------ 7. measured model evals on synth_eval | |
| def evals(): | |
| ev = load("evals") | |
| if not ev: | |
| return | |
| base = [r for r in ev if r.get("kind") == "baseline"] | |
| tuned = [r for r in ev if r.get("kind") == "opus-sft"] | |
| fig, (a1, a2) = plt.subplots(1, 2, figsize=(14, 4.8), gridspec_kw={"width_ratios": [1.2, 1]}) | |
| if base: | |
| base = sorted(base, key=lambda r: r["params_b"]) | |
| x = np.arange(len(base)) | |
| a1.bar(x - 0.2, [100 * r["by_language"]["en"] for r in base], 0.38, color=C[0], label="English items") | |
| a1.bar(x + 0.2, [100 * r["by_language"]["tr"] for r in base], 0.38, color=C[1], label="Turkish items") | |
| for xi, r in zip(x, base): | |
| a1.text(xi, 100 * max(r["by_language"].values()) + 2, f"{100 * r['accuracy']:.0f}%", ha="center", | |
| fontsize=9, color=INK) | |
| a1.set_xticks(x, [f"{r['label']}\n{r['params_b']:g}B" for r in base], fontsize=9) | |
| a1.set_ylim(0, 100) | |
| a1.set_ylabel("exact-match accuracy (%)") | |
| a1.set_title(f"Measured: off-the-shelf models on OPUS synth_eval (n={base[0]['n']})") | |
| a1.grid(axis="x", visible=False) | |
| a1.legend(frameon=False, fontsize=9) | |
| if tuned: | |
| pairs = [] | |
| for t in tuned: | |
| b = next((r for r in ev if r["model"] == t["base_model"]), None) | |
| if b: | |
| pairs.append((b, t)) | |
| fams = sorted(pairs[0][1]["by_family"]) if pairs else [] | |
| if pairs: | |
| b, t = pairs[0] | |
| y = np.arange(len(fams) + 1)[::-1] | |
| bv = [100 * b["accuracy"]] + [100 * b["by_family"].get(f, 0) for f in fams] | |
| tv = [100 * t["accuracy"]] + [100 * t["by_family"].get(f, 0) for f in fams] | |
| a2.barh(y + 0.2, bv, 0.38, color="#c9c8c2", label=f"{b['label']} (before)") | |
| a2.barh(y - 0.2, tv, 0.38, color=C[2], label=f"after OPUS-SFT ({t['train_examples']:,} ex.)") | |
| a2.set_yticks(y, ["OVERALL"] + fams, fontsize=9) | |
| a2.set_xlim(0, 100) | |
| a2.set_xlabel("exact-match accuracy (%)") | |
| a2.set_title("Measured: fine-tuning a small model on OPUS-SFT") | |
| a2.grid(axis="y", visible=False) | |
| a2.legend(frameon=False, fontsize=9, loc="lower right") | |
| else: | |
| a2.axis("off") | |
| save(fig, "evals.png") | |
| if __name__ == "__main__": | |
| for f in (composition, sft_mix, lengths, funnel, ladder, projections, evals): | |
| f() | |