Add NanoCodeSearchNet eval script

nano_code_search_net_eval.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""Evaluate a SentenceTransformer model on NanoCodeSearchNet (NDCG@10).
+
+This mirrors the NanoBEIR evaluation style from sentence-transformers, adapted to
+hotchpotch/NanoCodeSearchNet's layout (configs: corpus/queries/qrels, splits: NanoCodeSearchNet{Lang}).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+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
+
+DATASET_ID = "hotchpotch/NanoCodeSearchNet"
+
+LANGS = ["Go", "Java", "JavaScript", "PHP", "Python", "Ruby"]
+_LANGS_BY_LOWER = {name.lower(): name for name in LANGS}
+ALIASES = {
+    "js": "JavaScript",
+    "py": "Python",
+}
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_lang(name: str) -> str:
+    key = name.lower()
+    key = ALIASES.get(key, key)
+    return _LANGS_BY_LOWER.get(key, name)
+
+
+def _split_name(lang: str) -> str:
+    return f"NanoCodeSearchNet{lang}"
+
+
+def _human_readable(lang: str) -> str:
+    return f"NanoCodeSearchNet-{lang}"
+
+
+class NanoCodeSearchNetEvaluator(SentenceEvaluator):
+    """Evaluate a model on NanoCodeSearchNet across languages."""
+
+    information_retrieval_class = InformationRetrievalEvaluator
+
+    def __init__(
+        self,
+        dataset_names: list[str] | None = None,
+        dataset_id: str = DATASET_ID,
+        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.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"NanoCodeSearchNet_{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 NanoCodeSearchNet", leave=False)
+        ]
+
+        self.csv_file = f"NanoCodeSearchNet_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 _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()
+        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)
+        logger.info("[NanoCodeSearchNet] 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(
+            "[NanoCodeSearchNet] 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=_split_name(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 NanoCodeSearchNet", 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 NanoCodeSearchNet")
+    parser.add_argument("--model-path", required=True, help="Path or HF id for SentenceTransformer model")
+    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 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
+
+    model = SentenceTransformer(args.model_path, prompts=None, trust_remote_code=args.trust_remote_code)
+    model.eval()
+
+    evaluator = NanoCodeSearchNetEvaluator(
+        dataset_names=langs,
+        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("NanoCodeSearchNet 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"NanoCodeSearchNet_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()