#!/usr/bin/env python3 """Evaluate a SentenceTransformer model on NanoMIRACL (NDCG@10). This mirrors the NanoBEIR evaluation style from sentence-transformers, adapted to the NanoMIRACL layout (configs: corpus/queries/qrels, splits: NanoMIRACL-). """ from __future__ import annotations import argparse import glob import json import logging import os import time from collections.abc import Callable, Sequence from typing import Any, cast import numpy as np from sentence_transformers import SentenceTransformer from sentence_transformers.evaluation import InformationRetrievalEvaluator from sentence_transformers.evaluation.SentenceEvaluator import SentenceEvaluator from sentence_transformers.similarity_functions import SimilarityFunction from sentence_transformers.util import is_datasets_available from torch import Tensor from tqdm import tqdm DEFAULT_DATASET_PATH = "output/NanoMIRACL-fixed" DEFAULT_DATASET_ID = "hotchpotch/NanoMIRACL" LANGS = [ "ar", "bn", "de", "en", "es", "fa", "fi", "fr", "hi", "id", "ja", "ko", "ru", "sw", "te", "th", "yo", "zh", ] ALIASES = { "jp": "ja", } logger = logging.getLogger(__name__) def _normalize_lang(name: str) -> str: key = name.lower() return ALIASES.get(key, key) def _split_name(lang: str) -> str: return f"NanoMIRACL-{lang}" def _human_readable(lang: str) -> str: return f"NanoMIRACL-{lang}" class NanoMiraclEvaluator(SentenceEvaluator): """Evaluate a model on NanoMIRACL across languages.""" information_retrieval_class = InformationRetrievalEvaluator def __init__( self, dataset_names: list[str] | None = None, dataset_path: str | None = DEFAULT_DATASET_PATH, dataset_id: str | None = None, mrr_at_k: list[int] | None = None, ndcg_at_k: list[int] | None = None, accuracy_at_k: list[int] | None = None, precision_recall_at_k: list[int] | None = None, map_at_k: list[int] | None = None, show_progress_bar: bool = False, batch_size: int = 32, write_csv: bool = True, truncate_dim: int | None = None, score_functions: dict[str, Callable[[Tensor, Tensor], Tensor]] | None = None, main_score_function: str | SimilarityFunction | None = None, aggregate_fn: Callable[[list[float]], float] = np.mean, aggregate_key: str = "mean", query_prompts: str | dict[str, str] | None = None, corpus_prompts: str | dict[str, str] | None = None, write_predictions: bool = False, ndcg_only: bool = True, ) -> None: super().__init__() if dataset_names is None: dataset_names = LANGS self.dataset_names = [_normalize_lang(name) for name in dataset_names] self.dataset_id = dataset_id self.dataset_path = dataset_path self.aggregate_fn = aggregate_fn self.aggregate_key = aggregate_key self.write_csv = write_csv self.query_prompts = self._normalize_prompts(query_prompts) self.corpus_prompts = self._normalize_prompts(corpus_prompts) self.show_progress_bar = show_progress_bar self.score_functions = score_functions or {} self.score_function_names = sorted(self.score_functions.keys()) self.main_score_function = main_score_function self.truncate_dim = truncate_dim self.name = f"NanoMIRACL_{aggregate_key}" if self.truncate_dim: self.name += f"_{self.truncate_dim}" self.ndcg_only = ndcg_only self.mrr_at_k = mrr_at_k or [10] self.ndcg_at_k = ndcg_at_k or [10] if ndcg_only: self.accuracy_at_k = [10] self.precision_recall_at_k = [10] self.map_at_k = [10] else: self.accuracy_at_k = accuracy_at_k or [1, 3, 5, 10] self.precision_recall_at_k = precision_recall_at_k or [1, 3, 5, 10] self.map_at_k = map_at_k or [100] self._validate_dataset_names() self._validate_prompts() ir_kwargs = { "mrr_at_k": self.mrr_at_k, "ndcg_at_k": self.ndcg_at_k, "accuracy_at_k": self.accuracy_at_k, "precision_recall_at_k": self.precision_recall_at_k, "map_at_k": self.map_at_k, "show_progress_bar": show_progress_bar, "batch_size": batch_size, "write_csv": write_csv, "truncate_dim": truncate_dim, "score_functions": score_functions, "main_score_function": main_score_function, "write_predictions": write_predictions, } self.evaluators = [ self._load_dataset(name, **ir_kwargs) for name in tqdm(self.dataset_names, desc="Loading NanoMIRACL", leave=False) ] self.csv_file = f"NanoMIRACL_evaluation_{aggregate_key}_results.csv" self.csv_headers = ["epoch", "steps"] self._append_csv_headers(self.score_function_names) def _normalize_prompts(self, prompts: str | dict[str, str] | None) -> dict[str, str] | None: if prompts is None: return None if isinstance(prompts, str): return {name: prompts for name in self.dataset_names} normalized: dict[str, str] = {} for key, value in prompts.items(): normalized[_normalize_lang(key)] = value return normalized def _append_csv_headers(self, score_function_names): for score_name in score_function_names: for k in self.accuracy_at_k: self.csv_headers.append(f"{score_name}-Accuracy@{k}") for k in self.precision_recall_at_k: self.csv_headers.append(f"{score_name}-Precision@{k}") self.csv_headers.append(f"{score_name}-Recall@{k}") for k in self.mrr_at_k: self.csv_headers.append(f"{score_name}-MRR@{k}") for k in self.ndcg_at_k: self.csv_headers.append(f"{score_name}-NDCG@{k}") for k in self.map_at_k: self.csv_headers.append(f"{score_name}-MAP@{k}") def _find_files(self, config: str, split: str) -> list[str]: if not self.dataset_path: raise ValueError("dataset_path is required when loading from local parquet files.") pattern = os.path.join(self.dataset_path, config, f"{split}-*.parquet") files = sorted(glob.glob(pattern)) if not files: raise FileNotFoundError(f"No parquet files found for {config}/{split} under {self.dataset_path}") return files def _load_dataset(self, lang: str, **ir_kwargs) -> InformationRetrievalEvaluator: if not is_datasets_available(): raise ValueError("datasets is required; install via `pip install datasets`.") from datasets import load_dataset split_name = _split_name(lang) t0 = time.perf_counter() if self.dataset_id: corpus_ds = load_dataset(self.dataset_id, "corpus", split=split_name) queries_ds = load_dataset(self.dataset_id, "queries", split=split_name) qrels_ds = load_dataset(self.dataset_id, "qrels", split=split_name) else: corpus_ds = load_dataset( "parquet", data_files=self._find_files("corpus", split_name), split="train", ) queries_ds = load_dataset( "parquet", data_files=self._find_files("queries", split_name), split="train", ) qrels_ds = load_dataset( "parquet", data_files=self._find_files("qrels", split_name), split="train", ) logger.info("[NanoMIRACL] loaded datasets for %s in %.2fs", lang, time.perf_counter() - t0) corpus_dict = {} t1 = time.perf_counter() for sample in corpus_ds: row = cast(dict[str, Any], sample) text = row.get("text") if text: corpus_dict[row["_id"]] = text queries_dict = {} for sample in queries_ds: row = cast(dict[str, Any], sample) text = row.get("text") if text: queries_dict[row["_id"]] = text qrels_dict: dict[str, set[str]] = {} for sample in qrels_ds: row = cast(dict[str, Any], sample) qid = row["query-id"] cids = row["corpus-id"] if isinstance(cids, list): qrels_dict.setdefault(qid, set()).update(cids) else: qrels_dict.setdefault(qid, set()).add(cids) logger.info( "[NanoMIRACL] materialized dicts for %s in %.2fs (corpus=%d, queries=%d, qrels=%d)", lang, time.perf_counter() - t1, len(corpus_dict), len(queries_dict), len(qrels_dict), ) if self.query_prompts is not None: ir_kwargs["query_prompt"] = self.query_prompts.get(lang, None) if self.corpus_prompts is not None: ir_kwargs["corpus_prompt"] = self.corpus_prompts.get(lang, None) evaluator = InformationRetrievalEvaluator( queries_dict, corpus_dict, qrels_dict, name=_human_readable(lang), **ir_kwargs, ) return evaluator def _validate_dataset_names(self) -> None: valid = set(LANGS) missing = [name for name in self.dataset_names if name not in valid] if missing: raise ValueError(f"Invalid language(s): {missing}. Valid: {sorted(valid)}") def _validate_prompts(self) -> None: error_msg = "" if self.query_prompts is not None: missing = [lang for lang in self.dataset_names if lang not in self.query_prompts] if missing: error_msg += f"Missing query prompts for: {missing}\n" if self.corpus_prompts is not None: missing = [lang for lang in self.dataset_names if lang not in self.corpus_prompts] if missing: error_msg += f"Missing corpus prompts for: {missing}\n" if error_msg: raise ValueError(error_msg.strip()) def __call__( self, model: SentenceTransformer, output_path: str | None = None, epoch: int = -1, steps: int = -1, *args, **kwargs, ) -> dict[str, float]: per_metric_agg: dict[str, list[float]] = {} per_dataset: dict[str, float] = {} if self.score_functions is None: self.score_functions = {model.similarity_fn_name: model.similarity} self.score_function_names = [model.similarity_fn_name] self._append_csv_headers(self.score_function_names) for evaluator in tqdm(self.evaluators, desc="Evaluating NanoMIRACL", disable=not self.show_progress_bar): logger.info("Evaluating %s", evaluator.name) results = evaluator(model, output_path, epoch, steps) for key, value in results.items(): per_dataset[key] = value if "_" in key: _, metric_name = key.split("_", 1) else: metric_name = key per_metric_agg.setdefault(metric_name, []).append(value) agg_results = { f"{self.name}_{metric}": self.aggregate_fn(vals) for metric, vals in per_metric_agg.items() } if not self.primary_metric: main_score_fn = self.main_score_function main = None if main_score_fn is None else str(main_score_fn) ndcg_target = f"ndcg@{max(self.ndcg_at_k)}" candidates = [k for k in agg_results if k.endswith(ndcg_target)] if main: preferred = [k for k in candidates if main in k] if preferred: self.primary_metric = preferred[0] if not self.primary_metric and candidates: self.primary_metric = candidates[0] if self.primary_metric and self.primary_metric in agg_results: logger.info("Primary %s: %.4f", self.primary_metric, agg_results[self.primary_metric]) per_dataset.update(agg_results) if self.ndcg_only: per_dataset = {k: v for k, v in per_dataset.items() if "ndcg@10" in k} return per_dataset def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description="Evaluate a model on NanoMIRACL") parser.add_argument("--model-path", required=True, help="Path or HF id for SentenceTransformer model") parser.add_argument( "--dataset-path", default=DEFAULT_DATASET_PATH, help="Local NanoMIRACL dataset root (or HF dataset id if the path does not exist).", ) parser.add_argument( "--dataset-id", default=DEFAULT_DATASET_ID, help="Hugging Face dataset id (overrides --dataset-path).", ) parser.add_argument("--langs", nargs="*", default=None, help="Languages (default: all)") parser.add_argument("--batch-size", type=int, default=128, help="Eval batch size") parser.add_argument("--output", default=None, help="Optional JSON output path for metrics") parser.add_argument("--show-progress", action="store_true", help="Show per-language tqdm during eval") parser.add_argument( "--no-autocast", action="store_true", help="Disable torch.autocast (default: enabled on CUDA with bf16 if available)", ) parser.add_argument( "--autocast-dtype", choices=["bf16", "fp16"], default="bf16", help="autocast dtype (bf16 or fp16)", ) parser.add_argument("--query-prompt", default=None, help="Prefix applied to queries") parser.add_argument("--corpus-prompt", default=None, help="Prefix applied to corpus/passages") parser.add_argument( "--all-metrics", action="store_true", help="Return all metrics (default: ndcg@10 only)", ) parser.add_argument( "--trust-remote-code", action="store_true", help="Pass trust_remote_code=True to SentenceTransformer (needed for some HF models)", ) return parser.parse_args() def _infer_dataset_id(dataset_path: str | None) -> str | None: if dataset_path is None: return None if os.path.exists(dataset_path): return None if "/" in dataset_path: return dataset_path raise FileNotFoundError( f"dataset-path '{dataset_path}' not found and does not look like a HF dataset id (expected 'namespace/name')." ) def main(argv: Sequence[str] | None = None) -> None: args = parse_args() logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") langs = args.langs or LANGS langs = [_normalize_lang(lang) for lang in langs] model = SentenceTransformer(args.model_path, prompts=None, trust_remote_code=args.trust_remote_code) model.eval() dataset_id = args.dataset_id dataset_path = args.dataset_path if dataset_id is None: inferred = _infer_dataset_id(dataset_path) if inferred is not None: dataset_id = inferred dataset_path = None evaluator = NanoMiraclEvaluator( dataset_names=langs, dataset_path=dataset_path, dataset_id=dataset_id, batch_size=args.batch_size, show_progress_bar=args.show_progress, write_csv=False, query_prompts=args.query_prompt if args.query_prompt else None, corpus_prompts=args.corpus_prompt if args.corpus_prompt else None, ndcg_only=not args.all_metrics, ) use_autocast = not args.no_autocast autocast_dtype = {"bf16": "bfloat16", "fp16": "float16"}[args.autocast_dtype] autocast_ctx = None if use_autocast: import torch device_type = "cuda" if torch.cuda.is_available() else "cpu" autocast_ctx = torch.autocast(device_type=device_type, dtype=getattr(torch, autocast_dtype)) if autocast_ctx: with autocast_ctx: results = evaluator(model) else: results = evaluator(model) score_fn = model.similarity_fn_name ndcg_key_suffix = f"{score_fn}_ndcg@10" per_lang = {} for lang in evaluator.dataset_names: key = f"{_split_name(lang)}_{ndcg_key_suffix}" if key in results: per_lang[lang] = results[key] avg = float(np.mean(list(per_lang.values()))) if per_lang else float("nan") print("NanoMIRACL Evaluation (NDCG@10)") print(f"Model: {args.model_path}") for lang in evaluator.dataset_names: val = per_lang.get(lang) if val is None: continue print(f"{_split_name(lang)}_{ndcg_key_suffix}: {val:.4f}") print(f"NanoMIRACL_mean_{ndcg_key_suffix}: {avg:.4f}") if args.output: payload = {"model": args.model_path, "avg": avg, "per_lang": per_lang, "metrics": results} with open(args.output, "w", encoding="utf-8") as f: json.dump(payload, f, ensure_ascii=False, indent=2) if __name__ == "__main__": main()