Datasets:

omneity-labs
/

spellbench

"""Run SawBench evaluation against a HuggingFace Transformers model.
Usage:
    python run_eval_transformers.py --model Qwen/Qwen2.5-0.5B-Instruct
    python run_eval_transformers.py --model mistralai/Mistral-7B-Instruct-v0.3 --tasks spell,reverse --max-items 50
"""
import argparse, json, re, sys, time
from pathlib import Path
from collections import defaultdict

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset


def load_items(tasks=None, max_items=None):
    """Load test items from HuggingFace, optionally filtering by task."""
    ds = load_dataset("omneity-labs/spellbench", split="test")
    items = list(ds)
    
    if tasks:
        items = [item for item in items if item["task"] in tasks]
        
    if max_items:
        # Take up to max_items per task
        by_task = defaultdict(list)
        for item in items:
            by_task[item["task"]].append(item)
        items = []
        for task_items in by_task.values():
            items.extend(task_items[:max_items])
    return items


def load_prompts(data_dir):
    """Load prompt templates."""
    with open(data_dir / "prompts.json") as f:
        return json.load(f)


def format_prompt(item, prompt_templates):
    """Format a prompt for a given item using the first template."""
    task = item["task"]
    tmpl_info = prompt_templates.get(task)
    if not tmpl_info:
        return f"Task: {task}\nInput: {item['input']}"

    tmpl = tmpl_info["prompts"][0]
    input_val = item["input"]

    # Handle tasks with | separator for extra params
    if " | " in input_val:
        parts = input_val.split(" | ")
        main_input = parts[0]
        params = {}
        for p in parts[1:]:
            if ": " in p:
                k, v = p.split(": ", 1)
                params[k.strip()] = v.strip()

        # Build format kwargs
        fmt = {"input": main_input, "word": main_input, "sentence": main_input}
        fmt.update(params)
        # Map common param keys
        if "position" in params:
            fmt["n"] = params["position"]
        if "word number" in params:
            fmt["n"] = params["word number"]
        if "word" in params:
            fmt["word"] = params["word"]

        # Handle compare_lengths: "word N vs word M"
        for p in parts[1:]:
            m = re.match(r"word (\d+) vs word (\d+)", p.strip())
            if m:
                fmt["n"] = m.group(1)
                fmt["m"] = m.group(2)
    else:
        fmt = {"input": input_val, "word": input_val, "sentence": input_val}

    try:
        return tmpl.format(**fmt)
    except KeyError:
        return f"Task: {task}\nInput: {item['input']}"


def extract_answer(response, task):
    """Extract the answer from model response. Handles both JSON and natural language."""
    response = response.strip()

    # Try to find a JSON block
    json_match = re.search(r'\{[^}]+\}', response)
    if json_match:
        try:
            data = json.loads(json_match.group())
            if "answer" in data:
                return str(data["answer"])
            if "result" in data:
                return str(data["result"])
        except json.JSONDecodeError:
            pass

    # For simple numeric answers, find the last number
    if task in ("word_length", "vowel_count", "consonant_count", "count_letter",
                "word_count", "total_letters", "nth_word_length"):
        nums = re.findall(r'\b(\d+)\b', response)
        if nums:
            return nums[-1]

    # For true/false tasks
    if task in ("is_palindrome", "contains_letter"):
        lower = response.lower()
        if "true" in lower or "yes" in lower:
            return "true"
        if "false" in lower or "no" in lower:
            return "false"

    # For compare_lengths
    if task == "compare_lengths":
        lower = response.lower()
        if "equal" in lower:
            return "equal"
        if "first" in lower:
            return "first"
        if "second" in lower:
            return "second"

    # For letter-based answers (first_letter, last_letter)
    if task in ("first_letter", "last_letter", "nth_letter"):
        # Look for quoted single character
        m = re.search(r"['\"](.)['\"]", response)
        if m:
            return m.group(1)
        # Take last single character on its own
        m = re.search(r'\b([a-zA-Z])\b', response)
        if m:
            return m.group(1)

    # Default: take the last line as the answer
    lines = response.strip().split("\n")
    return lines[-1].strip()


def check_answer(predicted, expected, task):
    """Compare predicted vs expected, with task-appropriate normalization."""
    predicted = str(predicted).strip().lower()
    expected = str(expected).strip().lower()

    if task in ("spell", "reverse", "copy", "remove_vowels", "pig_latin",
                "sentence_reverse", "longest_word", "shortest_word",
                "alphabetical_order", "sort_by_length",
                "nth_word_spell", "nth_word_reverse"):
        return predicted == expected

    if task in ("word_length", "vowel_count", "consonant_count", "count_letter",
                "word_count", "total_letters", "nth_word_length"):
        return predicted == expected

    if task in ("first_letter", "last_letter", "nth_letter"):
        return predicted == expected

    if task in ("is_palindrome", "contains_letter"):
        return predicted == expected

    if task == "compare_lengths":
        return predicted == expected

    # For list-based tasks, normalize spacing
    if task in ("unique_letters", "double_letters", "all_first_letters", "letter_positions"):
        pred_norm = re.sub(r'\s*,\s*', ', ', predicted)
        exp_norm = re.sub(r'\s*,\s*', ', ', expected)
        return pred_norm == exp_norm

    if task == "char_frequency":
        return predicted == expected

    return predicted == expected


def run_eval(model_name, data_dir, tasks=None, max_items=None,
             max_new_tokens=128, device="auto", batch_size=1):
    """Run evaluation and return results."""
    print(f"Loading model: {model_name}")
    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map=device,
        trust_remote_code=True,
    )
    model.eval()

    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    prompts_data = load_prompts(data_dir)
    items = load_items(tasks, max_items)
    print(f"Loaded {len(items)} items across {len(set(i['task'] for i in items))} tasks")

    results = []
    task_scores = defaultdict(lambda: {"correct": 0, "total": 0})
    t0 = time.time()

    for i, item in enumerate(items):
        prompt_text = format_prompt(item, prompts_data)

        messages = [{"role": "user", "content": prompt_text}]
        text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        inputs = tokenizer(text, return_tensors="pt").to(model.device)

        with torch.no_grad():
            outputs = model.generate(
                **inputs,
                max_new_tokens=max_new_tokens,
                do_sample=False,
                temperature=None,
                top_p=None,
            )

        response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
        predicted = extract_answer(response, item["task"])
        correct = check_answer(predicted, item["expected"], item["task"])

        task_scores[item["task"]]["total"] += 1
        if correct:
            task_scores[item["task"]]["correct"] += 1

        results.append({
            "id": item["id"],
            "task": item["task"],
            "input": item["input"],
            "expected": item["expected"],
            "predicted": predicted,
            "raw_response": response,
            "correct": correct,
            "metadata": item["metadata"]
        })

        if (i + 1) % 50 == 0:
            elapsed = time.time() - t0
            print(f"  [{i+1}/{len(items)}] {elapsed:.1f}s elapsed")

    elapsed = time.time() - t0

    # Summary
    summary = {
        "model": model_name,
        "total_items": len(items),
        "total_correct": sum(1 for r in results if r["correct"]),
        "accuracy": sum(1 for r in results if r["correct"]) / len(items) if items else 0,
        "elapsed_seconds": round(elapsed, 1),
        "per_task": {},
    }
    for task, scores in sorted(task_scores.items()):
        acc = scores["correct"] / scores["total"] if scores["total"] else 0
        summary["per_task"][task] = {
            "correct": scores["correct"],
            "total": scores["total"],
            "accuracy": round(acc, 4),
        }

    return summary, results


def main():
    parser = argparse.ArgumentParser(description="Run SawBench evaluation with a HF model")
    parser.add_argument("--model", required=True, help="HuggingFace model name or path")
    parser.add_argument("--data-dir", default=str(Path(__file__).parent / "data"),
                        help="Path to data/ directory")
    parser.add_argument("--tasks", default=None,
                        help="Comma-separated task names (default: all)")
    parser.add_argument("--max-items", type=int, default=None,
                        help="Max items per task (default: all)")
    parser.add_argument("--max-new-tokens", type=int, default=128)
    parser.add_argument("--device", default="auto")
    parser.add_argument("--output", default="results.json",
                        help="Output file for detailed results")
    args = parser.parse_args()

    tasks = args.tasks.split(",") if args.tasks else None
    data_dir = Path(args.data_dir)

    summary, results = run_eval(
        args.model, data_dir, tasks, args.max_items,
        args.max_new_tokens, args.device,
    )

    # Print summary
    print(f"\n{'='*60}")
    print(f"Model: {summary['model']}")
    print(f"Overall: {summary['total_correct']}/{summary['total_items']} "
          f"({summary['accuracy']:.1%})")
    print(f"Time: {summary['elapsed_seconds']}s")
    print(f"{'='*60}")
    print(f"{'Task':<25} {'Correct':>8} {'Total':>6} {'Accuracy':>9}")
    print(f"{'-'*25} {'-'*8} {'-'*6} {'-'*9}")
    for task, info in summary["per_task"].items():
        print(f"{task:<25} {info['correct']:>8} {info['total']:>6} {info['accuracy']:>8.1%}")

    # Save detailed results
    output_path = Path(args.output)
    with open(output_path, "w") as f:
        json.dump({"summary": summary, "results": results}, f, indent=2, ensure_ascii=False)
    print(f"\nDetailed results saved to {output_path}")


if __name__ == "__main__":
    main()

	"""Run SawBench evaluation against a HuggingFace Transformers model.

	Usage:
	python run_eval_transformers.py --model Qwen/Qwen2.5-0.5B-Instruct
	python run_eval_transformers.py --model mistralai/Mistral-7B-Instruct-v0.3 --tasks spell,reverse --max-items 50
	"""
	import argparse, json, re, sys, time
	from pathlib import Path
	from collections import defaultdict

	import torch
	from transformers import AutoModelForCausalLM, AutoTokenizer
	from datasets import load_dataset


	def load_items(tasks=None, max_items=None):
	"""Load test items from HuggingFace, optionally filtering by task."""
	ds = load_dataset("omneity-labs/spellbench", split="test")
	items = list(ds)

	if tasks:
	items = [item for item in items if item["task"] in tasks]

	if max_items:
	# Take up to max_items per task
	by_task = defaultdict(list)
	for item in items:
	by_task[item["task"]].append(item)
	items = []
	for task_items in by_task.values():
	items.extend(task_items[:max_items])
	return items


	def load_prompts(data_dir):
	"""Load prompt templates."""
	with open(data_dir / "prompts.json") as f:
	return json.load(f)


	def format_prompt(item, prompt_templates):
	"""Format a prompt for a given item using the first template."""
	task = item["task"]
	tmpl_info = prompt_templates.get(task)
	if not tmpl_info:
	return f"Task: {task}\nInput: {item['input']}"

	tmpl = tmpl_info["prompts"][0]
	input_val = item["input"]

	# Handle tasks with \| separator for extra params
	if " \| " in input_val:
	parts = input_val.split(" \| ")
	main_input = parts[0]
	params = {}
	for p in parts[1:]:
	if ": " in p:
	k, v = p.split(": ", 1)
	params[k.strip()] = v.strip()

	# Build format kwargs
	fmt = {"input": main_input, "word": main_input, "sentence": main_input}
	fmt.update(params)
	# Map common param keys
	if "position" in params:
	fmt["n"] = params["position"]
	if "word number" in params:
	fmt["n"] = params["word number"]
	if "word" in params:
	fmt["word"] = params["word"]

	# Handle compare_lengths: "word N vs word M"
	for p in parts[1:]:
	m = re.match(r"word (\d+) vs word (\d+)", p.strip())
	if m:
	fmt["n"] = m.group(1)
	fmt["m"] = m.group(2)
	else:
	fmt = {"input": input_val, "word": input_val, "sentence": input_val}

	try:
	return tmpl.format(**fmt)
	except KeyError:
	return f"Task: {task}\nInput: {item['input']}"


	def extract_answer(response, task):
	"""Extract the answer from model response. Handles both JSON and natural language."""
	response = response.strip()

	# Try to find a JSON block
	json_match = re.search(r'\{[^}]+\}', response)
	if json_match:
	try:
	data = json.loads(json_match.group())
	if "answer" in data:
	return str(data["answer"])
	if "result" in data:
	return str(data["result"])
	except json.JSONDecodeError:
	pass

	# For simple numeric answers, find the last number
	if task in ("word_length", "vowel_count", "consonant_count", "count_letter",
	"word_count", "total_letters", "nth_word_length"):
	nums = re.findall(r'\b(\d+)\b', response)
	if nums:
	return nums[-1]

	# For true/false tasks
	if task in ("is_palindrome", "contains_letter"):
	lower = response.lower()
	if "true" in lower or "yes" in lower:
	return "true"
	if "false" in lower or "no" in lower:
	return "false"

	# For compare_lengths
	if task == "compare_lengths":
	lower = response.lower()
	if "equal" in lower:
	return "equal"
	if "first" in lower:
	return "first"
	if "second" in lower:
	return "second"

	# For letter-based answers (first_letter, last_letter)
	if task in ("first_letter", "last_letter", "nth_letter"):
	# Look for quoted single character
	m = re.search(r"['\"](.)['\"]", response)
	if m:
	return m.group(1)
	# Take last single character on its own
	m = re.search(r'\b([a-zA-Z])\b', response)
	if m:
	return m.group(1)

	# Default: take the last line as the answer
	lines = response.strip().split("\n")
	return lines[-1].strip()


	def check_answer(predicted, expected, task):
	"""Compare predicted vs expected, with task-appropriate normalization."""
	predicted = str(predicted).strip().lower()
	expected = str(expected).strip().lower()

	if task in ("spell", "reverse", "copy", "remove_vowels", "pig_latin",
	"sentence_reverse", "longest_word", "shortest_word",
	"alphabetical_order", "sort_by_length",
	"nth_word_spell", "nth_word_reverse"):
	return predicted == expected

	if task in ("word_length", "vowel_count", "consonant_count", "count_letter",
	"word_count", "total_letters", "nth_word_length"):
	return predicted == expected

	if task in ("first_letter", "last_letter", "nth_letter"):
	return predicted == expected

	if task in ("is_palindrome", "contains_letter"):
	return predicted == expected

	if task == "compare_lengths":
	return predicted == expected

	# For list-based tasks, normalize spacing
	if task in ("unique_letters", "double_letters", "all_first_letters", "letter_positions"):
	pred_norm = re.sub(r'\s,\s', ', ', predicted)
	exp_norm = re.sub(r'\s,\s', ', ', expected)
	return pred_norm == exp_norm

	if task == "char_frequency":
	return predicted == expected

	return predicted == expected


	def run_eval(model_name, data_dir, tasks=None, max_items=None,
	max_new_tokens=128, device="auto", batch_size=1):
	"""Run evaluation and return results."""
	print(f"Loading model: {model_name}")
	tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
	model = AutoModelForCausalLM.from_pretrained(
	model_name,
	torch_dtype=torch.bfloat16,
	device_map=device,
	trust_remote_code=True,
	)
	model.eval()

	if tokenizer.pad_token is None:
	tokenizer.pad_token = tokenizer.eos_token

	prompts_data = load_prompts(data_dir)
	items = load_items(tasks, max_items)
	print(f"Loaded {len(items)} items across {len(set(i['task'] for i in items))} tasks")

	results = []
	task_scores = defaultdict(lambda: {"correct": 0, "total": 0})
	t0 = time.time()

	for i, item in enumerate(items):
	prompt_text = format_prompt(item, prompts_data)

	messages = [{"role": "user", "content": prompt_text}]
	text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
	inputs = tokenizer(text, return_tensors="pt").to(model.device)

	with torch.no_grad():
	outputs = model.generate(
	**inputs,
	max_new_tokens=max_new_tokens,
	do_sample=False,
	temperature=None,
	top_p=None,
	)

	response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
	predicted = extract_answer(response, item["task"])
	correct = check_answer(predicted, item["expected"], item["task"])

	task_scores[item["task"]]["total"] += 1
	if correct:
	task_scores[item["task"]]["correct"] += 1

	results.append({
	"id": item["id"],
	"task": item["task"],
	"input": item["input"],
	"expected": item["expected"],
	"predicted": predicted,
	"raw_response": response,
	"correct": correct,
	"metadata": item["metadata"]
	})

	if (i + 1) % 50 == 0:
	elapsed = time.time() - t0
	print(f" [{i+1}/{len(items)}] {elapsed:.1f}s elapsed")

	elapsed = time.time() - t0

	# Summary
	summary = {
	"model": model_name,
	"total_items": len(items),
	"total_correct": sum(1 for r in results if r["correct"]),
	"accuracy": sum(1 for r in results if r["correct"]) / len(items) if items else 0,
	"elapsed_seconds": round(elapsed, 1),
	"per_task": {},
	}
	for task, scores in sorted(task_scores.items()):
	acc = scores["correct"] / scores["total"] if scores["total"] else 0
	summary["per_task"][task] = {
	"correct": scores["correct"],
	"total": scores["total"],
	"accuracy": round(acc, 4),
	}

	return summary, results


	def main():
	parser = argparse.ArgumentParser(description="Run SawBench evaluation with a HF model")
	parser.add_argument("--model", required=True, help="HuggingFace model name or path")
	parser.add_argument("--data-dir", default=str(Path(__file__).parent / "data"),
	help="Path to data/ directory")
	parser.add_argument("--tasks", default=None,
	help="Comma-separated task names (default: all)")
	parser.add_argument("--max-items", type=int, default=None,
	help="Max items per task (default: all)")
	parser.add_argument("--max-new-tokens", type=int, default=128)
	parser.add_argument("--device", default="auto")
	parser.add_argument("--output", default="results.json",
	help="Output file for detailed results")
	args = parser.parse_args()

	tasks = args.tasks.split(",") if args.tasks else None
	data_dir = Path(args.data_dir)

	summary, results = run_eval(
	args.model, data_dir, tasks, args.max_items,
	args.max_new_tokens, args.device,
	)

	# Print summary
	print(f"\n{'='*60}")
	print(f"Model: {summary['model']}")
	print(f"Overall: {summary['total_correct']}/{summary['total_items']} "
	f"({summary['accuracy']:.1%})")
	print(f"Time: {summary['elapsed_seconds']}s")
	print(f"{'='*60}")
	print(f"{'Task':<25} {'Correct':>8} {'Total':>6} {'Accuracy':>9}")
	print(f"{'-'25} {'-'8} {'-'6} {'-'9}")
	for task, info in summary["per_task"].items():
	print(f"{task:<25} {info['correct']:>8} {info['total']:>6} {info['accuracy']:>8.1%}")

	# Save detailed results
	output_path = Path(args.output)
	with open(output_path, "w") as f:
	json.dump({"summary": summary, "results": results}, f, indent=2, ensure_ascii=False)
	print(f"\nDetailed results saved to {output_path}")


	if __name__ == "__main__":
	main()