Upload folder using huggingface_hub

README.md

@@ -0,0 +1,36 @@
+---
+license: apache-2.0
+library_name: transformers
+base_model: google/gemma-4-12B
+pipeline_tag: text-generation
+tags:
+  - gemma4
+  - iol-ai-2026
+---
+
+# IOL-AI 2026 — gemma4:12b hybrid (symbolic numeral solver + budget-managed LLM)
+
+Three-pass pipeline:
+
+1. **Symbolic pass** — `numeral_solver.py` brute-forces numeral systems
+   (base, word values, word-order convention) from the problem's own
+   examples and answers `text_to_num` / `num_to_text` exactly when a
+   consistent system exists; otherwise falls through to the LLM.
+2. **Baseline pass** — a fast low-token answer for every remaining
+   problem, with `submission.csv` atomically checkpointed after every row.
+3. **Upgrade pass** — per-row time-sliced reasoning with per-task-type
+   method prompts; a baseline answer is replaced only when the upgrade
+   parses to the correct number of answers. Translation reasoning is
+   deliberately capped low: on gemma4-12B, truncated reasoning plus a
+   forced short answer scored measurably higher than completed reasoning.
+
+Model: gemma4-12B (Apache 2.0), weights shipped in this repo, loaded 4-bit
+via bitsandbytes at startup (fp16 12B does not fit the 16 GB T4).
+
+## Upload checklist (before submitting)
+
+1. Put the gemma4-12B weight files (safetensors + config + tokenizer) in
+   the repo root so `script.py` loads them from `"."`.
+2. Repo must be **public** at submission time.
+3. Submit via the competition Space; the platform mounts the hidden test
+   set at `/tmp/data/test.csv` and runs `script.py`.

numeral_solver.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Constraint solver for IOL-style numeral problems.
+
+Given example lines "word word = value", searches over (base, word values,
+combination convention) for a system that reproduces every example, then
+answers queries in either direction (words -> digits, digits -> words).
+
+Grammar family searched: value words for units (1..base-1) and powers
+(base, base^2, base^3); a numeral is a sequence of groups read left to
+right, each group = [unit multiplier] power, plus an optional trailing
+unit addend. Two conventions tried: multiplier-before-power ("two ten"=20,
+"ten two"=12) and power-before-multiplier (the reverse).
+
+Returns None rather than guessing when no consistent system exists, so a
+caller can fall back to an LLM. Standalone test:
+    python3 numeral_solver.py            # runs against data/dev.csv
+"""
+import itertools
+import re
+
+
+def parse_examples(context):
+    """Extract (tokens, value) pairs from lines like 'lo tem = 10'."""
+    ex = []
+    for line in context.splitlines():
+        m = re.match(r"^\s*([^\d=]+?)\s*=\s*(\d+)\s*$", line)
+        if m:
+            ex.append((tuple(m.group(1).split()), int(m.group(2))))
+    return ex
+
+
+def parse_value(tokens, vals, base, mult_first):
+    """Parse a numeral under one convention; None if malformed."""
+    powers = {base, base * base, base ** 3}
+    total, i = 0, 0
+    prev_power = None
+    while i < len(tokens):
+        v = vals.get(tokens[i])
+        if v is None:
+            return None
+        if v in powers:
+            total += v
+            prev_power = v
+            i += 1
+        else:                                   # unit word
+            if mult_first and i + 1 < len(tokens) and \
+                    vals.get(tokens[i + 1]) in powers:
+                p = vals[tokens[i + 1]]
+                if prev_power is not None and p >= prev_power:
+                    return None                 # powers must descend
+                total += v * p
+                prev_power = p
+                i += 2
+            elif not mult_first and prev_power is not None and i == len(tokens) - 1:
+                total += v
+                i += 1
+            elif not mult_first and i > 0 and vals.get(tokens[i - 1]) in powers:
+                # power-first: unit right after a power multiplies it
+                p = vals[tokens[i - 1]]
+                total += v * p - p              # power already added once
+                i += 1
+            elif i == len(tokens) - 1:
+                total += v                      # trailing addend
+                i += 1
+            else:
+                return None
+    return total
+
+
+def solve(context):
+    """Find (base, vals, mult_first) consistent with every example."""
+    examples = parse_examples(context)
+    if len(examples) < 3:
+        return None
+    words = sorted({w for toks, _ in examples for w in toks})
+
+    # words pinned by single-token examples
+    pinned = {toks[0]: v for toks, v in examples if len(toks) == 1}
+    free = [w for w in words if w not in pinned]
+    max_val = max(v for _, v in examples)
+
+    for base in range(3, 31):
+        if base * base > max_val * base:
+            break
+        powers = [base, base * base, base ** 3]
+        cand = [v for v in list(range(1, base)) + powers if v <= max_val * 2]
+        if any(v >= base and v not in powers for v in pinned.values()):
+            continue
+        if len(free) > 3:
+            continue                            # search would explode
+        for combo in itertools.product(cand, repeat=len(free)):
+            vals = dict(pinned)
+            vals.update(zip(free, combo))
+            if len(set(vals.values())) != len(vals):
+                continue
+            for mult_first in (True, False):
+                if all(parse_value(t, vals, base, mult_first) == v
+                       for t, v in examples):
+                    return base, vals, mult_first
+    return None
+
+
+def render(value, base, vals, mult_first):
+    """Compose the numeral words for a value under a solved system."""
+    inv = {v: w for w, v in vals.items()}
+    parts = []
+    for p in (base ** 3, base * base, base):
+        if p in inv:
+            mult, value = divmod(value, p)
+            if mult == 0:
+                continue
+            if mult == 1:
+                parts.append(inv[p])
+            elif mult in inv:
+                pair = [inv[mult], inv[p]]
+                parts.extend(pair if mult_first else pair[::-1])
+            else:
+                return None
+    if value:
+        if value not in inv:
+            return None
+        parts.append(inv[value])
+    return " ".join(parts) if parts else None
+
+
+def answer(context, query, task_type):
+    """Answer all items, or None if the system can't be solved."""
+    solved = solve(context)
+    if not solved:
+        return None
+    base, vals, mult_first = solved
+    items = re.findall(r"^\s*\d+[.)]\s*(.+)$", query, re.M)
+    out = []
+    for item in items:
+        item = item.strip()
+        if task_type == "text_to_num":
+            v = parse_value(tuple(item.split()), vals, base, mult_first)
+            out.append(str(v) if v is not None else None)
+        else:
+            m = re.search(r"\d+", item)
+            out.append(render(int(m.group()), base, vals, mult_first)
+                       if m else None)
+    return out if all(a is not None for a in out) else None
+
+
+if __name__ == "__main__":
+    import csv
+    import json
+    gold = json.load(open("data/dev_answers.json", encoding="utf-8"))
+    total = solved_ok = items_right = items_total = 0
+    for r in csv.DictReader(open("data/dev.csv", newline="", encoding="utf-8")):
+        if r["task_type"] not in ("text_to_num", "num_to_text"):
+            continue
+        total += 1
+        ans = answer(r["context"], r["query"], r["task_type"])
+        g = gold[r["id"]]
+        items_total += len(g)
+        if ans is None:
+            print(f"{r['id']} {r['task_type']:12} UNSOLVED")
+            continue
+        right = sum(a == b for a, b in zip(ans, g))
+        items_right += right
+        solved_ok += 1
+        flag = "" if right == len(g) else f"  <-- {ans} vs {g}"
+        print(f"{r['id']} {r['task_type']:12} solved, {right}/{len(g)} items{flag}")
+    print(f"\nsolved {solved_ok}/{total} problems, "
+          f"{items_right}/{items_total} items exactly right")

script.py

@@ -0,0 +1,245 @@
+"""IOL-AI 2026 submission — v5 hybrid (solver + budget-managed gemma4:12b).
+
+Everything here was validated on a local dev set (see README):
+  pass 0  symbolic numeral solver (numeral_solver.py, shipped in this repo);
+          answers text_to_num / num_to_text exactly when the system fits the
+          searched grammar family, returns None -> LLM fallback otherwise
+  pass 1  fast low-token answer for every remaining problem, submission.csv
+          atomically checkpointed after every row (a kill never leaves an
+          invalid/partial file)
+  pass 2  per-row time-sliced re-solve with reasoning; overwrites baseline
+          only if the result parses to the right number of answers; translation
+          reasoning is deliberately capped LOW (truncated reasoning + a forced
+          short answer scored higher than completed reasoning on gemma4:12b)
+
+Repo layout expected: this file as script.py, numeral_solver.py beside it,
+gemma4:12b weights in the repo root (load from "."). fp16 12B does not fit a
+16 GB T4, so weights load 4-bit via bitsandbytes (the organizer-reference
+recipe).
+"""
+import os
+import subprocess
+import sys
+import time
+
+T0 = time.monotonic()
+TIME_LIMIT = 30 * 60
+DEADLINE = T0 + TIME_LIMIT - 3 * 60          # 3-min reserve for writes/exit
+
+# Smoke mode (local CPU shakeout, mirrors the leader's IOL_DUMMY pattern):
+#   IOL_SMOKE=1        skip bitsandbytes (no CUDA), load fp32 on CPU
+#   IOL_MODEL_ID=...   substitute a tiny model for the shipped weights
+#   IOL_INPUT=...      read a local CSV instead of /tmp/data/test.csv
+SMOKE = os.environ.get("IOL_SMOKE", "0") == "1"
+
+deps = ["transformers>=4.51", "accelerate>=0.30", "torch>=2.2", "pandas"]
+if not SMOKE:
+    deps.append("bitsandbytes")
+subprocess.run([sys.executable, "-m", "pip", "install", "-q", *deps], check=True)
+
+import json
+import re
+
+import pandas as pd
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+import numeral_solver
+
+MODEL_ID = os.environ.get("IOL_MODEL_ID", ".")
+INPUT_CSV = os.environ.get("IOL_INPUT", "/tmp/data/test.csv")
+MARKER = "FINAL ANSWERS"
+TRANSLATION_CAP = 3000        # tokens; see module docstring
+GLOBAL_CAP = 8192
+
+BASE_RULES = (
+    f"You solve International Linguistics Olympiad problems. Your reasoning budget "
+    f"is limited, so be systematic and compact — do not second-guess a hypothesis "
+    f"that fits all the data. Verify against every given example once, then commit. "
+    f"End with the line '{MARKER}:' followed by one answer per line, in item order, "
+    f"with no numbering and no extra text."
+)
+
+NUMERAL_CORE = (
+    "1) For EVERY example, write one arithmetic equation showing exactly how its "
+    "words produce its value. 2) Determine the base from the single-word values. "
+    "3) CRITICAL: find pairs of examples using the same words in different orders "
+    "with different values — decide which order means multiplication and which "
+    "means addition. 4) Only after your equations reproduce ALL examples, "
+)
+
+STRATEGIES = {
+    "translation": (
+        "Method: 1) Align the given sentence pairs and segment every word into "
+        "morphemes by comparing entries that share meaning components. 2) Write a "
+        "compact table: each root, prefix, and suffix with its meaning, plus the "
+        "morpheme order. 3) Compose each requested item from the table. Mind the "
+        "direction of translation asked for."
+    ),
+    "text_to_num": "Method: " + NUMERAL_CORE + "convert each item to digits.",
+    "num_to_text": "Method: " + NUMERAL_CORE + "compose each requested number in "
+                   "the puzzle language.",
+    "fill_blanks": (
+        "Method: deduce the paradigm from the completed cells, state the rule for "
+        "each row/column, then fill each blank consistently with it."
+    ),
+    "match_letters": (
+        "Method: find anchor items you can pair with certainty first (word length, "
+        "repeated letters), then use elimination. Every item gets exactly one match."
+    ),
+}
+
+SALVAGE = (
+    "Time is up. Based on the partial analysis below, give your best answer for "
+    "all {n} items RIGHT NOW: one answer per line, in order, no numbering, no "
+    "other text, no further reasoning.\n\nThe items to answer:\n{query}\n\n"
+    "Partial analysis:\n{tail}"
+)
+
+
+def remaining():
+    return DEADLINE - time.monotonic()
+
+
+tok = AutoTokenizer.from_pretrained(MODEL_ID, local_files_only=not SMOKE)
+if SMOKE:
+    model = AutoModelForCausalLM.from_pretrained(MODEL_ID).eval()
+else:
+    from transformers import BitsAndBytesConfig
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        quantization_config=BitsAndBytesConfig(
+            load_in_4bit=True, bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.float16),
+        device_map="auto", local_files_only=True,
+    ).eval()
+print(f"[model] loaded at {time.monotonic()-T0:.0f}s", flush=True)
+
+
+def generate(messages, max_new, max_time=None):
+    """Greedy generation. Returns (text, truncated, tokens_per_sec)."""
+    enc = tok.apply_chat_template(
+        messages, add_generation_prompt=True, return_tensors="pt",
+    )
+    if hasattr(enc, "keys"):        # BatchEncoding on newer transformers
+        inputs = {k: v.to(model.device) for k, v in enc.items()}
+    else:                           # bare tensor on older versions
+        inputs = {"input_ids": enc.to(model.device)}
+    prompt_len = inputs["input_ids"].shape[-1]
+    kw = {"max_new_tokens": max_new, "do_sample": False,
+          "pad_token_id": tok.eos_token_id}
+    if max_time:
+        kw["max_time"] = max_time
+    t0 = time.monotonic()
+    with torch.no_grad():
+        out = model.generate(**inputs, **kw)
+    n_new = out.shape[-1] - prompt_len
+    tps = n_new / max(time.monotonic() - t0, 1e-6)
+    text = tok.decode(out[0][prompt_len:], skip_special_tokens=True).strip()
+    return text, n_new >= max_new, tps
+
+
+def item_count(query):
+    return len(re.findall(r"^\s*\d+[.)]", query, re.M)) or 1
+
+
+def extract_answers(text, n):
+    m = re.search(rf"{MARKER}\s*:?", text, re.I)
+    block = text[m.end():] if m else text
+    lines = [ln.strip() for ln in block.splitlines() if ln.strip()]
+    if not m:
+        lines = lines[-n:]
+    lines = [re.sub(r"^\d+[.)]\s*", "", ln) for ln in lines]
+    return (lines + [""] * n)[:n]
+
+
+def valid(answers, n):
+    return len(answers) == n and all(answers)
+
+
+def checkpoint(rows):
+    tmp = ".submission.csv.tmp"
+    pd.DataFrame(rows, columns=["id", "pred"]).to_csv(tmp, index=False)
+    os.replace(tmp, "submission.csv")
+
+
+def build_messages(r):
+    system = BASE_RULES + "\n\n" + STRATEGIES.get(r["task_type"], "")
+    return [
+        {"role": "system", "content": system},
+        {"role": "user", "content": f"{r['context'].strip()}\n\n{r['query'].strip()}"},
+    ]
+
+
+df = pd.read_csv(INPUT_CSV, dtype=str).fillna("")
+problems = [r for _, r in df.iterrows()]
+counts = [item_count(r["query"]) for r in problems]
+rows = [{"id": r["id"], "pred": json.dumps([""] * counts[i])}
+        for i, r in enumerate(problems)]
+checkpoint(rows)
+
+# ── pass 0: symbolic numeral solver ──────────────────────────────────────────
+solved = [False] * len(problems)
+for i, r in enumerate(problems):
+    if r["task_type"] in ("text_to_num", "num_to_text"):
+        try:
+            ans = numeral_solver.answer(r["context"], r["query"], r["task_type"])
+        except Exception as exc:
+            print(f"[solver] {r['id']} error: {exc}", flush=True)
+            ans = None
+        if ans is not None:
+            rows[i]["pred"] = json.dumps(ans, ensure_ascii=False)
+            solved[i] = True
+            print(f"[solver] {r['id']} solved", flush=True)
+checkpoint(rows)
+
+# ── pass 1: fast complete baseline ───────────────────────────────────────────
+tps_est = 20.0
+for i, r in enumerate(problems):
+    if solved[i] or remaining() < 60:
+        continue
+    text, _, tps_est = generate(build_messages(r), max_new=48 * counts[i] + 128,
+                                max_time=min(90.0, remaining() / 4))
+    rows[i]["pred"] = json.dumps(extract_answers(text, counts[i]),
+                                 ensure_ascii=False)
+    checkpoint(rows)
+    print(f"[base {i+1}/{len(problems)}] done at {time.monotonic()-T0:.0f}s",
+          flush=True)
+
+# ── pass 2: time-sliced reasoning upgrades ───────────────────────────────────
+for i, r in enumerate(problems):
+    if solved[i]:
+        continue
+    n = counts[i]
+    if remaining() < 30:
+        print("[deadline] stopping upgrades", flush=True)
+        break
+    todo = sum(1 for j in range(i, len(problems)) if not solved[j])
+    slice_s = max(remaining() / max(todo, 1), 10.0)
+    max_new = int(min(max(slice_s * 0.8 * tps_est, 512), GLOBAL_CAP))
+    if r["task_type"] == "translation":
+        max_new = min(max_new, TRANSLATION_CAP)
+
+    text, truncated, tps_est = generate(build_messages(r), max_new,
+                                        max_time=slice_s * 0.8)
+    upgraded = extract_answers(text, n) if text else []
+
+    if not valid(upgraded, n) and remaining() > 20:
+        msgs = [
+            {"role": "system", "content": "Output only the answers, one per line."},
+            {"role": "user", "content": SALVAGE.format(
+                n=n, query=r["query"].strip(), tail=text[-3000:])},
+        ]
+        text, _, _ = generate(msgs, max_new=48 * n + 64,
+                              max_time=min(60.0, remaining()))
+        upgraded = extract_answers(text, n)
+
+    if valid(upgraded, n):
+        rows[i]["pred"] = json.dumps(upgraded, ensure_ascii=False)
+        checkpoint(rows)
+        print(f"[think {i+1}/{len(problems)}] upgraded", flush=True)
+    else:
+        print(f"[think {i+1}/{len(problems)}] kept baseline", flush=True)
+
+checkpoint(rows)
+print(f"wrote submission.csv at {time.monotonic()-T0:.0f}s", flush=True)