Teaching TinyAya to say "I don't know" in languages with no labelled QA data

Ask a small multilingual model a question it cannot answer and it will usually answer anyway. We measured this on CohereLabs/tiny-aya-global with 252 held-out MKQA questions per language. In English, Spanish, Arabic and Malay the base model answers every question and gets 80 to 85 percent of all questions wrong.

The obvious fix is to fine-tune the model to abstain when it does not know. The catch is the labels. To train abstention you need to know which questions the model does not know, and that normally means gold answers. Most languages do not have them.

This project asks whether we can get those known/unknown labels without gold answers in the target language, and still end up with a model that abstains about as well as one trained on gold labels. It was built for the Lexsi AI Safety and Alignment Hackathon, Track 1 (Fine-tuning and Data Curation).

Links: code · adapters · data and outputs · results explorer

The idea

We label each training question as known or unknown in two gold-free ways:

Known questions keep their answer as the training target. Unknown questions get an "I don't know" in the question's language. We fine-tune a small LoRA adapter (r=16) for each language and compare five recipes:

Recipe Labels come from
R1 Trap questions written by a teacher model
R2 Gold answers (the upper bound)
R3 Consistency
R4 The transferred probe
R5 Probe and consistency must agree (an ablation)

Everything runs on a Kaggle T4. In total there are 61 evaluation runs: the base model plus 5 recipes, 4 languages and 3 seeds. Differences are tested with a paired bootstrap over the test questions.

What we found

Hallucination here means "answered and wrong", counted over all questions. Lower is better. Values are means over 3 seeds.

Language Base R1 teacher traps R2 gold R3 consistency R4 probe R5 probe and consistency
English 0.802 0.713 0.192 0.245 0.193 0.192
Spanish 0.825 0.712 0.212 0.196 0.189 0.167
Arabic 0.853 0.541 0.262 0.239 0.222 0.233
Malay 0.845 0.754 0.259 0.311 0.262 0.180

Gold-free labels work. R4 cuts hallucination from 0.80 to 0.85 down to 0.19 to 0.26. In English, Spanish and Malay it is not significantly different from training on gold labels (R2). The paired bootstrap interval for the difference includes zero.

Arabic is the exception. R4 hallucinates 0.040 less than R2, but it also gets 0.021 fewer answers right, because it abstains more. That is a more conservative model, not a better one.

Teacher-written traps barely help. R1 only moves hallucination from about 0.8 to about 0.7 in English, Spanish and Malay. One possible reason is that the questions a teacher model writes as traps are not the ones this small model actually gets wrong; we did not test that.

The probe labels are at least as good as consistency. AUROC for separating known from unknown questions is 0.84 to 0.90 for the probe and 0.74 to 0.81 for consistency. The confidence intervals overlap, so we claim "comparable or better", not "clearly better".

The cost is over-refusal. Among questions the base model answered correctly, R4 refuses 19 to 38 percent (across R2 to R5 the range is 19 to 49 percent).

Transfer across languages is partial. An adapter trained on English also helps on Spanish and Malay (roughly 0.35 less hallucination than the base model) but much less on Arabic. Adapters trained on one non-English language transfer poorly to the others. This matrix is from one seed.

Using the Lexsi tools

We used two Lexsi toolkits and skipped a third because of a dependency clash.

What went wrong along the way

Our first set of evaluations was wrong. The fine-tuned adapters did not stop generating at the end-of-sequence token, so they kept writing after the answer and exact match failed. For a while Arabic and Malay looked worse than the base model. It was purely an evaluation bug. We fixed generation to stop at EOS and re-ran every evaluation except the base model.

We also lost about five hours when a Kaggle session reset wiped the working directory. After that, every finished run uploaded its adapter and results to the Hub as it completed.

Limits you should know about

Try it

from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

tok = AutoTokenizer.from_pretrained("CohereLabs/tiny-aya-global")
base = AutoModelForCausalLM.from_pretrained(
    "CohereLabs/tiny-aya-global", torch_dtype="float16", device_map="auto")
model = PeftModel.from_pretrained(
    base, "EmanMirza2025/tinyaya-idk-adapters", subfolder="R4_es_s1")

Adapter folders are named R{recipe}_{language}_s{seed}. Use the few-shot prompt from configs/config.yaml in the GitHub repository, since the reported numbers were measured with it. The repository also has a small Gradio demo (src/app.py) that shows the base model and an adapter side by side, and full reproduction steps in the README.

Where everything is

Built by Eman Mirza for the Lexsi AI Safety and Alignment Hackathon.