code/evaluate_suite.py

#!/usr/bin/env python3
"""Run a pinned five-task Turkish retrieval suite with official MTEB evaluators."""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import mteb
import torch
from mteb.models import SentenceTransformerEncoderWrapper
from sentence_transformers import SentenceTransformer

HARIER_TASK = "Given a Turkish web search query, retrieve relevant passages that answer the query"

TASK_NAMES = [
    "TurHistQuadRetrieval",
    "XQuADRetrieval",
    "WebFAQRetrieval",
    "MKQARetrieval",
    "BelebeleRetrieval",
]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", required=True)
    parser.add_argument("--revision")
    parser.add_argument("--label")
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--batch-size", type=int, default=16)
    parser.add_argument("--max-seq-length", type=int, default=512)
    parser.add_argument(
        "--prompt-style",
        choices=["auto", "plain", "harrier", "e5"],
        default="auto",
        help="Select the query/document format explicitly for fair local-model evaluation.",
    )
    parser.add_argument("--tasks", nargs="+", choices=TASK_NAMES, default=TASK_NAMES)
    parser.add_argument("--overwrite", action="store_true")
    return parser.parse_args()


def prompts_for(model_id: str, style: str = "auto") -> dict[str, str] | None:
    if style == "plain":
        return None
    if style == "harrier":
        return {
            "Retrieval-query": f"Instruct: {HARIER_TASK}\nQuery: ",
            "Retrieval-document": "",
        }
    if style == "e5":
        return {"Retrieval-query": "query: ", "Retrieval-document": "passage: "}
    normalized = model_id.casefold()
    if "harrier" in normalized or "dusunen-rota" in normalized:
        return {
            "Retrieval-query": f"Instruct: {HARIER_TASK}\nQuery: ",
            "Retrieval-document": "",
        }
    if "e5" in normalized:
        return {"Retrieval-query": "query: ", "Retrieval-document": "passage: "}
    return None


def build_tasks(task_names: list[str] | None = None) -> list:
    selected = task_names or TASK_NAMES
    return [
        mteb.get_task(
            task_name=name,
            languages=["tur"],
            exclusive_language_filter=True,
        )
        for name in selected
    ]


def main() -> None:
    args = parse_args()
    args.output.parent.mkdir(parents=True, exist_ok=True)
    tasks = build_tasks(args.tasks)
    model = SentenceTransformer(
        args.model,
        revision=args.revision,
        model_kwargs={"dtype": torch.bfloat16},
    )
    model.max_seq_length = args.max_seq_length
    parameter_count = sum(parameter.numel() for parameter in model.parameters())
    wrapper = SentenceTransformerEncoderWrapper(
        model=model,
        model_prompts=prompts_for(args.model, args.prompt_style),
    )
    result = mteb.evaluate(
        wrapper,
        tasks,
        cache=None,
        overwrite_strategy="always" if args.overwrite else "only-missing",
        encode_kwargs={
            "batch_size": args.batch_size,
            "normalize_embeddings": True,
        },
        show_progress_bar=True,
        co2_tracker=False,
        public_only=True,
    )
    task_scores = {}
    for task_result in result.task_results:
        task_scores[task_result.task_name] = float(task_result.get_score())
    task_metadata = []
    for task in tasks:
        metadata = task.metadata.model_dump(mode="json")
        task_metadata.append(
            {
                "name": metadata["name"],
                "dataset": metadata["dataset"],
                "license": metadata["license"],
                "domains": metadata["domains"],
                "eval_splits": metadata["eval_splits"],
                "subsets": list(task.hf_subsets),
            }
        )
    payload = {
        "suite": "dusunen-turkish-retrieval-benchmark-v1",
        "language_filter": "turkish_only_exclusive",
        "model": args.label or args.model,
        "model_source": args.model,
        "model_revision": args.revision,
        "parameters": parameter_count,
        "embedding_dimension": model.get_sentence_embedding_dimension(),
        "inference_dtype": "bfloat16",
        "normalized_embeddings": True,
        "prompt_style": args.prompt_style,
        "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "cpu",
        "mteb_version": mteb.__version__,
        "task_main_scores": task_scores,
        "macro_average": sum(task_scores.values()) / len(task_scores),
        "tasks": task_metadata,
        "raw_mteb_result": result.model_dump(mode="json"),
    }
    args.output.write_text(
        json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
    )
    print(
        json.dumps(
            {k: v for k, v in payload.items() if k != "raw_mteb_result"},
            ensure_ascii=False,
            indent=2,
        )
    )


if __name__ == "__main__":
    main()