| |
| """v4-Zaehldaten (deterministisch): Zeichen zaehlen, Buchstabenhaeufigkeit, Buchstaben insgesamt, Woerter zaehlen. |
| |
| Ohne System-Prompt, ohne Persona, ohne Zaehlshow: <think> mit Spreizung/Zaehlung, danach ein normaler Satz. |
| Jedes Beispiel wird gegen die bekannte Wahrheit validiert. Testtexte (alle Test-Sets) sind ausgeschlossen. |
| |
| Ausgabe: v4/counting_v4.jsonl (Felder: messages, kind, text). Aufruf: v4_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 TC, TO |
| from v3_data import (SPACE, code_like, compound, load_sentences, misc_string, rand_alnum, rand_sym, runs, sym) |
| import v4_tests |
|
|
| PLATTE = "/home/david/Schreibtisch/Platte" |
| V4 = Path(f"{PLATTE}/models/graf_zahl/v4") |
| SEED = 44 |
| COUNTS = {"len_old": 1900, "len_de_word": 700, "len_de_sent": 500, "len_en_sent": 330, "len_en_word": 250, "len_code_misc": 320, |
| "len_periodic": 480, "len_long": 420, "letter": 1500, "letters_all": 350, "words": 400} |
|
|
|
|
| |
| def think_len(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 think_tally(text, label, pred): |
| tally, lines = 0, [TO, f"Wort: {text}", f"Gesucht: {label}", "Spreizung: " + " - ".join(sym(c) for c in text), "Zählung:"] |
| for i, c in enumerate(text, 1): |
| hit = pred(c) |
| tally += hit |
| lines.append(f"[Position {i}: {sym(c)}] -> {'ja!' if hit else 'nein.'} Bisher: {tally}.") |
| lines += [f"Zur Sicherheit nachgezählt: {tally}.", TC] |
| return "\n".join(lines), tally |
|
|
|
|
| def think_words(text): |
| words = text.split() |
| lines = [TO, f"Satz: {text}", "Zählung nach Wörtern (durch Leerzeichen getrennt):"] |
| lines += [f"[Wort {i}: {w}] -> Zähler: {i}." for i, w in enumerate(words, 1)] |
| lines += [f"Zur Sicherheit nachgezählt: {len(words)}.", TC] |
| return "\n".join(lines), len(words) |
|
|
|
|
| |
| def echo_ok(text): |
| return len(text) <= 30 and "„" not in text and "“" not in text and "\n" not in text |
|
|
|
|
| def ans_len(text, n, lang, letters_word): |
| unit_de = "Buchstaben" if letters_word else "Zeichen" |
| unit_en = "letters" if letters_word else "characters" |
| if lang == "de": |
| if " " not in text and text.isalpha() and echo_ok(text): |
| return f"Das Wort „{text}“ hat {n} {unit_de}." |
| if " " in text: |
| return f"Der Text hat {n} {unit_de} (Leerzeichen eingerechnet)." if not letters_word else f"Der Text hat {n} Zeichen (Leerzeichen eingerechnet)." |
| return f"Der String hat {n} Zeichen." |
| if " " not in text and text.isalpha() and echo_ok(text): |
| return f"The word “{text}” has {n} {unit_en}." |
| if " " in text: |
| return f"The text has {n} characters (spaces included)." |
| return f"The string has {n} characters." |
|
|
|
|
| def cap(s): |
| return s[:1].upper() + s[1:] |
|
|
|
|
| def ans_letter(text, c, k, lang): |
| what_de = "die Ziffer" if c.isdigit() else "der Buchstabe" |
| what_en = "digit" if c.isdigit() else "letter" |
| if lang == "de": |
| if echo_ok(text): |
| return f"In „{text}“ kommt {what_de} „{c}“ nicht vor (0-mal)." if k == 0 else f"{cap(what_de)} „{c}“ kommt {k}-mal in „{text}“ vor." |
| return f"{cap(what_de)} „{c}“ kommt nicht vor (0-mal)." if k == 0 else f"{cap(what_de)} „{c}“ kommt {k}-mal vor." |
| if echo_ok(text): |
| return f"The {what_en} “{c}” does not appear in “{text}” (0 times)." if k == 0 else f"The {what_en} “{c}” appears {k} times in “{text}”." |
| return f"The {what_en} “{c}” does not appear (0 times)." if k == 0 else f"The {what_en} “{c}” appears {k} times." |
|
|
|
|
| def ans_words(n, lang): |
| if lang == "de": |
| return "Der Satz hat 1 Wort." if n == 1 else f"Der Satz hat {n} Wörter." |
| return "The sentence has 1 word." if n == 1 else f"The sentence has {n} words." |
|
|
|
|
| |
| LEN_DE = ["Wie viele Zeichen hat {q}?", "Wie viele Zeichen hat das Wort {q}?", "Zähle die Zeichen in {q}.", "Wie lang ist {q}?", |
| "Bitte zähle alle Zeichen von {q}.", "Hey, wie viele Zeichen hat {q}?", "Kannst du mir sagen, wie viele Zeichen {q} hat?", |
| "Zerlege und zähle: {q}", "Wie viele Zeichen hat der String {q}?"] |
| LEN_EN = ["How many characters does {q} have?", "How many characters are in {q}?", "Count the characters in {q}.", |
| "What is the length of {q}?", "How long is {q} (in characters)?"] |
| LETTER_DE = ["Wie viele {c} sind in {q}?", "Wie oft kommt der Buchstabe {c} in {q} vor?", "Zähle die {c} in {q}.", "Wie viele {c} hat {q}?", |
| "Wie oft steckt ein {c} in {q}?", "Kommt in {q} ein {c} vor? Wie oft?", "Zähle bitte alle {c} in dem Wort {q}."] |
| LETTER_EN = ["How many {c}'s are in {q}?", "How many times does the letter {c} appear in {q}?", "Count the {c} in {q}.", |
| "How often does {c} occur in {q}?"] |
| LETTERS_ALL_DE = ["Wie viele Buchstaben hat {q}?", "Wie viele Buchstaben (ohne Leerzeichen und Satzzeichen) hat {q}?", "Zähle nur die Buchstaben in {q}."] |
| LETTERS_ALL_EN = ["How many letters are in {q}?", "Count only the letters in {q} (no spaces or punctuation)."] |
| WORDS_DE = ["Wie viele Wörter hat dieser Satz: {q}?", "Zähle die Wörter in {q}.", "Wie viele Wörter sind in {q}?", "Aus wie vielen Wörtern besteht {q}?"] |
| WORDS_EN = ["How many words are in {q}?", "Count the words in {q}.", "How many words does this sentence have: {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 fmt_q(text, r, bare_ok=True): |
| if bare_ok and " " not in text and text.isalpha() and r.random() < 0.35: |
| return text |
| return quote(text) |
|
|
|
|
| |
| def ex(kind, text, user, assistant, extra=None): |
| d = {"messages": [{"role": "user", "content": user}, {"role": "assistant", "content": assistant}], "kind": kind, "text": text} |
| if extra: |
| d.update(extra) |
| return d |
|
|
|
|
| def make_len(text, lang, r): |
| words_only = " " not in text and text.isalpha() |
| tpl = r.choice(LEN_DE if lang == "de" else LEN_EN) |
| if lang == "de" and words_only and r.random() < 0.2: |
| tpl = "Wie viele Buchstaben hat {q}?" |
| user = tpl.format(q=fmt_q(text, r)) |
| if " " in text and r.random() < 0.35: |
| user += " Leerzeichen zählen mit." if lang == "de" else " Count the spaces too." |
| letters_word = words_only and "Buchstaben" in user |
| return ex("len", text, user, think_len(text) + "\n" + ans_len(text, len(text), lang, letters_word)) |
|
|
|
|
| def make_letter(text, c, lang, r): |
| think, k = think_tally(text, f"{c} (Groß-/Kleinschreibung egal)", lambda x: x.lower() == c.lower()) |
| tpl = r.choice(LETTER_DE if lang == "de" else LETTER_EN) |
| user = tpl.format(c=c, q=fmt_q(text, r)) |
| return ex("letter", text, user, think + "\n" + ans_letter(text, c, k, lang), {"target": c}) |
|
|
|
|
| def make_letters_all(text, lang, r): |
| think, k = think_tally(text, "alle Buchstaben (ohne Leerzeichen, Ziffern und Satzzeichen)", lambda x: x.isalpha()) |
| tpl = r.choice(LETTERS_ALL_DE if lang == "de" else LETTERS_ALL_EN) |
| user = tpl.format(q=quote(text)) |
| ans = (f"Der Text hat {k} Buchstaben." if lang == "de" else f"The text has {k} letters.") |
| return ex("letters_all", text, user, think + "\n" + ans, {"target": "*"}) |
|
|
|
|
| def make_words(text, lang, r): |
| think, n = think_words(text) |
| tpl = r.choice(WORDS_DE if lang == "de" else WORDS_EN) |
| return ex("words", text, tpl.format(q=quote(text)), think + "\n" + ans_words(n, lang)) |
|
|
|
|
| |
| NUM_RE = re.compile(r"(\d+)(?:-mal| times| Zeichen| characters| Buchstaben| letters| Wörter| words| Wort| word)") |
|
|
|
|
| def final_number(after_think): |
| m = NUM_RE.findall(after_think) |
| if m: |
| return int(m[-1]) |
| nums = re.findall(r"\d+", after_think) |
| return int(nums[-1]) if nums else None |
|
|
|
|
| def validate(e): |
| a = e["messages"][1]["content"] |
| text, kind = e["text"], e["kind"] |
| if kind == "len": |
| think, truth = think_len(text), len(text) |
| elif kind == "letter": |
| c = e["target"] |
| think, truth = think_tally(text, f"{c} (Groß-/Kleinschreibung egal)", lambda x: x.lower() == c.lower()) |
| elif kind == "letters_all": |
| think, truth = think_tally(text, "alle Buchstaben (ohne Leerzeichen, Ziffern und Satzzeichen)", lambda x: x.isalpha()) |
| else: |
| think, truth = think_words(text) |
| if not a.startswith(think + "\n"): |
| return "Think-Block weicht ab" |
| fn = final_number(a[len(think) + 1:]) |
| return None if fn == truth else f"Endzahl {fn} != {truth}" |
|
|
|
|
| |
| def periodic(r, lo, hi): |
| n = r.randint(lo, hi) |
| alph = string.ascii_letters + string.digits + "!#$%&*+=?_.:;,@/|~^" |
| unit_len = r.choice([1, 1, 2, 2, 2, 3, 3, 4]) |
| unit = "".join(r.choice(alph) for _ in range(unit_len)) |
| if r.random() < 0.4: |
| unit = unit + " " |
| s = (unit * (n // len(unit) + 2))[:n] |
| return s.strip() if r.random() < 0.8 else s.rstrip() |
|
|
|
|
| def load_excluded(): |
| strings = set(v4_tests.all_test_strings()) |
| words = set() |
| for f in ("ab_test_results.json", "generalization_results.json", "v3/independent_results_v3.json", "v3/heldout_v3.json"): |
| p = Path(f"{PLATTE}/models/graf_zahl/{f}") |
| if p.exists(): |
| for r in json.load(open(p, encoding="utf-8")): |
| t = r.get("wort") or r.get("text") |
| strings.add(t) |
| for t in list(strings): |
| if t.isalpha() and len(t) >= 6: |
| words.add(t.lower()) |
| return words, strings |
|
|
|
|
| def load_v3_texts(excl_words, excl_strings): |
| out = [] |
| for line in open(f"{PLATTE}/models/graf_zahl/v3/dataset_v3_plain.jsonl", encoding="utf-8"): |
| t = re.search(r"^Wort: (.+)$", json.loads(line)["messages"][2]["content"], re.M).group(1) |
| if t not in excl_strings and not any(w in t.lower() for w in excl_words): |
| out.append(t) |
| return sorted(set(out)) |
|
|
|
|
| def natural_words(sentences): |
| ws = set() |
| for s in sentences: |
| for w in s.split(): |
| w = w.strip(".,;:!?()\"'-") |
| if 5 <= len(w) <= 18 and w.isalpha(): |
| ws.add(w) |
| return sorted(ws) |
|
|
|
|
| def build(seed=SEED): |
| r = random.Random(seed) |
| excl_words, excl_strings = load_excluded() |
| de_sent = load_sentences(excl_words) |
| pools = json.load(open(V4 / "replay_prompts.json", encoding="utf-8")) |
| en_sent = [s for s in pools["en_sentences"] if not any(w in s.lower() for w in excl_words)] |
| de_words = [w for w in natural_words(de_sent) if w.lower() not in excl_words] |
| en_words = [w for w in pools["en_words"] if w.lower() not in excl_words] |
| old = load_v3_texts(excl_words, excl_strings) |
| old_words = [t for t in old if t.isalpha()] |
| print(f"Pools: DE-Saetze {len(de_sent)}, EN-Saetze {len(en_sent)}, DE-Woerter {len(de_words)}, EN-Woerter {len(en_words)}, " |
| f"alte Texte {len(old)} (davon Woerter {len(old_words)})", flush=True) |
|
|
| taken, rows = set(), [] |
|
|
| def add(e, cat): |
| key = (e["kind"], e["text"], e.get("target")) |
| if key in taken or e["text"] in excl_strings or e["text"] != e["text"].strip() or " " in e["text"] or not (1 <= len(e["text"]) <= 95): |
| return False |
| if validate(e) is not None: |
| raise AssertionError((cat, e["text"], validate(e))) |
| taken.add(key) |
| e["cat"] = cat |
| rows.append(e) |
| return True |
|
|
| def lang_for(text_lang): |
| return text_lang if r.random() < 0.88 else ("en" if text_lang == "de" else "de") |
|
|
| def fill(cat, n, gen): |
| c = tries = 0 |
| while c < n and tries < n * 60: |
| tries += 1 |
| item = gen() |
| if item is not None: |
| c += add(item, cat) |
|
|
| fill("len_old", COUNTS["len_old"], lambda: make_len(r.choice(old), lang_for("de"), r)) |
| fill("len_de_word", COUNTS["len_de_word"], lambda: make_len(r.choice(de_words), lang_for("de"), r)) |
| fill("len_de_sent", COUNTS["len_de_sent"], lambda: make_len(r.choice(de_sent), lang_for("de"), r)) |
| fill("len_en_sent", COUNTS["len_en_sent"], lambda: make_len(r.choice(en_sent), lang_for("en"), r)) |
| fill("len_en_word", COUNTS["len_en_word"], lambda: make_len(r.choice(en_words), lang_for("en"), r)) |
| fill("len_code_misc", COUNTS["len_code_misc"], lambda: make_len(code_like(r, de_words[:400]) if r.random() < 0.6 else misc_string(r, de_words[:400]), lang_for("de"), r)) |
| fill("len_periodic", COUNTS["len_periodic"], lambda: make_len(periodic(r, 6, 90), lang_for("de"), r)) |
|
|
| def long_text(): |
| k = r.random() |
| if k < 0.30: return rand_alnum(r, r.randint(46, 90)) |
| if k < 0.50: return rand_sym(r, r.randint(46, 90)) |
| if k < 0.70: return compound(r, [w for w in old_words if 5 <= len(w) <= 30], 46, 90) |
| return r.choice([s for s in (de_sent if r.random() < 0.7 else en_sent) if len(s) >= 46] or [None]) |
| fill("len_long", COUNTS["len_long"], lambda: (lambda t: make_len(t, lang_for("de"), r) if t else None)(long_text())) |
|
|
| def letter_item(): |
| src = r.random() |
| if src < 0.40: text, lang = r.choice(de_words), "de" |
| elif src < 0.55: text, lang = r.choice(old_words), "de" |
| elif src < 0.72: text, lang = r.choice(de_sent), "de" |
| elif src < 0.90: text, lang = r.choice(en_words if r.random() < 0.6 else en_sent), "en" |
| elif src < 0.95: text, lang = periodic(r, 6, 40), "de" |
| else: text, lang = rand_alnum(r, r.randint(8, 30)), "de" |
| if not text: |
| return None |
| chars = [c for c in text if c.isalnum()] |
| if not chars: |
| return None |
| mode = r.random() |
| counts = Counter(c.lower() for c in chars) |
| if mode < 0.14: |
| absent = [c for c in "abcdefghijklmnopqrstuvwxyz" if c not in counts] |
| if not absent: return None |
| c = r.choice(absent) |
| elif mode < 0.55: |
| multi = [c for c, k in counts.items() if k >= 2] |
| c = r.choice(multi or list(counts)) |
| else: |
| c = r.choice(list(counts)) |
| if r.random() < 0.2 and c.isalpha(): |
| c = c.upper() |
| return make_letter(text, c, lang_for(lang), r) |
| fill("letter", COUNTS["letter"], letter_item) |
|
|
| fill("letters_all", COUNTS["letters_all"], lambda: (lambda s: make_letters_all(s, "de" if s in de_sent_set else "en", r))(r.choice(de_sent if r.random() < 0.75 else en_sent))) |
| fill("words", COUNTS["words"], lambda: (lambda s: make_words(s, "de" if s in de_sent_set else "en", r))(r.choice(de_sent if r.random() < 0.75 else en_sent))) |
| return rows |
|
|
|
|
| de_sent_set = set() |
|
|
|
|
| def main(): |
| global de_sent_set |
| V4.mkdir(parents=True, exist_ok=True) |
| de_sent_set = set(load_sentences(load_excluded()[0])) |
| rows = build() |
| random.Random(SEED).shuffle(rows) |
| with open(V4 / "counting_v4.jsonl", "w", encoding="utf-8") as f: |
| for e in rows: |
| f.write(json.dumps(e, ensure_ascii=False) + "\n") |
| print(f"\n{len(rows)} Zaehl-Beispiele, alle gegen die Wahrheit validiert -> {V4 / 'counting_v4.jsonl'}") |
| print("nach Aufgabentyp:", dict(Counter(e['kind'] for e in rows))) |
| print("nach Quelle:", dict(Counter(e['cat'] for e in rows))) |
| L = [len(e["text"]) for e in rows] |
| print(f"Textlaenge: Median {sorted(L)[len(L)//2]}, max {max(L)}; > 45 Zeichen: {sum(l > 45 for l in L)}, mit Leerzeichen: {sum(' ' in e['text'] for e in rows)}") |
|
|
|
|
| def selftest(): |
| r = random.Random(1) |
| for kind_fn in (lambda: make_len("Erdbee re", "de", r), lambda: make_letter("Erdbeere", "r", "de", r), lambda: make_letter("Zebra", "q", "en", r), |
| lambda: make_letters_all("Hallo, Welt 2!", "de", r), lambda: make_words("Der Hund läuft.", "de", r), lambda: make_len("abababab", "en", r)): |
| e = kind_fn() |
| assert validate(e) is None, e |
| e["messages"][1]["content"] = e["messages"][1]["content"].replace("nachgezählt: ", "nachgezählt: 9") |
| assert validate(e) is not None |
| e = make_letter("Erdbeere", "r", "de", r) |
| assert "Bisher: 2." in e["messages"][1]["content"] and "kommt 2-mal" in e["messages"][1]["content"], e["messages"][1]["content"] |
| p = periodic(r, 6, 40) |
| assert 1 <= len(p) <= 40 |
| print("Selbsttest bestanden. Beispiel-Buchstabe:\n" + e["messages"][0]["content"] + "\n" + e["messages"][1]["content"]) |
|
|
|
|
| if __name__ == "__main__": |
| selftest() if "--selftest" in sys.argv else main() |
|
|
