Proper commit

.gitignore

@@ -0,0 +1,3 @@
+generate_integer_arithmetic.py
+*.json
+*.parquet

README.md

@@ -15,6 +15,47 @@ ArithMark 2.0 is a procedurally generated benchmark for evaluating integer arith
 
 The benchmark is designed for base-model log-likelihood scoring. It does not require instruction following, chain-of-thought, or generated explanations. Random chance is 25%.
 
+The included script benchmark_arithmark-2.0.py can be used to run the benchmark.
+---
+
+## Baseline Results
+
+The following results use raw continuation log-likelihood scoring on the 2,500-example ArithMark 2.0 set. Random chance is 25%.
+
+| Model | Parameters | Overall | 1 Op | 2 Ops | 3 Ops |
+| ----- | ---------- | ------: | ---: | ----: | ----: |
+| Qwen/Qwen2.5-Math-1.5B | 1.54B | 82.08% | 97.44% | 77.87% | 50.00% |
+| Qwen/Qwen2.5-3B | 3.09B | 78.44% | 95.52% | 71.47% | 46.20% |
+| Qwen/Qwen2.5-1.5B | 1.54B | 77.72% | 97.12% | 69.47% | 41.60% |
+| Qwen/Qwen2.5-Coder-1.5B | 1.54B | 74.88% | 94.96% | 65.73% | 38.40% |
+| HuggingFaceTB/SmolLM2-1.7B | 1.71B | 66.12% | 89.36% | 49.33% | 33.20% |
+| Qwen/Qwen2.5-0.5B | 494M | 63.04% | 82.96% | 49.87% | 33.00% |
+| facebook/MobileLLM-R1-140M-base | 140M | 53.88% | 62.16% | 51.47% | 36.80% |
+| EleutherAI/pythia-2.8b | 2.78B | 36.72% | 34.48% | 44.93% | 30.00% |
+| HuggingFaceTB/SmolLM2-135M | 135M | 33.48% | 36.32% | 33.87% | 25.80% |
+| AxiomicLabs/GPT-X2-125M | 125M | 30.72% | 28.88% | 36.00% | 27.40% |
+| AxiomicLabs/GPT-X-125M | 125M | 30.16% | 27.92% | 35.20% | 28.20% |
+| openai-community/gpt2-xl | 1.56B | 29.92% | 29.84% | 35.20% | 22.20% |
+| HuggingFaceTB/SmolLM-135M | 135M | 28.96% | 28.40% | 31.47% | 26.60% |
+| AxiomicLabs/GPT-S-5M | 5.2M | 27.24% | 26.32% | 30.00% | 25.40% |
+| SupraLabs/Supra-50M-Base | 52M | 27.12% | 26.08% | 31.60% | 23.00% |
+| EleutherAI/pythia-31m | 30M | 27.04% | 26.16% | 31.60% | 22.40% |
+| EleutherAI/pythia-14m | 14M | 27.04% | 25.04% | 31.87% | 24.80% |
+| CompactAI-O/Shard-1 | 55M | 26.92% | 26.00% | 29.20% | 25.80% |
+| google/gemma-3-270m | 268M | 26.84% | 25.76% | 30.40% | 24.20% |
+| openai-community/gpt2 | 124M | 26.52% | 24.80% | 31.33% | 23.60% |
+| openai-community/gpt2-medium | 355M | 26.48% | 24.96% | 30.67% | 24.00% |
+| EleutherAI/gpt-neo-125m | 125M | 26.36% | 27.28% | 27.87% | 21.80% |
+| HuggingFaceTB/nanowhale-100m-base | 110M | 25.52% | 23.68% | 27.20% | 27.60% |
+| EleutherAI/pythia-70m | 70M | 25.40% | 24.48% | 26.80% | 25.60% |
+| EleutherAI/pythia-160m | 162M | 25.32% | 25.44% | 26.93% | 22.60% |
+| LH-Tech-AI/Spark-5M-Base-v4 | 5.0M | 25.04% | 25.04% | 27.33% | 21.60% |
+| Harley-ml/Dillion-1.2M | 1.3M | 24.92% | 24.56% | 27.47% | 22.00% |
+| facebook/opt-125m | 125M | 24.68% | 24.56% | 26.67% | 22.00% |
+| CompactAI-O/Glint-1.3 | 982k | 24.68% | 24.48% | 24.13% | 26.00% |
+| SupraLabs/Supra-Mini-v5-8M | 7.9M | 24.40% | 24.48% | 25.73% | 22.20% |
+| SupraLabs/Supra-Mini-v4-2M | 2.6M | 24.08% | 23.04% | 27.47% | 21.60% |
+
 ---
 
 ## Task Format

benchmark_arithmark-2.0.py

@@ -0,0 +1,285 @@
+"""
+Benchmark Hugging Face causal language models exclusively on ArithMark 2.0.
+
+The benchmark data is pulled from the official dataset repo:
+https://huggingface.co/datasets/AxiomicLabs/Arithmark-2.0
+"""
+
+import argparse
+import json
+import subprocess
+from contextlib import nullcontext
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+OFFICIAL_REPO = "https://huggingface.co/datasets/AxiomicLabs/Arithmark-2.0"
+DATA_FILE = "arithmark_2.0.jsonl"
+CACHE_DIR = "benchmark_cache"
+BATCH_SIZE = 16
+MAX_CONTEXT = 1024
+
+# (model_name,) or (model_name, tokenizer_name)
+MODELS = [
+    ("AxiomicLabs/GPT-X2-125M",),
+    ("AxiomicLabs/GPT-X-125M",),
+    ("HuggingFaceTB/SmolLM-135M",),
+]
+
+
+def ensure_official_arithmark_repo(dataset_dir: Path, pull: bool = True) -> Path:
+    """Ensure the official ArithMark 2.0 repo exists locally and is current."""
+    data_path = dataset_dir / DATA_FILE
+
+    if dataset_dir.exists() and (dataset_dir / ".git").exists():
+        if pull:
+            print(f"Updating official ArithMark 2.0 repo in {dataset_dir}...")
+            try:
+                subprocess.run(
+                    ["git", "pull", "--ff-only"],
+                    cwd=dataset_dir,
+                    check=True,
+                    text=True,
+                )
+            except (OSError, subprocess.CalledProcessError) as exc:
+                if not data_path.exists():
+                    raise RuntimeError(f"Could not pull {OFFICIAL_REPO}, and {data_path} is missing.") from exc
+                print(f"  Git pull failed; using existing {data_path.name}. ({exc})")
+    elif not dataset_dir.exists():
+        print(f"Cloning official ArithMark 2.0 repo into {dataset_dir}...")
+        subprocess.run(["git", "clone", OFFICIAL_REPO, str(dataset_dir)], check=True, text=True)
+    elif not data_path.exists():
+        raise FileNotFoundError(
+            f"{dataset_dir} exists but is not a git repo and {DATA_FILE} is missing. "
+            f"Clone {OFFICIAL_REPO} there or pass --dataset-dir to a repo checkout."
+        )
+
+    if not data_path.exists():
+        raise FileNotFoundError(f"Expected ArithMark 2.0 data file not found: {data_path}")
+
+    return data_path
+
+
+def load_arithmark_2(data_path: Path):
+    examples = []
+    with data_path.open("r", encoding="utf-8") as f:
+        for line in f:
+            item = json.loads(line)
+            examples.append(
+                {
+                    "ctx": item["ctx"],
+                    "endings": item["endings"],
+                    "label": int(item["label"]),
+                    "metadata": item.get("metadata", {}),
+                }
+            )
+    return examples
+
+
+def load_hf_model(model_name: str, tokenizer_name: str, device: str):
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        dtype=torch.bfloat16 if device == "cuda" else torch.float32,
+        trust_remote_code=True,
+    ).to(device)
+    model.eval()
+
+    tokenizer = AutoTokenizer.from_pretrained(tokenizer_name, trust_remote_code=True, use_fast=False)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token_id = tokenizer.eos_token_id if tokenizer.eos_token_id is not None else 0
+
+    return model, tokenizer
+
+
+def tokenize_request(tokenizer, context: str, continuation: str):
+    ctx_tokens = tokenizer(context, add_special_tokens=False).input_ids
+    # ArithMark 2.0 continuations already include the leading space documented
+    # by the official dataset, so score the raw continuation as provided.
+    cont_tokens = tokenizer(continuation, add_special_tokens=False).input_ids
+    tokens = ctx_tokens + cont_tokens
+
+    if len(tokens) > MAX_CONTEXT:
+        tokens = tokens[-MAX_CONTEXT:]
+        ctx_len = max(1, len(tokens) - len(cont_tokens))
+    else:
+        ctx_len = len(ctx_tokens)
+
+    return tokens, max(0, len(tokens) - ctx_len)
+
+
+def evaluate_arithmark_2(model, tokenizer, device: str, examples, batch_size: int):
+    correct = 0
+    total = 0
+    grouped = {}
+
+    for idx_start in tqdm(range(0, len(examples), batch_size), desc="  arithmark_2.0"):
+        batch_ex = examples[idx_start:idx_start + batch_size]
+        batch_tokens = []
+        batch_cont_lens = []
+        ex_offsets = []
+
+        for ex in batch_ex:
+            flat_start = len(batch_tokens)
+            for ending in ex["endings"]:
+                tokens, cont_len = tokenize_request(tokenizer, ex["ctx"], ending)
+                batch_tokens.append(tokens)
+                batch_cont_lens.append(cont_len)
+            ex_offsets.append((flat_start, len(ex["endings"])))
+
+        max_len = max(len(tokens) for tokens in batch_tokens)
+        padded = [tokens + [tokenizer.pad_token_id] * (max_len - len(tokens)) for tokens in batch_tokens]
+        tokens_t = torch.tensor(padded, dtype=torch.long, device=device)
+        lengths = torch.tensor([len(tokens) for tokens in batch_tokens], device=device)
+        attention_mask = torch.arange(max_len, device=device)[None, :] < lengths[:, None]
+
+        attention_mask = attention_mask.bool()
+
+        autocast_context = (
+            torch.autocast(device_type="cuda", dtype=torch.bfloat16)
+            if device == "cuda"
+            else nullcontext()
+        )
+
+        with torch.no_grad():
+            with autocast_context:
+                logits = model(tokens_t, attention_mask=attention_mask).logits
+
+        log_probs = F.log_softmax(logits.float(), dim=-1)
+
+        for ex_idx, ex in enumerate(batch_ex):
+            flat_start, num_choices = ex_offsets[ex_idx]
+            lls = []
+            for choice_idx in range(num_choices):
+                flat_idx = flat_start + choice_idx
+                tokens_i = batch_tokens[flat_idx]
+                cont_len = batch_cont_lens[flat_idx]
+                start = len(tokens_i) - cont_len
+                ll = 0.0
+                for pos in range(start, len(tokens_i)):
+                    if pos > 0:
+                        ll += log_probs[flat_idx, pos - 1, tokens_i[pos]].item()
+                lls.append(ll)
+
+            pred = max(range(num_choices), key=lambda i: lls[i])
+            label = int(ex["label"])
+            correct += int(pred == label)
+            total += 1
+
+            operator_count = ex.get("metadata", {}).get("operator_count", "unknown")
+            if operator_count not in grouped:
+                grouped[operator_count] = [0, 0]
+            grouped[operator_count][0] += int(pred == label)
+            grouped[operator_count][1] += 1
+
+        del tokens_t, logits, log_probs
+        if device == "cuda":
+            torch.cuda.empty_cache()
+
+    acc = correct / total * 100 if total else 0.0
+    print(f"  arithmark_2.0: acc {acc:.2f}% ({correct}/{total})")
+
+    if grouped:
+        groups = sorted(grouped, key=lambda value: (str(type(value)), value))
+        header = "  " + "  ".join(f"ops={group!s:>3}" for group in groups) + f"  {'Avg':>6}"
+        vals = []
+        for group in groups:
+            group_correct, group_total = grouped[group]
+            vals.append(group_correct / group_total * 100 if group_total else 0.0)
+        print(header)
+        print(f"  {'-' * (len(header) - 2)}")
+        print("  " + "  ".join(f"{value:>6.2f}%" for value in vals) + f"  {acc:>5.2f}%")
+
+    return {"acc": acc, "correct": correct, "total": total}
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run ArithMark 2.0 only.")
+    parser.add_argument("--model", action="append", help="HF model id. Can be passed multiple times.")
+    parser.add_argument("--tokenizer", help="Tokenizer id to use for all --model entries.")
+    parser.add_argument("--batch-size", type=int, default=BATCH_SIZE)
+    parser.add_argument("--dataset-dir", default=str(Path(__file__).resolve().parent))
+    parser.add_argument("--no-pull", action="store_true", help="Do not git pull the official dataset repo before running.")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    torch.set_float32_matmul_precision("high")
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+
+    dataset_dir = Path(args.dataset_dir).resolve()
+    data_path = ensure_official_arithmark_repo(dataset_dir, pull=not args.no_pull)
+    examples = load_arithmark_2(data_path)
+    print(f"Loaded {len(examples)} ArithMark 2.0 examples from {data_path}")
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Using device: {device}")
+
+    model_entries = [(model,) for model in args.model] if args.model else MODELS
+    all_results = {}
+
+    for model_entry in model_entries:
+        model_name = model_entry[0]
+        tokenizer_name = args.tokenizer or (model_entry[1] if len(model_entry) > 1 else model_name)
+
+        print(f"\n{'=' * 60}")
+        print(f"  Loading {model_name}...")
+        print(f"{'=' * 60}")
+
+        try:
+            model, tokenizer = load_hf_model(model_name, tokenizer_name, device)
+        except Exception as exc:
+            print(f"  Failed to load model: {exc}")
+            continue
+
+        total_params = sum(param.numel() for param in model.parameters())
+        print(f"  {total_params:,} parameters")
+
+        result = evaluate_arithmark_2(model, tokenizer, device, examples, args.batch_size)
+        all_results[model_name] = result
+
+        print(f"\n{'=' * 60}")
+        print(f"  {model_name} ({total_params:,} params) RESULTS")
+        print(f"{'=' * 60}")
+        print(f"  arithmark_2.0 {result['acc']:>9.2f}%")
+        print(f"{'=' * 60}")
+
+        model_tag = model_name.replace("/", "_")
+        results_dir = Path(CACHE_DIR)
+        results_dir.mkdir(parents=True, exist_ok=True)
+        results_file = results_dir / f"{model_tag}_arithmark_2.0_results.json"
+        with results_file.open("w", encoding="utf-8") as f:
+            json.dump(
+                {
+                    "model": model_name,
+                    "params": total_params,
+                    "dataset": str(data_path),
+                    "results": {"arithmark_2.0": result},
+                },
+                f,
+                indent=2,
+            )
+        print(f"Results saved to {results_file}")
+
+        del model
+        if device == "cuda":
+            torch.cuda.empty_cache()
+
+    if len(all_results) > 1:
+        print(f"\n{'=' * 60}")
+        print("  FINAL SUMMARY")
+        print(f"{'=' * 60}")
+        for model_name, result in all_results.items():
+            print(f"  {model_name:<45} {result['acc']:>7.2f}%")
+        print(f"{'=' * 60}")
+
+
+if __name__ == "__main__":
+    main()