| |
| """v3-Trainingsdaten (rein deterministisch, ohne 27B; die Wahrheit ist immer bekannt). |
| |
| Neu gegenueber v2/Hardcore: |
| * Leerzeichen zaehlen als Zeichen und stehen als sichtbares Symbol (SPACE) in Spreizung/Positionen |
| * neue Beispiele: Ueberlaenge 46-80 Zeichen, Saetze, Code, Pfade/URLs/Mails, Sonderzeichen-Gruppen |
| * Zaehlspektakel beginnt mit einer Ansage 'Ich zaehle bis N!'; Variante 'counter' schreibt hinter jede Zahl [k/N] |
| * die alten Beispiele (v2 + Hardcore, 4172) werden ins neue Format umgeschrieben (stoerender '.' nach dem Think-Block entfaellt) |
| Ausgabe: v3/dataset_v3_<variante>.jsonl, v3/heldout_v3.json (frisches Testset, nie im Training). |
| |
| Aufruf: v3_data.py [--selftest] |
| """ |
| import json |
| import os |
| import random |
| import re |
| import string |
| import sys |
| from collections import Counter |
| from pathlib import Path |
|
|
| os.environ["CUDA_VISIBLE_DEVICES"] = "" |
| sys.path.insert(0, "/mnt/models/graf_zahl") |
| from generate_hardcore_massive import PERF_RE, TC, TO, canonical_number |
|
|
| PLATTE = "/home/david/Schreibtisch/Platte" |
| OUTDIR = Path(f"{PLATTE}/models/graf_zahl/v3") |
| MIX = f"{PLATTE}/models/graf_zahl/mixed_hardcore_dataset.jsonl" |
| CPT = "/mnt/models/graf_zahl/cpt_data/fineweb_heal_dataset.jsonl" |
| POOL = "/mnt/models/graf_zahl/word_pool_hardcore.json" |
| TESTS = [f"{PLATTE}/models/graf_zahl/ab_test_results.json", f"{PLATTE}/models/graf_zahl/generalization_results.json"] |
| TOKENIZER = f"{PLATTE}/models/graf_zahl/qwen_healed_merged" |
| SPACE = "␣" |
| SEED = 3407 |
| VARIANTS = ("plain", "counter") |
|
|
| N_LONG, N_SPACE_CODE, N_RUNS = 500, 700, 300 |
|
|
|
|
| def sym(c): |
| return SPACE if c == " " else c |
|
|
|
|
| def build_think(text): |
| n = len(text) |
| lines = [TO, f"Wort: {text}", "Spreizung: " + " - ".join(sym(c) for c in text), "Zählung:"] |
| lines += [f"[Position {i}: {sym(c)}] -> Zähler: {i}." for i, c in enumerate(text, 1)] |
| lines += [f"Zur Sicherheit nachgezählt: {n}.", TC] |
| return "\n".join(lines) |
|
|
|
|
| def build_spectacle(n, comments, variant): |
| items = [] |
| for i in range(1, n + 1): |
| s = f"{canonical_number(i)}! Ah ah ah! ({comments[i - 1]})" |
| items.append(s + f" [{i}/{n}]" if variant == "counter" else s) |
| return f"Ich zähle bis {n}!\n" + " ".join(items) + f" Das sind {n}." |
|
|
|
|
| def build_assistant(text, comments, variant): |
| return build_think(text) + "\n" + build_spectacle(len(text), comments, variant) |
|
|
|
|
| ITEM_RE = re.compile(r"([A-Za-zäöüÄÖÜß]+)! Ah ah ah! \(([^()\n]{1,80})\)(?: \[(\d+)/(\d+)\])?") |
|
|
|
|
| def validate(text, assistant, variant): |
| """Rueckgabe: Fehlertext oder None. Prueft gegen die Wahrheit (text).""" |
| n = len(text) |
| head = build_think(text) + f"\nIch zähle bis {n}!\n" |
| if not assistant.startswith(head): |
| return "Think-Block oder Ansage weicht ab" |
| perf = assistant[len(head):] |
| items = ITEM_RE.findall(perf) |
| if len(items) != n: |
| return f"{len(items)} Zahlen statt {n}" |
| for i, (num, _, k, nn) in enumerate(items, 1): |
| if num != canonical_number(i): |
| return f"Zahlwort {i}" |
| if variant == "counter" and (k, nn) != (str(i), str(n)): |
| return f"Zaehler {i}" |
| if build_assistant(text, [c for _, c, _, _ in items], variant) != assistant: |
| return "Format weicht ab" |
| return None |
|
|
|
|
| |
| def load_sentences(exclude_words, limit_articles=8000): |
| out = [] |
| for i, line in enumerate(open(CPT, encoding="utf-8")): |
| if i >= limit_articles: |
| break |
| for s in re.split(r"(?<=[a-zäöüß][.!?])\s+", json.loads(line)["text"][:4000]): |
| s = s.strip() |
| if (20 <= len(s) <= 80 and re.fullmatch(r"[A-Za-zÄÖÜäöüß0-9 ,.;:!?()\-]+", s) and " " not in s |
| and s[0].isupper() and s[-1] in ".!?" and len(s.split()) >= 4 |
| and sum(c.isalpha() for c in s) >= 0.7 * len(s) |
| and not any(w in s.lower() for w in exclude_words)): |
| out.append(s) |
| return sorted(set(out)) |
|
|
|
|
| def load_pool_words(exclude_words): |
| return [p["wort"] for p in json.load(open(POOL, encoding="utf-8")) |
| if not any(w in p["wort"].lower() for w in exclude_words)] |
|
|
|
|
| def load_excluded(): |
| words, strings = set(), set() |
| for p in TESTS: |
| for r in json.load(open(p, encoding="utf-8")): |
| t = r.get("wort") or r.get("text") |
| (strings if r.get("text") else words).add(t.lower()) |
| strings.add(t) |
| return words | {w for w in strings if len(w) >= 8 and w.isalpha()}, strings |
|
|
|
|
| def load_comments(): |
| c = Counter() |
| for line in open(f"/mnt/models/graf_zahl/dataset_massive_v2.jsonl", encoding="utf-8"): |
| for _, cm in PERF_RE.findall(json.loads(line)["messages"][2]["content"]): |
| cm = cm.strip() |
| if cm and len(cm) <= 40 and not re.search(r"\d", cm): |
| c[cm] += 1 |
| return [k for k, _ in c.most_common(40)] |
|
|
|
|
| |
| SYMS = "!#$%&*+-=?_.:;,@/|~^" |
| BRACKETS = "()[]{}<>" |
|
|
|
|
| def rand_alnum(r, n): |
| return "".join(r.choice(string.ascii_letters + string.digits) for _ in range(n)) |
|
|
|
|
| def rand_sym(r, n): |
| return "".join(r.choice(string.ascii_letters + string.digits + SYMS + BRACKETS) for _ in range(n)) |
|
|
|
|
| def compound(r, words, lo, hi): |
| for _ in range(200): |
| parts, total = [], 0 |
| while total < lo: |
| w = r.choice(words) |
| if total + len(w) > hi: |
| break |
| parts.append(w if not parts else w[0].lower() + w[1:]) |
| total += len(w) |
| if lo <= total <= hi: |
| return "".join(parts) |
| return None |
|
|
|
|
| def runs(r, lo, hi): |
| pool = string.ascii_letters + string.digits + SYMS + "()[]{}<>" |
| s, prev = "", None |
| target = r.randint(lo, hi) |
| while len(s) < target: |
| c = r.choice([x for x in pool if x != prev]) |
| s += c * r.randint(2, 5) |
| prev = c |
| return s[:target] if r.random() < 0.5 else s[:target] + rand_alnum(r, 0) |
|
|
|
|
| def hexs(r, n): |
| return "".join(r.choice("0123456789abcdef") for _ in range(n)) |
|
|
|
|
| def code_like(r, words): |
| w = lambda: r.choice(["count", "total", "value", "index", "result", "name", "data", "item", "size", "temp"]) |
| n = lambda: str(r.randint(1, 999)) |
| a, b, f = w(), w(), w() |
| kind = r.randrange(24) |
| return [ |
| f"def {f}({a}): return {a} + {n()}", f"for {a} in range({n()}):", f'print("{r.choice(words)[:10]}")', |
| f"if {a} > {n()}: {b} = {a}", f"{a} = [{n()}, {n()}, {n()}]", f"import {r.choice(['os', 'sys', 'json', 'math', 'time'])}", |
| f"while {a} < {n()}:", f"return {a}[{r.randint(0, 9)}]", f"SELECT {a} FROM {b} WHERE id = {n()};", |
| f"UPDATE {a} SET {b} = {n()} WHERE id = {n()};", f"const {a} = {n()} * {n()};", f"console.log({a});", |
| f"function {f}({a}) {{ return {a}; }}", f'<div class="{a}">{r.choice(words)[:8]}</div>', f'<a href="/{a}">{b}</a>', |
| f"ls -la /home/{a}", f'grep -r "{a}" ./src', f"cd ../{a} && make", f"{a}.{b}({n()})", f"x = {n()} if {a} else {n()}", |
| f"git commit -m \"{a} {b}\"", f"{a}[{b}] = {a}[{f}] + {n()};", f"int {a} = {n()};", f"#include <{r.choice(['stdio', 'stdlib', 'string'])}.h>", |
| ][kind] |
|
|
|
|
| def misc_string(r, words): |
| kind = r.randrange(10) |
| name = lambda: r.choice(["max", "anna", "tom", "lisa", "peter", "julia"]) |
| dom = lambda: r.choice(["example", "mail", "firma", "test", "server"]) |
| return [ |
| f"/usr/local/bin/{r.choice(['python', 'node', 'gcc', 'tool'])}{r.randint(1, 9)}", f"https://www.{dom()}.de/{r.choice(['seite', 'blog', 'shop'])}/{r.randint(1, 999)}", |
| f"{name()}.{name()}@{dom()}.de", f"{r.randint(1, 255)}.{r.randint(0, 255)}.{r.randint(0, 255)}.{r.randint(0, 255)}", |
| ":".join(hexs(r, 2).upper() for _ in range(6)), f"{hexs(r, 8)}-{hexs(r, 4)}-{hexs(r, 4)}-{hexs(r, 12)}"[:r.randint(30, 36)], |
| f"0x{hexs(r, r.randint(6, 16))}", f"2026-{r.randint(1, 12):02d}-{r.randint(1, 28):02d} {r.randint(0, 23):02d}:{r.randint(0, 59):02d}:{r.randint(0, 59):02d}", |
| f"v{r.randint(1, 9)}.{r.randint(0, 99)}.{r.randint(0, 999)}-{r.choice(['beta', 'rc1', 'alpha'])}", |
| json.dumps({r.choice(["id", "name", "wert"]): r.randint(1, 99), "ok": r.choice([True, False])}), |
| ][kind] |
|
|
|
|
| |
| Q_STR = ["Wie viele Zeichen hat der String {q}?", "Zähle die Zeichen in {q}.", "Wie lang ist {q} (in Zeichen)?", |
| "Bitte zähle alle Zeichen von {q}.", "How many characters are in {q}?", "Hey Graf, wie viele Zeichen hat {q}?", |
| "Wie viele Zeichen hat das Wort {q}?", "Zerlege und zähle: {q}"] |
|
|
|
|
| def quote(s): |
| for a, b in (("'", "'"), ('"', '"'), ("«", "»")): |
| if a not in s and b not in s: |
| return f"{a}{s}{b}" |
| return f"«{s}»" |
|
|
|
|
| def make_prompt(r, text): |
| tpl = r.choice(Q_STR) |
| if " " in text and r.random() < 0.5: |
| tpl += " Leerzeichen zählen mit." if not tpl.startswith("How") else " Count the spaces too." |
| return tpl.format(q=quote(text)) |
|
|
|
|
| |
| def build_new(seed, counts, words, sentences, excluded_strings, taken): |
| r = random.Random(seed) |
| rows = [] |
|
|
| def add(text, kat): |
| if text and 7 <= len(text) <= 80 and text not in excluded_strings and text not in taken and text == text.strip() and " " not in text: |
| taken.add(text) |
| rows.append((kat, text)) |
| return True |
| return False |
|
|
| def fill(kat, n, fn): |
| c, tries = 0, 0 |
| while c < n and tries < n * 50: |
| tries += 1 |
| c += add(fn(), kat) |
|
|
| long_n, sc_n, run_n = counts |
| fill("lang", int(long_n * 0.30), lambda: rand_alnum(r, r.randint(46, 80))) |
| fill("lang", int(long_n * 0.20), lambda: rand_sym(r, r.randint(46, 80))) |
| fill("lang", int(long_n * 0.25), lambda: compound(r, words, 46, 80)) |
| long_sent = [s for s in sentences if len(s) >= 46] |
| fill("lang", int(long_n * 0.25), lambda: r.choice(long_sent) if long_sent else None) |
| short_sent = [s for s in sentences if len(s) <= 60] |
| fill("satz", int(sc_n * 0.36), lambda: r.choice(short_sent)) |
| fill("code", int(sc_n * 0.36), lambda: code_like(r, words)) |
| fill("misc", int(sc_n * 0.28), lambda: misc_string(r, words)) |
| fill("runs", run_n, lambda: runs(r, 8, 45)) |
| return rows |
|
|
|
|
| def rewrite_old(variant, comments_pool): |
| rows = [] |
| for i, line in enumerate(open(MIX, encoding="utf-8")): |
| ex = json.loads(line) |
| a = ex["messages"][2]["content"] |
| text = re.search(r"^Wort: (.+)$", a, re.M).group(1) |
| cms = [c.strip() for _, c in PERF_RE.findall(a.split("</think>")[-1])] |
| if len(cms) != len(text): |
| continue |
| ex["messages"][2]["content"] = build_assistant(text, cms, variant) |
| rows.append(("alt", text, ex)) |
| return rows |
|
|
|
|
| def main(): |
| OUTDIR.mkdir(parents=True, exist_ok=True) |
| ex_words, ex_strings = load_excluded() |
| words = [w for w in load_pool_words(ex_words) if len(w) <= 30] |
| sentences = [s for s in load_sentences(ex_words)] |
| comments = load_comments() |
| v2_system = json.loads(open(MIX, encoding="utf-8").readline())["messages"][0]["content"] |
| print(f"Woerter {len(words)}, Saetze {len(sentences)}, Kommentare {len(comments)}, ausgeschlossene Teststrings {len(ex_strings)}", flush=True) |
|
|
| taken = set() |
| new = build_new(SEED, (N_LONG, N_SPACE_CODE, N_RUNS), words, sentences, ex_strings, taken) |
| held = build_new(777, (0, 0, 0), words, sentences, ex_strings, taken) |
| print("Neue Beispiele:", dict(Counter(k for k, _ in new)), "gesamt", len(new), flush=True) |
|
|
| |
| rh = random.Random(777) |
| hs = [] |
| def add_h(kat, text, n): |
| if text and text not in taken and text not in ex_strings and text == text.strip() and " " not in text and 7 <= len(text) <= 80: |
| taken.add(text); hs.append({"kategorie": kat, "text": text, "prompt": make_prompt(rh, text)}) |
| tries = 0 |
| plan = [("H Satz (Leerzeichen)", 8, lambda: rh.choice(sentences)), ("H Code", 8, lambda: code_like(rh, words)), |
| ("H Pfad/URL/Mail/IP", 6, lambda: misc_string(rh, words)), ("H Sonderzeichen-Gruppen", 6, lambda: runs(rh, 8, 45)), |
| ("H Zufall 50-75", 6, lambda: rand_sym(rh, rh.randint(50, 75))), ("H Satz 55-75", 4, lambda: rh.choice([s for s in sentences if len(s) >= 55])), |
| ("H Kompositum 50-75", 4, lambda: compound(rh, words, 50, 75))] |
| for kat, n, fn in plan: |
| have = 0 |
| while have < n and tries < 5000: |
| tries += 1 |
| before = len(hs); add_h(kat, fn(), n); have += len(hs) - before |
| json.dump(hs, open(OUTDIR / "heldout_v3.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1) |
| print("Testset:", dict(Counter(h["kategorie"] for h in hs)), "gesamt", len(hs), flush=True) |
|
|
| for variant in VARIANTS: |
| rng = random.Random(SEED) |
| allrows = rewrite_old(variant, comments) |
| for kat, text in new: |
| cms = [rng.choice(comments) for _ in text] |
| ex = {"messages": [{"role": "system", "content": v2_system}, |
| {"role": "user", "content": make_prompt(rng, text)}, |
| {"role": "assistant", "content": build_assistant(text, cms, variant)}]} |
| allrows.append((kat, text, ex)) |
| bad = [(k, t[:30], validate(t, e["messages"][2]["content"], variant)) for k, t, e in allrows |
| if validate(t, e["messages"][2]["content"], variant)] |
| assert not bad, bad[:3] |
| seen_t, dedup = set(), [] |
| for row in allrows: |
| if row[1] in seen_t: |
| continue |
| seen_t.add(row[1]) |
| dedup.append(row) |
| print(f"[{variant}] {len(allrows) - len(dedup)} doppelte Texte entfernt", flush=True) |
| allrows = dedup |
| rng.shuffle(allrows) |
| out = OUTDIR / f"dataset_v3_{variant}.jsonl" |
| with open(out, "w", encoding="utf-8") as f: |
| for _, _, e in allrows: |
| f.write(json.dumps(e, ensure_ascii=False) + "\n") |
| print(f"[{variant}] {len(allrows)} Beispiele, alle validiert -> {out} ({out.stat().st_size / 1e6:.1f} MB)", flush=True) |
|
|
|
|
| def selftest(): |
| for variant in VARIANTS: |
| for t in ("Kaffee", "Hallo Welt", "arr[i] = 1;", "@@@###$$$%%%"): |
| a = build_assistant(t, ["Donner"] * len(t), variant) |
| assert validate(t, a, variant) is None, (variant, t) |
| assert validate(t, a.replace(f"Ich zähle bis {len(t)}!", "Ich zähle bis 99!"), variant) is not None |
| assert validate(t + "x", a, variant) is not None |
| assert validate("ab cd", build_assistant("ab cd", ["Blitz"] * 5, "plain"), "plain") is None |
| assert SPACE in build_think("a b") |
| print("Selbsttest bestanden: Think-Block mit Leerzeichen-Symbol, beide Spektakel-Varianten, Fehlererkennung.") |
|
|
|
|
| if __name__ == "__main__": |
| selftest() if "--selftest" in sys.argv else main() |
|
|
