| |
| """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-<lang>). |
| """ |
|
|
| 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() |
|
|
