Add synthetic numeracy pretraining corpus

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+train.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,16 @@
+---
+license: apache-2.0
+tags:
+- synthetic
+- math
+- numeracy
+- pretraining
+---
+
+# AGILLM Math Numeracy Synthetic
+
+Synthetic plain-text numeracy corpus for AGILLM pretraining. Each JSONL row has `text` and `kind`.
+
+Coverage includes addition/subtraction/multiplication/division facts, multi-digit arithmetic, comparisons, order/parity, place value, missing-number equations, simple word problems, fractions, money, and two-step arithmetic.
+
+Generated deterministically with `generate_math_numeracy.py`.

generate_math_numeracy.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+import json, random, hashlib, time
+from pathlib import Path
+OUT = Path('/workspace/agillm_math_numeracy_synth/train.jsonl')
+META = Path('/workspace/agillm_math_numeracy_synth/metadata.json')
+README = Path('/workspace/agillm_math_numeracy_synth/README.md')
+N = 2_000_000
+SEED = 731095
+rng = random.Random(SEED)
+objects = ['apples','coins','books','marbles','pencils','blocks','tokens','stickers']
+names = ['Ada','Ben','Cara','Dion','Eli','Fay','Gus','Hana']
+counts = {}
+
+def jwrite(f, text, kind):
+    counts[kind] = counts.get(kind, 0) + 1
+    f.write(json.dumps({'text': text.strip() + '\n', 'kind': kind}, ensure_ascii=True, separators=(',', ':')) + '\n')
+
+def choose(xs): return xs[rng.randrange(len(xs))]
+
+def gen_add(big=False):
+    m = 9999 if big else 100
+    a,b = rng.randint(0,m), rng.randint(0,m); c=a+b
+    return choose([f'{a} + {b} = {c}.', f'{a}+{b}={c}', f'Compute {a} + {b}. Answer: {c}.', f'What is {a} plus {b}? {c}.', f'The sum of {a} and {b} is {c}.']), 'multi_digit_addition' if big else 'addition'
+
+def gen_sub():
+    b,c = rng.randint(0,1000), rng.randint(0,1000); a=b+c
+    return choose([f'{a} - {b} = {c}.', f'{a}-{b}={c}', f'Compute {a} minus {b}. Answer: {c}.', f'What is {a} - {b}? {c}.']), 'subtraction'
+
+def gen_mul():
+    a,b = (rng.randint(0,20), rng.randint(0,20)) if rng.random()<0.75 else (rng.randint(0,99), rng.randint(0,12))
+    c=a*b
+    return choose([f'{a} * {b} = {c}.', f'{a} times {b} equals {c}.', f'Compute {a} x {b}. Answer: {c}.', f'The product of {a} and {b} is {c}.']), 'multiplication'
+
+def gen_div():
+    b,c = rng.randint(1,20), rng.randint(0,100); a=b*c
+    return choose([f'{a} / {b} = {c}.', f'{a} divided by {b} equals {c}.', f'Compute {a} / {b}. Answer: {c}.']), 'exact_division'
+
+def gen_compare():
+    a,b = rng.randint(-200,200), rng.randint(-200,200)
+    sym = '>' if a>b else '<' if a<b else '='
+    word = 'greater than' if a>b else 'less than' if a<b else 'equal to'
+    return choose([f'{a} {sym} {b}.', f'{a} is {word} {b}.', f'Compare {a} and {b}: {a} {sym} {b}.']), 'comparison'
+
+def gen_order_parity():
+    n = rng.randint(-1000,1000)
+    if rng.random()<0.5:
+        return choose([f'The number after {n} is {n+1}.', f'The number before {n} is {n-1}.', f'{n-1}, {n}, {n+1}.']), 'number_order'
+    par = 'even' if n % 2 == 0 else 'odd'
+    return f'{n} is {par}.', 'parity'
+
+def gen_place():
+    n = rng.randint(0,9999); ones=n%10; tens=(n//10)%10; hundreds=(n//100)%10; thousands=(n//1000)%10
+    return choose([f'In {n}, the ones digit is {ones}.', f'In {n}, the tens digit is {tens}.', f'In {n}, the hundreds digit is {hundreds}.', f'In {n}, the thousands digit is {thousands}.', f'{n} = {thousands} thousands + {hundreds} hundreds + {tens} tens + {ones} ones.']), 'place_value'
+
+def gen_missing():
+    a = rng.randint(0,100); x = rng.randint(0,100); b = a+x
+    if rng.random()<0.5:
+        return f'Solve x + {a} = {b}. x = {x}. Check: {x} + {a} = {b}.', 'missing_number'
+    return f'Solve {b} - x = {a}. x = {x}. Check: {b} - {x} = {a}.', 'missing_number'
+
+def gen_word():
+    name=choose(names); obj=choose(objects); a=rng.randint(0,30); b=rng.randint(0,30)
+    if rng.random()<0.55:
+        return f'{name} has {a} {obj} and gets {b} more {obj}. {name} has {a+b} {obj}.', 'word_addition'
+    if b>a: a,b=b,a
+    return f'{name} has {a} {obj} and gives away {b}. {name} has {a-b} {obj} left.', 'word_subtraction'
+
+def gen_multistep():
+    a,b,c = rng.randint(0,50), rng.randint(0,50), rng.randint(0,50)
+    if rng.random()<0.5:
+        r=a+b-c
+        return f'{a} + {b} - {c} = {r}. First {a} + {b} = {a+b}; then {a+b} - {c} = {r}.', 'two_step'
+    r=a*b+c
+    return f'{a} * {b} + {c} = {r}. First {a} * {b} = {a*b}; then {a*b} + {c} = {r}.', 'two_step'
+
+def gen_fraction():
+    d=rng.randint(2,12); n=rng.randint(1,d-1); k=rng.randint(2,10)
+    return f'{n}/{d} = {n*k}/{d*k}. Multiplying numerator and denominator by {k} makes an equivalent fraction.', 'fractions'
+
+def gen_money():
+    cents=rng.randint(0,9999); dollars=cents//100; rem=cents%100
+    return f'{cents} cents = {dollars} dollars and {rem} cents.', 'money'
+
+gens = [gen_add, lambda: gen_add(True), gen_sub, gen_mul, gen_div, gen_compare, gen_order_parity, gen_place, gen_missing, gen_word, gen_multistep, gen_fraction, gen_money]
+weights = [0.18,0.07,0.14,0.14,0.08,0.08,0.08,0.06,0.07,0.07,0.05,0.04,0.04]
+
+def weighted_gen():
+    total = sum(weights)
+    r=rng.random() * total; acc=0.0
+    for g,w in zip(gens,weights):
+        acc += w
+        if r <= acc: return g()
+    return gens[-1]()
+
+start=time.time(); sha=hashlib.sha256(); rows=0
+with OUT.open('w', encoding='utf-8') as f:
+    # Exhaustive core facts first, repeated in clean forms.
+    for a in range(0,101):
+        for b in range(0,101):
+            jwrite(f, f'{a} + {b} = {a+b}.', 'addition_table'); rows+=1
+            if a >= b:
+                jwrite(f, f'{a} - {b} = {a-b}.', 'subtraction_table'); rows+=1
+    for a in range(0,21):
+        for b in range(0,21):
+            jwrite(f, f'{a} * {b} = {a*b}.', 'multiplication_table'); rows+=1
+            if b != 0:
+                jwrite(f, f'{a*b} / {b} = {a}.', 'division_table'); rows+=1
+    while rows < N:
+        text, kind = weighted_gen()
+        jwrite(f, text, kind); rows += 1
+        if rows % 250000 == 0:
+            print(f'generated {rows:,}', flush=True)
+# Hash after close.
+with OUT.open('rb') as f:
+    for chunk in iter(lambda: f.read(1<<20), b''):
+        sha.update(chunk)
+meta = {'name':'agillm-math-numeracy-synthetic','rows':rows,'seed':SEED,'sha256':sha.hexdigest(),'counts':counts,'created_unix':int(time.time()),'description':'Synthetic numeracy pretraining JSONL with exact arithmetic facts, comparisons, place value, word problems, and simple step-by-step arithmetic.'}
+META.write_text(json.dumps(meta, indent=2, sort_keys=True) + '\n')
+README.write_text('''---\nlicense: apache-2.0\ntags:\n- synthetic\n- math\n- numeracy\n- pretraining\n---\n\n# AGILLM Math Numeracy Synthetic\n\nSynthetic plain-text numeracy corpus for AGILLM pretraining. Each JSONL row has `text` and `kind`.\n\nCoverage includes addition/subtraction/multiplication/division facts, multi-digit arithmetic, comparisons, order/parity, place value, missing-number equations, simple word problems, fractions, money, and two-step arithmetic.\n\nGenerated deterministically with `generate_math_numeracy.py`.\n''')
+print(json.dumps(meta, indent=2, sort_keys=True))
+print(f'elapsed_sec={time.time()-start:.1f}')

metadata.json

@@ -0,0 +1,29 @@
+{
+  "counts": {
+    "addition": 324553,
+    "addition_table": 10201,
+    "comparison": 144775,
+    "division_table": 420,
+    "exact_division": 144311,
+    "fractions": 72327,
+    "missing_number": 126466,
+    "money": 71675,
+    "multi_digit_addition": 125494,
+    "multiplication": 253019,
+    "multiplication_table": 441,
+    "number_order": 72122,
+    "parity": 71839,
+    "place_value": 108699,
+    "subtraction": 251795,
+    "subtraction_table": 5151,
+    "two_step": 90161,
+    "word_addition": 69737,
+    "word_subtraction": 56814
+  },
+  "created_unix": 1780047216,
+  "description": "Synthetic numeracy pretraining JSONL with exact arithmetic facts, comparisons, place value, word problems, and simple step-by-step arithmetic.",
+  "name": "agillm-math-numeracy-synthetic",
+  "rows": 2000000,
+  "seed": 731095,
+  "sha256": "11e893285638c733c7068510f07011273ac856586f2aa1239a7d526533a24280"
+}

train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11e893285638c733c7068510f07011273ac856586f2aa1239a7d526533a24280
+size 132737866