nano_code_search_net_eval.py

#!/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()