Update README

README.md

@@ -23,11 +23,21 @@ datasets:
 
 # Atom2.7m
 
-Atom2.7m is a small decoder-only causal language model trained with a general byte-level BPE tokenizer plus arithmetic-specific digit features. The model has 2,738,880 parameters and uses custom code for both the model and the tokenizer path.
+Atom2.7m is a 2.74M-parameter causal language model for text continuation, with an arithmetic-aware tokenizer and digit-feature pathway designed to improve integer arithmetic behavior at very small scale.
 
-The main result is on [ArithMark 2.0](https://huggingface.co/datasets/AxiomicLabs/ArithMark-2.0), a 2,500-example integer-arithmetic continuation benchmark. Atom2.7m scores 69.24% accuracy. This places it above the nearby published range of SmolLM2-1.7B at 66.12% and Qwen2.5-0.5B at 63.04%, while using only 2.74M parameters.
+The model keeps ordinary byte-level BPE behavior for general text while adding structured handling for arithmetic-sensitive spans: digits are atomic, operators are isolated, digit spans are represented least-significant-digit first, and derived place/role features are passed to the model.
 
-The result shows the leverage of domain-specific design. With arithmetic-aware tokenization and digit features, Atom2.7m reaches the same ArithMark score band as models hundreds of times larger.
+On ArithMark 2.0, Atom2.7m reaches 69.24% accuracy, making it an unusually strong arithmetic-continuation model for its size. It should be understood as a compact research model for language modeling, tiny-LM experiments, arithmetic-aware tokenization, and resource-constrained inference, not as a chat assistant or broad mathematical reasoning system.
+
+## Key result
+
+| Model | Parameters | ArithMark 2.0 accuracy |
+|---|---:|---:|
+| Atom2.7m | 2.74M | **69.24%** |
+| SmolLM2-1.7B | 1.7B | 66.12% |
+| Qwen2.5-0.5B | 0.5B | 63.04% |
+
+This comparison is limited to **ArithMark 2.0**. Atom2.7m is not claimed to be generally stronger than larger models; the result highlights the value of arithmetic-aware representation for integer arithmetic continuation.
 
 ## Model Details
 
@@ -47,9 +57,9 @@ The result shows the leverage of domain-specific design. With arithmetic-aware t
 
 ## Tokenizer
 
-Use this model with `trust_remote_code=True`. The submission includes an `AtomTokenizer` remote-code wrapper in `tokenization_atom.py` so standard Hugging Face callers can use `AutoTokenizer.from_pretrained(...)`.
+Most tokenizers represent numbers as ordinary text fragments, which can obscure digit structure. Atom2.7m keeps normal byte-level BPE for general text, but uses a structured arithmetic path for numeric expressions.
 
-The tokenizer keeps byte-level BPE for ordinary text, but treats arithmetic sensitive spans specially:
+For arithmetic-sensitive spans:
 
 - digits `0`-`9` are atomic and never BPE-merged
 - digit spans are emitted least-significant-digit first
@@ -57,6 +67,10 @@ The tokenizer keeps byte-level BPE for ordinary text, but treats arithmetic sens
 - whitespace is isolated from text
 - arithmetic feature IDs are derived by the model from token IDs at inference time
 
+This gives a very small causal LM an inductive bias that is better aligned with elementary integer arithmetic.
+
+Use this model with `trust_remote_code=True`. The submission includes an `AtomTokenizer` remote-code wrapper in `tokenization_atom.py` so standard Hugging Face callers can use `AutoTokenizer.from_pretrained(...)`.
+
 Training and custom tooling may still pass aligned `place_ids` and `role_ids`, but generic inference and evaluation only need `input_ids` and `attention_mask`.
 
 ## Usage
@@ -65,17 +79,18 @@ Training and custom tooling may still pass aligned `place_ids` and `role_ids`, b
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-model_dir = "."
+model_id = "UniversalComputingResearch/Atom2.7m"
 
-model = AutoModelForCausalLM.from_pretrained(
-    model_dir,
-    trust_remote_code=True,
-).eval()
 tokenizer = AutoTokenizer.from_pretrained(
-    model_dir,
+    model_id,
     trust_remote_code=True,
 )
 
+model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    trust_remote_code=True,
+).eval()
+
 text = "12 + 34 ="
 inputs = tokenizer(text, return_tensors="pt", add_special_tokens=False)
 
@@ -142,9 +157,7 @@ multiple-choice continuations do not trip the harness assertion that a
 continuation must fit inside the model window. The tokenizer also advertises
 `model_max_length=548`, matching the longest sequence observed in this eval run.
 The checkpoint was trained with a 512-token context, but the RoPE
-implementation can score this slightly longer harness window; reduce batch size
-or set `max_length` to the longest sequence found if a task variant contains
-longer continuations.
+implementation can score this slightly longer harness window.
 
 For multiple-choice or benchmark-style evaluation, no special generation cache
 setting is required. Log-likelihood scoring runs full `context + continuation`