File size: 17,017 Bytes
ba82887 f3f832d ba82887 f3f832d ba82887 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 | """NNAI-Bench v0.1: deterministic synthetic tasks, scoring and CPU baselines.
Python 3.10+, standard library only. No CAEL dependencies or neural models.
"""
from __future__ import annotations
import argparse
from collections import Counter, defaultdict
import hashlib
import json
import math
from pathlib import Path
import random
import re
import time
VERSION = "nnai-bench-0.1"
ROOT = Path(__file__).resolve().parent
DATASET = ROOT / "dataset" if (ROOT / "dataset").is_dir() else ROOT
ARTIFACTS = ROOT / "space" if (ROOT / "space").is_dir() else ROOT
CATEGORIES = ("arithmetic", "logic", "ordering", "state_tracking", "strings", "tables")
LETTERS = "ABCD"
SPLITS = {"train": 100, "validation": 50, "test": 150}
def dump(path, value):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8", newline="\n")
def write_rows(path, rows):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text("".join(json.dumps(r, ensure_ascii=False) + "\n" for r in rows), encoding="utf-8", newline="\n")
def read_rows(path):
return [json.loads(line) for line in Path(path).read_text(encoding="utf-8").splitlines() if line.strip()]
def numeric_choices(answer, rng):
options = {str(answer)}
while len(options) < 4:
options.add(str(answer + rng.choice((-1, 1)) * rng.randint(1, 19)))
return sorted(options)
def make_task(category, tier, rng, tag):
"""Return a prompt, four distinct options, answer and independently auditable program."""
size = (3, 5, 8)[tier - 1]
if category == "arithmetic":
a, b, c = (rng.randint(3, 99) for _ in range(3))
if tier == 1:
answer, expression = a + b, f"{a} + {b}"
elif tier == 2:
answer, expression = a * b - c, f"({a} * {b}) - {c}"
else:
answer, expression = (a + b) * c - a, f"(({a} + {b}) * {c}) - {a}"
prompt = rng.choice((f"Calculate {expression}. What is the result?", f"Using standard arithmetic, evaluate {expression}."))
return prompt, numeric_choices(answer, rng), str(answer), {"expression": expression, "value": answer}
if category == "logic":
predicates = [f"kind_{tag}_{i}" for i in range(size + 2)]
entity = f"object_{tag}"
edges = list(zip(predicates[:size], predicates[1:size + 1]))
mode = rng.randrange(3)
target = predicates[size] if mode != 2 else predicates[-1]
facts = [f"{entity} is a {predicates[0]}."]
facts += [f"Every {a} is a {b}." for a, b in edges]
negatives = [target] if mode == 1 else []
if negatives:
# Make negative-only cases consistent: remove the final implication.
edges = edges[:-1]
facts = [facts[0]] + [f"Every {a} is a {b}." for a, b in edges]
facts.append(f"{entity} is not a {target}.")
rng.shuffle(facts)
answer = ("true", "false", "unknown")[mode]
prompt = "\n".join(facts) + f"\nUnder open-world logic, is '{entity} is a {target}' true, false, or unknown? No fact implies its converse."
return prompt, ["true", "false", "unknown", "inconsistent"], answer, {"start": predicates[0], "edges": edges, "negatives": negatives, "target": target}
if category == "ordering":
objects = [f"item_{tag}_{i}" for i in range(size + 1)]
order = rng.sample(objects, len(objects))
rules = [f"{a} comes before {b}." for a, b in zip(order, order[1:])]
rng.shuffle(rules)
if tier == 1:
index, question = 0, "Which item comes first?"
elif tier == 2:
index, question = len(order) - 1, "Which item comes last?"
else:
index = rng.randint(1, len(order) - 2)
question = f"Which item comes immediately after {order[index - 1]}?"
answer = order[index]
options = [answer] + rng.sample([x for x in order if x != answer], 3)
return "\n".join(rules + [question]), options, answer, {"order": order, "index": index}
if category == "state_tracking":
people = [f"person_{tag}_{i}" for i in range(4)]
rooms = [f"room_{tag}_{i}" for i in range(4)]
events = []
for person, room in zip(people, rng.sample(rooms, 4)):
events.append([person, room])
for _ in range(size * 2):
events.append([rng.choice(people), rng.choice(rooms)])
target = rng.choice(people)
state = {p: r for p, r in events}
prompt = "Events are listed from earliest to latest.\n" + "\n".join(f"{p} went to {r}." for p, r in events)
prompt += f"\nWhere is {target} now?"
return prompt, rooms, state[target], {"events": events, "target": target}
if category == "strings":
text = "".join(rng.choice("abcdefghjkmnpqrstuvwxyz") for _ in range(size + 2))
if tier == 1:
answer, operation = text[::-1], "reverse"
question = f'Reverse the string "{text}".'
elif tier == 2:
answer, operation = text[1::2], "even_positions"
question = f'From "{text}", keep characters at positions 2, 4, 6, and so on (1-based).'
else:
k = rng.randint(1, len(text) - 1)
answer, operation = (text[k:] + text[:k])[::-1], "rotate_reverse"
question = f'Rotate "{text}" left by {k} characters, then reverse the result.'
options = {answer, text, text[::-1], text[::2], text[1::2]}
while len(options) < 4:
options.add(text + rng.choice("xyz"))
options = [answer] + rng.sample(sorted(options - {answer}), 3)
return question, options, answer, {"text": text, "operation": operation, "k": k if tier == 3 else 0}
if category == "tables":
records = [{"item": f"row_{tag}_{i}", "group": rng.choice(("red", "blue")), "units": rng.randint(1, 40), "price": rng.randint(2, 20)} for i in range(size + 1)]
group = rng.choice(("red", "blue"))
selected = [r for r in records if r["group"] == group]
if tier == 1:
answer, operation = len(selected), "count"
question = f"How many rows have group {group}?"
elif tier == 2:
answer, operation = sum(r["units"] for r in selected), "sum"
question = f"What is the total units for group {group}?"
else:
answer, operation = sum(r["units"] * r["price"] for r in selected), "weighted_sum"
question = f"What is the sum of units * price for group {group}?"
table = "item | group | units | price\n" + "\n".join(f'{r["item"]} | {r["group"]} | {r["units"]} | {r["price"]}' for r in records)
return table + "\n" + question, numeric_choices(answer, rng), str(answer), {"records": records, "group": group, "operation": operation}
raise ValueError(category)
def audit_answer(category, program):
"""A separate ground-truth checker; never a model input or ranked solver."""
p = program
if category == "arithmetic":
# Only generator-owned numeric expressions; never evaluate submitted code.
import ast
import operator
operators = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul}
def calc(node):
if isinstance(node, ast.Constant) and type(node.value) is int:
return node.value
if isinstance(node, ast.BinOp) and type(node.op) in operators:
return operators[type(node.op)](calc(node.left), calc(node.right))
raise ValueError("Unsupported expression")
return str(calc(ast.parse(p["expression"], mode="eval").body))
if category == "logic":
known = {p["start"]}
while True:
expanded = known | {b for a, b in p["edges"] if a in known}
if expanded == known:
break
known = expanded
pos, neg = p["target"] in known, p["target"] in p["negatives"]
return "inconsistent" if pos and neg else "true" if pos else "false" if neg else "unknown"
if category == "ordering":
return p["order"][p["index"]]
if category == "state_tracking":
return next(room for person, room in reversed(p["events"]) if person == p["target"])
if category == "strings":
text = p["text"]
if p["operation"] == "reverse":
return "".join(reversed(text))
if p["operation"] == "even_positions":
return "".join(c for i, c in enumerate(text, 1) if i % 2 == 0)
return "".join(reversed(text[p["k"]:] + text[:p["k"]]))
selected = [r for r in p["records"] if r["group"] == p["group"]]
if p["operation"] == "count":
return str(len(selected))
if p["operation"] == "sum":
return str(sum(r["units"] for r in selected))
return str(sum(r["units"] * r["price"] for r in selected))
def generate():
output = DATASET
seen = set()
audits = []
for split_index, (split, count) in enumerate(SPLITS.items()):
rng = random.Random(20261018 + split_index)
rows = []
for category in CATEGORIES:
positions = [(len(rows) + i) % 4 for i in range(count)]
rng.shuffle(positions)
for i in range(count):
tier = i % 3 + 1
while True:
tag = f"{split[0]}{rng.getrandbits(28):07x}"
prompt, choices, answer, program = make_task(category, tier, rng, tag)
if prompt not in seen:
seen.add(prompt)
break
assert answer == audit_answer(category, program)
wrong = sorted(set(choices) - {answer})
rng.shuffle(wrong)
label = positions[i]
wrong.insert(label, answer)
row = {"id": f"{split}-{category}-{i:04d}", "split": split, "category": category,
"difficulty": tier, "prompt": prompt, "choices": wrong, "answer": LETTERS[label]}
rows.append(row)
audits.append({"id": row["id"], "category": category, "program": program, "answer_text": answer})
rng.shuffle(rows)
write_rows(output / "data" / f"{split}.jsonl", rows)
questions = [{k: v for k, v in r.items() if k != "answer"} for r in rows]
write_rows(output / "questions" / f"{split}.jsonl", questions)
if split == "test" and (ROOT / "space").is_dir():
dump(ROOT / "space" / "test.json", rows)
write_rows(output / "audit.jsonl", audits)
checksums = {str(p.relative_to(output)).replace("\\", "/"): hashlib.sha256(p.read_bytes()).hexdigest()
for p in sorted(output.rglob("*.jsonl"))}
manifest = {"benchmark_version": VERSION, "seed": 20261018,
"split_sizes": {s: n * len(CATEGORIES) for s, n in SPLITS.items()},
"categories": list(CATEGORIES), "sha256": checksums}
dump(output / "manifest.json", manifest)
if (ROOT / "space").is_dir():
dump(ROOT / "space" / "manifest.json", manifest)
dump(output / "example_predictions.json", [{"id": r["id"], "prediction": "ABSTAIN"} for r in read_rows(output / "data/test.jsonl")])
print(json.dumps(manifest, indent=2))
def normalise_predictions(predictions, questions):
if not isinstance(predictions, list):
raise ValueError("Predictions must be a JSON array of {id, prediction} objects.")
expected = {r["id"] for r in questions}
got = {}
for row in predictions:
if not isinstance(row, dict) or set(row) != {"id", "prediction"}:
raise ValueError("Each prediction must contain exactly id and prediction.")
ident, pred = row["id"], row["prediction"]
if not isinstance(ident, str) or ident not in expected or ident in got:
raise ValueError(f"Unknown or duplicate ID: {ident!r}")
if not isinstance(pred, str) or pred not in (*LETTERS, "ABSTAIN"):
raise ValueError(f"Invalid prediction for {ident}; use A, B, C, D or ABSTAIN.")
got[ident] = pred
if set(got) != expected:
raise ValueError(f"Expected {len(expected)} unique IDs, received {len(got)}. Use ABSTAIN for unanswered items.")
return got
def score(predictions, questions):
got = normalise_predictions(predictions, questions)
counts = defaultdict(lambda: {"correct": 0, "answered": 0, "total": 0})
for row in questions:
c = counts[row["category"]]
c["total"] += 1
c["answered"] += got[row["id"]] != "ABSTAIN"
c["correct"] += got[row["id"]] == row["answer"]
categories = {k: {**v, "accuracy": 100 * v["correct"] / v["total"]} for k, v in sorted(counts.items())}
total = len(questions)
correct = sum(v["correct"] for v in counts.values())
answered = sum(v["answered"] for v in counts.values())
return {"benchmark_version": VERSION, "macro_accuracy": sum(v["accuracy"] for v in categories.values()) / len(categories),
"accuracy": 100 * correct / total, "coverage": 100 * answered / total,
"answered_accuracy": 100 * correct / answered if answered else 0,
"correct": correct, "total": total, "categories": categories}
def tokens(row):
return re.findall(r"[a-z]+|\d+", row["prompt"].lower())
def baseline_predictions(kind, train, test):
rng = random.Random(314159)
if kind == "seeded-random":
return [{"id": r["id"], "prediction": rng.choice(LETTERS)} for r in test]
if kind == "train-majority":
# Deterministic tie-break; no test labels or test-derived label frequencies.
counts = Counter(r["answer"] for r in train)
best = max(LETTERS, key=lambda x: (counts[x], -LETTERS.index(x)))
return [{"id": r["id"], "prediction": best} for r in test]
# Unigram BM25 nearest training prompt, returning the neighbour's answer letter.
# Deliberately simple retrieval baseline, without embeddings or test labels.
docs = [Counter(tokens(r)) for r in train]
df = Counter(t for d in docs for t in d)
average = sum(sum(d.values()) for d in docs) / len(docs)
index = defaultdict(list)
for i, d in enumerate(docs):
for term, tf in d.items():
idf = math.log(1 + (len(docs) - df[term] + .5) / (df[term] + .5))
weight = idf * tf * 2.5 / (tf + 1.5 * (.25 + .75 * sum(d.values()) / average))
index[term].append((i, weight))
predictions = []
for row in test:
values = defaultdict(float)
for term in sorted(set(tokens(row))):
for i, weight in index[term]:
values[i] += weight
best = max(values, key=lambda i: (values[i], -i)) if values else 0
predictions.append({"id": row["id"], "prediction": train[best]["answer"]})
return predictions
def baselines():
train = read_rows(DATASET / "data/train.jsonl")
labelled = read_rows(DATASET / "data/test.jsonl")
inputs = [{k: v for k, v in r.items() if k != "answer"} for r in labelled]
entries = []
for kind in ("seeded-random", "train-majority", "bm25-nearest-training"):
started = time.perf_counter()
predictions = baseline_predictions(kind, train, inputs)
elapsed = time.perf_counter() - started
report = score(predictions, labelled)
dump(ARTIFACTS / f"baselines/{kind}.predictions.json", predictions)
dump(ARTIFACTS / f"baselines/{kind}.report.json", report)
entries.append({"id": kind, "name": kind.replace("-", " ").title(), "kind": "baseline",
"status": "reproduced", "architecture": "BM25" if kind.startswith("bm25") else "statistical control",
"track": "closed-book", "training_provenance": "no neural assistance",
"source_url": "https://huggingface.co/datasets/vynly/nnai-bench/blob/main/benchmark.py",
"revision": VERSION, "runtime_seconds": round(elapsed, 5), "score": report})
dump(ARTIFACTS / "leaderboard.json", {"benchmark_version": VERSION, "entries": entries})
print(json.dumps([{r["name"]: r["score"]["macro_accuracy"]} for r in entries]))
def main():
parser = argparse.ArgumentParser(description=__doc__)
sub = parser.add_subparsers(dest="command", required=True)
sub.add_parser("generate")
sub.add_parser("baselines")
ev = sub.add_parser("score")
ev.add_argument("predictions")
ev.add_argument("--questions", default=str(DATASET / "data/test.jsonl"))
ev.add_argument("--output")
args = parser.parse_args()
if args.command == "generate":
generate()
elif args.command == "baselines":
baselines()
else:
report = score(json.loads(Path(args.predictions).read_text(encoding="utf-8")), read_rows(args.questions))
if args.output:
dump(args.output, report)
print(json.dumps(report, indent=2))
if __name__ == "__main__":
main()
|