Upload TinyAdd2LLM model files

MODEL_CARD.md

@@ -0,0 +1,28 @@
+# Model Card: Tiny Add2 LLM 10MB
+
+## Purpose
+
+A small addition-only model for exactly two non-negative integers.
+
+## Architecture
+
+This is a lookup-table style mini model, not a general LLM. The model stores all sums for numbers from `0` to `2199` in a 10 MiB binary file.
+
+## Strength
+
+- Exact answers for supported range
+- Very low CPU/RAM
+- Works offline
+- Simple code
+
+## Weakness
+
+- Not a real chatbot
+- No reasoning outside two-number addition
+- Default range is only `0..2199`
+
+## Example
+
+Input: `12 + 30`
+
+Output: `42`

README.md

@@ -0,0 +1,60 @@
+# Tiny Add2 LLM 10MB
+
+This is a **tiny addition-only model package**. It is not a real general-purpose LLM like Llama/GPT. It is made for one job only:
+
+> add exactly 2 non-negative numbers.
+
+Example:
+
+```bash
+python infer.py "12 + 30"
+# 42
+```
+
+## What is included
+
+- `model/add2_model.bin` — 10 MB model file
+- `model.py` — model loader
+- `infer.py` — one-shot addition answer
+- `chat.py` — simple chat mode
+- `build_model.py` — rebuild the 10 MB model file
+- `test_model.py` — quick tests
+
+## Limit
+
+Default model supports numbers from `0` to `2199`.
+
+Valid inputs:
+
+```text
+12 + 30
+add 15 and 7
+100 plus 55
+```
+
+Invalid inputs:
+
+```text
+hello
+12 + 30 + 5
+-1 + 5
+99999 + 1
+```
+
+## Run on PC
+
+```bash
+pip install -r requirements.txt
+python infer.py "123 + 456"
+python chat.py
+```
+
+## Rebuild model
+
+```bash
+python build_model.py --max-number 2199 --target-mb 10 --out model/add2_model.bin
+```
+
+## Hinglish note
+
+Bhai, ye ek chhota **addition-only mini model** hai. Ye chatbot jaisa general answer nahi dega. Sirf 2 number add karega.

chat.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from model import Add2ModelError, TinyAdd2LLM
+
+
+def main() -> None:
+    model = TinyAdd2LLM.load("model/add2_model.bin")
+    print("Tiny Add2 LLM loaded.")
+    print(f"Limit: 0 to {model.max_number}. Type 'exit' to stop.")
+    print("Examples: 12 + 30 | add 15 and 7 | 100 plus 55")
+
+    while True:
+        user = input("You: ").strip()
+        if user.lower() in {"exit", "quit", "q"}:
+            print("Bye")
+            break
+        try:
+            print("TinyAdd2LLM:", model.answer(user))
+        except Add2ModelError as e:
+            print("TinyAdd2LLM:", e)
+
+
+if __name__ == "__main__":
+    main()

infer.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from model import Add2ModelError, TinyAdd2LLM
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Tiny Add2 LLM inference")
+    parser.add_argument("prompt", help="Example: '12 + 30'")
+    parser.add_argument("--model", default=str(Path("model") / "add2_model.bin"), help="Path to model file")
+    args = parser.parse_args()
+
+    try:
+        model = TinyAdd2LLM.load(args.model)
+        print(model.answer(args.prompt))
+    except (Add2ModelError, FileNotFoundError) as e:
+        print(f"ERROR: {e}")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

model.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import re
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+MAGIC = b"ADD2LLM1"  # 8 bytes
+HEADER_STRUCT = "<8sIIII"  # magic, max_number, rows, cols, table_bytes
+HEADER_SIZE = struct.calcsize(HEADER_STRUCT)
+
+
+class Add2ModelError(Exception):
+    """Raised when input cannot be handled by the tiny addition model."""
+
+
+@dataclass
+class TinyAdd2LLM:
+    model_path: Path
+    max_number: int
+    table: np.ndarray
+
+    @classmethod
+    def load(cls, model_path: str | Path = "model/add2_model.bin") -> "TinyAdd2LLM":
+        path = Path(model_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Model file not found: {path}")
+
+        with path.open("rb") as f:
+            header = f.read(HEADER_SIZE)
+            magic, max_number, rows, cols, table_bytes = struct.unpack(HEADER_STRUCT, header)
+            if magic != MAGIC:
+                raise Add2ModelError("Invalid model file: bad magic header")
+            raw = f.read(table_bytes)
+
+        table = np.frombuffer(raw, dtype=np.uint16).reshape((rows, cols))
+        return cls(model_path=path, max_number=max_number, table=table)
+
+    def add(self, a: int, b: int) -> int:
+        if not (0 <= a <= self.max_number and 0 <= b <= self.max_number):
+            raise Add2ModelError(
+                f"This 10MB model supports only numbers 0 to {self.max_number}. "
+                f"Got: {a}, {b}"
+            )
+        return int(self.table[a, b])
+
+    def answer(self, text: str) -> str:
+        a, b = parse_two_number_addition(text)
+        return str(self.add(a, b))
+
+
+def parse_two_number_addition(text: str) -> Tuple[int, int]:
+    text = text.strip().lower()
+    patterns = [
+        r"^\s*(\d+)\s*\+\s*(\d+)\s*\??\s*$",
+        r"^\s*(\d+)\s+plus\s+(\d+)\s*\??\s*$",
+        r"^\s*add\s+(\d+)\s+and\s+(\d+)\s*\??\s*$",
+        r"^\s*what\s+is\s+(\d+)\s*\+\s*(\d+)\s*\??\s*$",
+        r"^\s*what\s+is\s+(\d+)\s+plus\s+(\d+)\s*\??\s*$",
+    ]
+    for pattern in patterns:
+        match = re.match(pattern, text)
+        if match:
+            return int(match.group(1)), int(match.group(2))
+    raise Add2ModelError(
+        "I only understand two-number addition, like: 12 + 30, 12 plus 30, or add 12 and 30."
+    )

model/add2_model.bin

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

requirements.txt

@@ -0,0 +1 @@
+numpy>=1.22