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