Update README.md

README.md

@@ -67,7 +67,87 @@ Kullanıcı: {message}
 Töz: {response}<|endoftext|>
 ```
 
-## Training
+## Tool use: calculator
+
+Töz-1.5 does not compute arithmetic itself. It writes the expression inside `<hesap>…</hesap>` ("hesap" = calculation), an external calculator evaluates it, and the result is inserted inside `<sonuc>…</sonuc>` ("sonuç" = result). The model then continues and writes the final answer:
+
+```
+Kullanıcı: 25*4-10 kaç eder peki?
+Töz: Hesaplayalım: <hesap>25*4-10</hesap>
+<sonuc>90</sonuc>
+ Sonuç: 90.
+```
+
+How it works:
+
+1. Generate until the model writes `</hesap>`, then stop.
+2. Evaluate the expression between `<hesap>` and `</hesap>`.
+3. Append `\n<sonuc>{result}</sonuc>\n` to the text and continue generating.
+
+If you skip the tool loop, the model may fill in `<sonuc>` on its own, and that value is not reliable, especially for large numbers. Always run the calculator.
+
+```python
+import ast, operator
+from fractions import Fraction
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+model_id = "TozAI/Toz-1.5"
+tok = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.float16)  # use torch.float32 on CPU
+
+OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
+       ast.Div: operator.truediv, ast.Mod: operator.mod, ast.Pow: operator.pow,
+       ast.USub: operator.neg, ast.UAdd: operator.pos}
+
+def calculate(expr: str) -> str:
+    """Safe calculator: numbers, + - * / % ** and parentheses only. No eval()."""
+    expr = expr.replace("×", "*").replace("÷", "/").replace("^", "**")
+    def ev(n):
+        if isinstance(n, ast.Expression):
+            return ev(n.body)
+        if isinstance(n, ast.Constant) and isinstance(n.value, (int, float)):
+            return Fraction(str(n.value))
+        if isinstance(n, ast.BinOp) and type(n.op) in OPS:
+            a, b = ev(n.left), ev(n.right)
+            if isinstance(n.op, ast.Pow):
+                if b.denominator != 1 or abs(b) > 1000:
+                    raise ValueError("unsupported exponent")
+                b = int(b)
+            return OPS[type(n.op)](a, b)
+        if isinstance(n, ast.UnaryOp) and type(n.op) in OPS:
+            return OPS[type(n.op)](ev(n.operand))
+        raise ValueError("unsupported expression")
+    r = ev(ast.parse(expr, mode="eval"))
+    return str(r.numerator) if r.denominator == 1 else f"{float(r):.10g}"
+
+def chat(question: str, max_new_tokens: int = 256, max_calls: int = 5) -> str:
+    text = tok.apply_chat_template([{"role": "user", "content": question}],
+                                   add_generation_prompt=True, tokenize=False)
+    start = len(text)
+    for _ in range(max_calls + 1):
+        ids = tok(text, return_tensors="pt", add_special_tokens=False)
+        out = model.generate(**ids, max_new_tokens=max_new_tokens, do_sample=False,
+                             stop_strings=["</hesap>"], tokenizer=tok)
+        new = tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
+        text += new
+        if not new.rstrip().endswith("</hesap>"):
+            break
+        expr = text.rsplit("<hesap>", 1)[1].rsplit("</hesap>", 1)[0]
+        try:
+            result = calculate(expr)
+        except Exception:
+            result = "hata"  # "error"
+        text += f"\n<sonuc>{result}</sonuc>\n"
+    return text[start:].strip()
+
+print(chat("12*7 kaç eder?"))
+# Hesaplayalım: <hesap>12*7</hesap>
+# <sonuc>84</sonuc>
+#  Sonuç: 84.
+```
+
+The calculator uses exact integer and fraction arithmetic, so large numbers are not rounded. It never calls `eval()`. Only numbers, the four operations, `%`, `**` and parentheses are accepted.
 
 ### Pre-training
 Fineweb-2 + wiki filtered, trained 15B token