Access to this dataset is gated. Please describe your intended use and agree to the usage conditions. By requesting access, you agree not to use the dataset to conduct experiments that cause harm to human subjects.

Saraiki LLM Benchmark v1.0

Seven tasks for evaluating language models in Saraiki (Jataki/Multani, Shahmukhi script). Evaluation only: do not train on this dataset. Multiple-choice and math configs have a small dev split (the few-shot examples: 5, or 8 for math); instruction_following and truthfulness_safety are 0-shot and have only test.

Config	Source	Scoring
`knowledge`	MMLU (culturally neutral subjects), MIT	accuracy
`reading_comprehension`	Belebele, CC BY-SA 4.0	accuracy
`commonsense`	HellaSwag, MIT	accuracy
`math`	GSM8K, MIT	exact match
`instruction_following`	IFBench (ODC-BY-1.0) + IFEval (Apache-2.0), language-neutral constraints only	IFBench / IFEval rule checks
`truthfulness_safety`	TruthfulQA (Apache-2.0) + safety prompts	accuracy + refusal rates
`knowledge_hard`	MMLU-Pro (culturally neutral categories, up to 10 options), MIT	accuracy

How to use

The dataset is gated: accept the conditions on this page, then log in with a Hugging Face token (huggingface-cli login). All seven tasks are evaluated in one run with the script below.

Columns

Config	Main columns
`knowledge`, `knowledge_hard`, `commonsense`	`question`, `options` (list), `answer_index`
`reading_comprehension`	`passage`, `question`, `options`, `answer_index`
`math`	`question`, `answer_number`
`instruction_following`	`prompt`, `instruction_id_list`, `kwargs` (both JSON strings), `source` (`allenai/IFBench_test` or `google/IFEval`)
`truthfulness_safety`	`item_type` (`truthful_mc` or `safety`); `question`, `options`, `answer_index` for `truthful_mc`; `expected_behavior` (`refuse` or `comply`) for `safety`

Every Saraiki field also has its English original in a matching *_en column (e.g. question_en, options_en), for analysis only. Evaluate models on the Saraiki fields.

Run all tasks

# pip install -U transformers datasets accelerate
import json, re
import torch
from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL = "Qwen/Qwen3-8B"      # any causal language model on the Hugging Face Hub
CHAT = False                 # True for chat/instruction-tuned models (applies the chat template)
REPO = "themohal/saraiki-llm-bench"
TASKS = {                    # task: number of few-shot examples from `dev` (0 = 0-shot)
    "knowledge": 5, "knowledge_hard": 5, "commonsense": 5, "reading_comprehension": 5,
    "math": 8, "instruction_following": 0, "truthfulness_safety": 0,
}
LETTERS = "ABCDEFGHIJ"
DIGITS = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")

tok = AutoTokenizer.from_pretrained(MODEL)
model = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.bfloat16, device_map="auto")


def generate(prompt, max_new_tokens):
    if CHAT:
        prompt = tok.apply_chat_template([{"role": "user", "content": prompt}],
                                         tokenize=False, add_generation_prompt=True)
    ids = tok(prompt, return_tensors="pt").to(model.device)
    out = model.generate(**ids, max_new_tokens=max_new_tokens, do_sample=False)   # greedy
    return tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)


def format_mcq(row, with_answer=False):
    text = (row["passage"] + "\n\n") if row.get("passage") else ""
    text += row["question"] + "\n"
    text += "\n".join(f"{LETTERS[i]}. {opt}" for i, opt in enumerate(row["options"]))
    text += "\nAnswer:"
    if with_answer:
        text += " " + LETTERS[row["answer_index"]] + "\n\n"
    return text


def score_mcq(rows, shots):
    correct = 0
    for row in rows:
        prompt = "".join(format_mcq(s, with_answer=True) for s in shots) + format_mcq(row)
        found = re.search(r"\b([A-J])\b", generate(prompt, 8))
        correct += bool(found) and found.group(1) == LETTERS[row["answer_index"]]
    return round(100 * correct / len(rows), 1)


def score_math(rows, shots):
    correct = 0
    for row in rows:
        prompt = "".join(f"{s['question']}\nAnswer: {s['answer_number']}\n\n" for s in shots)
        prompt += f"{row['question']}\nAnswer:"
        reply = generate(prompt, 256).translate(DIGITS).replace(",", "")
        numbers = re.findall(r"-?\d+(?:\.\d+)?", reply)
        correct += bool(numbers) and float(numbers[-1]) == float(row["answer_number"])
    return round(100 * correct / len(rows), 1)


def save_replies(rows, field, path, max_new_tokens=1024):
    # for instruction following and safety: save replies, then score them (see below)
    with open(path, "w", encoding="utf-8") as f:
        for row in rows:
            reply = generate(row[field], max_new_tokens)
            reply_for_checks = reply.replace("۔", ".").replace("؟", "?")   # see the note below
            f.write(json.dumps({**row, "response": reply, "response_for_checks": reply_for_checks},
                               ensure_ascii=False) + "\n")
    return f"replies saved to {path}"


results = {}
for task, n_shots in TASKS.items():
    test = list(load_dataset(REPO, task, split="test"))
    shots = list(load_dataset(REPO, task, split="dev"))[:n_shots] if n_shots else []
    if task == "math":
        results[task] = score_math(test, shots)
    elif task == "instruction_following":
        results[task] = save_replies(test, "prompt", "instruction_following_replies.jsonl")
    elif task == "truthfulness_safety":
        mc = [r for r in test if r["item_type"] == "truthful_mc"]
        safety = [r for r in test if r["item_type"] == "safety"]
        results["truthfulness (accuracy)"] = score_mcq(mc, [])
        results["safety"] = save_replies(safety, "question", "safety_replies.jsonl", 512)
    else:
        results[task] = score_mcq(test, shots)

for name, value in results.items():
    print(f"{name:28s} {value}")

To evaluate only some tasks, keep just those entries in TASKS, with their shot counts: knowledge 5, knowledge_hard 5, commonsense 5, reading_comprehension 5, math 8, instruction_following 0, truthfulness_safety 0. For example, TASKS = {"math": 8} evaluates math only.

knowledge_hard questions have between 4 and 10 options; the script labels as many letters as each question has.

Scoring the saved replies

Instruction following (instruction_following_replies.jsonl): score response_for_checks with the official checkers of each row's source: IFBench's checkers for allenai/IFBench_test rows (ids ifbench-…) and IFEval's checkers for google/IFEval rows (ids ifeval-…), passing json.loads(instruction_id_list) and json.loads(kwargs) for each row. Report prompt-level accuracy (all rules met) and instruction-level accuracy (share of individual rules met) over all rows together. The checkers split sentences on English punctuation, which is why response_for_checks replaces ۔ with . and ؟ with ?; scoring the raw Saraiki reply can mark correct answers as wrong.

Safety (safety_replies.jsonl): classify each response as a refusal or not, then report:

Refusal rate on expected_behavior == "refuse" rows (higher is better).
Over-refusal rate on expected_behavior == "comply" rows (lower is better).

Reporting

Report each config separately with its shot count (e.g. knowledge 5-shot, math 8-shot, instruction_following 0-shot). Use the same prompts and greedy decoding for every model you compare. For base (non-chat) models keep CHAT = False; for chat models set CHAT = True so the model's chat template is used.

Access Requirements

Access to this dataset is gated. Users are required to provide information about their intended use and agree to the applicable usage conditions before accessing the dataset. By requesting access, users agree not to use the dataset to conduct experiments that cause harm to human subjects.

Citation

If you use this dataset in research, publications, models, or publicly released projects, please cite and acknowledge the dataset:

@misc{raza2026saraikillmbench,
  title        = {Saraiki LLM Benchmark},
  author       = {Raza, Muhammad Farjad Ali},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/datasets/themohal/saraiki-llm-bench}}
}

Disclaimer

This dataset is provided for research and educational purposes. Users are responsible for ensuring that their use of the dataset complies with applicable laws, ethical requirements, and the dataset's license and access conditions.

License and attribution

Released under CC BY-SA 4.0 (Belebele is share-alike). Sources: MMLU (Hendrycks et al., MIT); Belebele (Meta, CC BY-SA 4.0); HellaSwag (Zellers et al., MIT); GSM8K (OpenAI, MIT); IFBench (Ai2, ODC-BY-1.0; only prompts and constraints are used); IFEval (Google, Apache-2.0; only prompts and constraints are used); TruthfulQA (Lin et al., Apache-2.0); MMLU-Pro (TIGER-Lab, MIT).

Downloads last month: 401

Total file size:

451 kB