"""Proof that sea_thinking fixes the problem: LoRA-SFT a small thinking model (Qwen3-0.6B) on Beam's in-language
traces, then measure the language of its block and its accuracy on HELD-OUT math problems (never seen in
training, in any language), before vs after. Runs on a 6 GB consumer GPU.
Usage: python distill.py baseline | train | after (results -> data/distill/)"""
import json, math, os, random, re, sys, time
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
BASE = "Qwen/Qwen3-0.6B"
OUT = "data/distill"; ADAPTER = f"{OUT}/adapter"
EVAL_LANGS = ["ind_Latn", "jav_Latn", "sun_Latn", "tha_Thai"]
N_HELD = 15
os.makedirs(OUT, exist_ok=True)
torch.manual_seed(0)
dev = "cuda"
def held_out_ids():
par = json.load(open("data/math/parallel.json", encoding="utf-8"))
ok = sorted(int(i) for i, v in par.items() if all(v.get(c, {}).get("numbers_ok") for c in EVAL_LANGS))
return sorted(random.Random(42).sample(ok, N_HELD)), par
def load(adapter=False):
tok = AutoTokenizer.from_pretrained(BASE)
tok.padding_side = "left"
m = AutoModelForCausalLM.from_pretrained(BASE, torch_dtype=torch.float16).to(dev)
if adapter:
from peft import PeftModel
m = PeftModel.from_pretrained(m, ADAPTER).merge_and_unload().half().to(dev) # merged: no LoRA overhead at inference
return tok, m.eval()
def evaluate(tag, adapter=False, bs=int(os.environ.get("BS", 12)), max_new=1200):
from lid import profile
from benak_reward import _boxed, _num
ids, par = held_out_ids()
probs = {p["id"]: p for p in json.load(open("data/math/problems.json", encoding="utf-8"))}
tok, m = load(adapter)
jobs = [(i, l) for l in EVAL_LANGS for i in ids]
raw_path = f"{OUT}/raw_{tag}.jsonl" # incremental, so a crash never loses finished batches
done = {}
if os.path.exists(raw_path):
for line in open(raw_path, encoding="utf-8"):
d = json.loads(line); done[(d["id"], d["lang"])] = d
jobs_left = [j for j in jobs if j not in done]
rows = []
for k in range(0, len(jobs_left), bs):
chunk = jobs_left[k:k + bs]
texts = [tok.apply_chat_template([{"role": "user", "content": par[str(i)][l]["text"]}], tokenize=False,
add_generation_prompt=True, enable_thinking=True) for i, l in chunk]
enc = tok(texts, return_tensors="pt", padding=True).to(dev)
with torch.no_grad():
out = m.generate(**enc, max_new_tokens=max_new, do_sample=True, temperature=0.6, top_p=0.95, top_k=20, repetition_penalty=float(os.environ.get("REP_PEN", 1.0)),
pad_token_id=tok.pad_token_id)
with open(raw_path, "a", encoding="utf-8") as f:
for (i, l), seq in zip(chunk, out[:, enc["input_ids"].shape[1]:]):
txt = tok.decode(seq, skip_special_tokens=True)
d = {"id": i, "lang": l, "txt": txt, "think_tokens": int((seq != tok.pad_token_id).sum())}
done[(i, l)] = d
f.write(json.dumps(d, ensure_ascii=False) + chr(10))
print(f"[{tag}] {len(done)}/{len(jobs)}", flush=True)
if os.environ.get("GEN_ONLY"): # low-RAM machines: score in a separate process (GlotLID needs 1.7 GB RAM)
print("generation done; run: python distill.py score", tag); return
del m; import gc; gc.collect(); torch.cuda.empty_cache()
for (i, l) in jobs:
txt = done[(i, l)]["txt"]
think, _, final = txt.partition("")
think = think.replace("", "").strip()
got = _num(_boxed(final) or "") if final else None
ans = probs[i]["answer"]
correct = got is not None and abs(got - ans) <= max(0.011, 1e-4 * abs(ans))
rows.append({"id": i, "lang": l, "tag": tag, "correct": correct, "finished": bool(final),
"think_tokens": done[(i, l)]["think_tokens"], "lid": profile(think, l, exclude=par[str(i)][l]["text"]),
"think": think, "final": final})
json.dump(rows, open(f"{OUT}/eval_{tag}.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1)
summarize(tag, rows)
def summarize(tag, rows):
s = {}
for l in EVAL_LANGS + ["all"]:
rs = [r for r in rows if l == "all" or r["lang"] == l]
t = [r["lid"]["target_share"] for r in rs if r["lid"]["target_share"] is not None]
e = [r["lid"]["eng_share"] for r in rs if r["lid"]["eng_share"] is not None]
s[l] = {"n": len(rs), "acc": round(100 * sum(r["correct"] for r in rs) / len(rs), 1),
"target_share": round(sum(t) / len(t), 3) if t else None, "eng_share": round(sum(e) / len(e), 3) if e else None,
"finished": round(100 * sum(r["finished"] for r in rs) / len(rs), 1)}
json.dump(s, open(f"{OUT}/summary_{tag}.json", "w"), indent=1)
print(tag, json.dumps(s))
def train(epochs=1, max_len=int(os.environ.get("MAXLEN", 768)), lr=2e-4, accum=8, limit=int(os.environ.get("LIMIT", 0))):
from peft import LoraConfig, get_peft_model
ids, _ = held_out_ids()
rows = [json.loads(l) for l in open("release/dataset/data/sea_thinking.jsonl", encoding="utf-8")]
# no leakage: drop every math row whose problem is held out (in any language)
heldp = {json.load(open("data/math/parallel.json", encoding="utf-8"))[str(i)][l]["text"] for i in ids
for l in json.load(open("data/math/parallel.json", encoding="utf-8"))[str(i)]}
rows = [r for r in rows if r["user"] not in heldp]
tok = AutoTokenizer.from_pretrained(BASE)
m = AutoModelForCausalLM.from_pretrained(BASE, torch_dtype=torch.float16).to(dev)
m.gradient_checkpointing_enable(); m.enable_input_require_grads()
m = get_peft_model(m, LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, task_type="CAUSAL_LM",
target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]))
for p in m.parameters():
if p.requires_grad:
p.data = p.data.float() # fp32 adapters, fp16 frozen base
ex = []
for r in rows:
prompt = tok.apply_chat_template([{"role": "user", "content": r["user"]}], tokenize=False,
add_generation_prompt=True, enable_thinking=True)
target = f"\n{r['analysis'].strip()}\n\n\n{r['final'].strip()}<|im_end|>"
p_ids = tok(prompt, add_special_tokens=False)["input_ids"]; t_ids = tok(target, add_special_tokens=False)["input_ids"]
ids_ = (p_ids + t_ids)[:max_len]; lab = ([-100] * len(p_ids) + t_ids)[:max_len]
if any(x != -100 for x in lab):
ex.append((ids_, lab))
random.Random(0).shuffle(ex)
if limit:
ex = ex[:limit]
print(f"train examples {len(ex)}, mean len {sum(len(e[0]) for e in ex) / len(ex):.0f}", flush=True)
opt = torch.optim.AdamW([p for p in m.parameters() if p.requires_grad], lr=lr, weight_decay=0.0)
steps = math.ceil(len(ex) * epochs / accum)
sched = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: min(1.0, (s + 1) / 10) * max(0.0, 1 - s / steps))
scaler = torch.amp.GradScaler("cuda")
m.train(); log = []; t0 = time.time(); step = 0
for ep in range(epochs):
for k, (ids_, lab) in enumerate(ex):
x = torch.tensor([ids_], device=dev); y = torch.tensor([lab], device=dev)
with torch.autocast("cuda", dtype=torch.float16):
loss = m(input_ids=x, labels=y).loss / accum
scaler.scale(loss).backward()
if (k + 1) % accum == 0 or k == len(ex) - 1:
scaler.unscale_(opt); torch.nn.utils.clip_grad_norm_(m.parameters(), 1.0)
scaler.step(opt); scaler.update(); opt.zero_grad(); sched.step(); step += 1
log.append({"step": step, "loss": round(loss.item() * accum, 4), "s": round(time.time() - t0)})
if step % 2 == 0:
print(f"step {step}/{steps} loss {log[-1]['loss']} {log[-1]['s']}s", flush=True)
m.save_pretrained(ADAPTER)
json.dump({"n_train": len(ex), "held_out_problem_ids": ids, "epochs": epochs, "max_len": max_len, "lr": lr,
"accum": accum, "lora_r": 16, "base": BASE, "log": log}, open(f"{OUT}/train_log.json", "w"), indent=1)
print("saved adapter; train examples", len(ex))
def publish(repo="PugarHuda/benak-qwen3-0.6b-lora"):
from huggingface_hub import HfApi
b = json.load(open(f"{OUT}/summary_baseline.json")); a = json.load(open(f"{OUT}/summary_after.json"))
tl = json.load(open(f"{OUT}/train_log.json"))
names = {"ind_Latn": "Indonesian", "jav_Latn": "Javanese", "sun_Latn": "Sundanese", "tha_Thai": "Thai", "all": "**all**"}
table = "\n".join(f"| {names[l]} | {pct(b[l]['eng_share'])} → **{pct(a[l]['eng_share'])}** | {pct(b[l]['target_share'])} → **{pct(a[l]['target_share'])}** | {b[l]['acc']}% → {a[l]['acc']}% |"
for l in EVAL_LANGS + ["all"])
S = json.load(open(f"{OUT}/stats.json"))
st_, mc, dg = S["eng_share_sign_test"], S["acc_mcnemar"], S["degenerate_think_gt20pct_repeat"]
stats_md = (f"* The English share of thinking fell in **{st_['decreased']} of {st_['pairs']}** paired items and rose in "
f"{st_['increased']} (exact sign test p = {st_['p_exact']:.1e})." + chr(10) +
f"* The accuracy change is **not significant** (McNemar {mc['baseline_only']} vs {mc['after_only']}, p = {mc['p_exact']})." + chr(10) +
f"* **Cost:** {dg['after']}/{S['n']} outputs fall into repetition loops (> 20% of the thinking is one repeated "
f"8-gram), against {dg['baseline']}/{S['n']} before. One epoch of LoRA on about 1k traces makes the model think "
f"in the language but also makes it loop. That is a measured trade-off, not hidden.")
card = f"""---
base_model: {BASE}
library_name: peft
license: apache-2.0
datasets:
- PugarHuda/benak
language: [id, jv, su, th, ms, tl, vi, ceb]
tags: [lora, reasoning, multilingual, southeast-asia, beam, distillation]
---
# benak-qwen3-0.6b-lora: a small model that thinks in your language
A LoRA adapter for **{BASE}**, trained on the [`sea_thinking`](https://huggingface.co/datasets/PugarHuda/benak) traces from
Beam-1.0-501B-A23B. These are correct answers whose reasoning is ≥ 80% in the user's language. It is the proof-of-use for the [Benak](https://huggingface.co/spaces/PugarHuda/benak) dataset,
built for the Build with Beam challenge.
## Before vs after, on **held-out** math problems
The {N_HELD} problems below were never in training, in any language. There is no language instruction in the prompt (Benak condition C0), and each problem is
sampled once (temperature 0.6) per language. Reasoning language is measured by GlotLID on the `` block, after removing sentences that quote the prompt.
| language | English share of thinking | in-language share of thinking | accuracy |
|---|---|---|---|
{table}
## Training
* {tl['n_train']} examples, {tl['epochs']} epoch, LoRA r={tl['lora_r']} on all attention and MLP projections, lr {tl['lr']}, max length {tl['max_len']}, effective batch {tl['accum']}.
* Trained on one GTX 1660 SUPER (6 GB) with fp16 autocast. The final logged loss was {tl['log'][-1]['loss']}, after {tl['log'][-1]['s']} s.
* Code: `distill.py` in the dataset repo. Held-out ids: {tl['held_out_problem_ids']}.
## Statistics
{stats_md}
## Limits
{N_HELD} problems × 4 languages = {N_HELD * 4} generations per side, one sample each. Accuracy at 0.6B is low on these multi-step problems, and the
claim here is about the **language of thinking**, not about math skill. Sundanese moved least (in-language 5% → 19%).
"""
os.makedirs(f"{OUT}/card", exist_ok=True)
open(f"{ADAPTER}/README.md", "w", encoding="utf-8").write(card)
api = HfApi(); api.create_repo(repo, exist_ok=True)
api.upload_folder(folder_path=ADAPTER, repo_id=repo, commit_message="benak LoRA adapter + eval card")
print("published", repo)
def pct(x):
return "–" if x is None else f"{round(100 * x)}%"
if __name__ == "__main__":
if sys.argv[1] == "score": # scoring only: reuse raw generations, never loads the LLM
tag = sys.argv[2]
def evaluate_score(tag=tag):
from lid import profile
from benak_reward import _boxed, _num
ids, par = held_out_ids()
probs = {p["id"]: p for p in json.load(open("data/math/problems.json", encoding="utf-8"))}
done = {(d["id"], d["lang"]): d for d in map(json.loads, open(f"{OUT}/raw_{tag}.jsonl", encoding="utf-8"))}
rows = []
for (i, l) in [(i, l) for l in EVAL_LANGS for i in ids]:
think, _, final = done[(i, l)]["txt"].partition("")
think = think.replace("", "").strip()
got = _num(_boxed(final) or "") if final else None
ans = probs[i]["answer"]
rows.append({"id": i, "lang": l, "tag": tag, "finished": bool(final), "think_tokens": done[(i, l)]["think_tokens"],
"correct": got is not None and abs(got - ans) <= max(0.011, 1e-4 * abs(ans)),
"lid": profile(think, l, exclude=par[str(i)][l]["text"]), "think": think, "final": final})
json.dump(rows, open(f"{OUT}/eval_{tag}.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1)
summarize(tag, rows)
evaluate_score()
else:
{"baseline": lambda: evaluate("baseline"), "train": train, "after": lambda: evaluate("after", adapter=True),
"after_rp": lambda: evaluate("after_rp", adapter=True),
"publish": publish}[sys.argv[1]]()