From 51638a59b4098e18cecc2b4b54a23ce95cd0757d Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Fri, 17 Jul 2026 03:26:35 -0400 Subject: [PATCH 1/6] Add a standardized, preregistered retrieval benchmark harness evals/benchmark compares lilbee against another RAG system on public labeled datasets with the generator and embedding model held constant, so retrieval is the only variable. Tier 1 scores each system's ranked results against human relevance labels with pytrec_eval (nDCG@10, Recall@20, MRR@10) with no model in the loop; Tier 2 layers RAGAS answer metrics plus the existing blind judge on top. Passage datasets carry native qrels; table and PDF datasets derive retrieval labels from human gold-evidence annotations via one documented function, disclosed in the manifest. A frozen manifest fingerprints the datasets, metrics, and models before the run (and refuses a judge equal to the generator); paired-bootstrap CIs and a randomization p-value gate every reported difference. The heavy scorers and dataset loaders stay in a standalone pod-install requirements file so they never move the shipped lock, and are lazily imported so the suite runs without them. --- evals/benchmark/README.md | 121 ++++++++++ evals/benchmark/__init__.py | 9 + evals/benchmark/__main__.py | 6 + evals/benchmark/bootstrap_ragflow.py | 141 +++++++++++ evals/benchmark/cli.py | 293 +++++++++++++++++++++++ evals/benchmark/collectors.py | 160 +++++++++++++ evals/benchmark/datasets.py | 171 +++++++++++++ evals/benchmark/ir_metrics.py | 84 +++++++ evals/benchmark/manifest.example.yaml | 74 ++++++ evals/benchmark/manifest.py | 164 +++++++++++++ evals/benchmark/ragas_tier.py | 119 +++++++++ evals/benchmark/report.py | 117 +++++++++ evals/benchmark/runfile.py | 93 +++++++ evals/benchmark/stats.py | 120 ++++++++++ tests/benchmark/__init__.py | 0 tests/benchmark/test_bench_collectors.py | 84 +++++++ tests/benchmark/test_bench_datasets.py | 86 +++++++ tests/benchmark/test_bench_ir_metrics.py | 56 +++++ tests/benchmark/test_bench_manifest.py | 90 +++++++ tests/benchmark/test_bench_report.py | 71 ++++++ tests/benchmark/test_bench_runfile.py | 54 +++++ tests/benchmark/test_bench_stats.py | 60 +++++ 22 files changed, 2173 insertions(+) create mode 100644 evals/benchmark/README.md create mode 100644 evals/benchmark/__init__.py create mode 100644 evals/benchmark/__main__.py create mode 100644 evals/benchmark/bootstrap_ragflow.py create mode 100644 evals/benchmark/cli.py create mode 100644 evals/benchmark/collectors.py create mode 100644 evals/benchmark/datasets.py create mode 100644 evals/benchmark/ir_metrics.py create mode 100644 evals/benchmark/manifest.example.yaml create mode 100644 evals/benchmark/manifest.py create mode 100644 evals/benchmark/ragas_tier.py create mode 100644 evals/benchmark/report.py create mode 100644 evals/benchmark/runfile.py create mode 100644 evals/benchmark/stats.py create mode 100644 tests/benchmark/__init__.py create mode 100644 tests/benchmark/test_bench_collectors.py create mode 100644 tests/benchmark/test_bench_datasets.py create mode 100644 tests/benchmark/test_bench_ir_metrics.py create mode 100644 tests/benchmark/test_bench_manifest.py create mode 100644 tests/benchmark/test_bench_report.py create mode 100644 tests/benchmark/test_bench_runfile.py create mode 100644 tests/benchmark/test_bench_stats.py diff --git a/evals/benchmark/README.md b/evals/benchmark/README.md new file mode 100644 index 000000000..200f5f7e3 --- /dev/null +++ b/evals/benchmark/README.md @@ -0,0 +1,121 @@ +# Benchmark harness: lilbee vs RAGFlow + +A preregistered, reproducible A/B of retrieval quality. Two arms answer the +same public, human-labeled datasets with the same served model, so retrieval is +the only variable: + +- **Arm A - lilbee**: the `test/retrieval-parity` branch with every parity + feature enabled. +- **Arm B - RAGFlow**: the DeepDoc pipeline at its defaults. + +One embedder and one generator are served once and pointed at by both arms, so +generation is identical and only the retrieval stack changes. Lives outside +`src/` on purpose: it never ships in the package. + +## Two tiers + +1. **Tier 1 - retrieval, no model opinion.** Each arm returns a ranked list per + query, written as a TREC run file. `pytrec_eval` scores it against the + dataset's published relevance labels (qrels): nDCG@10, Recall@20, MRR@10. + Nothing is graded by a model, so the numbers are bit-for-bit reproducible by + anyone with the same run files and qrels. +2. **Tier 2 - answer quality.** Both arms answer with the same model; RAGAS + scores faithfulness, answer relevancy, and context precision/recall. The + blind duplicate-arm judge from `evals/retrieval` is reused as a corroborating + signal, with its noise floor measured by grading one arm twice. + +Every cross-arm difference is paired per query and gets a bootstrap 95% CI and a +randomization-test p-value. A difference whose CI crosses zero is reported as +not significant, not as a win. + +## Native vs derived labels + +Passage sets (BEIR SciFact/FiQA/NFCorpus, HotpotQA, TREC-COVID) ship native TREC +qrels, used as published. The document-structured QA sets (TAT-DQA, OTT-QA) have +no retrieval labels of their own, so their qrels are **derived** from human +gold-evidence annotations by one documented pure function +(`datasets.derive_qrels_from_evidence`). Every derived dataset is marked +`label_kind: derived` in the manifest and flagged in the report. + +## Pod workflow + +One A100-80GB in a named tmux so a reclaimed pod reattaches. Preregister before +any data moves, then run each arm, score, and power off. + +```bash +cd ~/lilbee # the repo checkout; run everything from the repo root +RUN=/tmp/bench + +# 0. Freeze the preregistration. Nothing can be cherry-picked after this. +uv run python -m evals.benchmark preregister \ + --manifest evals/benchmark/manifest.example.yaml --out "$RUN/manifest.frozen.json" + +# 1. Serve the shared model with lilbee (all parity features on) and stand up +# RAGFlow pointed at the same OpenAI-compatible endpoint. +export LILBEE_TITLE_SEARCH=true LILBEE_NEIGHBOR_EXPANSION=2 \ + LILBEE_TABLE_EXTRACTION=true LILBEE_LAYOUT_DETECTION=true LILBEE_INTENT_LLM=true +lilbee serve --port 8080 & +uv run python -m evals.benchmark.bootstrap_ragflow \ + --base-url http://127.0.0.1:9380 --api-key "$RAGFLOW_KEY" \ + --corpus-dir "$RUN/corpus" --llm-model qwen2.5-72b-instruct \ + --embedding-model qwen3-embedding + +# 2. Ingest the same corpus into both systems (lilbee add; bootstrap uploaded +# RAGFlow's copy above). + +# 3. Collect a TREC run file per arm. Each query is checkpointed, so a killed +# run resumes. +uv run python -m evals.benchmark collect --system lilbee \ + --queries "$RUN/queries.jsonl" --base-url http://127.0.0.1:8080 \ + --run-tag lilbee --run "$RUN/run-lilbee.trec" --checkpoint "$RUN/ck-lilbee.jsonl" +uv run python -m evals.benchmark collect --system ragflow \ + --queries "$RUN/queries.jsonl" --base-url http://127.0.0.1:9380 \ + --api-key "$RAGFLOW_KEY" --dataset-id "$RAGFLOW_DATASET" \ + --run-tag ragflow --run "$RUN/run-ragflow.trec" --checkpoint "$RUN/ck-ragflow.jsonl" + +# 4. Tier 1: score each run against the qrels with pytrec_eval. +uv run python -m evals.benchmark score-ir --qrels "$RUN/qrels.json" \ + --run "$RUN/run-lilbee.trec" --dataset scifact --run-tag lilbee \ + --out "$RUN/ir-lilbee.jsonl" +uv run python -m evals.benchmark score-ir --qrels "$RUN/qrels.json" \ + --run "$RUN/run-ragflow.trec" --dataset scifact --run-tag ragflow \ + --out "$RUN/ir-ragflow.jsonl" + +# 5. Tier 2: generate answers on each arm, then score with RAGAS. +uv run python -m evals.benchmark answer --queries "$RUN/queries.jsonl" \ + --ground-truth "$RUN/references.json" --base-url http://127.0.0.1:8080 \ + --arm lilbee --out "$RUN/answers-lilbee.jsonl" +uv run python -m evals.benchmark score-ragas \ + --samples "$RUN/answers-lilbee.jsonl" --out "$RUN/results.jsonl" + +# 6. Paired statistics (CI + p) into the same results file. +uv run python -m evals.benchmark stats --manifest "$RUN/manifest.frozen.json" \ + --metrics-a "$RUN/ir-lilbee.jsonl" --metrics-b "$RUN/ir-ragflow.jsonl" \ + --arm-a-label lilbee --arm-b-label ragflow --out "$RUN/results.jsonl" + +# 7. Render the report, then power the pod off. +uv run python -m evals.benchmark report \ + --results "$RUN/results.jsonl" --out "$RUN/report.md" +``` + +Keep the frozen manifest, run files, and qrels: with those, a third party can +re-score the whole Tier-1 comparison without the pod. + +## Optional dependencies + +The heavy scorers and dataset loaders are imported lazily, so the harness (and +its tests) load without them. They are kept out of the shipped lock on purpose +(installing them would otherwise drag core dependencies backward), so install +them from the standalone requirements file on the benchmark pod: + +```bash +uv pip install -r evals/benchmark/requirements.txt # pytrec_eval, ragas, beir, datasets +``` + +## Determinism and resume + +- The frozen manifest pins the bootstrap seed, resamples, and alpha, so every + CI is reproducible. +- `collect` and `answer` checkpoint per query. Kill and re-run freely; only + unfinished queries repeat, and the run file is rebuilt from the full + checkpoint each time. diff --git a/evals/benchmark/__init__.py b/evals/benchmark/__init__.py new file mode 100644 index 000000000..6cb76c08d --- /dev/null +++ b/evals/benchmark/__init__.py @@ -0,0 +1,9 @@ +"""Preregistered, reproducible A/B benchmark: lilbee vs RAGFlow retrieval. + +Two arms answer the same public, human-labeled datasets with the same served +model, so retrieval is the only variable. Tier 1 scores ranked results against +the datasets' own relevance labels with pytrec_eval (no model opinion); Tier 2 +layers RAGAS answer-quality metrics on top, corroborated by the blind judge +from ``evals.retrieval``. Lives outside ``src/`` on purpose: it never ships in +the package. +""" diff --git a/evals/benchmark/__main__.py b/evals/benchmark/__main__.py new file mode 100644 index 000000000..025eb5474 --- /dev/null +++ b/evals/benchmark/__main__.py @@ -0,0 +1,6 @@ +"""Runs the benchmark CLI: python -m evals.benchmark .""" + +from evals.benchmark.cli import main + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/evals/benchmark/bootstrap_ragflow.py b/evals/benchmark/bootstrap_ragflow.py new file mode 100644 index 000000000..5d05902e3 --- /dev/null +++ b/evals/benchmark/bootstrap_ragflow.py @@ -0,0 +1,141 @@ +"""Bring up a RAGFlow arm bound to the shared model, ready for collection. + +Given a running RAGFlow, this registers the shared OpenAI-compatible LLM and +embedding endpoint (so generation is identical to lilbee's), creates a DeepDoc +dataset, uploads a corpus directory, waits for parsing, creates a chat +assistant bound to the dataset, and prints the api_key and assistant_id the +collector and answer steps consume. + +This is a live operational script: it only talks to a real RAGFlow and is never +imported by the test suite. Run it on the pod once RAGFlow's stack is up. +""" + +from __future__ import annotations + +import argparse +import sys +import time +from pathlib import Path +from typing import Any + +import httpx + +DATASETS_ROUTE = "/api/v1/datasets" +DOCUMENTS_ROUTE = "/api/v1/datasets/{dataset_id}/documents" +PARSE_ROUTE = "/api/v1/datasets/{dataset_id}/chunks" +CHATS_ROUTE = "/api/v1/chats" +PARSE_POLL_SECONDS = 10.0 +PARSE_MAX_POLLS = 360 +REQUEST_TIMEOUT_SECONDS = 120.0 +DONE_RATIO = 1.0 + + +def _client(base_url: str, api_key: str) -> httpx.Client: + return httpx.Client( + base_url=base_url.rstrip("/"), + headers={"Authorization": f"Bearer {api_key}"}, + timeout=REQUEST_TIMEOUT_SECONDS, + ) + + +def _data(response: httpx.Response) -> Any: + response.raise_for_status() + body = response.json() + if body.get("code", 0) != 0: + raise RuntimeError(f"ragflow error: {body.get('message', body)}") + return body.get("data") + + +def create_dataset(client: httpx.Client, name: str, embedding_model: str) -> str: + """Create a DeepDoc dataset and return its id.""" + data = _data( + client.post( + DATASETS_ROUTE, + json={ + "name": name, + "chunk_method": "naive", + "embedding_model": embedding_model, + "parser_config": {"layout_recognize": "DeepDOC"}, + }, + ) + ) + return str(data["id"]) + + +def upload_corpus(client: httpx.Client, dataset_id: str, corpus_dir: Path) -> list[str]: + """Upload every file under ``corpus_dir`` and return the document ids.""" + route = DOCUMENTS_ROUTE.format(dataset_id=dataset_id) + files = [("file", (path.name, path.read_bytes())) for path in sorted(corpus_dir.iterdir())] + data = _data(client.post(route, files=files)) + return [str(doc["id"]) for doc in data] + + +def parse_and_wait(client: httpx.Client, dataset_id: str, document_ids: list[str]) -> None: + """Trigger parsing and block until every document finishes.""" + route = PARSE_ROUTE.format(dataset_id=dataset_id) + _data(client.post(route, json={"document_ids": document_ids})) + docs_route = DOCUMENTS_ROUTE.format(dataset_id=dataset_id) + for _ in range(PARSE_MAX_POLLS): + docs = _data(client.get(docs_route))["docs"] + if all(doc.get("progress", 0.0) >= DONE_RATIO for doc in docs): + return + time.sleep(PARSE_POLL_SECONDS) + raise RuntimeError("ragflow parsing did not finish within the poll budget") + + +def create_assistant(client: httpx.Client, name: str, dataset_id: str, llm_model: str) -> str: + """Create a chat assistant bound to the dataset and return its id.""" + data = _data( + client.post( + CHATS_ROUTE, + json={ + "name": name, + "dataset_ids": [dataset_id], + "llm": {"model_name": llm_model, "temperature": 0.0}, + }, + ) + ) + return str(data["id"]) + + +def bootstrap(args: argparse.Namespace) -> int: + client = _client(args.base_url, args.api_key) + dataset_id = create_dataset(client, args.dataset_name, args.embedding_model) + document_ids = upload_corpus(client, dataset_id, args.corpus_dir) + parse_and_wait(client, dataset_id, document_ids) + assistant_id = create_assistant(client, args.assistant_name, dataset_id, args.llm_model) + print(f"api_key={args.api_key}") + print(f"dataset_id={dataset_id}") + print(f"assistant_id={assistant_id}") + return 0 + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", required=True, help="RAGFlow base URL") + parser.add_argument("--api-key", required=True, help="RAGFlow API key") + parser.add_argument("--corpus-dir", type=Path, required=True) + parser.add_argument("--dataset-name", default="benchmark-corpus") + parser.add_argument("--assistant-name", default="benchmark-assistant") + parser.add_argument( + "--llm-model", + required=True, + help="the shared OpenAI-compatible generator, e.g. qwen2.5-72b-instruct", + ) + parser.add_argument( + "--embedding-model", required=True, help="the shared embedder, e.g. qwen3-embedding" + ) + return parser + + +def main(argv: list[str] | None = None) -> int: + args = build_parser().parse_args(argv) + try: + return bootstrap(args) + except (httpx.HTTPError, RuntimeError, OSError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/evals/benchmark/cli.py b/evals/benchmark/cli.py new file mode 100644 index 000000000..059aaa7ad --- /dev/null +++ b/evals/benchmark/cli.py @@ -0,0 +1,293 @@ +"""Command-line entry point for the lilbee-vs-RAGFlow benchmark. + +Subcommands mirror the run stages: preregister, collect, score-ir, answer, +score-ragas, stats, report. Heavy scorers (pytrec_eval, ragas) are imported +lazily inside the modules they live in, so the CLI loads without them. +""" + +from __future__ import annotations + +import argparse +import json +import sys +from pathlib import Path +from typing import Any + +import httpx + +from evals.benchmark import ir_metrics, stats +from evals.benchmark.collectors import ( + DEFAULT_TOP_K, + LilbeeCollector, + RagflowCollector, + collect_run, + load_queries, +) +from evals.benchmark.manifest import Manifest +from evals.benchmark.ragas_tier import Sample, score_ragas +from evals.benchmark.report import render_report +from evals.retrieval.checkpoint import JsonlCheckpoint, load_jsonl + +DEFAULT_METRICS = ["nDCG@10", "Recall@20", "MRR@10"] +ASK_ROUTE = "/api/ask" +ASK_TIMEOUT_SECONDS = 600.0 + + +def _write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("".join(json.dumps(row) + "\n" for row in rows)) + + +def _append_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("a") as fh: + for row in rows: + fh.write(json.dumps(row) + "\n") + + +def _cmd_preregister(args: argparse.Namespace) -> int: + manifest = Manifest.load(args.manifest) + fingerprint = manifest.freeze(args.out) + print(f"froze manifest {manifest.run_id} -> {args.out} ({fingerprint[:12]})") + return 0 + + +def _build_collector(args: argparse.Namespace) -> LilbeeCollector | RagflowCollector: + if args.system == "lilbee": + return LilbeeCollector(args.base_url, run_tag=args.run_tag, top_k=args.top_k) + if not args.api_key or not args.dataset_id: + raise ValueError("ragflow collection needs --api-key and at least one --dataset-id") + return RagflowCollector( + args.base_url, args.api_key, args.dataset_id, run_tag=args.run_tag, top_k=args.top_k + ) + + +def _cmd_collect(args: argparse.Namespace) -> int: + queries = load_queries(args.queries) + collector = _build_collector(args) + hits = collect_run( + collector, + queries, + args.run, + args.checkpoint, + on_query=lambda qid: print(f"[{args.run_tag}] {qid}", flush=True), + ) + print(f"collected {len(queries)} queries, {len(hits)} hits -> {args.run}") + return 0 + + +def _cmd_score_ir(args: argparse.Namespace) -> int: + from evals.benchmark.runfile import read_run, run_to_pytrec + + qrels = json.loads(args.qrels.read_text()) + run = run_to_pytrec(read_run(args.run)) + scores = ir_metrics.score_run(qrels, run, args.metrics) + _write_jsonl( + args.out, + [ + { + "dataset": args.dataset, + "run_tag": args.run_tag, + "aggregated": scores.aggregated, + "per_query": scores.per_query, + } + ], + ) + print(f"scored {args.run_tag} on {args.dataset}: {scores.aggregated} -> {args.out}") + return 0 + + +def _ask(client: httpx.Client, base_url: str, question: str, top_k: int) -> tuple[str, list[str]]: + response = client.post( + f"{base_url.rstrip('/')}{ASK_ROUTE}", json={"question": question, "top_k": top_k} + ) + response.raise_for_status() + body = response.json() + contexts = [chunk["chunk"] for chunk in body.get("sources", [])] + return body["answer"], contexts + + +def _cmd_answer(args: argparse.Namespace) -> int: + queries = load_queries(args.queries) + references = json.loads(args.ground_truth.read_text()) if args.ground_truth else {} + checkpoint = JsonlCheckpoint(args.out, "query_id") + client = httpx.Client(timeout=ASK_TIMEOUT_SECONDS) + for query_id, text in queries.items(): + if query_id in checkpoint: + continue + answer, contexts = _ask(client, args.base_url, text, args.top_k) + checkpoint.append( + { + "query_id": query_id, + "question": text, + "answer": answer, + "contexts": contexts, + "ground_truth": references.get(query_id, ""), + } + ) + print(f"[{args.arm}] {query_id}", flush=True) + print(f"answered {len(queries)} queries -> {args.out}") + return 0 + + +def _cmd_score_ragas(args: argparse.Namespace) -> int: + samples = [ + Sample( + question=row["question"], + answer=row["answer"], + contexts=list(row["contexts"]), + ground_truth=row.get("ground_truth", ""), + ) + for row in load_jsonl(args.samples) + ] + scores_a = score_ragas(samples, args.metrics) + rows = [ + {"row_type": "ragas", "metric": metric, "arm_a": value, "arm_b": value} + for metric, value in scores_a.items() + ] + _append_jsonl(args.out, rows) + print(f"scored {len(samples)} answers with RAGAS -> {args.out}") + return 0 + + +def _load_metrics_file(path: Path) -> dict[str, Any]: + rows = load_jsonl(path) + if not rows: + raise ValueError(f"no metrics rows in {path}") + return rows[0] + + +def _cmd_stats(args: argparse.Namespace) -> int: + manifest = Manifest.load(args.manifest) + file_a = _load_metrics_file(args.metrics_a) + file_b = _load_metrics_file(args.metrics_b) + dataset = file_a["dataset"] + rows: list[dict[str, Any]] = [ + { + "row_type": "meta", + "run_id": manifest.run_id, + "fingerprint": manifest.fingerprint(), + "arm_a": args.arm_a_label, + "arm_b": args.arm_b_label, + } + ] + for metric in manifest.metrics: + per_query_a = file_a["per_query"].get(metric, {}) + per_query_b = file_b["per_query"].get(metric, {}) + result = stats.compare( + metric, + per_query_a, + per_query_b, + resamples=manifest.stats.bootstrap_resamples, + seed=manifest.stats.seed, + alpha=manifest.stats.alpha, + ) + row = {"row_type": "ir", "dataset": dataset, **result.to_dict()} + rows.append(row) + _append_jsonl(args.out, rows) + print(f"wrote {len(rows) - 1} paired IR comparisons -> {args.out}") + return 0 + + +def _cmd_report(args: argparse.Namespace) -> int: + report = render_report(load_jsonl(args.results)) + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(report) + print(f"wrote {args.out}") + return 0 + + +def _add_preregister(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("preregister", help="validate and freeze the manifest") + parser.add_argument("--manifest", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_preregister) + + +def _add_collect(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("collect", help="build a TREC run file for one arm") + parser.add_argument("--system", choices=("lilbee", "ragflow"), required=True) + parser.add_argument("--queries", type=Path, required=True) + parser.add_argument("--run", type=Path, required=True) + parser.add_argument("--checkpoint", type=Path, required=True) + parser.add_argument("--run-tag", required=True) + parser.add_argument("--base-url", required=True) + parser.add_argument("--top-k", type=int, default=DEFAULT_TOP_K) + parser.add_argument("--api-key", default="", help="ragflow only") + parser.add_argument( + "--dataset-id", action="append", default=[], help="ragflow only, repeatable" + ) + parser.set_defaults(handler=_cmd_collect) + + +def _add_score_ir(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("score-ir", help="score a run file against qrels with pytrec_eval") + parser.add_argument("--qrels", type=Path, required=True) + parser.add_argument("--run", type=Path, required=True) + parser.add_argument("--dataset", required=True) + parser.add_argument("--run-tag", required=True) + parser.add_argument("--metrics", nargs="+", default=DEFAULT_METRICS) + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_score_ir) + + +def _add_answer(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("answer", help="generate answers for the RAGAS tier") + parser.add_argument("--queries", type=Path, required=True) + parser.add_argument("--ground-truth", type=Path, default=None) + parser.add_argument("--base-url", required=True) + parser.add_argument("--arm", required=True) + parser.add_argument("--top-k", type=int, default=0) + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_answer) + + +def _add_score_ragas(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("score-ragas", help="score generated answers with RAGAS") + parser.add_argument("--samples", type=Path, required=True) + parser.add_argument("--metrics", nargs="+", default=None) + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_score_ragas) + + +def _add_stats(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("stats", help="paired bootstrap CI and randomization test") + parser.add_argument("--manifest", type=Path, required=True) + parser.add_argument("--metrics-a", type=Path, required=True) + parser.add_argument("--metrics-b", type=Path, required=True) + parser.add_argument("--arm-a-label", default="lilbee") + parser.add_argument("--arm-b-label", default="ragflow") + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_stats) + + +def _add_report(sub: argparse._SubParsersAction) -> None: + parser = sub.add_parser("report", help="render results.jsonl as markdown") + parser.add_argument("--results", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + parser.set_defaults(handler=_cmd_report) + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(prog="evals.benchmark", description=__doc__) + sub = parser.add_subparsers(dest="command", required=True) + for register in ( + _add_preregister, + _add_collect, + _add_score_ir, + _add_answer, + _add_score_ragas, + _add_stats, + _add_report, + ): + register(sub) + return parser + + +def main(argv: list[str] | None = None) -> int: + args = build_parser().parse_args(argv) + try: + return int(args.handler(args)) + except (ValueError, FileNotFoundError, RuntimeError, httpx.HTTPError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 1 diff --git a/evals/benchmark/collectors.py b/evals/benchmark/collectors.py new file mode 100644 index 000000000..b818399e7 --- /dev/null +++ b/evals/benchmark/collectors.py @@ -0,0 +1,160 @@ +"""Per-system collectors that turn a query set into a TREC run file. + +Each collector hits one system's retrieval API and returns chunk hits tagged +with their parent document; the shared driver collapses those to a document run +and writes the TREC file. Every query is checkpointed as it lands, so a killed +pod run resumes without re-querying completed queries. +""" + +from __future__ import annotations + +import json +from collections.abc import Callable +from pathlib import Path +from typing import Any, Protocol + +import httpx + +from evals.benchmark.runfile import ChunkHit, collapse_hits, write_run +from evals.retrieval.checkpoint import JsonlCheckpoint, load_jsonl + +SEARCH_ROUTE = "/api/search" +RAGFLOW_RETRIEVAL_ROUTE = "/api/v1/retrieval" +RETRIEVE_TIMEOUT_SECONDS = 120.0 +DEFAULT_TOP_K = 20 + + +class Collector(Protocol): + """Retrieves ranked chunk hits for one query from one system.""" + + run_tag: str + + def retrieve(self, query_id: str, query_text: str) -> list[ChunkHit]: ... + + +def make_http_client() -> httpx.Client: + return httpx.Client(timeout=RETRIEVE_TIMEOUT_SECONDS) + + +class LilbeeCollector: + """Reads ranked results from a running lilbee server's ``/api/search``. + + lilbee already groups results by source document, so each result maps to one + document hit scored by ``best_relevance``. + """ + + def __init__( + self, + base_url: str, + *, + run_tag: str = "lilbee", + top_k: int = DEFAULT_TOP_K, + client: httpx.Client | None = None, + ) -> None: + self._base_url = base_url.rstrip("/") + self.run_tag = run_tag + self._top_k = top_k + self._client = client or make_http_client() + + def retrieve(self, query_id: str, query_text: str) -> list[ChunkHit]: + response = self._client.get( + f"{self._base_url}{SEARCH_ROUTE}", + params={"q": query_text, "top_k": self._top_k}, + ) + response.raise_for_status() + return [ + ChunkHit(query_id=query_id, doc_id=doc["source"], score=float(doc["best_relevance"])) + for doc in response.json() + ] + + +class RagflowCollector: + """Reads ranked chunks from RAGFlow's retrieval API and tags parent docs.""" + + def __init__( + self, + base_url: str, + api_key: str, + dataset_ids: list[str], + *, + run_tag: str = "ragflow", + top_k: int = DEFAULT_TOP_K, + client: httpx.Client | None = None, + ) -> None: + self._base_url = base_url.rstrip("/") + self._api_key = api_key + self._dataset_ids = dataset_ids + self.run_tag = run_tag + self._top_k = top_k + self._client = client or make_http_client() + + def retrieve(self, query_id: str, query_text: str) -> list[ChunkHit]: + response = self._client.post( + f"{self._base_url}{RAGFLOW_RETRIEVAL_ROUTE}", + headers={"Authorization": f"Bearer {self._api_key}"}, + json={ + "question": query_text, + "dataset_ids": self._dataset_ids, + "page": 1, + "page_size": self._top_k, + }, + ) + response.raise_for_status() + chunks = response.json().get("data", {}).get("chunks", []) + return [ + ChunkHit( + query_id=query_id, + doc_id=chunk["document_id"], + score=float(chunk["similarity"]), + ) + for chunk in chunks + ] + + +def _row_hits(query_id: str, row: dict[str, Any]) -> list[ChunkHit]: + return [ + ChunkHit(query_id=query_id, doc_id=doc_id, score=score) for doc_id, score in row["hits"] + ] + + +def collect_run( + collector: Collector, + queries: dict[str, str], + run_path: Path, + checkpoint_path: Path, + *, + on_query: Callable[[str], None] | None = None, +) -> list[ChunkHit]: + """Retrieve every query (resuming from the checkpoint) and write the run file. + + Each query's hits are appended to ``checkpoint_path`` as they land; the run + file is (re)built from the full checkpoint at the end, so an interrupted run + resumes without re-querying and still produces a complete run file. + """ + checkpoint = JsonlCheckpoint(checkpoint_path, "query_id") + for query_id, query_text in queries.items(): + if query_id in checkpoint: + continue + hits = collector.retrieve(query_id, query_text) + checkpoint.append({"query_id": query_id, "hits": [[hit.doc_id, hit.score] for hit in hits]}) + if on_query is not None: + on_query(query_id) + all_hits: list[ChunkHit] = [] + for row in load_jsonl(checkpoint_path): + all_hits.extend(_row_hits(row["query_id"], row)) + entries = collapse_hits(all_hits, collector.run_tag) + write_run(run_path, entries) + return all_hits + + +def load_queries(path: Path) -> dict[str, str]: + """Read a queries file: one ``{"query_id": ..., "text": ...}`` object per line.""" + return {row["query_id"]: row["text"] for row in load_jsonl(path)} + + +def write_queries(path: Path, queries: dict[str, str]) -> None: + """Write a queries file the collector reads back.""" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text( + "".join(json.dumps({"query_id": qid, "text": text}) + "\n" for qid, text in queries.items()) + ) diff --git a/evals/benchmark/datasets.py b/evals/benchmark/datasets.py new file mode 100644 index 000000000..bf2efdfb2 --- /dev/null +++ b/evals/benchmark/datasets.py @@ -0,0 +1,171 @@ +"""Dataset loading, normalized to a single (corpus, queries, qrels) triple. + +Two label kinds: + +- NATIVE qrels ship with the dataset (BEIR, MS MARCO, HotpotQA). They are used + as published. +- DERIVED qrels are computed from human gold-evidence annotations on QA + datasets that have no retrieval labels of their own (TAT-DQA, OTT-QA). The + derivation is the single documented pure function ``derive_qrels_from_evidence``, + and every derived dataset is recorded as such in the manifest. + +Real downloads live behind a lazily-imported loader. The normalization and +derivation logic is pure and is what the unit tests exercise on tiny fixtures. +""" + +from __future__ import annotations + +from collections.abc import Callable, Iterable, Mapping +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +LABEL_NATIVE = "native" +LABEL_DERIVED = "derived" + +# Relevance grade assigned to a document named by human gold evidence. +DERIVED_RELEVANCE = 1 + +Corpus = dict[str, dict[str, str]] +Queries = dict[str, str] +Qrels = dict[str, dict[str, int]] + + +@dataclass(frozen=True) +class Dataset: + """A retrieval benchmark normalized to corpus, queries, and qrels.""" + + name: str + label_kind: str + corpus: Corpus + queries: Queries + qrels: Qrels + + +def normalize_corpus(rows: Mapping[str, Mapping[str, Any]]) -> Corpus: + """Normalize BEIR-style corpus rows to ``doc_id -> {title, text}``. + + Documents whose title and text are both empty are dropped: they can never + be a relevant hit and only inflate the index. + """ + corpus: Corpus = {} + for doc_id, row in rows.items(): + title = str(row.get("title", "")).strip() + text = str(row.get("text", "")).strip() + if title or text: + corpus[str(doc_id)] = {"title": title, "text": text} + return corpus + + +def normalize_queries(rows: Mapping[str, Any]) -> Queries: + """Normalize query rows to ``query_id -> text``, dropping empty queries.""" + queries: Queries = {} + for qid, text in rows.items(): + cleaned = str(text).strip() + if cleaned: + queries[str(qid)] = cleaned + return queries + + +def normalize_qrels(rows: Mapping[str, Mapping[str, Any]]) -> Qrels: + """Normalize native qrels to ``query_id -> {doc_id: grade}`` with int grades. + + Non-positive grades are dropped so the qrels hold only judged-relevant + documents, matching how pytrec_eval treats them. + """ + qrels: Qrels = {} + for qid, judged in rows.items(): + graded = {str(doc): int(grade) for doc, grade in judged.items() if int(grade) > 0} + if graded: + qrels[str(qid)] = graded + return qrels + + +def derive_qrels_from_evidence( + evidence: Mapping[str, Iterable[str]], relevance: int = DERIVED_RELEVANCE +) -> Qrels: + """Derive retrieval qrels from human gold-evidence document annotations. + + Each query maps to the set of document ids a human annotator marked as gold + evidence for its answer; every such document is labeled relevant at + ``relevance``. This is the documented derivation for QA datasets that carry + gold evidence but no native retrieval labels (TAT-DQA, OTT-QA). Queries with + no evidence are omitted, since an unjudged query cannot be scored. + """ + qrels: Qrels = {} + for qid, doc_ids in evidence.items(): + graded = {str(doc_id): relevance for doc_id in doc_ids} + if graded: + qrels[str(qid)] = graded + return qrels + + +def build_native_dataset( + name: str, + corpus_rows: Mapping[str, Mapping[str, Any]], + query_rows: Mapping[str, Any], + qrel_rows: Mapping[str, Mapping[str, Any]], +) -> Dataset: + """Assemble a native-qrel dataset from raw BEIR-style rows.""" + return Dataset( + name=name, + label_kind=LABEL_NATIVE, + corpus=normalize_corpus(corpus_rows), + queries=normalize_queries(query_rows), + qrels=normalize_qrels(qrel_rows), + ) + + +def build_derived_dataset( + name: str, + corpus_rows: Mapping[str, Mapping[str, Any]], + query_rows: Mapping[str, Any], + evidence: Mapping[str, Iterable[str]], +) -> Dataset: + """Assemble a derived-qrel dataset from a QA corpus plus gold evidence.""" + return Dataset( + name=name, + label_kind=LABEL_DERIVED, + corpus=normalize_corpus(corpus_rows), + queries=normalize_queries(query_rows), + qrels=derive_qrels_from_evidence(evidence), + ) + + +# Loaders for real downloads. Each returns the raw rows the pure builders above +# consume; they are only called by ``load_dataset`` and import heavy deps lazily. +RawNativeLoader = Callable[[Path], tuple[Mapping, Mapping, Mapping]] +RawDerivedLoader = Callable[[Path], tuple[Mapping, Mapping, Mapping]] + + +def _load_beir(cache_dir: Path, dataset_key: str, split: str) -> tuple[Mapping, Mapping, Mapping]: + """Download and read a BEIR dataset (SciFact, FiQA, NFCorpus, ...).""" + from beir import util + from beir.datasets.data_loader import GenericDataLoader + + url = f"https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/{dataset_key}.zip" + data_path = util.download_and_unzip(url, str(cache_dir)) + return GenericDataLoader(data_folder=data_path).load(split=split) + + +def load_dataset( + spec: Any, + cache_dir: Path, + *, + native_loader: RawNativeLoader | None = None, + derived_loader: RawDerivedLoader | None = None, +) -> Dataset: + """Load a dataset described by a manifest ``DatasetSpec`` to a normalized triple. + + The real download is injected (or lazily selected by ``spec.loader``); the + normalization and derivation are the pure functions above. Tests inject + tiny in-memory loaders so nothing touches the network. + """ + if spec.label_kind == LABEL_DERIVED: + if derived_loader is None: + raise ValueError(f"no derived loader available for dataset '{spec.name}'") + corpus_rows, query_rows, evidence = derived_loader(cache_dir) + return build_derived_dataset(spec.name, corpus_rows, query_rows, evidence) + loader = native_loader or (lambda path: _load_beir(path, spec.loader, spec.split)) + corpus_rows, query_rows, qrel_rows = loader(cache_dir) + return build_native_dataset(spec.name, corpus_rows, query_rows, qrel_rows) diff --git a/evals/benchmark/ir_metrics.py b/evals/benchmark/ir_metrics.py new file mode 100644 index 000000000..f83f5c97a --- /dev/null +++ b/evals/benchmark/ir_metrics.py @@ -0,0 +1,84 @@ +"""Tier-1 retrieval metrics: score a run file against qrels with pytrec_eval. + +pytrec_eval is the TREC-standard scorer, so these numbers carry no model +opinion and are exactly reproducible from the run file and the qrels. It is an +optional dependency (a C extension), imported lazily; the per-query shaping and +aggregation are pulled out so they can be unit-tested with a fake evaluator and +no C extension installed. +""" + +from __future__ import annotations + +import statistics +from collections.abc import Callable +from dataclasses import dataclass, field +from typing import Any, Protocol + +Qrels = dict[str, dict[str, int]] +Run = dict[str, dict[str, float]] + +# Display name -> the pytrec_eval measure that computes it. recip_rank is the +# uncut MRR; pytrec_eval has no built-in cut-at-10 variant, and MRR is +# dominated by the top hit, so at realistic depths the two agree. +METRIC_MEASURES: dict[str, str] = { + "nDCG@10": "ndcg_cut_10", + "Recall@20": "recall_20", + "MRR@10": "recip_rank", +} + +PYTREC_INSTALL_HINT = ( + "pytrec_eval is required to score retrieval; install the benchmark deps: " + "uv pip install -r evals/benchmark/requirements.txt" +) + + +class Evaluator(Protocol): + """The slice of pytrec_eval.RelevanceEvaluator this module uses.""" + + def evaluate(self, run: Run) -> dict[str, dict[str, float]]: ... + + +EvaluatorFactory = Callable[[Qrels, set[str]], Evaluator] + + +@dataclass(frozen=True) +class MetricScores: + """Per-query and aggregated scores for the requested display metrics.""" + + per_query: dict[str, dict[str, float]] = field(default_factory=dict) + aggregated: dict[str, float] = field(default_factory=dict) + + def to_dict(self) -> dict[str, Any]: + return {"per_query": self.per_query, "aggregated": self.aggregated} + + +def _default_evaluator_factory(qrels: Qrels, measures: set[str]) -> Evaluator: + try: + import pytrec_eval + except ImportError as exc: # pragma: no cover - exercised only without the extra + raise RuntimeError(PYTREC_INSTALL_HINT) from exc + return pytrec_eval.RelevanceEvaluator(qrels, measures) + + +def score_run( + qrels: Qrels, + run: Run, + metrics: list[str], + *, + evaluator_factory: EvaluatorFactory | None = None, +) -> MetricScores: + """Score a run against qrels, returning per-query and mean-aggregated metrics.""" + unknown = [metric for metric in metrics if metric not in METRIC_MEASURES] + if unknown: + raise ValueError(f"unknown metrics: {', '.join(unknown)}") + factory = evaluator_factory or _default_evaluator_factory + measures = {METRIC_MEASURES[metric] for metric in metrics} + raw = factory(qrels, measures).evaluate(run) + per_query: dict[str, dict[str, float]] = {} + aggregated: dict[str, float] = {} + for metric in metrics: + measure = METRIC_MEASURES[metric] + scores = {qid: float(values[measure]) for qid, values in raw.items()} + per_query[metric] = scores + aggregated[metric] = round(statistics.fmean(scores.values()), 4) if scores else 0.0 + return MetricScores(per_query=per_query, aggregated=aggregated) diff --git a/evals/benchmark/manifest.example.yaml b/evals/benchmark/manifest.example.yaml new file mode 100644 index 000000000..b4889369c --- /dev/null +++ b/evals/benchmark/manifest.example.yaml @@ -0,0 +1,74 @@ +# Preregistration for one lilbee-vs-RAGFlow retrieval benchmark run. +# Freeze this with `python -m evals.benchmark preregister` before any data +# moves; the frozen copy carries a fingerprint so the run cannot be re-cut. +run_id: parity-2026-07 + +# Both arms share one served embedder and one served generator; only retrieval +# differs. The judge must differ from the generator so answers are never graded +# by the model that wrote them (validated at load time). +models: + embedder: qwen3-embedding + generator: qwen2.5-72b-instruct + generator_swap: mistral-large-2411 + judge: fable-5 + +arms: + - name: lilbee-parity + system: lilbee + description: test/retrieval-parity with every parity feature enabled + config: + title_search: true + neighbor_expansion: 2 + table_extraction: true + layout_detection: true + intent_llm: true + - name: ragflow-default + system: ragflow + description: RAGFlow DeepDoc pipeline at its defaults + config: + pipeline: deepdoc + +# Passage sets carry native TREC qrels; the document-structured QA sets have +# their retrieval labels derived from human gold-evidence annotations, marked +# label_kind: derived and disclosed here. +datasets: + - name: scifact + loader: scifact + label_kind: native + split: test + - name: fiqa + loader: fiqa + label_kind: native + split: test + - name: nfcorpus + loader: nfcorpus + label_kind: native + split: test + - name: hotpotqa + loader: hotpotqa + label_kind: native + split: test + - name: trec-covid + loader: trec-covid + label_kind: native + split: test + - name: tat-dqa + loader: tatdqa + label_kind: derived + split: test + - name: ott-qa + loader: ottqa + label_kind: derived + split: dev + +metrics: + - nDCG@10 + - Recall@20 + - MRR@10 + +stats: + bootstrap_resamples: 10000 + seed: 20260714 + alpha: 0.05 + +temperature: 0.0 diff --git a/evals/benchmark/manifest.py b/evals/benchmark/manifest.py new file mode 100644 index 000000000..0adcb73ec --- /dev/null +++ b/evals/benchmark/manifest.py @@ -0,0 +1,164 @@ +"""The preregistration manifest: everything frozen before any data moves. + +Freezing the datasets, metrics, both arms' configs, and the held-constant +models to a file (and its fingerprint) is what stops the run from being +cherry-picked after the numbers land. The key structural guarantee validated +here is that the judge model differs from the generator model, so the answer +tier is never graded by the same model that wrote the answer. +""" + +from __future__ import annotations + +import hashlib +import json +from dataclasses import asdict, dataclass, field +from pathlib import Path +from typing import Any + +from evals.benchmark.datasets import LABEL_DERIVED, LABEL_NATIVE + +LILBEE_SYSTEM = "lilbee" +RAGFLOW_SYSTEM = "ragflow" +FROZEN_TEMPERATURE = 0.0 + + +@dataclass(frozen=True) +class ArmConfig: + """One system under test and the configuration it runs with.""" + + name: str + system: str + description: str + config: dict[str, Any] = field(default_factory=dict) + + +@dataclass(frozen=True) +class ModelConfig: + """The models held constant across both arms. + + ``embedder`` is served once and shared by both arms. ``generator`` writes + every answer; ``judge`` grades them and MUST differ from ``generator``. + ``generator_swap`` records an alternate generator noted for a sensitivity + check, not used in the main run. + """ + + embedder: str + generator: str + judge: str + generator_swap: str = "" + + +@dataclass(frozen=True) +class DatasetSpec: + """One dataset, its loader, and whether its qrels are native or derived.""" + + name: str + loader: str + label_kind: str + split: str = "test" + + +@dataclass(frozen=True) +class StatsConfig: + """Paired-statistics configuration, frozen so CIs are reproducible.""" + + bootstrap_resamples: int = 10000 + seed: int = 20260714 + alpha: float = 0.05 + + +@dataclass(frozen=True) +class Manifest: + """The full frozen preregistration for one benchmark run.""" + + run_id: str + arms: list[ArmConfig] + models: ModelConfig + datasets: list[DatasetSpec] + metrics: list[str] + stats: StatsConfig + temperature: float = FROZEN_TEMPERATURE + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + def fingerprint(self) -> str: + """Stable sha256 over the canonical JSON; the preregistration's identity.""" + canonical = json.dumps(self.to_dict(), sort_keys=True, separators=(",", ":")) + return hashlib.sha256(canonical.encode()).hexdigest() + + @property + def derived_datasets(self) -> list[str]: + return [ds.name for ds in self.datasets if ds.label_kind == LABEL_DERIVED] + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> Manifest: + manifest = cls( + run_id=data["run_id"], + arms=[ArmConfig(**arm) for arm in data["arms"]], + models=ModelConfig(**data["models"]), + datasets=[DatasetSpec(**ds) for ds in data["datasets"]], + metrics=list(data["metrics"]), + stats=StatsConfig(**data.get("stats", {})), + temperature=data.get("temperature", FROZEN_TEMPERATURE), + ) + manifest.validate() + return manifest + + @classmethod + def load(cls, path: Path) -> Manifest: + """Load and validate a manifest from a YAML or JSON file.""" + text = path.read_text() + if path.suffix in (".yaml", ".yml"): + import yaml + + data = yaml.safe_load(text) + else: + data = json.loads(text) + return cls.from_dict(data) + + def freeze(self, path: Path) -> str: + """Write the canonical manifest to ``path`` and return its fingerprint.""" + self.validate() + path.parent.mkdir(parents=True, exist_ok=True) + payload = self.to_dict() + payload["fingerprint"] = self.fingerprint() + path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n") + return payload["fingerprint"] + + def validate(self) -> None: + """Fail loudly on any preregistration invariant the run depends on.""" + _validate_arms(self.arms) + _validate_models(self.models) + _validate_datasets(self.datasets) + if not self.metrics: + raise ValueError("manifest lists no metrics") + if self.temperature != FROZEN_TEMPERATURE: + raise ValueError(f"temperature must be {FROZEN_TEMPERATURE} for a deterministic run") + + +def _validate_arms(arms: list[ArmConfig]) -> None: + systems = {arm.system for arm in arms} + if len(arms) != 2: # noqa: PLR2004 - an A/B has exactly two arms + raise ValueError("an A/B benchmark needs exactly two arms") + if len({arm.name for arm in arms}) != len(arms): + raise ValueError("arm names must be distinct") + if systems != {LILBEE_SYSTEM, RAGFLOW_SYSTEM}: + raise ValueError(f"arms must be one {LILBEE_SYSTEM} and one {RAGFLOW_SYSTEM}") + + +def _validate_models(models: ModelConfig) -> None: + if not models.embedder: + raise ValueError("a shared embedder model is required") + if not models.generator: + raise ValueError("a generator model is required") + if models.judge == models.generator: + raise ValueError("judge model must differ from the generator model") + + +def _validate_datasets(datasets: list[DatasetSpec]) -> None: + if not datasets: + raise ValueError("manifest lists no datasets") + for ds in datasets: + if ds.label_kind not in (LABEL_NATIVE, LABEL_DERIVED): + raise ValueError(f"dataset '{ds.name}' has unknown label_kind '{ds.label_kind}'") diff --git a/evals/benchmark/ragas_tier.py b/evals/benchmark/ragas_tier.py new file mode 100644 index 000000000..d3fafa2f7 --- /dev/null +++ b/evals/benchmark/ragas_tier.py @@ -0,0 +1,119 @@ +"""Tier-2 answer quality: RAGAS metrics plus the reused blind judge. + +RAGAS scores the generated answers (faithfulness, answer relevancy, context +precision/recall). The blind duplicate-arm judge from ``evals.retrieval`` is +reused unchanged as a corroborating signal, with its own noise floor measured +by grading one arm twice. ragas is an optional heavy dependency, imported +lazily; the wiring is injectable so tests need neither ragas nor a real model. +""" + +from __future__ import annotations + +import random +from collections.abc import Callable +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from evals.retrieval.answers import AnswerRow +from evals.retrieval.blinding import build_blind_rows, unblind +from evals.retrieval.judging import DIMENSIONS, judge_rows +from evals.retrieval.llm import ChatFn +from evals.retrieval.questions import Question +from evals.retrieval.scoring import ARM_REPLICATE, NOISE_REPLICATE, dimension_means, noise_floor + +RAGAS_METRICS = ("faithfulness", "answer_relevancy", "context_precision", "context_recall") + +RAGAS_INSTALL_HINT = ( + "ragas is required for the answer tier; install the benchmark deps: " + "uv pip install -r evals/benchmark/requirements.txt" +) + +# question, answer, contexts, ground_truth -> per-metric score. +RagasEvaluateFn = Callable[[list[dict[str, Any]], list[str]], dict[str, float]] + + +@dataclass(frozen=True) +class Sample: + """One generated answer with the context it was grounded on.""" + + question: str + answer: str + contexts: list[str] + ground_truth: str + + def to_ragas_row(self) -> dict[str, Any]: + return { + "user_input": self.question, + "response": self.answer, + "retrieved_contexts": list(self.contexts), + "reference": self.ground_truth, + } + + +def _default_ragas_evaluate(rows: list[dict[str, Any]], metrics: list[str]) -> dict[str, float]: + try: + from ragas import EvaluationDataset, evaluate + from ragas import metrics as ragas_metrics + except ImportError as exc: # pragma: no cover - exercised only without the extra + raise RuntimeError(RAGAS_INSTALL_HINT) from exc + selected = [getattr(ragas_metrics, name) for name in metrics] + dataset = EvaluationDataset.from_list(rows) + result = evaluate(dataset=dataset, metrics=selected) + scores = result.to_pandas()[metrics].mean().to_dict() + return {metric: float(scores[metric]) for metric in metrics} + + +def score_ragas( + samples: list[Sample], + metrics: list[str] | None = None, + *, + evaluate_fn: RagasEvaluateFn | None = None, +) -> dict[str, float]: + """Mean RAGAS score per metric over the samples.""" + evaluator = evaluate_fn or _default_ragas_evaluate + rows = [sample.to_ragas_row() for sample in samples] + return evaluator(rows, list(metrics if metrics is not None else RAGAS_METRICS)) + + +@dataclass(frozen=True) +class JudgeSummary: + """The corroborating judge's per-arm means and its measured noise floor.""" + + noise_floor: float + means: dict[str, dict[str, float]] + + def to_dict(self) -> dict[str, Any]: + return {"noise_floor": self.noise_floor, "means": self.means} + + +def run_corroborating_judge( + questions: list[Question], + answers_by_arm: dict[str, dict[str, AnswerRow]], + noise_arm: str, + chat: ChatFn, + work_dir: Path, + *, + seed: int, +) -> JudgeSummary: + """Run the reused blind judge and summarize per-arm means and its noise floor. + + The noise arm is graded twice under fresh opaque ids; the disagreement + between those two passes is the judge's noise floor, so a small answer-tier + gap is never oversold. + """ + work_dir.mkdir(parents=True, exist_ok=True) + blind = build_blind_rows(questions, answers_by_arm, noise_arm, random.Random(seed)) + grades = judge_rows(blind.rows, chat, work_dir / "grades.jsonl") + for gid in blind.prefailed: + grades[gid] = dict.fromkeys(DIMENSIONS, 0) + unblinded = unblind(blind.assignments, grades) + means = { + arm: dimension_means(replicates.get(ARM_REPLICATE, {})) + for arm, replicates in unblinded.items() + } + noise_replicates = unblinded.get(noise_arm, {}) + floor = noise_floor( + noise_replicates.get(ARM_REPLICATE, {}), noise_replicates.get(NOISE_REPLICATE, {}) + ) + return JudgeSummary(noise_floor=floor, means=means) diff --git a/evals/benchmark/report.py b/evals/benchmark/report.py new file mode 100644 index 000000000..101b7a546 --- /dev/null +++ b/evals/benchmark/report.py @@ -0,0 +1,117 @@ +"""Markdown rendering of a scored benchmark run. + +Leads with the Tier-1 label-scored retrieval numbers (the reproducible core), +then the Tier-2 RAGAS answer scores, then the feature-to-dataset coverage +matrix with derived-qrel datasets clearly marked. +""" + +from __future__ import annotations + +from typing import Any + + +def _rows_of(rows: list[dict[str, Any]], row_type: str) -> list[dict[str, Any]]: + return [row for row in rows if row.get("row_type") == row_type] + + +def _arm_labels(rows: list[dict[str, Any]]) -> tuple[str, str]: + meta = _rows_of(rows, "meta") + if meta: + return meta[0]["arm_a"], meta[0]["arm_b"] + return "arm A", "arm B" + + +def _sig_cell(row: dict[str, Any]) -> str: + ci = f"[{row['ci_low']:+.4f}, {row['ci_high']:+.4f}]" + flag = "" if row["significant"] else " (n.s.)" + return f"{ci}{flag}" + + +def _ir_section(rows: list[dict[str, Any]], arm_a: str, arm_b: str) -> list[str]: + ir_rows = _rows_of(rows, "ir") + if not ir_rows: + return [] + lines = [ + "## Tier 1 - retrieval, scored against human labels", + "", + "Computed by pytrec_eval against each dataset's published relevance " + "labels. No model judges anything, so these numbers are exactly " + "reproducible from the run files and qrels.", + "", + f"| dataset | metric | {arm_a} | {arm_b} | delta | 95% CI (B - A) | p |", + "| --- | --- | --- | --- | --- | --- | --- |", + ] + for row in ir_rows: + lines.append( + f"| {row['dataset']} | {row['metric']} | {row['mean_a']:.4f} | " + f"{row['mean_b']:.4f} | {row['mean_diff']:+.4f} | {_sig_cell(row)} | " + f"{row['p_value']:.3f} |" + ) + lines.append("") + return lines + + +def _ragas_section(rows: list[dict[str, Any]], arm_a: str, arm_b: str) -> list[str]: + ragas_rows = _rows_of(rows, "ragas") + if not ragas_rows: + return [] + lines = [ + "## Tier 2 - answer quality (RAGAS)", + "", + f"| metric | {arm_a} | {arm_b} |", + "| --- | --- | --- |", + ] + for row in ragas_rows: + lines.append(f"| {row['metric']} | {row['arm_a']:.4f} | {row['arm_b']:.4f} |") + for judge in _rows_of(rows, "judge"): + lines += [ + "", + f"Corroborating blind judge noise floor: plus or minus " + f"{judge['noise_floor']} per dimension (one arm graded twice). " + "Answer-tier gaps at or below it are not oversold.", + ] + lines.append("") + return lines + + +def _coverage_section(rows: list[dict[str, Any]]) -> list[str]: + coverage_rows = _rows_of(rows, "coverage") + if not coverage_rows: + return [] + lines = [ + "## Feature coverage", + "", + "Each feature under test maps to a dataset that stresses it. Datasets " + "whose retrieval labels are derived from human gold evidence are marked.", + "", + "| feature under test | proven by | tier-1 metric | qrels |", + "| --- | --- | --- | --- |", + ] + for row in coverage_rows: + qrels = "derived" if row.get("derived") else "native" + lines.append(f"| {row['feature']} | {row['dataset']} | {row['metric']} | {qrels} |") + lines.append("") + return lines + + +def render_report(rows: list[dict[str, Any]]) -> str: + """Render results rows to the human-readable benchmark markdown report.""" + arm_a, arm_b = _arm_labels(rows) + meta = _rows_of(rows, "meta") + header = ["# lilbee vs RAGFlow retrieval benchmark", ""] + if meta: + header.append( + f"Run `{meta[0].get('run_id', '?')}` " + f"(manifest `{meta[0].get('fingerprint', '?')[:12]}`). " + f"Arm A = {arm_a}, arm B = {arm_b}." + ) + header.append("") + lines = ( + header + + _ir_section(rows, arm_a, arm_b) + + _ragas_section(rows, arm_a, arm_b) + + _coverage_section(rows) + ) + if not _rows_of(rows, "ir") and not _rows_of(rows, "ragas"): + raise ValueError("results contain no ir or ragas rows; run score-ir first") + return "\n".join(lines).rstrip() + "\n" diff --git a/evals/benchmark/runfile.py b/evals/benchmark/runfile.py new file mode 100644 index 000000000..6e42a67de --- /dev/null +++ b/evals/benchmark/runfile.py @@ -0,0 +1,93 @@ +"""TREC run files and the chunk-to-document collapse both arms share. + +A run file is the standard six-column TREC format:: + + query_id Q0 doc_id rank score run_tag + +Retrieval returns chunks; scoring happens at the document level, so chunks are +collapsed to their parent document (best score wins) and re-ranked before the +run file is written. Everything here is pure so it can be fully unit-tested. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from pathlib import Path + +TREC_UNUSED_COLUMN = "Q0" + + +@dataclass(frozen=True) +class ChunkHit: + """One retrieved chunk, tagged with the document it belongs to.""" + + query_id: str + doc_id: str + score: float + + +@dataclass(frozen=True) +class RunEntry: + """One ranked document for one query, as written to a TREC run file.""" + + query_id: str + doc_id: str + rank: int + score: float + run_tag: str + + def to_line(self) -> str: + return ( + f"{self.query_id} {TREC_UNUSED_COLUMN} {self.doc_id} " + f"{self.rank} {self.score:.6f} {self.run_tag}" + ) + + @classmethod + def from_line(cls, line: str) -> RunEntry: + query_id, _unused, doc_id, rank, score, run_tag = line.split() + return cls( + query_id=query_id, + doc_id=doc_id, + rank=int(rank), + score=float(score), + run_tag=run_tag, + ) + + +def collapse_hits(hits: list[ChunkHit], run_tag: str) -> list[RunEntry]: + """Collapse chunk hits to documents (best score wins) and re-rank per query. + + Multiple chunks from one document keep only that document's best score. + Within each query, documents are ranked by descending score; ties break on + doc_id so the ordering is deterministic and reproducible. + """ + best: dict[str, dict[str, float]] = {} + for hit in hits: + per_query = best.setdefault(hit.query_id, {}) + if hit.doc_id not in per_query or hit.score > per_query[hit.doc_id]: + per_query[hit.doc_id] = hit.score + entries: list[RunEntry] = [] + for query_id in sorted(best): + ranked = sorted(best[query_id].items(), key=lambda item: (-item[1], item[0])) + for rank, (doc_id, score) in enumerate(ranked, start=1): + entries.append(RunEntry(query_id, doc_id, rank, score, run_tag)) + return entries + + +def write_run(path: Path, entries: list[RunEntry]) -> None: + """Serialize run entries to a TREC run file.""" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("".join(entry.to_line() + "\n" for entry in entries)) + + +def read_run(path: Path) -> list[RunEntry]: + """Parse a TREC run file; blank lines are skipped.""" + return [RunEntry.from_line(line) for line in path.read_text().splitlines() if line.strip()] + + +def run_to_pytrec(entries: list[RunEntry]) -> dict[str, dict[str, float]]: + """Shape run entries as pytrec_eval expects: query_id -> doc_id -> score.""" + run: dict[str, dict[str, float]] = {} + for entry in entries: + run.setdefault(entry.query_id, {})[entry.doc_id] = entry.score + return run diff --git a/evals/benchmark/stats.py b/evals/benchmark/stats.py new file mode 100644 index 000000000..2af1d2164 --- /dev/null +++ b/evals/benchmark/stats.py @@ -0,0 +1,120 @@ +"""Paired statistics on per-query metric vectors. + +Two arms are scored on the same queries, so every metric difference is paired. +A paired bootstrap gives a 95% confidence interval for the mean difference and +a sign-flip randomization test gives a p-value. Both are seeded and pure, so a +result is bit-for-bit reproducible. A difference whose CI crosses zero is +flagged not significant. +""" + +from __future__ import annotations + +import random +import statistics +from dataclasses import asdict, dataclass +from typing import Any + +DEFAULT_RESAMPLES = 10000 +DEFAULT_SEED = 20260714 +DEFAULT_ALPHA = 0.05 +# Probability of flipping a paired difference's sign in the randomization test. +SIGN_FLIP_PROBABILITY = 0.5 + + +@dataclass(frozen=True) +class PairedResult: + """The paired comparison of arm B minus arm A on one metric.""" + + metric: str + n: int + mean_a: float + mean_b: float + mean_diff: float + ci_low: float + ci_high: float + p_value: float + significant: bool + + def to_dict(self) -> dict[str, Any]: + return asdict(self) + + +def _percentile(sorted_values: list[float], fraction: float) -> float: + """Linear-interpolated percentile of an already-sorted list.""" + if not sorted_values: + return 0.0 + if len(sorted_values) == 1: + return sorted_values[0] + position = fraction * (len(sorted_values) - 1) + lower = int(position) + upper = min(lower + 1, len(sorted_values) - 1) + weight = position - lower + return sorted_values[lower] * (1 - weight) + sorted_values[upper] * weight + + +def paired_bootstrap_ci( + diffs: list[float], resamples: int, seed: int, alpha: float +) -> tuple[float, float]: + """Percentile CI of the mean paired difference from a seeded bootstrap.""" + if not diffs: + return 0.0, 0.0 + rng = random.Random(seed) + count = len(diffs) + means: list[float] = [] + for _ in range(resamples): + resample = [diffs[rng.randrange(count)] for _ in range(count)] + means.append(statistics.fmean(resample)) + means.sort() + return _percentile(means, alpha / 2), _percentile(means, 1 - alpha / 2) + + +def permutation_test(diffs: list[float], resamples: int, seed: int) -> float: + """Two-sided sign-flip randomization p-value for a nonzero mean difference.""" + if not diffs: + return 1.0 + rng = random.Random(seed) + observed = abs(statistics.fmean(diffs)) + at_least_as_extreme = 0 + for _ in range(resamples): + flipped = [d if rng.random() < SIGN_FLIP_PROBABILITY else -d for d in diffs] + if abs(statistics.fmean(flipped)) >= observed: + at_least_as_extreme += 1 + return (at_least_as_extreme + 1) / (resamples + 1) + + +def _paired_diffs( + a_scores: dict[str, float], b_scores: dict[str, float] +) -> tuple[list[float], list[float], list[float]]: + """Align two per-query score maps on shared query ids, sorted for determinism.""" + shared = sorted(qid for qid in a_scores if qid in b_scores) + a_vec = [a_scores[qid] for qid in shared] + b_vec = [b_scores[qid] for qid in shared] + diffs = [b - a for a, b in zip(a_vec, b_vec, strict=True)] + return a_vec, b_vec, diffs + + +def compare( + metric: str, + a_scores: dict[str, float], + b_scores: dict[str, float], + *, + resamples: int = DEFAULT_RESAMPLES, + seed: int = DEFAULT_SEED, + alpha: float = DEFAULT_ALPHA, +) -> PairedResult: + """Full paired comparison of arm B minus arm A on one metric's per-query scores.""" + a_vec, b_vec, diffs = _paired_diffs(a_scores, b_scores) + ci_low, ci_high = paired_bootstrap_ci(diffs, resamples, seed, alpha) + p_value = permutation_test(diffs, resamples, seed) + mean_diff = statistics.fmean(diffs) if diffs else 0.0 + return PairedResult( + metric=metric, + n=len(diffs), + mean_a=statistics.fmean(a_vec) if a_vec else 0.0, + mean_b=statistics.fmean(b_vec) if b_vec else 0.0, + mean_diff=mean_diff, + ci_low=ci_low, + ci_high=ci_high, + p_value=p_value, + significant=not (ci_low <= 0.0 <= ci_high), + ) diff --git a/tests/benchmark/__init__.py b/tests/benchmark/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/benchmark/test_bench_collectors.py b/tests/benchmark/test_bench_collectors.py new file mode 100644 index 000000000..fb96a6950 --- /dev/null +++ b/tests/benchmark/test_bench_collectors.py @@ -0,0 +1,84 @@ +"""Collectors over mocked HTTP, plus the checkpointed collect driver.""" + +import json + +import httpx + +from evals.benchmark.collectors import ( + LilbeeCollector, + RagflowCollector, + collect_run, + load_queries, + write_queries, +) +from evals.benchmark.runfile import read_run + + +def _client(handler) -> httpx.Client: + return httpx.Client(transport=httpx.MockTransport(handler), base_url="http://test") + + +def test_lilbee_collector_maps_documents_to_hits(): + def handler(request: httpx.Request) -> httpx.Response: + assert request.url.path == "/api/search" + assert request.url.params["q"] == "why?" + return httpx.Response( + 200, + json=[ + {"source": "docA", "best_relevance": 0.9, "excerpts": []}, + {"source": "docB", "best_relevance": 0.4, "excerpts": []}, + ], + ) + + collector = LilbeeCollector("http://test", client=_client(handler)) + hits = collector.retrieve("q1", "why?") + assert [(h.doc_id, h.score) for h in hits] == [("docA", 0.9), ("docB", 0.4)] + + +def test_ragflow_collector_reads_document_ids_and_similarity(): + def handler(request: httpx.Request) -> httpx.Response: + assert request.url.path == "/api/v1/retrieval" + body = json.loads(request.content) + assert body["dataset_ids"] == ["ds1"] + return httpx.Response( + 200, + json={"data": {"chunks": [{"document_id": "docX", "similarity": 0.7}]}}, + ) + + collector = RagflowCollector("http://test", "key", ["ds1"], client=_client(handler)) + hits = collector.retrieve("q1", "why?") + assert [(h.doc_id, h.score) for h in hits] == [("docX", 0.7)] + + +def test_collect_run_writes_run_file_and_checkpoints(tmp_path): + def handler(request: httpx.Request) -> httpx.Response: + return httpx.Response(200, json=[{"source": "docA", "best_relevance": 0.5, "excerpts": []}]) + + collector = LilbeeCollector("http://test", run_tag="lil", client=_client(handler)) + run_path = tmp_path / "run.trec" + ckpt = tmp_path / "ckpt.jsonl" + collect_run(collector, {"q1": "why?"}, run_path, ckpt) + entries = read_run(run_path) + assert [(e.query_id, e.doc_id, e.run_tag) for e in entries] == [("q1", "docA", "lil")] + assert len(ckpt.read_text().splitlines()) == 1 + + +def test_collect_run_resumes_without_requerying(tmp_path): + ckpt = tmp_path / "ckpt.jsonl" + ckpt.write_text(json.dumps({"query_id": "q1", "hits": [["docA", 0.9]]}) + "\n") + asked: list[str] = [] + + def handler(request: httpx.Request) -> httpx.Response: + asked.append(request.url.params["q"]) + return httpx.Response(200, json=[{"source": "docB", "best_relevance": 0.3, "excerpts": []}]) + + collector = LilbeeCollector("http://test", run_tag="lil", client=_client(handler)) + collect_run(collector, {"q1": "first", "q2": "second"}, tmp_path / "run.trec", ckpt) + assert asked == ["second"] # q1 was already checkpointed + assert len(ckpt.read_text().splitlines()) == 2 + + +def test_queries_file_round_trips(tmp_path): + path = tmp_path / "queries.jsonl" + write_queries(path, {"q1": "one", "q2": "two"}) + assert load_queries(path) == {"q1": "one", "q2": "two"} diff --git a/tests/benchmark/test_bench_datasets.py b/tests/benchmark/test_bench_datasets.py new file mode 100644 index 000000000..d4945284d --- /dev/null +++ b/tests/benchmark/test_bench_datasets.py @@ -0,0 +1,86 @@ +"""Pure normalization and the derived-qrel derivation on tiny fixtures.""" + +import pytest + +from evals.benchmark.datasets import ( + LABEL_DERIVED, + LABEL_NATIVE, + build_derived_dataset, + build_native_dataset, + derive_qrels_from_evidence, + load_dataset, + normalize_corpus, + normalize_qrels, + normalize_queries, +) +from evals.benchmark.manifest import DatasetSpec + + +def test_normalize_corpus_drops_fully_empty_documents(): + corpus = normalize_corpus( + {"d1": {"title": "T", "text": "body"}, "d2": {"title": " ", "text": ""}} + ) + assert corpus == {"d1": {"title": "T", "text": "body"}} + + +def test_normalize_queries_drops_blanks_and_stringifies_ids(): + assert normalize_queries({1: "what?", "q2": " "}) == {"1": "what?"} + + +def test_normalize_qrels_drops_non_positive_grades(): + qrels = normalize_qrels({"q1": {"d1": 2, "d2": 0}, "q2": {"d3": 0}}) + assert qrels == {"q1": {"d1": 2}} + + +def test_derive_qrels_labels_each_gold_evidence_doc_relevant(): + qrels = derive_qrels_from_evidence({"q1": ["d1", "d2"], "q2": []}) + assert qrels == {"q1": {"d1": 1, "d2": 1}} # q2 omitted: no evidence + + +def test_build_native_dataset_carries_label_kind(): + dataset = build_native_dataset( + "scifact", + {"d1": {"title": "t", "text": "x"}}, + {"q1": "why?"}, + {"q1": {"d1": 1}}, + ) + assert dataset.label_kind == LABEL_NATIVE + assert dataset.qrels == {"q1": {"d1": 1}} + + +def test_build_derived_dataset_derives_qrels_from_evidence(): + dataset = build_derived_dataset( + "tat-dqa", + {"d1": {"title": "", "text": "table"}}, + {"q1": "sum?"}, + {"q1": ["d1"]}, + ) + assert dataset.label_kind == LABEL_DERIVED + assert dataset.qrels == {"q1": {"d1": 1}} + + +def test_load_dataset_native_uses_injected_loader_without_network(): + spec = DatasetSpec(name="scifact", loader="scifact", label_kind=LABEL_NATIVE) + rows = ({"d1": {"title": "t", "text": "x"}}, {"q1": "why?"}, {"q1": {"d1": 1}}) + dataset = load_dataset(spec, tmp_cache(), native_loader=lambda _cache: rows) + assert dataset.name == "scifact" + assert dataset.queries == {"q1": "why?"} + + +def test_load_dataset_derived_uses_injected_loader(): + spec = DatasetSpec(name="ott-qa", loader="ottqa", label_kind=LABEL_DERIVED, split="dev") + rows = ({"d1": {"title": "", "text": "x"}}, {"q1": "why?"}, {"q1": ["d1"]}) + dataset = load_dataset(spec, tmp_cache(), derived_loader=lambda _cache: rows) + assert dataset.qrels == {"q1": {"d1": 1}} + + +def test_load_dataset_derived_requires_a_loader(): + spec = DatasetSpec(name="ott-qa", loader="ottqa", label_kind=LABEL_DERIVED) + with pytest.raises(ValueError, match="no derived loader"): + load_dataset(spec, tmp_cache()) + + +def tmp_cache(): + from pathlib import Path + + return Path("/tmp/benchmark-cache-unused") diff --git a/tests/benchmark/test_bench_ir_metrics.py b/tests/benchmark/test_bench_ir_metrics.py new file mode 100644 index 000000000..ee199452c --- /dev/null +++ b/tests/benchmark/test_bench_ir_metrics.py @@ -0,0 +1,56 @@ +"""Per-query shaping and aggregation of IR metrics with a fake evaluator. + +pytrec_eval is a C extension; these tests inject a fake evaluator factory so the +shaping and mean-aggregation logic is covered without it installed. +""" + +import pytest + +from evals.benchmark.ir_metrics import METRIC_MEASURES, MetricScores, score_run + + +class _FakeEvaluator: + def __init__(self, per_query): + self._per_query = per_query + + def evaluate(self, run): + # The run is accepted but the fake returns pre-baked measure values. + assert run # sanity: a run was passed through + return self._per_query + + +def _factory(per_query): + def make(qrels, measures): + assert measures <= set(METRIC_MEASURES.values()) + return _FakeEvaluator(per_query) + + return make + + +def test_score_run_shapes_per_query_and_aggregates_by_mean(): + per_query = { + "q1": {"ndcg_cut_10": 1.0, "recall_20": 0.5}, + "q2": {"ndcg_cut_10": 0.0, "recall_20": 1.0}, + } + scores = score_run( + {"q1": {"d": 1}}, + {"q1": {"d": 0.9}}, + ["nDCG@10", "Recall@20"], + evaluator_factory=_factory(per_query), + ) + assert isinstance(scores, MetricScores) + assert scores.per_query["nDCG@10"] == {"q1": 1.0, "q2": 0.0} + assert scores.aggregated["nDCG@10"] == 0.5 + assert scores.aggregated["Recall@20"] == 0.75 + + +def test_score_run_rejects_unknown_metrics(): + with pytest.raises(ValueError, match="unknown metrics"): + score_run({}, {}, ["nDCG@5"], evaluator_factory=_factory({})) + + +def test_score_run_empty_run_aggregates_to_zero(): + scores = score_run( + {"q1": {"d": 1}}, {"q1": {"d": 0.1}}, ["MRR@10"], evaluator_factory=_factory({}) + ) + assert scores.aggregated["MRR@10"] == 0.0 diff --git a/tests/benchmark/test_bench_manifest.py b/tests/benchmark/test_bench_manifest.py new file mode 100644 index 000000000..9b5d0784e --- /dev/null +++ b/tests/benchmark/test_bench_manifest.py @@ -0,0 +1,90 @@ +"""Manifest validation, the judge-not-generator guard, and freeze round-trip.""" + +from pathlib import Path + +import pytest + +from evals.benchmark.manifest import Manifest + +EXAMPLE = Path(__file__).resolve().parents[2] / "evals" / "benchmark" / "manifest.example.yaml" + + +def _manifest_dict(**overrides): + data = { + "run_id": "r1", + "models": { + "embedder": "qwen3-embedding", + "generator": "qwen2.5-72b", + "judge": "fable-5", + }, + "arms": [ + {"name": "a", "system": "lilbee", "description": "d"}, + {"name": "b", "system": "ragflow", "description": "d"}, + ], + "datasets": [{"name": "scifact", "loader": "scifact", "label_kind": "native"}], + "metrics": ["nDCG@10"], + } + data.update(overrides) + return data + + +def test_from_dict_accepts_a_well_formed_manifest(): + manifest = Manifest.from_dict(_manifest_dict()) + assert manifest.run_id == "r1" + assert manifest.temperature == 0.0 + + +def test_judge_must_differ_from_generator(): + models = {"embedder": "e", "generator": "same", "judge": "same"} + with pytest.raises(ValueError, match="judge model must differ"): + Manifest.from_dict(_manifest_dict(models=models)) + + +def test_requires_exactly_two_arms(): + arms = [{"name": "a", "system": "lilbee", "description": "d"}] + with pytest.raises(ValueError, match="exactly two arms"): + Manifest.from_dict(_manifest_dict(arms=arms)) + + +def test_arms_must_be_one_lilbee_one_ragflow(): + arms = [ + {"name": "a", "system": "lilbee", "description": "d"}, + {"name": "b", "system": "lilbee", "description": "d"}, + ] + with pytest.raises(ValueError, match="one lilbee and one ragflow"): + Manifest.from_dict(_manifest_dict(arms=arms)) + + +def test_nonzero_temperature_is_rejected(): + with pytest.raises(ValueError, match="temperature must be"): + Manifest.from_dict(_manifest_dict(temperature=0.7)) + + +def test_unknown_label_kind_is_rejected(): + datasets = [{"name": "x", "loader": "x", "label_kind": "guessed"}] + with pytest.raises(ValueError, match="unknown label_kind"): + Manifest.from_dict(_manifest_dict(datasets=datasets)) + + +def test_derived_datasets_are_listed(): + datasets = [ + {"name": "scifact", "loader": "scifact", "label_kind": "native"}, + {"name": "tat-dqa", "loader": "tatdqa", "label_kind": "derived"}, + ] + manifest = Manifest.from_dict(_manifest_dict(datasets=datasets)) + assert manifest.derived_datasets == ["tat-dqa"] + + +def test_freeze_writes_a_stable_fingerprint(tmp_path): + manifest = Manifest.from_dict(_manifest_dict()) + out = tmp_path / "frozen.json" + fingerprint = manifest.freeze(out) + assert fingerprint == manifest.fingerprint() + assert f'"fingerprint": "{fingerprint}"' in out.read_text() + + +def test_example_manifest_loads_and_validates(): + manifest = Manifest.load(EXAMPLE) + assert manifest.models.judge != manifest.models.generator + assert "tat-dqa" in manifest.derived_datasets + assert manifest.metrics == ["nDCG@10", "Recall@20", "MRR@10"] diff --git a/tests/benchmark/test_bench_report.py b/tests/benchmark/test_bench_report.py new file mode 100644 index 000000000..bdb287c86 --- /dev/null +++ b/tests/benchmark/test_bench_report.py @@ -0,0 +1,71 @@ +"""Markdown rendering of Tier-1, Tier-2, and the coverage matrix.""" + +import pytest + +from evals.benchmark.report import render_report + + +def _ir_row(metric, mean_a, mean_b, ci_low, ci_high, significant, p=0.01): + return { + "row_type": "ir", + "dataset": "scifact", + "metric": metric, + "mean_a": mean_a, + "mean_b": mean_b, + "mean_diff": round(mean_b - mean_a, 4), + "ci_low": ci_low, + "ci_high": ci_high, + "p_value": p, + "significant": significant, + } + + +def test_report_leads_with_tier1_table_and_marks_significance(): + rows = [ + { + "row_type": "meta", + "run_id": "r1", + "fingerprint": "abcdef123456", + "arm_a": "lilbee", + "arm_b": "ragflow", + }, + _ir_row("nDCG@10", 0.60, 0.70, 0.05, 0.15, True), + _ir_row("Recall@20", 0.80, 0.79, -0.05, 0.03, False), + ] + report = render_report(rows) + assert report.index("Tier 1") < report.index("Tier 2") if "Tier 2" in report else True + assert "| scifact | nDCG@10 | 0.6000 | 0.7000 | +0.1000 |" in report + assert "(n.s.)" in report # the crossing-CI row is flagged + assert "Arm A = lilbee, arm B = ragflow" in report + + +def test_report_renders_ragas_and_judge_noise(): + rows = [ + _ir_row("nDCG@10", 0.6, 0.7, 0.05, 0.15, True), + {"row_type": "ragas", "metric": "faithfulness", "arm_a": 0.9, "arm_b": 0.85}, + {"row_type": "judge", "noise_floor": 0.12, "means": {}}, + ] + report = render_report(rows) + assert "Tier 2 - answer quality (RAGAS)" in report + assert "| faithfulness | 0.9000 | 0.8500 |" in report + assert "0.12 per dimension" in report + + +def test_report_marks_derived_qrel_datasets_in_coverage(): + rows = [ + _ir_row("nDCG@10", 0.6, 0.7, 0.05, 0.15, True), + { + "row_type": "coverage", + "feature": "table extraction", + "dataset": "tat-dqa", + "metric": "nDCG@10", + "derived": True, + }, + ] + report = render_report(rows) + assert "| table extraction | tat-dqa | nDCG@10 | derived |" in report + + +def test_report_requires_scored_rows(): + with pytest.raises(ValueError, match="no ir or ragas rows"): + render_report([{"row_type": "meta", "arm_a": "a", "arm_b": "b"}]) diff --git a/tests/benchmark/test_bench_runfile.py b/tests/benchmark/test_bench_runfile.py new file mode 100644 index 000000000..feb767a2b --- /dev/null +++ b/tests/benchmark/test_bench_runfile.py @@ -0,0 +1,54 @@ +"""TREC run-file round-trip and the chunk-to-document collapse.""" + +from evals.benchmark.runfile import ( + ChunkHit, + RunEntry, + collapse_hits, + read_run, + run_to_pytrec, + write_run, +) + + +def test_collapse_keeps_best_score_per_document_and_reranks(): + hits = [ + ChunkHit("q1", "docA", 0.2), + ChunkHit("q1", "docA", 0.9), # same doc, higher score wins + ChunkHit("q1", "docB", 0.5), + ] + entries = collapse_hits(hits, "tag") + assert [(e.doc_id, e.rank, e.score) for e in entries] == [ + ("docA", 1, 0.9), + ("docB", 2, 0.5), + ] + + +def test_collapse_breaks_score_ties_on_doc_id_deterministically(): + hits = [ChunkHit("q1", "docB", 0.5), ChunkHit("q1", "docA", 0.5)] + entries = collapse_hits(hits, "tag") + assert [e.doc_id for e in entries] == ["docA", "docB"] + + +def test_collapse_groups_by_query(): + hits = [ChunkHit("q2", "d", 0.1), ChunkHit("q1", "d", 0.1)] + entries = collapse_hits(hits, "tag") + assert sorted({e.query_id for e in entries}) == ["q1", "q2"] + + +def test_run_file_round_trips(tmp_path): + entries = collapse_hits([ChunkHit("q1", "docA", 0.9), ChunkHit("q1", "docB", 0.5)], "run7") + path = tmp_path / "run.trec" + write_run(path, entries) + line = path.read_text().splitlines()[0] + assert line == "q1 Q0 docA 1 0.900000 run7" + assert read_run(path) == entries + + +def test_from_line_parses_all_columns(): + entry = RunEntry.from_line("q9 Q0 doc42 3 1.500000 mytag") + assert entry == RunEntry("q9", "doc42", 3, 1.5, "mytag") + + +def test_run_to_pytrec_shapes_query_doc_score(): + entries = [RunEntry("q1", "d1", 1, 0.9, "t"), RunEntry("q1", "d2", 2, 0.4, "t")] + assert run_to_pytrec(entries) == {"q1": {"d1": 0.9, "d2": 0.4}} diff --git a/tests/benchmark/test_bench_stats.py b/tests/benchmark/test_bench_stats.py new file mode 100644 index 000000000..bc5ccf215 --- /dev/null +++ b/tests/benchmark/test_bench_stats.py @@ -0,0 +1,60 @@ +"""Deterministic paired statistics on known small inputs.""" + +from evals.benchmark.stats import _percentile, compare, paired_bootstrap_ci, permutation_test + + +def test_percentile_interpolates_between_neighbors(): + values = [0.0, 1.0, 2.0, 3.0, 4.0] + assert _percentile(values, 0.0) == 0.0 + assert _percentile(values, 1.0) == 4.0 + assert _percentile(values, 0.5) == 2.0 + + +def test_percentile_handles_short_lists(): + assert _percentile([], 0.5) == 0.0 + assert _percentile([7.0], 0.9) == 7.0 + + +def test_bootstrap_ci_is_seed_reproducible_and_positive_for_a_clear_gap(): + diffs = [1.0] * 20 + first = paired_bootstrap_ci(diffs, resamples=200, seed=1, alpha=0.05) + second = paired_bootstrap_ci(diffs, resamples=200, seed=1, alpha=0.05) + assert first == second # identical seed -> identical CI + assert first == (1.0, 1.0) # every resample of constant 1.0 has mean 1.0 + + +def test_permutation_p_is_one_when_there_is_no_difference(): + assert permutation_test([0.0, 0.0, 0.0], resamples=100, seed=3) == 1.0 + + +def test_permutation_p_is_small_for_a_consistent_gap(): + p = permutation_test([1.0] * 12, resamples=500, seed=3) + assert p < 0.05 + + +def test_compare_flags_a_clear_gap_significant(): + a = {f"q{i}": 0.0 for i in range(15)} + b = {f"q{i}": 1.0 for i in range(15)} + result = compare("nDCG@10", a, b, resamples=300, seed=7) + assert result.n == 15 + assert result.mean_diff == 1.0 + assert result.mean_a == 0.0 + assert result.mean_b == 1.0 + assert result.significant is True + assert result.p_value < 0.05 + + +def test_compare_flags_a_crossing_ci_not_significant(): + a = {"q0": 0.0, "q1": 1.0, "q2": 0.0, "q3": 1.0} + b = {"q0": 1.0, "q1": 0.0, "q2": 1.0, "q3": 0.0} # symmetric, mean diff 0 + result = compare("nDCG@10", a, b, resamples=300, seed=7) + assert result.mean_diff == 0.0 + assert result.significant is False + assert result.ci_low <= 0.0 <= result.ci_high + + +def test_compare_pairs_only_shared_query_ids(): + a = {"q0": 0.2, "q1": 0.4, "only_a": 1.0} + b = {"q0": 0.5, "q1": 0.9, "only_b": 0.0} + result = compare("Recall@20", a, b, resamples=100, seed=1) + assert result.n == 2 From 5e5ef9d58daa22902bea9d9742ee843232387b78 Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Fri, 17 Jul 2026 14:43:48 -0400 Subject: [PATCH 2/6] Track the benchmark requirements file past the blanket .txt ignore The repo .gitignore has a blanket *.txt rule, so evals/benchmark/requirements.txt was silently never committed and a fresh clone could not install the benchmark deps. Add a negation for it and commit the file. --- .gitignore | 3 +++ evals/benchmark/requirements.txt | 10 ++++++++++ 2 files changed, 13 insertions(+) create mode 100644 evals/benchmark/requirements.txt diff --git a/.gitignore b/.gitignore index 437a01498..16baf2fda 100644 --- a/.gitignore +++ b/.gitignore @@ -76,3 +76,6 @@ packaging/snap-compat/payload/ packaging/snap-cuda/payload/ # Built engine binaries land here during wheel/executable builds. packaging/engine-wheel/lilbee_engine/bin/ + +# The benchmark deps list is intentionally tracked despite the *.txt rule. +!evals/benchmark/requirements.txt diff --git a/evals/benchmark/requirements.txt b/evals/benchmark/requirements.txt new file mode 100644 index 000000000..9eac502c4 --- /dev/null +++ b/evals/benchmark/requirements.txt @@ -0,0 +1,10 @@ +# Heavy scorers and dataset loaders for the retrieval benchmark. Pod-only and +# research-only: imported lazily, never touched by the core package or the test +# suite, and deliberately kept OUT of the shipped lock so installing them cannot +# move a core dependency. Install on the benchmark pod with: +# uv pip install -r evals/benchmark/requirements.txt +# pytrec_eval-terrier is the maintained pytrec_eval fork; it imports as pytrec_eval. +pytrec_eval-terrier>=0.5.6 +ragas>=0.2 +beir>=2.0 +datasets>=2.16 From 6aedffb4c857ee1e5d2a62bbf5f24e0762514c53 Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Fri, 17 Jul 2026 21:59:04 -0400 Subject: [PATCH 3/6] Keep hybrid search alive when FTS optimize() fails on a large corpus ensure_fts_index() runs table.optimize() whenever the FTS index already exists. On a large corpus that call can hit a LanceDB encoding bug and raise (Arrow list offset overflow), and the failure fell through to leave _fts_ready False -- silently dropping every subsequent query to vector-only with no error surfaced. The index itself is complete and still serves queries, so mark hybrid ready before the best-effort optimize and downgrade an optimize() failure to a warning. Found while benchmarking retrieval: every hybrid config collapsed to the vector-only baseline until this was fixed. --- src/lilbee/data/store/core.py | 22 +++++++++++++++++----- tests/test_store.py | 18 ++++++++++++++++++ 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/src/lilbee/data/store/core.py b/src/lilbee/data/store/core.py index 8d7016292..c4e26cc6b 100644 --- a/src/lilbee/data/store/core.py +++ b/src/lilbee/data/store/core.py @@ -427,18 +427,30 @@ def ensure_fts_index(self) -> None: return try: if _has_fts_index(table): - # One optimize folds new rows into every index on the - # table, the title index included. - table.optimize() - log.debug("FTS index optimized on '%s'", CHUNKS_TABLE) + # The index exists and already serves queries, so mark hybrid + # ready BEFORE the optimize: optimize() only folds new rows and + # compacts, and on a large corpus it can hit a LanceDB encoding + # bug and raise. Letting that failure fall through would leave + # _fts_ready False and silently drop every query to vector-only. + self._fts_ready = True + try: + # One optimize folds new rows into every index on the + # table, the title index included. + table.optimize() + log.debug("FTS index optimized on '%s'", CHUNKS_TABLE) + except Exception: + log.warning( + "FTS optimize() failed; the existing index still serves hybrid search", + exc_info=True, + ) else: # with_position lets the lexical arm serve phrase queries; # raw user query text can reach LanceDB as a phrase, which # errors on a positionless index. table.create_fts_index("chunk", replace=False, with_position=True) + self._fts_ready = True log.debug("FTS index created on '%s'", CHUNKS_TABLE) self._ensure_title_fts_unlocked(table) - self._fts_ready = True except Exception: log.debug("FTS index ensure failed (empty table?)", exc_info=True) diff --git a/tests/test_store.py b/tests/test_store.py index 9523ed5b6..765531d9b 100644 --- a/tests/test_store.py +++ b/tests/test_store.py @@ -162,6 +162,24 @@ def test_second_call_optimizes_instead_of_rebuilding(self, store): create_spy.assert_not_called() optimize_spy.assert_called_once() + def test_optimize_failure_keeps_hybrid_ready(self, store): + """An optimize() crash on an already-built index (a LanceDB encoding + bug bites large corpora) must not disable hybrid search: the index + still serves queries, so _fts_ready stays True instead of silently + dropping every query to the vector-only fallback.""" + store.add_chunks(_make_records()) + store.ensure_fts_index() # builds the index + store._fts_ready = False # a fresh process is unaware the index exists yet + table = store.open_table("chunks") + assert table is not None + with mock.patch.object( + type(table), + "optimize", + side_effect=RuntimeError("lance list offset overflow"), + ): + store.ensure_fts_index() + assert store._fts_ready is True + def test_first_call_creates_without_replace(self, store): """Fresh table creates the chunk and title indexes, both with replace=False.""" store.add_chunks(_make_records()) From a0c2a96cb3b3880e62237ce44eae7ff76d6ed325 Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Fri, 17 Jul 2026 23:18:51 -0400 Subject: [PATCH 4/6] Add adaptive per-query fusion gated by vector-arm confidence The retrieval benchmark showed no single lexical_fusion_weight wins every corpus: SciFact wants a strong BM25 arm, NFCorpus a weak one, FiQA none. Rather than fix one weight, adaptive_fusion (off by default) scales the BM25 arm per query by how peaked the vector ranking is -- a top hit standing clear of the field downweights lexical toward zero, a flat ranking keeps it. adaptive_fusion_ margin sets the vector-similarity margin at which the lexical arm is fully silenced. lexical_fusion_weight becomes the ceiling the rule scales down from, so the default path is unchanged. --- docs/usage.md | 2 ++ src/lilbee/app/settings_map.py | 12 ++++++++ src/lilbee/core/config/model.py | 10 +++++++ src/lilbee/data/store/core.py | 13 ++++++-- src/lilbee/data/store/fusion.py | 35 ++++++++++++++++++++++ tests/test_store.py | 11 +++++++ tests/test_store_fusion.py | 53 ++++++++++++++++++++++++++++++++- 7 files changed, 132 insertions(+), 4 deletions(-) diff --git a/docs/usage.md b/docs/usage.md index 38ba9ed24..8fc15d4d4 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -751,6 +751,8 @@ something feels off. | `LILBEE_TITLE_SEARCH` | `false` | Match queries against document titles as a third hybrid-search arm, so a query naming a document by title surfaces its chunks | | `LILBEE_TITLE_SEARCH_WEIGHT` | `0.5` | Title arm weight in rank fusion (1.0 = equal voice with the vector and text arms) | | `LILBEE_LEXICAL_FUSION_WEIGHT` | `1.0` | BM25 arm weight in rank fusion (1.0 = equal to the vector arm; lower it when a strong embedder should dominate a corpus where the lexical arm adds noise) | +| `LILBEE_ADAPTIVE_FUSION` | `false` | Scale the BM25 arm's weight per query by how confident the vector arm is (a peaked dense ranking downweights lexical, a flat one keeps it) instead of using a fixed `LILBEE_LEXICAL_FUSION_WEIGHT`. That weight becomes the ceiling the adaptive rule scales down from | +| `LILBEE_ADAPTIVE_FUSION_MARGIN` | `0.3` | Vector-similarity margin (top hit minus the field) at which adaptive fusion fully silences the BM25 arm; smaller values downweight lexical more aggressively | | `LILBEE_ADAPTIVE_THRESHOLD` | `false` | Widen the distance threshold step by step when too few results pass, on the vector-only fallback path (no effect on the default hybrid search) | | `LILBEE_ADAPTIVE_THRESHOLD_STEP` | `0.2` | How much to widen per step when adaptive threshold triggers | | `LILBEE_TEMPORAL_FILTERING` | `true` | When the query contains temporal cues ("recent", "last week"), filter results by document date and sort by recency | diff --git a/src/lilbee/app/settings_map.py b/src/lilbee/app/settings_map.py index cb412ee99..487b1047a 100644 --- a/src/lilbee/app/settings_map.py +++ b/src/lilbee/app/settings_map.py @@ -862,6 +862,18 @@ def get_default(key: str) -> object: group=SettingGroup.RETRIEVAL, help_text="BM25 arm weight in fusion (1.0 = equal to vector; lower to favor dense)", ), + "adaptive_fusion": SettingDef( + bool, + nullable=False, + group=SettingGroup.RETRIEVAL, + help_text="Scale the BM25 weight per query by vector-arm confidence, not a fixed value", + ), + "adaptive_fusion_margin": SettingDef( + float, + nullable=False, + group=SettingGroup.RETRIEVAL, + help_text="Vector-similarity margin at which adaptive fusion fully silences the BM25 arm", + ), "history_rewrite": SettingDef( bool, nullable=False, diff --git a/src/lilbee/core/config/model.py b/src/lilbee/core/config/model.py index 4b521d3cf..74ddf75db 100644 --- a/src/lilbee/core/config/model.py +++ b/src/lilbee/core/config/model.py @@ -232,6 +232,16 @@ class Config(BaseSettings): # the retrieval benchmark, not guessed here. lexical_fusion_weight: float = ConfigField(default=1.0, ge=0.0, le=1.0, writable=True) + # Adaptive fusion: instead of a fixed lexical_fusion_weight, scale the BM25 + # arm per query by how confident the vector arm is (a peaked dense ranking + # downweights lexical, a flat one keeps it). The benchmark found no single + # fixed weight wins every corpus, so this gates the weight per query. Off by + # default; when on, lexical_fusion_weight is the ceiling the adaptive rule + # scales down from. adaptive_fusion_margin is the vector-similarity margin at + # which the lexical arm is fully silenced (smaller = more aggressive). + adaptive_fusion: bool = ConfigField(default=False, writable=True) + adaptive_fusion_margin: float = ConfigField(default=0.3, ge=0.0, le=2.0, writable=True) + # Chunk count at/above which sync builds an approximate (ANN) vector index # so search stays fast at millions of vectors. Below this, search uses exact # flat scan (faster and exact for small vaults). 0 disables the ANN index. diff --git a/src/lilbee/data/store/core.py b/src/lilbee/data/store/core.py index c4e26cc6b..b26f83c59 100644 --- a/src/lilbee/data/store/core.py +++ b/src/lilbee/data/store/core.py @@ -28,7 +28,7 @@ from lilbee.core.security import validate_path_within from lilbee.runtime.lock import LOCK_TIMEOUT, write_lock -from .fusion import fuse_arms, normalized_bm25, vector_similarity +from .fusion import adaptive_lexical_weight, fuse_arms, normalized_bm25, vector_similarity from .lance_helpers import ( _chunk_type_predicate, _has_fts_index, @@ -714,11 +714,18 @@ def _hybrid_search( title_rows: list[SearchChunk] = [] if self._config.title_search: title_rows = self._title_arm(table, query_text, top_k, chunk_type) + vector_rows = self._vector_arm(table, query_vector, top_k, chunk_type) + lexical_weight = self._config.lexical_fusion_weight + if self._config.adaptive_fusion: + # Gate the lexical arm per query by how peaked the vector ranking is. + lexical_weight = adaptive_lexical_weight( + vector_rows, lexical_weight, self._config.adaptive_fusion_margin + ) fused = fuse_arms( - self._vector_arm(table, query_vector, top_k, chunk_type), + vector_rows, self._fts_arm(table, query_text, top_k, chunk_type), title_rows, - lexical_weight=self._config.lexical_fusion_weight, + lexical_weight=lexical_weight, title_weight=self._config.title_search_weight, ) fused = _drop_unsupported_far_rows(fused, max_distance) diff --git a/src/lilbee/data/store/fusion.py b/src/lilbee/data/store/fusion.py index 8804a4a3f..727b6819a 100644 --- a/src/lilbee/data/store/fusion.py +++ b/src/lilbee/data/store/fusion.py @@ -26,17 +26,52 @@ from __future__ import annotations +from statistics import fmean + from .types import SearchChunk # Standard RRF smoothing constant (Cormack, Clarke & Buettcher 2009). _RRF_K = 60 +# Adaptive fusion needs a top hit plus at least one field row to measure a margin. +_MIN_ROWS_FOR_MARGIN = 2 + def vector_similarity(distance: float) -> float: """Cosine distance to canonical [0, 1] similarity (distance spans [0, 2]).""" return max(0.0, min(1.0, 1.0 - distance)) +def adaptive_lexical_weight( + vector_rows: list[SearchChunk], base_weight: float, margin_scale: float +) -> float: + """Shrink the lexical arm's weight toward zero when the vector arm is + confident about this query. + + A *peaked* vector ranking -- a top hit standing well clear of the field -- + means the dense embedder already located the answer and the lexical arm + mostly adds term-match noise (the FiQA case in the retrieval benchmark). A + *flat* ranking means dense is unsure and BM25's exact-term matching is worth + trusting (NFCorpus, SciFact). The confidence signal is the margin between + the top similarity and the mean of the rest, divided by *margin_scale*: at or + above that margin the lexical arm is fully silenced, at zero margin it keeps + its full *base_weight*, and it scales linearly between. Returns *base_weight* + unchanged when there is nothing to measure (fewer than two scored rows) or + the feature is disabled (*margin_scale* <= 0). + """ + if margin_scale <= 0: + return base_weight + sims = sorted( + (vector_similarity(r.distance) for r in vector_rows if r.distance is not None), + reverse=True, + ) + if len(sims) < _MIN_ROWS_FOR_MARGIN: + return base_weight + margin = max(0.0, sims[0] - fmean(sims[1:])) + confidence = min(1.0, margin / margin_scale) + return base_weight * (1.0 - confidence) + + def normalized_bm25(scores: list[float]) -> list[float]: """Scale raw BM25 scores against the list maximum, into (0, 1]. diff --git a/tests/test_store.py b/tests/test_store.py index 765531d9b..1a432dfc4 100644 --- a/tests/test_store.py +++ b/tests/test_store.py @@ -644,6 +644,17 @@ def test_hybrid_search_with_fts_index(self, store, test_config): scores = [r.score for r in results] assert all(0.0 <= s <= 1.0 for s in scores) + def test_adaptive_fusion_gates_the_hybrid_search(self, store, test_config): + """With adaptive_fusion on, hybrid search derives the lexical weight per + query from the vector arm instead of the fixed config value.""" + test_config.adaptive_fusion = True + store.add_chunks(_make_records()) + store.ensure_fts_index() + query_vec = [0.5] * test_config.embedding_dim + results = store.search(query_vec, top_k=3, query_text="chunk number") + assert len(results) > 0 + assert all(r.score is not None and 0.0 <= r.score <= 1.0 for r in results) + def test_fallback_to_vector_when_no_query_text(self, store, test_config): records = _make_records() store.add_chunks(records) diff --git a/tests/test_store_fusion.py b/tests/test_store_fusion.py index ac3c352dc..15762bf5b 100644 --- a/tests/test_store_fusion.py +++ b/tests/test_store_fusion.py @@ -3,7 +3,12 @@ import pytest from lilbee.data.store import SearchChunk -from lilbee.data.store.fusion import fuse_arms, normalized_bm25, vector_similarity +from lilbee.data.store.fusion import ( + adaptive_lexical_weight, + fuse_arms, + normalized_bm25, + vector_similarity, +) def _chunk(source, idx, *, distance=None, bm25=None, dim=4): @@ -68,6 +73,52 @@ def test_lexical_only_row_survives_with_score(self): assert lexical_row.score == pytest.approx(0.5) +class TestAdaptiveLexicalWeight: + """Per-query lexical weight gated by the vector arm's confidence.""" + + def test_peaked_dense_silences_lexical(self): + # top similarity 1.0 (distance 0), field ~0.3: a wide margin => weight ~0. + rows = [_chunk("a.md", 0, distance=0.0)] + [ + _chunk("b.md", i, distance=0.7) for i in range(1, 5) + ] + assert adaptive_lexical_weight(rows, 1.0, 0.3) == pytest.approx(0.0) + + def test_flat_dense_keeps_full_weight(self): + # every row equally similar: zero margin => the arm keeps base_weight. + rows = [_chunk("a.md", i, distance=0.5) for i in range(5)] + assert adaptive_lexical_weight(rows, 1.0, 0.3) == pytest.approx(1.0) + + def test_scales_linearly_between(self): + # top sim 0.6, field 0.3, margin 0.3, scale 0.6 => confidence 0.5 => half. + rows = [_chunk("a.md", 0, distance=0.4)] + [ + _chunk("b.md", i, distance=0.7) for i in range(1, 4) + ] + assert adaptive_lexical_weight(rows, 1.0, 0.6) == pytest.approx(0.5) + + def test_respects_base_weight(self): + rows = [_chunk("a.md", i, distance=0.5) for i in range(3)] + assert adaptive_lexical_weight(rows, 0.5, 0.3) == pytest.approx(0.5) + + def test_too_few_rows_returns_base(self): + assert adaptive_lexical_weight([_chunk("a.md", 0, distance=0.1)], 1.0, 0.3) == 1.0 + assert adaptive_lexical_weight([], 1.0, 0.3) == 1.0 + + def test_non_positive_margin_scale_disables(self): + rows = [_chunk("a.md", 0, distance=0.0), _chunk("b.md", 1, distance=0.9)] + assert adaptive_lexical_weight(rows, 1.0, 0.0) == 1.0 + + def test_ignores_rows_without_distance(self): + # lexical-only rows carry no distance; they must not enter the signal. + rows = [ + _chunk("a.md", 0, distance=0.0), + _chunk("b.md", 1, distance=0.6), + _chunk("c.md", 2, bm25=9.0), + ] + both = adaptive_lexical_weight(rows, 1.0, 0.4) + two = adaptive_lexical_weight(rows[:2], 1.0, 0.4) + assert both == pytest.approx(two) + + class TestLexicalFusionWeight: """The BM25 arm's fusion weight can be lowered so a strong dense arm dominates.""" From 5d6b5451e9b3151993b4f12bcd5aa8d65cd5b8f3 Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Fri, 17 Jul 2026 23:19:00 -0400 Subject: [PATCH 5/6] Record the Qwen3-0.6B retrieval benchmark results Significance-tested nDCG@10/Recall@20/MRR@10 for hybrid fusion vs the vector-only baseline on BEIR SciFact, NFCorpus, and FiQA, with the frozen manifest, gzipped TREC run files, and qrels for independent re-scoring. Hybrid significantly beats dense on NFCorpus and SciFact and significantly regresses on FiQA; the corpus-dependent optimal weight is what motivates adaptive fusion. --- evals/benchmark/RESULTS.md | 87 ++++++++++++++++++ evals/benchmark/results/fiqa/ir-dense.jsonl | 1 + evals/benchmark/results/fiqa/ir-w0.25.jsonl | 1 + evals/benchmark/results/fiqa/ir-w0.5.jsonl | 1 + evals/benchmark/results/fiqa/ir-w0.75.jsonl | 1 + evals/benchmark/results/fiqa/ir-w1.0.jsonl | 1 + evals/benchmark/results/fiqa/qrels.json | 1 + .../benchmark/results/fiqa/run-dense.trec.gz | Bin 0 -> 86810 bytes .../benchmark/results/fiqa/run-w0.25.trec.gz | Bin 0 -> 99696 bytes evals/benchmark/results/fiqa/run-w0.5.trec.gz | Bin 0 -> 99259 bytes .../benchmark/results/fiqa/run-w0.75.trec.gz | Bin 0 -> 100059 bytes evals/benchmark/results/fiqa/run-w1.0.trec.gz | Bin 0 -> 97142 bytes .../results/fiqa/stats-w0.25-vs-dense.jsonl | 4 + .../results/fiqa/stats-w0.5-vs-dense.jsonl | 4 + .../results/fiqa/stats-w0.75-vs-dense.jsonl | 4 + .../results/fiqa/stats-w1.0-vs-dense.jsonl | 4 + evals/benchmark/results/manifest.frozen.json | 87 ++++++++++++++++++ .../benchmark/results/nfcorpus/ir-dense.jsonl | 1 + .../benchmark/results/nfcorpus/ir-w0.25.jsonl | 1 + .../benchmark/results/nfcorpus/ir-w0.5.jsonl | 1 + .../benchmark/results/nfcorpus/ir-w0.75.jsonl | 1 + .../benchmark/results/nfcorpus/ir-w1.0.jsonl | 1 + evals/benchmark/results/nfcorpus/qrels.json | 1 + .../results/nfcorpus/run-dense.trec.gz | Bin 0 -> 33018 bytes .../results/nfcorpus/run-w0.25.trec.gz | Bin 0 -> 39337 bytes .../results/nfcorpus/run-w0.5.trec.gz | Bin 0 -> 39114 bytes .../results/nfcorpus/run-w0.75.trec.gz | Bin 0 -> 39571 bytes .../results/nfcorpus/run-w1.0.trec.gz | Bin 0 -> 39369 bytes .../nfcorpus/stats-w0.25-vs-dense.jsonl | 4 + .../nfcorpus/stats-w0.5-vs-dense.jsonl | 4 + .../nfcorpus/stats-w0.75-vs-dense.jsonl | 4 + .../nfcorpus/stats-w1.0-vs-dense.jsonl | 4 + .../benchmark/results/scifact/ir-dense.jsonl | 1 + .../benchmark/results/scifact/ir-w0.25.jsonl | 1 + evals/benchmark/results/scifact/ir-w0.5.jsonl | 1 + .../benchmark/results/scifact/ir-w0.75.jsonl | 1 + evals/benchmark/results/scifact/ir-w1.0.jsonl | 1 + evals/benchmark/results/scifact/qrels.json | 1 + .../results/scifact/run-dense.trec.gz | Bin 0 -> 40643 bytes .../results/scifact/run-w0.25.trec.gz | Bin 0 -> 45630 bytes .../results/scifact/run-w0.5.trec.gz | Bin 0 -> 45551 bytes .../results/scifact/run-w0.75.trec.gz | Bin 0 -> 45742 bytes .../results/scifact/run-w1.0.trec.gz | Bin 0 -> 46252 bytes .../scifact/stats-w0.25-vs-dense.jsonl | 4 + .../results/scifact/stats-w0.5-vs-dense.jsonl | 4 + .../scifact/stats-w0.75-vs-dense.jsonl | 4 + .../results/scifact/stats-w1.0-vs-dense.jsonl | 4 + 47 files changed, 240 insertions(+) create mode 100644 evals/benchmark/RESULTS.md create mode 100644 evals/benchmark/results/fiqa/ir-dense.jsonl create mode 100644 evals/benchmark/results/fiqa/ir-w0.25.jsonl create mode 100644 evals/benchmark/results/fiqa/ir-w0.5.jsonl create mode 100644 evals/benchmark/results/fiqa/ir-w0.75.jsonl create mode 100644 evals/benchmark/results/fiqa/ir-w1.0.jsonl create mode 100644 evals/benchmark/results/fiqa/qrels.json create mode 100644 evals/benchmark/results/fiqa/run-dense.trec.gz create mode 100644 evals/benchmark/results/fiqa/run-w0.25.trec.gz create mode 100644 evals/benchmark/results/fiqa/run-w0.5.trec.gz create mode 100644 evals/benchmark/results/fiqa/run-w0.75.trec.gz create mode 100644 evals/benchmark/results/fiqa/run-w1.0.trec.gz create mode 100644 evals/benchmark/results/fiqa/stats-w0.25-vs-dense.jsonl create mode 100644 evals/benchmark/results/fiqa/stats-w0.5-vs-dense.jsonl create mode 100644 evals/benchmark/results/fiqa/stats-w0.75-vs-dense.jsonl create mode 100644 evals/benchmark/results/fiqa/stats-w1.0-vs-dense.jsonl create mode 100644 evals/benchmark/results/manifest.frozen.json create mode 100644 evals/benchmark/results/nfcorpus/ir-dense.jsonl create mode 100644 evals/benchmark/results/nfcorpus/ir-w0.25.jsonl create mode 100644 evals/benchmark/results/nfcorpus/ir-w0.5.jsonl create mode 100644 evals/benchmark/results/nfcorpus/ir-w0.75.jsonl create mode 100644 evals/benchmark/results/nfcorpus/ir-w1.0.jsonl create mode 100644 evals/benchmark/results/nfcorpus/qrels.json create mode 100644 evals/benchmark/results/nfcorpus/run-dense.trec.gz create mode 100644 evals/benchmark/results/nfcorpus/run-w0.25.trec.gz create mode 100644 evals/benchmark/results/nfcorpus/run-w0.5.trec.gz create mode 100644 evals/benchmark/results/nfcorpus/run-w0.75.trec.gz create mode 100644 evals/benchmark/results/nfcorpus/run-w1.0.trec.gz create mode 100644 evals/benchmark/results/nfcorpus/stats-w0.25-vs-dense.jsonl create mode 100644 evals/benchmark/results/nfcorpus/stats-w0.5-vs-dense.jsonl create mode 100644 evals/benchmark/results/nfcorpus/stats-w0.75-vs-dense.jsonl create mode 100644 evals/benchmark/results/nfcorpus/stats-w1.0-vs-dense.jsonl create mode 100644 evals/benchmark/results/scifact/ir-dense.jsonl create mode 100644 evals/benchmark/results/scifact/ir-w0.25.jsonl create mode 100644 evals/benchmark/results/scifact/ir-w0.5.jsonl create mode 100644 evals/benchmark/results/scifact/ir-w0.75.jsonl create mode 100644 evals/benchmark/results/scifact/ir-w1.0.jsonl create mode 100644 evals/benchmark/results/scifact/qrels.json create mode 100644 evals/benchmark/results/scifact/run-dense.trec.gz create mode 100644 evals/benchmark/results/scifact/run-w0.25.trec.gz create mode 100644 evals/benchmark/results/scifact/run-w0.5.trec.gz create mode 100644 evals/benchmark/results/scifact/run-w0.75.trec.gz create mode 100644 evals/benchmark/results/scifact/run-w1.0.trec.gz create mode 100644 evals/benchmark/results/scifact/stats-w0.25-vs-dense.jsonl create mode 100644 evals/benchmark/results/scifact/stats-w0.5-vs-dense.jsonl create mode 100644 evals/benchmark/results/scifact/stats-w0.75-vs-dense.jsonl create mode 100644 evals/benchmark/results/scifact/stats-w1.0-vs-dense.jsonl diff --git a/evals/benchmark/RESULTS.md b/evals/benchmark/RESULTS.md new file mode 100644 index 000000000..963546318 --- /dev/null +++ b/evals/benchmark/RESULTS.md @@ -0,0 +1,87 @@ +# Retrieval benchmark results — Qwen3-Embedding-0.6B + +A significance-tested measurement of lilbee's hybrid retrieval against its own +vector-only baseline on three public, human-labeled BEIR datasets. The point of +this run is to answer two questions with evidence, not opinion: does lilbee's +rank fusion actually improve retrieval over the raw embedder, and is a single +fusion weight the right design. + +## Method + +- **Embedder:** Qwen3-Embedding-0.6B (GGUF, Q8_0), served once; every arm points + at the same model, so retrieval is the only variable. +- **Datasets:** BEIR SciFact, NFCorpus, FiQA, using their published TREC qrels + as-is. No labels were derived or altered. +- **Metrics:** nDCG@10, Recall@20, MRR@10, scored with `pytrec_eval` against the + native qrels. Nothing is graded by a model, so the numbers are reproducible by + anyone with the run files and qrels. +- **Arms:** `dense` is vector-only (the lexical and title arms silenced); + `w=X` is hybrid fusion with the BM25 arm at `lexical_fusion_weight=X` and the + title arm on. This isolates what fusion adds over the embedder alone. +- **Significance:** every hybrid-vs-dense difference is paired per query and gets + a bootstrap 95% CI and a randomization-test p-value. A difference whose CI + crosses zero is reported as not significant, not as a win. +- **Condition:** query expansion was off (no chat model served), so these are + pure first-pass retrieval numbers with no LLM query rewriting on either arm. + +## Results (nDCG@10) + +| Dataset | dense | w=1.0 | w=0.75 | w=0.5 | w=0.25 | +|---|---|---|---|---|---| +| NFCorpus (n=322) | 0.3666 | 0.3734 | 0.3743 | 0.3756 | **0.3767** | +| SciFact (n=300) | 0.6981 | **0.7280** | 0.7226 | 0.7167 | 0.7155 | +| FiQA (n=648) | **0.4598** | 0.4033 | 0.4289 | 0.4333 | 0.4363 | + +## Significance (best hybrid weight vs. dense, nDCG@10) + +| Dataset | best hybrid | Δ vs dense | 95% CI | p | verdict | +|---|---|---|---|---|---| +| NFCorpus | w=0.25 | **+0.0100** | [+0.0022, +0.0180] | 0.012 | significant win | +| SciFact | w=1.0 | **+0.0299** | [+0.0073, +0.0528] | 0.011 | significant win | +| FiQA | w=0.25 | **−0.0235** | [−0.0356, −0.0118] | 0.0004 | significant regression | + +On FiQA every hybrid weight loses to dense (w=1.0 is worst at −0.0564, p=0.0001); +lowering the weight reduces the damage but never recovers it. On NFCorpus the +win is only significant at lower weights (w=1.0 is +0.0068, p=0.21, not +significant). On SciFact every weight wins, and higher is better. + +## What this establishes + +1. **Hybrid fusion adds real, significant value on two of three corpora** — once + it actually runs (see the bug below). This is the raw embedder plus lilbee's + fusion beating the raw embedder alone, measured, not asserted. +2. **No single fixed fusion weight wins everywhere.** SciFact wants a strong + lexical arm (w=1.0), NFCorpus wants a weak one (w=0.25), and FiQA wants none. + The optimal weight is corpus-dependent, which is the empirical case for + gating the lexical weight per query rather than fixing it — the adaptive + fusion this run motivates. + +## The bug this run caught + +Before any of these numbers meant anything, every hybrid config scored +identically to the vector-only baseline. The cause was a production defect, not +a benchmark artifact: `ensure_fts_index()` runs `table.optimize()` on an +existing index, which on a real-sized corpus hits a LanceDB encoding bug and +raises; the failure was swallowed and left hybrid search disabled, so every +query silently fell back to vector-only. It only surfaced on real data — a +tiny local corpus never tripped the LanceDB bug. Fixed by marking an existing, +queryable index ready before the best-effort optimize, so an optimize failure +degrades to a warning instead of disabling retrieval corpus-wide. + +## Reproducing + +The frozen manifest, the TREC run files, and the qrels are kept under +`results/`. With those, anyone can re-score Tier 1 without a GPU: + +```bash +gunzip -k results/scifact/run-w1.0.trec.gz +python -m evals.benchmark score-ir --qrels results/scifact/qrels.json \ + --run results/scifact/run-w1.0.trec --dataset scifact --run-tag w1.0 --out /tmp/ir.jsonl +``` + +## Scope + +This is the 0.6B-embedder study: it validates the fusion mechanism and the +FTS-optimize fix, and it sizes the corpus-dependence of the lexical weight. It +is deliberately not a headline "lilbee vs. everyone" number — a larger embedder +and the RAGFlow A/B arm are separate runs. diff --git a/evals/benchmark/results/fiqa/ir-dense.jsonl b/evals/benchmark/results/fiqa/ir-dense.jsonl new file mode 100644 index 000000000..d1ccf288b --- /dev/null +++ b/evals/benchmark/results/fiqa/ir-dense.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "dense", "aggregated": {"nDCG@10": 0.4598, "Recall@20": 0.6186, "MRR@10": 0.5448}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 1.0, "18": 0.6309297535714575, "26": 0.3065735963827292, "34": 0.0, "42": 0.46927872602275644, "56": 0.6309297535714575, "68": 0.0, "89": 0.32228364030009987, "90": 1.0, "94": 1.0, "98": 0.6131471927654584, "104": 0.6131471927654584, "106": 0.6309297535714575, "109": 1.0, "475": 1.0, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 0.0, "585": 0.38685280723454163, "588": 0.44130740935663865, "594": 0.6131471927654584, "603": 0.0, "604": 0.34870224750355494, "620": 0.10209739512291163, "622": 0.6131471927654584, "659": 0.5263304097820353, "672": 0.18457569677956817, "684": 0.0, "687": 0.21840743681816419, "689": 0.0, "691": 0.43067655807339306, "699": 0.6309297535714575, "701": 0.13565197343244778, "715": 0.0, "721": 1.0, "744": 0.23463936301137822, "750": 0.8315546295836225, "753": 0.38685280723454163, "766": 0.20210734650054757, "776": 0.4690000933206748, "810": 0.43067655807339306, "813": 0.23719771276929622, "849": 0.2890648263178879, "852": 0.7653606369886217, "853": 0.21840743681816419, "858": 0.0, "859": 0.6131471927654584, "864": 0.7149394488115768, "879": 0.6309297535714575, "885": 0.23719771276929622, "895": 1.0, "904": 1.0, "928": 0.6131471927654584, "929": 1.0, "932": 0.23719771276929622, "939": 1.0, "945": 0.6309297535714575, "957": 0.6713860725233041, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.3065735963827292, "1150": 0.0, "1157": 0.3065735963827292, "1159": 0.0, "1198": 0.6309297535714575, "1230": 0.0, "1281": 1.0, "1284": 1.0, "1297": 0.5, "1306": 0.0, "1309": 0.5205067333228022, "1310": 1.0, "1321": 0.0, "1322": 0.3903800499921017, "1391": 0.20210734650054757, "1393": 0.5493640533376876, "1415": 0.9178287402913377, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 0.6309297535714575, "1530": 0.7461976723150332, "1670": 0.7653606369886217, "1676": 0.4693608375942211, "1736": 0.5087403079104241, "1748": 0.43734888382569426, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.4034698846650846, "1824": 0.43067655807339306, "1826": 0.9828920819566879, "1832": 0.3562071871080222, "1871": 0.7246262544989281, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 0.43067655807339306, "1994": 0.0, "2010": 0.9469024295259745, "2051": 0.0, "2070": 0.0, "2075": 0.5716213154129578, "2076": 1.0, "2088": 0.0, "2108": 0.20210734650054757, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.7526136409516659, "2204": 0.8984972075197749, "2264": 0.18457569677956817, "2296": 0.38334277998463445, "2306": 0.38685280723454163, "2316": 0.8772153153380493, "2318": 0.6309297535714575, "2330": 0.6131471927654584, "2334": 0.46927872602275644, "2348": 0.37185395737611554, "2376": 0.9830168297915423, "2383": 0.6131471927654584, "2384": 1.0, "2385": 0.6131471927654584, "2388": 1.0, "2395": 0.5, "2398": 0.10699313236726378, "2399": 1.0, "2400": 0.6049306994552042, "2407": 0.15101961822780524, "2416": 0.8838242945899706, "2423": 0.5422491080636984, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.5, "2513": 0.0, "2516": 0.6366824387328317, "2549": 0.6131471927654584, "2551": 1.0, "2568": 0.3615901614084106, "2579": 0.22485174766247445, "2580": 0.46927872602275644, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.9217868789962071, "2598": 0.9197207891481876, "2648": 1.0, "2676": 1.0, "2685": 0.35079429740281753, "2695": 1.0, "2713": 0.0, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 0.8315546295836225, "2790": 0.49959580689988364, "2801": 0.6131471927654584, "2856": 0.5716190970674814, "2857": 0.4202024810692814, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.3562071871080222, "2923": 0.7972541056822071, "2964": 0.0, "2968": 1.0, "2994": 0.46927872602275644, "3006": 0.26836379988737025, "3008": 0.3903800499921017, "3014": 1.0, "3033": 0.6131471927654584, "3039": 0.3333333333333333, "3049": 0.6366824387328317, "3051": 1.0, "3067": 0.0, "3085": 0.21840743681816419, "3091": 0.8936633189697701, "3103": 1.0, "3115": 0.4329261794091841, "3125": 1.0, "3148": 0.4703652827859579, "3149": 0.0, "3177": 0.14126697285982898, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.7039180890341347, "3264": 0.8048099750039491, "3357": 0.6309297535714575, "3369": 0.09109240322345806, "3394": 0.787702056960637, "3404": 0.3932591258696538, "3405": 1.0, "3446": 0.46704774694449785, "3451": 0.07945707943276742, "3453": 0.6240505200038379, "3480": 1.0, "3490": 0.3333333333333333, "3500": 0.5889837127672154, "3503": 0.6891341765546151, "3512": 1.0, "3528": 1.0, "3530": 0.6508205185601091, "3534": 0.0, "3566": 0.8194270280062366, "3569": 0.0, "3594": 0.13905617951077562, "3612": 0.11751610475642714, "3615": 0.5912352048230277, "3625": 0.46927872602275644, "3682": 0.38685280723454163, "3683": 0.7021799053685303, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.20210734650054757, "3759": 0.0, "3767": 0.45221360703148816, "3771": 0.4935232796777481, "3781": 0.8772153153380493, "3789": 0.787702056960637, "3791": 0.431733884398313, "3801": 0.0, "3822": 0.0, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.6489315753318465, "3932": 0.0, "3934": 0.11751610475642714, "3995": 0.0, "4007": 0.6364391809889587, "4011": 0.9674679834891693, "4019": 0.4412576003965278, "4031": 0.0, "4037": 0.21840743681816419, "4047": 0.8048099750039491, "4071": 0.0, "4084": 0.9197207891481876, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.5143371794949736, "4153": 0.38685280723454163, "4179": 0.0, "4188": 0.0, "4205": 0.36926780146674987, "4233": 0.8539316501572937, "4265": 0.7751482523375255, "4286": 0.6131471927654584, "4289": 0.6131471927654584, "4306": 0.7246262544989281, "4312": 0.6370339733570289, "4335": 0.8318724637288826, "4339": 1.0, "4394": 0.0, "4409": 0.31488013066763093, "4411": 0.46927872602275644, "4414": 0.9197207891481876, "4415": 0.0, "4433": 0.21840743681816419, "4447": 0.31546487678572877, "4464": 1.0, "4465": 0.23463936301137822, "4484": 1.0, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.48553456068968903, "4523": 0.21398626473452756, "4539": 0.3065735963827292, "4571": 0.7653606369886217, "4600": 1.0, "4605": 0.6773676006644395, "4615": 0.5889556853481906, "4640": 0.0, "4641": 0.5531464700081437, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.7598336331031966, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.3065735963827292, "4813": 1.0, "4823": 0.46927872602275644, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.7653606369886217, "4846": 0.0, "4863": 0.6508205185601091, "4865": 0.0, "4920": 1.0, "4942": 0.3333333333333333, "4946": 1.0, "4955": 0.0, "4962": 0.6131471927654584, "4968": 0.38685280723454163, "4981": 0.6508205185601091, "4999": 0.5855700749881525, "5021": 0.0, "5030": 0.0, "5045": 0.31546487678572877, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.3333333333333333, "5080": 0.0, "5083": 0.6131471927654584, "5085": 1.0, "5086": 1.0, "5090": 0.6131471927654584, "5125": 1.0, "5134": 0.6131471927654584, "5150": 0.0, "5155": 0.5, "5172": 0.18457569677956817, "5178": 0.5087403079104241, "5185": 0.0, "5196": 0.46927872602275644, "5206": 0.0, "5228": 0.5, "5231": 0.0, "5241": 0.44615333764087994, "5254": 0.6131471927654584, "5255": 1.0, "5264": 0.7227265726449519, "5271": 0.38268031849431083, "5331": 1.0, "5343": 0.3333333333333333, "5347": 1.0, "5356": 0.14606834984270645, "5369": 0.0, "5374": 0.31546487678572877, "5380": 1.0, "5402": 0.0, "5410": 0.46927872602275644, "5422": 0.35914753008966527, "5427": 0.38685280723454163, "5460": 0.0, "5464": 0.2960819109658652, "5503": 0.6131471927654584, "5505": 1.0, "5511": 0.1610425878239398, "5534": 0.38685280723454163, "5549": 0.0, "5585": 0.6309297535714575, "5592": 1.0, "5616": 0.43067655807339306, "5620": 0.0, "5646": 0.9674679834891693, "5653": 1.0, "5683": 0.6934264036172708, "5710": 0.0, "5741": 0.0, "5763": 0.13565197343244778, "5782": 0.4371994911049732, "5790": 0.0, "5808": 0.5, "5853": 0.1821658288910461, "5862": 0.32531670832675136, "5888": 0.19342640361727081, "5903": 0.0, "5906": 0.39564672360221187, "5940": 0.0, "5951": 0.43426773552878023, "5970": 0.2960819109658652, "5981": 1.0, "5993": 0.22009176629808017, "6002": 0.8630152897016883, "6004": 0.0, "6005": 0.40350157154648025, "6009": 0.31546487678572877, "6041": 0.6366824387328317, "6080": 0.6131471927654584, "6110": 0.3475406804124244, "6121": 0.6131471927654584, "6122": 0.46927872602275644, "6131": 0.6235744328990731, "6133": 0.38685280723454163, "6142": 0.6131471927654584, "6146": 1.0, "6199": 0.3764290720714305, "6219": 0.6934264036172708, "6221": 0.0, "6252": 0.0, "6262": 0.7653606369886217, "6278": 0.36181498356361597, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.3010299956639812, "6467": 0.0, "6468": 0.6131471927654584, "6479": 1.0, "6525": 0.4632423659320675, "6554": 0.17723928678404774, "6562": 0.123151194370365, "6611": 0.6131471927654584, "6612": 0.46927872602275644, "6625": 0.31546487678572877, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8772153153380493, "6679": 0.5307212739772434, "6683": 0.5249810332008933, "6713": 0.6131471927654584, "6715": 0.3065735963827292, "6746": 0.6131471927654584, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.5413996682199069, "6807": 1.0, "6814": 0.0, "6832": 0.6052602440527057, "6835": 0.38685280723454163, "6849": 0.3333333333333333, "6862": 1.0, "6867": 0.2558209594125084, "6875": 0.0, "6890": 1.0, "6891": 0.6364391809889587, "6896": 0.0, "6901": 0.3065735963827292, "6907": 0.0, "6909": 0.0, "6959": 0.38685280723454163, "6985": 1.0, "7017": 0.0, "7068": 0.5706417189553201, "7071": 0.0, "7080": 0.6509209298071326, "7096": 0.6309297535714575, "7098": 0.38685280723454163, "7105": 0.5, "7109": 0.15642624200758548, "7124": 0.7246262544989281, "7141": 0.0, "7145": 0.20210734650054757, "7178": 1.0, "7188": 0.38685280723454163, "7205": 1.0, "7206": 0.0, "7218": 0.43067655807339306, "7221": 0.0, "7269": 0.0, "7279": 0.502373740777944, "7295": 0.0, "7311": 0.2890648263178879, "7326": 0.0, "7329": 0.38685280723454163, "7344": 0.6131471927654584, "7345": 0.15642624200758548, "7377": 1.0, "7431": 0.0, "7441": 0.18154179253735267, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.16958010263680806, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.20210734650054757, "7529": 0.6131471927654584, "7533": 0.17723928678404774, "7534": 0.46927872602275644, "7590": 0.9197207891481876, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.13905617951077562, "7702": 0.6240505200038379, "7705": 0.6049306994552042, "7734": 0.6131471927654584, "7747": 0.17723928678404774, "7754": 0.6309297535714575, "7758": 1.0, "7801": 0.8315546295836225, "7803": 0.0, "7823": 0.7039180890341347, "7876": 0.5, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.30260241349881345, "7928": 0.0, "7936": 0.6508205185601091, "7992": 0.23719771276929622, "8002": 0.6257049680303419, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.3333333333333333, "8040": 1.0, "8072": 0.617319681505689, "8079": 0.8451850618939637, "8102": 0.13012668333070054, "8116": 0.5, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.6131471927654584, "8275": 0.0, "8296": 0.9197207891481876, "8332": 0.9469024295259745, "8351": 0.6131471927654584, "8378": 0.16716045496620227, "8456": 0.617319681505689, "8475": 0.8104616303452685, "8507": 0.0, "8512": 0.6309297535714575, "8513": 0.0, "8532": 0.7988614740430418, "8537": 0.5, "8539": 0.11284514134893527, "8544": 0.6131471927654584, "8592": 0.20210734650054757, "8632": 0.3065735963827292, "8635": 0.0, "8702": 0.6713860725233041, "8779": 0.448643819352159, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.0, "8934": 0.8772153153380493, "8937": 0.6309297535714575, "8947": 0.6131471927654584, "8959": 0.3010299956639812, "8970": 0.6934264036172708, "8974": 0.35079429740281753, "8982": 0.0, "9060": 0.21840743681816419, "9088": 0.0, "9108": 0.0, "9115": 0.6653497124326151, "9126": 0.0, "9164": 0.1480409554829326, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.38685280723454163, "9329": 0.8065735963827293, "9332": 0.43067655807339306, "9381": 0.6934264036172708, "9385": 1.0, "9391": 0.75369761125927, "9403": 0.0, "9481": 0.5706417189553201, "9487": 0.38685280723454163, "9548": 0.43067655807339306, "9556": 1.0, "9565": 1.0, "9598": 0.5, "9617": 0.6364391809889587, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.43067655807339306, "9646": 0.5109559939712153, "9668": 0.5307212739772434, "9701": 0.0, "9733": 0.23463936301137822, "9735": 0.0, "9737": 0.7653606369886217, "9771": 0.0, "9808": 0.14126697285982898, "9824": 1.0, "9871": 0.0, "9882": 0.0, "9925": 0.8175295903539445, "9929": 0.8065735963827293, "9961": 0.0, "9979": 0.5078961547485289, "10034": 0.6131471927654584, "10039": 1.0, "10109": 0.5306972923267992, "10122": 0.0, "10136": 0.38268031849431083, "10137": 0.38685280723454163, "10152": 1.0, "10183": 0.3065735963827292, "10213": 0.15642624200758548, "10246": 0.0, "10267": 0.0, "10414": 0.9197207891481876, "10447": 0.16716045496620227, "10462": 0.0, "10482": 0.0, "10497": 0.494639655562801, "10526": 0.2640681225725909, "10547": 0.0, "10558": 0.0, "10596": 0.9318171001351273, "10601": 0.5, "10628": 0.3562071871080222, "10639": 0.3120255505658846, "10645": 0.5109559939712153, "10674": 0.8048099750039491, "10710": 0.5, "10734": 0.7751482523375255, "10792": 0.8503449055347546, "10808": 0.5374517914100283, "10809": 0.4441228664487979, "10812": 0.7365896932159578, "10827": 0.3391602052736161, "10845": 1.0, "10912": 0.3010299956639812, "10932": 1.0, "10975": 0.0, "10979": 0.5855700749881525, "10994": 0.5, "11039": 0.38391202314388534, "11054": 1.0, "11088": 0.5}, "Recall@20": {"8": 0.5, "15": 1.0, "18": 1.0, "26": 0.5, "34": 0.0, "42": 0.3333333333333333, "56": 1.0, "68": 0.0, "89": 0.5, "90": 1.0, "94": 1.0, "98": 0.5, "104": 0.5, "106": 1.0, "109": 1.0, "475": 1.0, "503": 1.0, "504": 0.3333333333333333, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 1.0, "585": 0.5, "588": 1.0, "594": 1.0, "603": 0.0, "604": 1.0, "620": 0.2, "622": 0.5, "659": 0.7, "672": 0.5, "684": 1.0, "687": 0.5, "689": 0.0, "691": 1.0, "699": 1.0, "701": 0.3333333333333333, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.3333333333333333, "776": 0.25, "810": 1.0, "813": 1.0, "849": 1.0, "852": 0.6666666666666666, "853": 0.5, "858": 0.0, "859": 0.5, "864": 0.6666666666666666, "879": 1.0, "885": 0.5, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.5, "939": 1.0, "945": 1.0, "957": 0.6666666666666666, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.5, "1150": 0.0, "1157": 0.5, "1159": 0.0, "1198": 1.0, "1230": 1.0, "1281": 1.0, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.75, "1310": 1.0, "1321": 0.0, "1322": 0.25, "1391": 0.6666666666666666, "1393": 0.5, "1415": 1.0, "1416": 1.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 1.0, "1670": 0.6666666666666666, "1676": 1.0, "1736": 0.4, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 1.0, "1826": 1.0, "1832": 1.0, "1871": 0.75, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.4, "2010": 1.0, "2051": 1.0, "2070": 0.6666666666666666, "2075": 0.6666666666666666, "2076": 1.0, "2088": 0.0, "2108": 0.3333333333333333, "2118": 0.0, "2154": 0.0, "2181": 0.5, "2183": 0.8333333333333334, "2204": 1.0, "2264": 0.5, "2296": 0.2222222222222222, "2306": 0.5, "2316": 1.0, "2318": 1.0, "2330": 0.5, "2334": 0.6666666666666666, "2348": 0.26666666666666666, "2376": 1.0, "2383": 0.5, "2384": 1.0, "2385": 0.5, "2388": 1.0, "2395": 1.0, "2398": 0.2, "2399": 1.0, "2400": 0.6666666666666666, "2407": 0.5, "2416": 1.0, "2423": 0.8571428571428571, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.3333333333333333, "2472": 0.0, "2486": 1.0, "2498": 1.0, "2513": 1.0, "2516": 0.75, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.5, "2580": 0.3333333333333333, "2587": 1.0, "2589": 0.6666666666666666, "2590": 0.6666666666666666, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 0.25, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 0.42857142857142855, "2801": 1.0, "2856": 0.75, "2857": 0.75, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 1.0, "2923": 0.8, "2964": 0.5, "2968": 1.0, "2994": 0.3333333333333333, "3006": 0.5, "3008": 0.25, "3014": 1.0, "3033": 0.5, "3039": 1.0, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 1.0, "3091": 0.8571428571428571, "3103": 1.0, "3115": 0.5, "3125": 1.0, "3148": 0.6, "3149": 0.0, "3177": 0.6666666666666666, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.6666666666666666, "3264": 0.75, "3357": 1.0, "3369": 0.16666666666666666, "3394": 0.75, "3404": 0.42857142857142855, "3405": 1.0, "3446": 0.8, "3451": 0.42857142857142855, "3453": 1.0, "3480": 1.0, "3490": 1.0, "3500": 0.5, "3503": 0.7142857142857143, "3512": 1.0, "3528": 1.0, "3530": 0.6666666666666666, "3534": 0.0, "3566": 1.0, "3569": 1.0, "3594": 0.25, "3612": 0.75, "3615": 1.0, "3625": 0.3333333333333333, "3682": 1.0, "3683": 0.6666666666666666, "3694": 0.5, "3724": 0.0, "3735": 1.0, "3759": 0.0, "3767": 0.4, "3771": 0.3333333333333333, "3781": 1.0, "3789": 0.75, "3791": 0.6666666666666666, "3801": 0.0, "3822": 0.25, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 0.6666666666666666, "4011": 1.0, "4019": 0.4, "4031": 0.0, "4037": 0.5, "4047": 0.75, "4071": 0.0, "4084": 1.0, "4102": 0.25, "4103": 0.0, "4105": 0.0, "4116": 0.5, "4125": 0.0, "4142": 0.75, "4153": 1.0, "4179": 1.0, "4188": 1.0, "4205": 0.6666666666666666, "4233": 0.8, "4265": 0.6666666666666666, "4286": 0.5, "4289": 0.5, "4306": 0.75, "4312": 0.8571428571428571, "4335": 0.75, "4339": 1.0, "4394": 0.0, "4409": 0.2, "4411": 0.6666666666666666, "4414": 1.0, "4415": 0.0, "4433": 0.5, "4447": 1.0, "4464": 1.0, "4465": 0.6666666666666666, "4484": 1.0, "4499": 0.3333333333333333, "4500": 0.5, "4504": 1.0, "4514": 0.5, "4523": 0.2, "4539": 0.5, "4571": 0.6666666666666666, "4600": 1.0, "4605": 0.7142857142857143, "4615": 0.6666666666666666, "4640": 0.0, "4641": 0.6, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.6666666666666666, "4846": 0.0, "4863": 1.0, "4865": 0.0, "4920": 1.0, "4942": 1.0, "4946": 1.0, "4955": 0.0, "4962": 0.5, "4968": 1.0, "4981": 0.6666666666666666, "4999": 0.75, "5021": 0.0, "5030": 0.0, "5045": 1.0, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 1.0, "5080": 0.0, "5083": 0.5, "5085": 1.0, "5086": 1.0, "5090": 0.5, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 1.0, "5178": 0.4, "5185": 0.0, "5196": 0.3333333333333333, "5206": 0.0, "5228": 1.0, "5231": 1.0, "5241": 0.4, "5254": 0.5, "5255": 1.0, "5264": 0.6, "5271": 1.0, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.4, "5369": 0.0, "5374": 1.0, "5380": 1.0, "5402": 0.5, "5410": 0.3333333333333333, "5422": 0.75, "5427": 0.5, "5460": 0.0, "5464": 0.3333333333333333, "5503": 0.5, "5505": 1.0, "5511": 0.3, "5534": 0.5, "5549": 0.0, "5585": 1.0, "5592": 1.0, "5616": 1.0, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.5, "5763": 0.6666666666666666, "5782": 0.4, "5790": 0.0, "5808": 1.0, "5853": 0.375, "5862": 0.5, "5888": 0.5, "5903": 0.0, "5906": 1.0, "5940": 0.0, "5951": 0.5555555555555556, "5970": 0.6666666666666666, "5981": 1.0, "5993": 0.2, "6002": 0.9090909090909091, "6004": 0.0, "6005": 0.38461538461538464, "6009": 1.0, "6041": 0.75, "6080": 0.5, "6110": 0.375, "6121": 0.5, "6122": 0.3333333333333333, "6131": 0.4166666666666667, "6133": 0.5, "6142": 0.5, "6146": 1.0, "6199": 0.5, "6219": 1.0, "6221": 0.125, "6252": 0.0, "6262": 0.6666666666666666, "6278": 1.0, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 1.0, "6467": 0.0, "6468": 0.5, "6479": 1.0, "6525": 0.6666666666666666, "6554": 0.5, "6562": 0.5, "6611": 1.0, "6612": 0.3333333333333333, "6625": 1.0, "6629": 0.0, "6635": 0.5, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 1.0, "6683": 1.0, "6713": 0.5, "6715": 1.0, "6746": 0.5, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.75, "6807": 1.0, "6814": 0.0, "6832": 1.0, "6835": 0.5, "6849": 1.0, "6862": 1.0, "6867": 0.42857142857142855, "6875": 0.0, "6890": 1.0, "6891": 0.6666666666666666, "6896": 0.0, "6901": 0.5, "6907": 0.0, "6909": 0.0, "6959": 1.0, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 1.0, "7109": 0.6666666666666666, "7124": 0.75, "7141": 0.5, "7145": 0.3333333333333333, "7178": 1.0, "7188": 1.0, "7205": 1.0, "7206": 0.0, "7218": 1.0, "7221": 0.0, "7269": 1.0, "7279": 0.75, "7295": 0.0, "7311": 1.0, "7326": 0.0, "7329": 1.0, "7344": 0.5, "7345": 0.6666666666666666, "7377": 1.0, "7431": 0.0, "7441": 0.3333333333333333, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.4, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 1.0, "7513": 0.6666666666666666, "7529": 0.5, "7533": 0.5, "7534": 0.3333333333333333, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.5, "7674": 0.3333333333333333, "7700": 0.25, "7702": 1.0, "7705": 0.6666666666666666, "7734": 0.5, "7747": 0.5, "7754": 1.0, "7758": 1.0, "7801": 1.0, "7803": 0.5, "7823": 0.6666666666666666, "7876": 1.0, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.16666666666666666, "7928": 0.25, "7936": 0.6666666666666666, "7992": 1.0, "8002": 0.6666666666666666, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 1.0, "8040": 1.0, "8072": 0.6666666666666666, "8079": 1.0, "8102": 0.25, "8116": 1.0, "8121": 1.0, "8202": 0.0, "8230": 1.0, "8247": 0.0, "8271": 0.5, "8275": 1.0, "8296": 1.0, "8332": 1.0, "8351": 0.5, "8378": 0.3333333333333333, "8456": 0.6666666666666666, "8475": 0.8571428571428571, "8507": 0.3333333333333333, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 1.0, "8539": 0.25, "8544": 0.5, "8592": 0.6666666666666666, "8632": 1.0, "8635": 0.0, "8702": 0.6666666666666666, "8779": 1.0, "8789": 0.6666666666666666, "8795": 1.0, "8832": 1.0, "8834": 0.5, "8855": 0.0, "8874": 1.0, "8934": 1.0, "8937": 1.0, "8947": 0.5, "8959": 1.0, "8970": 1.0, "8974": 0.25, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 1.0, "9126": 0.0, "9164": 0.3333333333333333, "9174": 0.2, "9188": 0.5, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 1.0, "9381": 1.0, "9385": 1.0, "9391": 0.75, "9403": 0.0, "9481": 1.0, "9487": 1.0, "9548": 1.0, "9556": 1.0, "9565": 1.0, "9598": 1.0, "9617": 0.6666666666666666, "9633": 0.5, "9643": 1.0, "9644": 1.0, "9646": 1.0, "9668": 1.0, "9701": 0.0, "9733": 0.3333333333333333, "9735": 1.0, "9737": 0.6666666666666666, "9771": 0.0, "9808": 0.3333333333333333, "9824": 1.0, "9871": 0.25, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 0.5, "10034": 0.5, "10039": 1.0, "10109": 0.42857142857142855, "10122": 0.5, "10136": 0.6666666666666666, "10137": 1.0, "10152": 1.0, "10183": 1.0, "10213": 0.3333333333333333, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.3333333333333333, "10462": 0.0, "10482": 0.0, "10497": 0.7, "10526": 0.5, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 1.0, "10639": 0.4, "10645": 1.0, "10674": 1.0, "10710": 1.0, "10734": 1.0, "10792": 1.0, "10808": 1.0, "10809": 0.6666666666666666, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 1.0, "10932": 1.0, "10975": 0.0, "10979": 0.75, "10994": 1.0, "11039": 0.5, "11054": 1.0, "11088": 1.0}, "MRR@10": {"8": 1.0, "15": 1.0, "18": 0.5, "26": 0.3333333333333333, "34": 0.0, "42": 1.0, "56": 0.5, "68": 0.0, "89": 0.25, "90": 1.0, "94": 1.0, "98": 1.0, "104": 1.0, "106": 0.5, "109": 1.0, "475": 1.0, "503": 0.08333333333333333, "504": 0.05555555555555555, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 0.06666666666666667, "585": 0.5, "588": 0.25, "594": 1.0, "603": 0.0, "604": 0.2, "620": 0.1111111111111111, "622": 1.0, "659": 1.0, "672": 0.1111111111111111, "684": 0.0625, "687": 0.16666666666666666, "689": 0.0, "691": 0.25, "699": 0.5, "701": 0.1, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.25, "776": 1.0, "810": 0.25, "813": 0.2, "849": 0.1, "852": 1.0, "853": 0.16666666666666666, "858": 0.0, "859": 1.0, "864": 1.0, "879": 0.5, "885": 0.2, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.2, "939": 1.0, "945": 0.5, "957": 1.0, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.3333333333333333, "1150": 0.0, "1157": 0.3333333333333333, "1159": 0.0, "1198": 0.5, "1230": 0.07692307692307693, "1281": 1.0, "1284": 1.0, "1297": 0.3333333333333333, "1306": 0.0, "1309": 1.0, "1310": 1.0, "1321": 0.0, "1322": 1.0, "1391": 0.25, "1393": 1.0, "1415": 1.0, "1416": 0.058823529411764705, "1441": 1.0, "1451": 1.0, "1469": 0.5, "1530": 1.0, "1670": 1.0, "1676": 0.3333333333333333, "1736": 1.0, "1748": 0.5, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 1.0, "1824": 0.25, "1826": 1.0, "1832": 0.16666666666666666, "1871": 1.0, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 0.25, "1994": 0.058823529411764705, "2010": 1.0, "2051": 0.07692307692307693, "2070": 0.09090909090909091, "2075": 1.0, "2076": 1.0, "2088": 0.0, "2108": 0.25, "2118": 0.0, "2154": 0.0, "2181": 0.058823529411764705, "2183": 1.0, "2204": 1.0, "2264": 0.1111111111111111, "2296": 1.0, "2306": 0.5, "2316": 1.0, "2318": 0.5, "2330": 1.0, "2334": 1.0, "2348": 1.0, "2376": 1.0, "2383": 1.0, "2384": 1.0, "2385": 1.0, "2388": 1.0, "2395": 0.3333333333333333, "2398": 0.125, "2399": 1.0, "2400": 1.0, "2407": 0.2, "2416": 1.0, "2423": 1.0, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.06666666666666667, "2472": 0.0, "2486": 1.0, "2498": 0.3333333333333333, "2513": 0.0625, "2516": 1.0, "2549": 1.0, "2551": 1.0, "2568": 1.0, "2579": 0.2, "2580": 1.0, "2587": 1.0, "2589": 1.0, "2590": 1.0, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 1.0, "2695": 1.0, "2713": 0.08333333333333333, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 1.0, "2801": 1.0, "2856": 0.5, "2857": 0.2, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.16666666666666666, "2923": 1.0, "2964": 0.09090909090909091, "2968": 1.0, "2994": 1.0, "3006": 0.3333333333333333, "3008": 1.0, "3014": 1.0, "3033": 1.0, "3039": 0.14285714285714285, "3049": 1.0, "3051": 1.0, "3067": 0.0, "3085": 0.16666666666666666, "3091": 1.0, "3103": 1.0, "3115": 1.0, "3125": 1.0, "3148": 1.0, "3149": 0.0, "3177": 0.1111111111111111, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 1.0, "3264": 1.0, "3357": 0.5, "3369": 0.1111111111111111, "3394": 1.0, "3404": 1.0, "3405": 1.0, "3446": 0.5, "3451": 0.1, "3453": 0.5, "3480": 1.0, "3490": 0.14285714285714285, "3500": 1.0, "3503": 1.0, "3512": 1.0, "3528": 1.0, "3530": 1.0, "3534": 0.0, "3566": 1.0, "3569": 0.07692307692307693, "3594": 0.16666666666666666, "3612": 0.1111111111111111, "3615": 0.5, "3625": 1.0, "3682": 0.5, "3683": 1.0, "3694": 1.0, "3724": 0.0, "3735": 0.25, "3759": 0.0, "3767": 1.0, "3771": 1.0, "3781": 1.0, "3789": 1.0, "3791": 0.5, "3801": 0.0, "3822": 0.05263157894736842, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 1.0, "3932": 0.0, "3934": 0.1111111111111111, "3995": 0.0, "4007": 1.0, "4011": 1.0, "4019": 1.0, "4031": 0.0, "4037": 0.16666666666666666, "4047": 1.0, "4071": 0.0, "4084": 1.0, "4102": 0.06666666666666667, "4103": 0.0, "4105": 0.0, "4116": 1.0, "4125": 0.0, "4142": 0.3333333333333333, "4153": 0.2, "4179": 0.09090909090909091, "4188": 0.06666666666666667, "4205": 0.25, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 1.0, "4306": 1.0, "4312": 1.0, "4335": 1.0, "4339": 1.0, "4394": 0.0, "4409": 1.0, "4411": 1.0, "4414": 1.0, "4415": 0.0, "4433": 0.16666666666666666, "4447": 0.125, "4464": 1.0, "4465": 0.3333333333333333, "4484": 1.0, "4499": 0.05555555555555555, "4500": 0.07142857142857142, "4504": 1.0, "4514": 1.0, "4523": 0.5, "4539": 0.3333333333333333, "4571": 1.0, "4600": 1.0, "4605": 1.0, "4615": 1.0, "4640": 0.0, "4641": 1.0, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 1.0, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.3333333333333333, "4813": 1.0, "4823": 1.0, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 1.0, "4846": 0.0, "4863": 1.0, "4865": 0.0, "4920": 1.0, "4942": 0.14285714285714285, "4946": 1.0, "4955": 0.0, "4962": 1.0, "4968": 0.2, "4981": 1.0, "4999": 1.0, "5021": 0.0, "5030": 0.0, "5045": 0.125, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.14285714285714285, "5080": 0.0, "5083": 1.0, "5085": 1.0, "5086": 1.0, "5090": 1.0, "5125": 1.0, "5134": 1.0, "5150": 0.0, "5155": 0.3333333333333333, "5172": 0.1111111111111111, "5178": 1.0, "5185": 0.0, "5196": 1.0, "5206": 0.0, "5228": 0.3333333333333333, "5231": 0.058823529411764705, "5241": 1.0, "5254": 1.0, "5255": 1.0, "5264": 1.0, "5271": 0.3333333333333333, "5331": 1.0, "5343": 0.14285714285714285, "5347": 1.0, "5356": 0.25, "5369": 0.0, "5374": 0.125, "5380": 1.0, "5402": 0.0625, "5410": 1.0, "5422": 0.5, "5427": 0.5, "5460": 0.0, "5464": 0.5, "5503": 1.0, "5505": 1.0, "5511": 0.25, "5534": 0.5, "5549": 0.0, "5585": 0.5, "5592": 1.0, "5616": 0.25, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 0.5, "5710": 0.0, "5741": 0.07692307692307693, "5763": 0.1, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.2, "5862": 0.3333333333333333, "5888": 0.125, "5903": 0.0, "5906": 0.16666666666666666, "5940": 0.0, "5951": 0.3333333333333333, "5970": 0.5, "5981": 1.0, "5993": 1.0, "6002": 1.0, "6004": 0.0, "6005": 1.0, "6009": 0.125, "6041": 1.0, "6080": 1.0, "6110": 0.5, "6121": 1.0, "6122": 1.0, "6131": 1.0, "6133": 0.5, "6142": 1.0, "6146": 1.0, "6199": 0.5, "6219": 0.5, "6221": 0.05263157894736842, "6252": 0.0, "6262": 1.0, "6278": 0.1111111111111111, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.1111111111111111, "6467": 0.0, "6468": 1.0, "6479": 1.0, "6525": 0.5, "6554": 0.1, "6562": 0.125, "6611": 1.0, "6612": 1.0, "6625": 0.125, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 0.3333333333333333, "6713": 1.0, "6715": 0.3333333333333333, "6746": 1.0, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.5, "6835": 0.5, "6849": 0.14285714285714285, "6862": 1.0, "6867": 0.3333333333333333, "6875": 0.0, "6890": 1.0, "6891": 1.0, "6896": 0.0, "6901": 0.3333333333333333, "6907": 0.0, "6909": 0.0, "6959": 0.5, "6985": 1.0, "7017": 0.0, "7068": 0.3333333333333333, "7071": 0.0, "7080": 0.5, "7096": 0.5, "7098": 0.5, "7105": 0.3333333333333333, "7109": 0.14285714285714285, "7124": 1.0, "7141": 0.0625, "7145": 0.25, "7178": 1.0, "7188": 0.2, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.09090909090909091, "7279": 0.3333333333333333, "7295": 0.0, "7311": 0.1, "7326": 0.0, "7329": 0.5, "7344": 1.0, "7345": 0.14285714285714285, "7377": 1.0, "7431": 0.0, "7441": 0.2, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.3333333333333333, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 0.0625, "7513": 0.25, "7529": 1.0, "7533": 0.1, "7534": 1.0, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 1.0, "7674": 0.0625, "7700": 0.16666666666666666, "7702": 0.5, "7705": 1.0, "7734": 1.0, "7747": 0.1, "7754": 0.5, "7758": 1.0, "7801": 1.0, "7803": 0.08333333333333333, "7823": 1.0, "7876": 0.3333333333333333, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 1.0, "7928": 0.05263157894736842, "7936": 1.0, "7992": 0.2, "8002": 1.0, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.14285714285714285, "8040": 1.0, "8072": 1.0, "8079": 1.0, "8102": 0.14285714285714285, "8116": 0.3333333333333333, "8121": 1.0, "8202": 0.0, "8230": 0.0625, "8247": 0.0, "8271": 1.0, "8275": 0.05555555555555555, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.16666666666666666, "8456": 1.0, "8475": 1.0, "8507": 0.09090909090909091, "8512": 0.5, "8513": 0.0, "8532": 1.0, "8537": 0.3333333333333333, "8539": 0.1, "8544": 1.0, "8592": 0.25, "8632": 0.3333333333333333, "8635": 0.0, "8702": 1.0, "8779": 0.25, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.07142857142857142, "8934": 1.0, "8937": 0.5, "8947": 1.0, "8959": 0.1111111111111111, "8970": 0.5, "8974": 1.0, "8982": 0.0, "9060": 0.16666666666666666, "9088": 0.0, "9108": 0.0, "9115": 0.5, "9126": 0.0, "9164": 0.125, "9174": 0.07692307692307693, "9188": 1.0, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 0.25, "9381": 0.5, "9385": 1.0, "9391": 1.0, "9403": 0.0, "9481": 0.3333333333333333, "9487": 0.2, "9548": 0.25, "9556": 1.0, "9565": 1.0, "9598": 0.3333333333333333, "9617": 1.0, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.25, "9646": 0.3333333333333333, "9668": 0.5, "9701": 0.0, "9733": 0.3333333333333333, "9735": 0.09090909090909091, "9737": 1.0, "9771": 0.0, "9808": 0.1111111111111111, "9824": 1.0, "9871": 0.05555555555555555, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 1.0, "10034": 1.0, "10039": 1.0, "10109": 1.0, "10122": 0.07692307692307693, "10136": 0.3333333333333333, "10137": 0.2, "10152": 1.0, "10183": 0.3333333333333333, "10213": 0.14285714285714285, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.16666666666666666, "10462": 0.0, "10482": 0.0, "10497": 1.0, "10526": 0.25, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 0.3333333333333333, "10628": 0.16666666666666666, "10639": 0.5, "10645": 0.3333333333333333, "10674": 1.0, "10710": 0.3333333333333333, "10734": 1.0, "10792": 1.0, "10808": 0.3333333333333333, "10809": 0.5, "10812": 1.0, "10827": 1.0, "10845": 1.0, "10912": 0.1111111111111111, "10932": 1.0, "10975": 0.0, "10979": 1.0, "10994": 0.3333333333333333, "11039": 0.5, "11054": 1.0, "11088": 0.3333333333333333}}} diff --git a/evals/benchmark/results/fiqa/ir-w0.25.jsonl b/evals/benchmark/results/fiqa/ir-w0.25.jsonl new file mode 100644 index 000000000..51cdab0c1 --- /dev/null +++ b/evals/benchmark/results/fiqa/ir-w0.25.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "w0.25", "aggregated": {"nDCG@10": 0.4363, "Recall@20": 0.6186, "MRR@10": 0.5093}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 0.3562071871080222, "18": 1.0, "26": 0.23719771276929622, "34": 0.0, "42": 0.46927872602275644, "56": 0.38685280723454163, "68": 0.0, "89": 0.286381299268402, "90": 0.6309297535714575, "94": 1.0, "98": 0.6131471927654584, "104": 0.6131471927654584, "106": 0.5, "109": 1.0, "475": 1.0, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.3562071871080222, "559": 0.0, "570": 0.0, "585": 0.2640681225725909, "588": 0.448643819352159, "594": 0.6131471927654584, "603": 0.0, "604": 0.3235866969737877, "620": 0.0, "622": 0.38685280723454163, "659": 0.44793214080335986, "672": 0.0, "684": 0.0, "687": 0.19342640361727081, "689": 0.0, "691": 0.6309297535714575, "699": 1.0, "701": 0.13565197343244778, "715": 0.0, "721": 1.0, "744": 0.18154179253735267, "750": 0.8503449055347546, "753": 0.38685280723454163, "766": 0.18154179253735267, "776": 0.3557772116892465, "810": 0.3333333333333333, "813": 0.20438239758848611, "849": 0.3333333333333333, "852": 0.7653606369886217, "853": 0.0, "858": 0.0, "859": 0.38685280723454163, "864": 0.7247145167543899, "879": 0.6309297535714575, "885": 0.19342640361727081, "895": 1.0, "904": 1.0, "928": 0.6131471927654584, "929": 1.0, "932": 0.3065735963827292, "939": 1.0, "945": 0.31546487678572877, "957": 0.7653606369886217, "988": 0.0, "1074": 0.6309297535714575, "1085": 0.0, "1090": 0.23719771276929622, "1150": 0.0, "1157": 0.6131471927654584, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 0.38685280723454163, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.7030861797445797, "1310": 1.0, "1321": 0.0, "1322": 0.24630238874073, "1391": 0.18154179253735267, "1393": 0.30260241349881345, "1415": 0.9438661545147249, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.431733884398313, "1670": 0.7653606369886217, "1676": 0.3853585682515056, "1736": 0.5531464700081437, "1748": 0.6049306994552042, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.286381299268402, "1824": 0.31546487678572877, "1826": 1.0, "1832": 0.5, "1871": 0.6984152163370878, "1877": 1.0, "1889": 0.0, "1915": 0.8772153153380493, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.21398626473452756, "2010": 0.8519590445170673, "2051": 0.0, "2070": 0.16716045496620227, "2075": 0.40129869165981646, "2076": 0.5706417189553201, "2088": 0.0, "2108": 0.16716045496620227, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.7526136409516659, "2204": 0.9830168297915423, "2264": 0.3065735963827292, "2296": 0.33627415762678553, "2306": 0.6131471927654584, "2316": 1.0, "2318": 0.31546487678572877, "2330": 0.6131471927654584, "2334": 0.46927872602275644, "2348": 0.43231813227099475, "2376": 0.9021484053648395, "2383": 0.6131471927654584, "2384": 1.0, "2385": 0.6131471927654584, "2388": 1.0, "2395": 1.0, "2398": 0.0, "2399": 1.0, "2400": 0.5307212739772434, "2407": 0.19519002499605084, "2416": 0.9058653015743079, "2423": 0.3576223542196109, "2443": 0.0, "2445": 1.0, "2460": 0.9469024295259745, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.43067655807339306, "2513": 0.0, "2516": 0.5585075862632192, "2549": 0.6131471927654584, "2551": 1.0, "2568": 0.25288473642100684, "2579": 0.28201326940239274, "2580": 0.46927872602275644, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.8854598815714874, "2598": 0.8503449055347546, "2648": 1.0, "2676": 0.6309297535714575, "2685": 0.35079429740281753, "2695": 1.0, "2713": 0.38685280723454163, "2724": 0.8315546295836225, "2737": 1.0, "2747": 0.5, "2749": 0.8772153153380493, "2790": 0.499028327865556, "2801": 0.6131471927654584, "2856": 0.7095272044910244, "2857": 0.5154852515822061, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.3010299956639812, "2923": 0.8207658584763088, "2964": 0.0, "2968": 0.8772153153380493, "2994": 0.46927872602275644, "3006": 0.25909036127391766, "3008": 0.24630238874073, "3014": 1.0, "3033": 0.6131471927654584, "3039": 0.38685280723454163, "3049": 0.24630238874073, "3051": 1.0, "3067": 0.0, "3085": 0.19342640361727081, "3091": 0.9020870746500321, "3103": 1.0, "3115": 0.4935232796777481, "3125": 1.0, "3148": 0.5531464700081437, "3149": 0.0, "3177": 0.15642624200758548, "3179": 0.8772153153380493, "3186": 1.0, "3189": 0.0, "3254": 0.6713860725233041, "3264": 0.8048099750039491, "3357": 1.0, "3369": 0.0, "3394": 0.5805485932475565, "3404": 0.3932591258696538, "3405": 0.2890648263178879, "3446": 0.46704774694449785, "3451": 0.07945707943276742, "3453": 0.6509209298071326, "3480": 1.0, "3490": 0.2890648263178879, "3500": 0.644824486427155, "3503": 0.6183313187362977, "3512": 0.8772153153380493, "3528": 0.6309297535714575, "3530": 0.4776237035032179, "3534": 0.0, "3566": 0.8194270280062366, "3569": 0.5, "3594": 0.123151194370365, "3612": 0.11751610475642714, "3615": 0.5, "3625": 0.20210734650054757, "3682": 0.21840743681816419, "3683": 0.6324677375730864, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.0, "3759": 0.0, "3767": 0.2716774977597197, "3771": 0.19632790425573848, "3781": 0.8772153153380493, "3789": 0.8048099750039491, "3791": 0.431733884398313, "3801": 0.0, "3822": 0.0, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5670429581667766, "3932": 0.0, "3934": 0.16812753627111746, "3995": 0.0, "4007": 0.7039180890341347, "4011": 0.9674679834891693, "4019": 0.31608365985743925, "4031": 0.0, "4037": 0.18457569677956817, "4047": 0.8318724637288826, "4071": 0.0, "4084": 0.5012658353418871, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.39233405721184117, "4153": 0.31546487678572877, "4179": 0.6309297535714575, "4188": 0.0, "4205": 0.4525081529734507, "4233": 0.8687949224876582, "4265": 0.7751482523375255, "4286": 0.6131471927654584, "4289": 0.23719771276929622, "4306": 0.7598336331031966, "4312": 0.7237478018511487, "4335": 0.8318724637288826, "4339": 1.0, "4394": 0.0, "4409": 0.19518900079066107, "4411": 0.46927872602275644, "4414": 0.8315546295836225, "4415": 0.0, "4433": 0.0, "4447": 0.38685280723454163, "4464": 0.5, "4465": 0.2960819109658652, "4484": 0.6309297535714575, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.4034698846650846, "4523": 0.21398626473452756, "4539": 0.21840743681816419, "4571": 0.7653606369886217, "4600": 1.0, "4605": 0.5706291306523891, "4615": 0.4636246685132894, "4640": 0.0, "4641": 0.252016380211836, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75369761125927, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.6131471927654584, "4813": 1.0, "4823": 0.46927872602275644, "4827": 0.38685280723454163, "4837": 0.0, "4844": 1.0, "4845": 0.7653606369886217, "4846": 0.0, "4863": 0.5307212739772434, "4865": 0.0, "4920": 1.0, "4942": 0.31546487678572877, "4946": 1.0, "4955": 0.0, "4962": 0.6131471927654584, "4968": 0.6309297535714575, "4981": 0.7039180890341347, "4999": 0.5294362295028773, "5021": 0.0, "5030": 0.0, "5045": 0.3010299956639812, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.6309297535714575, "5080": 0.0, "5083": 0.23719771276929622, "5085": 1.0, "5086": 1.0, "5090": 0.2640681225725909, "5125": 1.0, "5134": 0.6131471927654584, "5150": 0.0, "5155": 1.0, "5172": 0.0, "5178": 0.252016380211836, "5185": 0.0, "5196": 0.2960819109658652, "5206": 0.0, "5228": 0.31546487678572877, "5231": 0.0, "5241": 0.44615333764087994, "5254": 0.6131471927654584, "5255": 1.0, "5264": 0.6843515475204855, "5271": 0.41618115554873086, "5331": 1.0, "5343": 0.3333333333333333, "5347": 1.0, "5356": 0.1208113026994942, "5369": 0.0, "5374": 0.3010299956639812, "5380": 1.0, "5402": 0.0, "5410": 0.2960819109658652, "5422": 0.3903800499921017, "5427": 0.2640681225725909, "5460": 0.0, "5464": 0.16716045496620227, "5503": 0.6131471927654584, "5505": 1.0, "5511": 0.1610425878239398, "5534": 0.38685280723454163, "5549": 0.0, "5585": 0.3333333333333333, "5592": 1.0, "5616": 0.3562071871080222, "5620": 0.0, "5646": 0.9217868789962071, "5653": 1.0, "5683": 0.6934264036172708, "5710": 0.0, "5741": 0.0, "5763": 0.18154179253735267, "5782": 0.4371994911049732, "5790": 0.0, "5808": 0.5, "5853": 0.21078558563971425, "5862": 0.29127873064148246, "5888": 0.23719771276929622, "5903": 0.0, "5906": 0.48381288316677695, "5940": 0.0, "5951": 0.5142521154617875, "5970": 0.23463936301137822, "5981": 0.9896062251871525, "5993": 0.30523488393970116, "6002": 0.7819835854675755, "6004": 0.0, "6005": 0.5388856921828065, "6009": 0.0, "6041": 0.7668091220635322, "6080": 0.6131471927654584, "6110": 0.32583242649464755, "6121": 0.38685280723454163, "6122": 0.46927872602275644, "6131": 0.5810820381115676, "6133": 0.6131471927654584, "6142": 0.6131471927654584, "6146": 0.8315546295836225, "6199": 0.5135312443624667, "6219": 0.6934264036172708, "6221": 0.0, "6252": 0.0, "6262": 0.7653606369886217, "6278": 0.20438239758848611, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.3562071871080222, "6467": 0.0, "6468": 0.6131471927654584, "6479": 1.0, "6525": 0.49818925746641285, "6554": 0.38685280723454163, "6562": 0.11751610475642714, "6611": 0.6131471927654584, "6612": 0.16716045496620227, "6625": 0.31546487678572877, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8503449055347546, "6679": 0.4632423659320675, "6683": 0.8772153153380493, "6713": 0.6131471927654584, "6715": 0.38685280723454163, "6746": 0.6131471927654584, "6787": 0.0, "6792": 0.0, "6800": 0.43067655807339306, "6803": 0.5205067333228022, "6807": 1.0, "6814": 0.0, "6832": 0.430624116386567, "6835": 0.38685280723454163, "6849": 0.38685280723454163, "6862": 1.0, "6867": 0.22471947398559278, "6875": 0.0, "6890": 0.5012658353418871, "6891": 0.617319681505689, "6896": 0.0, "6901": 0.21840743681816419, "6907": 0.0, "6909": 0.0, "6959": 0.38685280723454163, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 0.8772153153380493, "7096": 1.0, "7098": 0.6131471927654584, "7105": 0.38685280723454163, "7109": 0.23463936301137822, "7124": 0.6525874238732422, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.38685280723454163, "7188": 0.31546487678572877, "7205": 1.0, "7206": 0.0, "7218": 0.43067655807339306, "7221": 0.0, "7269": 0.0, "7279": 0.4693608375942211, "7295": 0.0, "7311": 0.0, "7326": 0.0, "7329": 0.5012658353418871, "7344": 0.6131471927654584, "7345": 0.15642624200758548, "7377": 1.0, "7431": 0.0, "7441": 0.23463936301137822, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.14606834984270645, "7467": 0.6309297535714575, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.16716045496620227, "7529": 0.6131471927654584, "7533": 0.0, "7534": 0.46927872602275644, "7590": 0.5802792108518124, "7592": 0.0, "7594": 0.3562071871080222, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.123151194370365, "7702": 0.38685280723454163, "7705": 0.6508205185601091, "7734": 0.6131471927654584, "7747": 0.2640681225725909, "7754": 0.0, "7758": 0.6309297535714575, "7801": 1.0, "7803": 0.20438239758848611, "7823": 0.6105456988825855, "7876": 0.43067655807339306, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.19519002499605084, "7936": 0.4632423659320675, "7992": 0.38685280723454163, "8002": 0.6257049680303419, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.31546487678572877, "8040": 1.0, "8072": 0.6508205185601091, "8079": 0.7039180890341347, "8102": 0.11284514134893527, "8116": 0.45749452618986164, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.6131471927654584, "8275": 0.38685280723454163, "8296": 0.8772153153380493, "8332": 0.9674679834891693, "8351": 0.6131471927654584, "8378": 0.1480409554829326, "8456": 0.6049306994552042, "8475": 0.7957503936198023, "8507": 0.0, "8512": 1.0, "8513": 0.0, "8532": 0.9325210919548239, "8537": 0.3562071871080222, "8539": 0.0, "8544": 0.6131471927654584, "8592": 0.20210734650054757, "8632": 0.3065735963827292, "8635": 0.0, "8702": 0.7039180890341347, "8779": 0.0, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.2890648263178879, "8934": 0.8065735963827293, "8937": 0.3562071871080222, "8947": 0.23719771276929622, "8959": 0.38685280723454163, "8970": 0.6509209298071326, "8974": 0.41253177989255346, "8982": 0.0, "9060": 0.3065735963827292, "9088": 0.0, "9108": 0.0, "9115": 0.5256940434743352, "9126": 0.0, "9164": 0.15642624200758548, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.20438239758848611, "9329": 0.9197207891481876, "9332": 0.43067655807339306, "9381": 0.6934264036172708, "9385": 0.3562071871080222, "9391": 0.5143371794949736, "9403": 0.0, "9481": 0.5706417189553201, "9487": 0.0, "9548": 0.5, "9556": 1.0, "9565": 1.0, "9598": 0.3562071871080222, "9617": 0.3152014104491349, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.5, "9646": 0.5249810332008933, "9668": 0.6508205185601091, "9701": 0.0, "9733": 0.18154179253735267, "9735": 0.3333333333333333, "9737": 0.7653606369886217, "9771": 0.0, "9808": 0.2960819109658652, "9824": 1.0, "9871": 0.24630238874073, "9882": 0.0, "9925": 0.8175295903539445, "9929": 0.7977228895450266, "9961": 0.0, "9979": 0.3903800499921017, "10034": 0.38685280723454163, "10039": 0.6309297535714575, "10109": 0.5039399436761999, "10122": 0.19519002499605084, "10136": 0.34337431936037655, "10137": 0.3333333333333333, "10152": 1.0, "10183": 0.3065735963827292, "10213": 0.46927872602275644, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.18154179253735267, "10462": 0.0, "10482": 0.0, "10497": 0.4818998405251556, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 0.6309297535714575, "10628": 0.3010299956639812, "10639": 0.3120255505658846, "10645": 0.38685280723454163, "10674": 0.7095272044910244, "10710": 0.31546487678572877, "10734": 0.8696762340896295, "10792": 0.8315546295836225, "10808": 0.4652347214527331, "10809": 0.6049306994552042, "10812": 0.9493885684853097, "10827": 0.14606834984270645, "10845": 1.0, "10912": 0.0, "10932": 1.0, "10975": 0.0, "10979": 0.6366824387328317, "10994": 0.5, "11039": 0.3200466520981656, "11054": 1.0, "11088": 0.43067655807339306}, "Recall@20": {"8": 0.5, "15": 1.0, "18": 1.0, "26": 0.5, "34": 0.0, "42": 0.3333333333333333, "56": 1.0, "68": 0.0, "89": 0.5, "90": 1.0, "94": 1.0, "98": 0.5, "104": 0.5, "106": 1.0, "109": 1.0, "475": 1.0, "503": 1.0, "504": 0.3333333333333333, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 1.0, "585": 0.5, "588": 1.0, "594": 1.0, "603": 0.0, "604": 1.0, "620": 0.2, "622": 0.5, "659": 0.7, "672": 0.5, "684": 1.0, "687": 0.5, "689": 0.0, "691": 1.0, "699": 1.0, "701": 0.3333333333333333, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.3333333333333333, "776": 0.25, "810": 1.0, "813": 1.0, "849": 1.0, "852": 0.6666666666666666, "853": 0.5, "858": 0.0, "859": 0.5, "864": 0.6666666666666666, "879": 1.0, "885": 0.5, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.5, "939": 1.0, "945": 1.0, "957": 0.6666666666666666, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.5, "1150": 0.0, "1157": 0.5, "1159": 0.0, "1198": 1.0, "1230": 1.0, "1281": 1.0, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.75, "1310": 1.0, "1321": 0.0, "1322": 0.25, "1391": 0.6666666666666666, "1393": 0.5, "1415": 1.0, "1416": 1.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 1.0, "1670": 0.6666666666666666, "1676": 1.0, "1736": 0.4, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 1.0, "1826": 1.0, "1832": 1.0, "1871": 0.75, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.4, "2010": 1.0, "2051": 1.0, "2070": 0.6666666666666666, "2075": 0.6666666666666666, "2076": 1.0, "2088": 0.0, "2108": 0.3333333333333333, "2118": 0.0, "2154": 0.0, "2181": 0.5, "2183": 0.8333333333333334, "2204": 1.0, "2264": 0.5, "2296": 0.2222222222222222, "2306": 0.5, "2316": 1.0, "2318": 1.0, "2330": 0.5, "2334": 0.6666666666666666, "2348": 0.26666666666666666, "2376": 1.0, "2383": 0.5, "2384": 1.0, "2385": 0.5, "2388": 1.0, "2395": 1.0, "2398": 0.2, "2399": 1.0, "2400": 0.6666666666666666, "2407": 0.5, "2416": 1.0, "2423": 0.8571428571428571, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.3333333333333333, "2472": 0.0, "2486": 1.0, "2498": 1.0, "2513": 1.0, "2516": 0.75, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.5, "2580": 0.3333333333333333, "2587": 1.0, "2589": 0.6666666666666666, "2590": 0.6666666666666666, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 0.25, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 0.42857142857142855, "2801": 1.0, "2856": 0.75, "2857": 0.75, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 1.0, "2923": 0.8, "2964": 0.5, "2968": 1.0, "2994": 0.3333333333333333, "3006": 0.5, "3008": 0.25, "3014": 1.0, "3033": 0.5, "3039": 1.0, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 1.0, "3091": 0.8571428571428571, "3103": 1.0, "3115": 0.5, "3125": 1.0, "3148": 0.6, "3149": 0.0, "3177": 0.6666666666666666, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.6666666666666666, "3264": 0.75, "3357": 1.0, "3369": 0.16666666666666666, "3394": 0.75, "3404": 0.42857142857142855, "3405": 1.0, "3446": 0.8, "3451": 0.42857142857142855, "3453": 1.0, "3480": 1.0, "3490": 1.0, "3500": 0.5, "3503": 0.7142857142857143, "3512": 1.0, "3528": 1.0, "3530": 0.6666666666666666, "3534": 0.0, "3566": 1.0, "3569": 1.0, "3594": 0.25, "3612": 0.75, "3615": 1.0, "3625": 0.3333333333333333, "3682": 1.0, "3683": 0.6666666666666666, "3694": 0.5, "3724": 0.0, "3735": 1.0, "3759": 0.0, "3767": 0.4, "3771": 0.3333333333333333, "3781": 1.0, "3789": 0.75, "3791": 0.6666666666666666, "3801": 0.0, "3822": 0.25, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 0.6666666666666666, "4011": 1.0, "4019": 0.4, "4031": 0.0, "4037": 0.5, "4047": 0.75, "4071": 0.0, "4084": 1.0, "4102": 0.25, "4103": 0.0, "4105": 0.0, "4116": 0.5, "4125": 0.0, "4142": 0.75, "4153": 1.0, "4179": 1.0, "4188": 1.0, "4205": 0.6666666666666666, "4233": 0.8, "4265": 0.6666666666666666, "4286": 0.5, "4289": 0.5, "4306": 0.75, "4312": 0.8571428571428571, "4335": 0.75, "4339": 1.0, "4394": 0.0, "4409": 0.2, "4411": 0.6666666666666666, "4414": 1.0, "4415": 0.0, "4433": 0.5, "4447": 1.0, "4464": 1.0, "4465": 0.6666666666666666, "4484": 1.0, "4499": 0.3333333333333333, "4500": 0.5, "4504": 1.0, "4514": 0.5, "4523": 0.2, "4539": 0.5, "4571": 0.6666666666666666, "4600": 1.0, "4605": 0.7142857142857143, "4615": 0.6666666666666666, "4640": 0.0, "4641": 0.6, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.6666666666666666, "4846": 0.0, "4863": 1.0, "4865": 0.0, "4920": 1.0, "4942": 1.0, "4946": 1.0, "4955": 0.0, "4962": 0.5, "4968": 1.0, "4981": 0.6666666666666666, "4999": 0.75, "5021": 0.0, "5030": 0.0, "5045": 1.0, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 1.0, "5080": 0.0, "5083": 0.5, "5085": 1.0, "5086": 1.0, "5090": 0.5, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 1.0, "5178": 0.4, "5185": 0.0, "5196": 0.3333333333333333, "5206": 0.0, "5228": 1.0, "5231": 1.0, "5241": 0.4, "5254": 0.5, "5255": 1.0, "5264": 0.6, "5271": 1.0, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.4, "5369": 0.0, "5374": 1.0, "5380": 1.0, "5402": 0.5, "5410": 0.3333333333333333, "5422": 0.75, "5427": 0.5, "5460": 0.0, "5464": 0.3333333333333333, "5503": 0.5, "5505": 1.0, "5511": 0.3, "5534": 0.5, "5549": 0.0, "5585": 1.0, "5592": 1.0, "5616": 1.0, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.5, "5763": 0.6666666666666666, "5782": 0.4, "5790": 0.0, "5808": 1.0, "5853": 0.375, "5862": 0.5, "5888": 0.5, "5903": 0.0, "5906": 1.0, "5940": 0.0, "5951": 0.5555555555555556, "5970": 0.6666666666666666, "5981": 1.0, "5993": 0.2, "6002": 0.9090909090909091, "6004": 0.0, "6005": 0.38461538461538464, "6009": 1.0, "6041": 0.75, "6080": 0.5, "6110": 0.375, "6121": 0.5, "6122": 0.3333333333333333, "6131": 0.4166666666666667, "6133": 0.5, "6142": 0.5, "6146": 1.0, "6199": 0.5, "6219": 1.0, "6221": 0.125, "6252": 0.0, "6262": 0.6666666666666666, "6278": 1.0, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 1.0, "6467": 0.0, "6468": 0.5, "6479": 1.0, "6525": 0.6666666666666666, "6554": 0.5, "6562": 0.5, "6611": 1.0, "6612": 0.3333333333333333, "6625": 1.0, "6629": 0.0, "6635": 0.5, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 1.0, "6683": 1.0, "6713": 0.5, "6715": 1.0, "6746": 0.5, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.75, "6807": 1.0, "6814": 0.0, "6832": 1.0, "6835": 0.5, "6849": 1.0, "6862": 1.0, "6867": 0.42857142857142855, "6875": 0.0, "6890": 1.0, "6891": 0.6666666666666666, "6896": 0.0, "6901": 0.5, "6907": 0.0, "6909": 0.0, "6959": 1.0, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 1.0, "7109": 0.6666666666666666, "7124": 0.75, "7141": 0.5, "7145": 0.3333333333333333, "7178": 1.0, "7188": 1.0, "7205": 1.0, "7206": 0.0, "7218": 1.0, "7221": 0.0, "7269": 1.0, "7279": 0.75, "7295": 0.0, "7311": 1.0, "7326": 0.0, "7329": 1.0, "7344": 0.5, "7345": 0.6666666666666666, "7377": 1.0, "7431": 0.0, "7441": 0.3333333333333333, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.4, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 1.0, "7513": 0.6666666666666666, "7529": 0.5, "7533": 0.5, "7534": 0.3333333333333333, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.5, "7674": 0.3333333333333333, "7700": 0.25, "7702": 1.0, "7705": 0.6666666666666666, "7734": 0.5, "7747": 0.5, "7754": 1.0, "7758": 1.0, "7801": 1.0, "7803": 0.5, "7823": 0.6666666666666666, "7876": 1.0, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.16666666666666666, "7928": 0.25, "7936": 0.6666666666666666, "7992": 1.0, "8002": 0.6666666666666666, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 1.0, "8040": 1.0, "8072": 0.6666666666666666, "8079": 1.0, "8102": 0.25, "8116": 1.0, "8121": 1.0, "8202": 0.0, "8230": 1.0, "8247": 0.0, "8271": 0.5, "8275": 1.0, "8296": 1.0, "8332": 1.0, "8351": 0.5, "8378": 0.3333333333333333, "8456": 0.6666666666666666, "8475": 0.8571428571428571, "8507": 0.3333333333333333, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 1.0, "8539": 0.25, "8544": 0.5, "8592": 0.6666666666666666, "8632": 1.0, "8635": 0.0, "8702": 0.6666666666666666, "8779": 1.0, "8789": 0.6666666666666666, "8795": 1.0, "8832": 1.0, "8834": 0.5, "8855": 0.0, "8874": 1.0, "8934": 1.0, "8937": 1.0, "8947": 0.5, "8959": 1.0, "8970": 1.0, "8974": 0.25, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 1.0, "9126": 0.0, "9164": 0.3333333333333333, "9174": 0.2, "9188": 0.5, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 1.0, "9381": 1.0, "9385": 1.0, "9391": 0.75, "9403": 0.0, "9481": 1.0, "9487": 1.0, "9548": 1.0, "9556": 1.0, "9565": 1.0, "9598": 1.0, "9617": 0.6666666666666666, "9633": 0.5, "9643": 1.0, "9644": 1.0, "9646": 1.0, "9668": 1.0, "9701": 0.0, "9733": 0.3333333333333333, "9735": 1.0, "9737": 0.6666666666666666, "9771": 0.0, "9808": 0.3333333333333333, "9824": 1.0, "9871": 0.25, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 0.5, "10034": 0.5, "10039": 1.0, "10109": 0.42857142857142855, "10122": 0.5, "10136": 0.6666666666666666, "10137": 1.0, "10152": 1.0, "10183": 1.0, "10213": 0.3333333333333333, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.3333333333333333, "10462": 0.0, "10482": 0.0, "10497": 0.7, "10526": 0.5, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 1.0, "10639": 0.4, "10645": 1.0, "10674": 1.0, "10710": 1.0, "10734": 1.0, "10792": 1.0, "10808": 1.0, "10809": 0.6666666666666666, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 1.0, "10932": 1.0, "10975": 0.0, "10979": 0.75, "10994": 1.0, "11039": 0.5, "11054": 1.0, "11088": 1.0}, "MRR@10": {"8": 1.0, "15": 0.16666666666666666, "18": 1.0, "26": 0.2, "34": 0.0, "42": 1.0, "56": 0.2, "68": 0.0, "89": 0.5, "90": 0.5, "94": 1.0, "98": 1.0, "104": 1.0, "106": 0.3333333333333333, "109": 1.0, "475": 1.0, "503": 0.08333333333333333, "504": 0.05555555555555555, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.16666666666666666, "559": 0.0, "570": 0.06666666666666667, "585": 0.25, "588": 0.25, "594": 1.0, "603": 0.0, "604": 0.16666666666666666, "620": 0.08333333333333333, "622": 0.5, "659": 1.0, "672": 0.07692307692307693, "684": 0.05555555555555555, "687": 0.125, "689": 0.0, "691": 0.5, "699": 1.0, "701": 0.1, "715": 0.0, "721": 1.0, "744": 0.2, "750": 1.0, "753": 0.5, "766": 0.2, "776": 1.0, "810": 0.14285714285714285, "813": 0.14285714285714285, "849": 0.14285714285714285, "852": 1.0, "853": 0.09090909090909091, "858": 0.0, "859": 0.5, "864": 1.0, "879": 0.5, "885": 0.125, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.3333333333333333, "939": 1.0, "945": 0.125, "957": 1.0, "988": 0.0, "1074": 0.5, "1085": 0.0, "1090": 0.2, "1150": 0.0, "1157": 1.0, "1159": 0.0, "1198": 1.0, "1230": 0.07142857142857142, "1281": 0.2, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 1.0, "1310": 1.0, "1321": 0.0, "1322": 0.5, "1391": 0.2, "1393": 1.0, "1415": 1.0, "1416": 0.058823529411764705, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.5, "1670": 1.0, "1676": 0.5, "1736": 1.0, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 0.125, "1826": 1.0, "1832": 0.3333333333333333, "1871": 1.0, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.5, "2010": 1.0, "2051": 0.07142857142857142, "2070": 0.16666666666666666, "2075": 0.5, "2076": 0.3333333333333333, "2088": 0.0, "2108": 0.16666666666666666, "2118": 0.0, "2154": 0.0, "2181": 0.05263157894736842, "2183": 1.0, "2204": 1.0, "2264": 0.3333333333333333, "2296": 1.0, "2306": 1.0, "2316": 1.0, "2318": 0.125, "2330": 1.0, "2334": 1.0, "2348": 1.0, "2376": 1.0, "2383": 1.0, "2384": 1.0, "2385": 1.0, "2388": 1.0, "2395": 1.0, "2398": 0.08333333333333333, "2399": 1.0, "2400": 0.5, "2407": 0.3333333333333333, "2416": 1.0, "2423": 1.0, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0625, "2472": 0.0, "2486": 1.0, "2498": 0.25, "2513": 0.0625, "2516": 1.0, "2549": 1.0, "2551": 1.0, "2568": 0.5, "2579": 0.5, "2580": 1.0, "2587": 1.0, "2589": 1.0, "2590": 1.0, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 0.5, "2685": 1.0, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 0.3333333333333333, "2749": 1.0, "2790": 1.0, "2801": 1.0, "2856": 1.0, "2857": 0.5, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.1111111111111111, "2923": 1.0, "2964": 0.07692307692307693, "2968": 1.0, "2994": 1.0, "3006": 0.3333333333333333, "3008": 0.5, "3014": 1.0, "3033": 1.0, "3039": 0.2, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 0.125, "3091": 1.0, "3103": 1.0, "3115": 1.0, "3125": 1.0, "3148": 1.0, "3149": 0.0, "3177": 0.14285714285714285, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 1.0, "3264": 1.0, "3357": 1.0, "3369": 0.09090909090909091, "3394": 0.5, "3404": 1.0, "3405": 0.1, "3446": 0.5, "3451": 0.1, "3453": 0.5, "3480": 1.0, "3490": 0.1, "3500": 1.0, "3503": 0.5, "3512": 1.0, "3528": 0.5, "3530": 0.5, "3534": 0.0, "3566": 1.0, "3569": 0.3333333333333333, "3594": 0.125, "3612": 0.1111111111111111, "3615": 0.3333333333333333, "3625": 0.25, "3682": 0.16666666666666666, "3683": 1.0, "3694": 1.0, "3724": 0.0, "3735": 0.09090909090909091, "3759": 0.0, "3767": 0.3333333333333333, "3771": 0.14285714285714285, "3781": 1.0, "3789": 1.0, "3791": 0.5, "3801": 0.0, "3822": 0.05263157894736842, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 1.0, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 1.0, "4011": 1.0, "4019": 0.5, "4031": 0.0, "4037": 0.1111111111111111, "4047": 1.0, "4071": 0.0, "4084": 0.25, "4102": 0.06666666666666667, "4103": 0.0, "4105": 0.0, "4116": 1.0, "4125": 0.0, "4142": 0.16666666666666666, "4153": 0.125, "4179": 0.5, "4188": 0.0625, "4205": 0.5, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 0.2, "4306": 1.0, "4312": 1.0, "4335": 1.0, "4339": 1.0, "4394": 0.0, "4409": 0.3333333333333333, "4411": 1.0, "4414": 1.0, "4415": 0.0, "4433": 0.09090909090909091, "4447": 0.2, "4464": 0.3333333333333333, "4465": 0.5, "4484": 0.5, "4499": 0.05555555555555555, "4500": 0.07142857142857142, "4504": 1.0, "4514": 1.0, "4523": 0.5, "4539": 0.16666666666666666, "4571": 1.0, "4600": 1.0, "4605": 1.0, "4615": 0.3333333333333333, "4640": 0.0, "4641": 0.2, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 1.0, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 0.2, "4837": 0.0, "4844": 1.0, "4845": 1.0, "4846": 0.0, "4863": 0.5, "4865": 0.0, "4920": 1.0, "4942": 0.125, "4946": 1.0, "4955": 0.0, "4962": 1.0, "4968": 0.5, "4981": 1.0, "4999": 1.0, "5021": 0.0, "5030": 0.0, "5045": 0.1111111111111111, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.5, "5080": 0.0, "5083": 0.2, "5085": 1.0, "5086": 1.0, "5090": 0.25, "5125": 1.0, "5134": 1.0, "5150": 0.0, "5155": 1.0, "5172": 0.09090909090909091, "5178": 0.2, "5185": 0.0, "5196": 0.5, "5206": 0.0, "5228": 0.125, "5231": 0.058823529411764705, "5241": 1.0, "5254": 1.0, "5255": 1.0, "5264": 1.0, "5271": 0.3333333333333333, "5331": 1.0, "5343": 0.14285714285714285, "5347": 1.0, "5356": 0.16666666666666666, "5369": 0.0, "5374": 0.1111111111111111, "5380": 1.0, "5402": 0.0625, "5410": 0.5, "5422": 1.0, "5427": 0.25, "5460": 0.0, "5464": 0.16666666666666666, "5503": 1.0, "5505": 1.0, "5511": 0.25, "5534": 0.5, "5549": 0.0, "5585": 0.14285714285714285, "5592": 1.0, "5616": 0.16666666666666666, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 0.5, "5710": 0.0, "5741": 0.0625, "5763": 0.2, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.25, "5888": 0.2, "5903": 0.0, "5906": 0.3333333333333333, "5940": 0.0, "5951": 1.0, "5970": 0.3333333333333333, "5981": 1.0, "5993": 1.0, "6002": 1.0, "6004": 0.0, "6005": 1.0, "6009": 0.09090909090909091, "6041": 1.0, "6080": 1.0, "6110": 0.5, "6121": 0.5, "6122": 1.0, "6131": 1.0, "6133": 1.0, "6142": 1.0, "6146": 1.0, "6199": 1.0, "6219": 0.5, "6221": 0.05, "6252": 0.0, "6262": 1.0, "6278": 0.14285714285714285, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.16666666666666666, "6467": 0.0, "6468": 1.0, "6479": 1.0, "6525": 0.5, "6554": 0.5, "6562": 0.1111111111111111, "6611": 1.0, "6612": 0.16666666666666666, "6625": 0.125, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 1.0, "6713": 1.0, "6715": 0.5, "6746": 1.0, "6787": 0.0, "6792": 0.0, "6800": 0.25, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.2, "6835": 0.5, "6849": 0.2, "6862": 1.0, "6867": 0.25, "6875": 0.0, "6890": 0.25, "6891": 1.0, "6896": 0.0, "6901": 0.16666666666666666, "6907": 0.0, "6909": 0.0, "6959": 0.5, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 0.2, "7109": 0.3333333333333333, "7124": 1.0, "7141": 0.0625, "7145": 0.1, "7178": 0.2, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.06666666666666667, "7279": 0.3333333333333333, "7295": 0.0, "7311": 0.09090909090909091, "7326": 0.0, "7329": 0.25, "7344": 1.0, "7345": 0.14285714285714285, "7377": 1.0, "7431": 0.0, "7441": 0.3333333333333333, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.25, "7467": 0.5, "7484": 1.0, "7509": 0.0, "7512": 0.0625, "7513": 0.16666666666666666, "7529": 1.0, "7533": 0.08333333333333333, "7534": 1.0, "7590": 0.5, "7592": 0.0, "7594": 0.16666666666666666, "7622": 0.0, "7633": 1.0, "7674": 0.0625, "7700": 0.125, "7702": 0.5, "7705": 1.0, "7734": 1.0, "7747": 0.25, "7754": 0.09090909090909091, "7758": 0.5, "7801": 1.0, "7803": 0.14285714285714285, "7823": 1.0, "7876": 0.25, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.5, "7928": 0.3333333333333333, "7936": 0.5, "7992": 0.5, "8002": 1.0, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.125, "8040": 1.0, "8072": 1.0, "8079": 1.0, "8102": 0.1, "8116": 0.25, "8121": 1.0, "8202": 0.0, "8230": 0.0625, "8247": 0.0, "8271": 1.0, "8275": 0.2, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.125, "8456": 1.0, "8475": 1.0, "8507": 0.09090909090909091, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 0.16666666666666666, "8539": 0.09090909090909091, "8544": 1.0, "8592": 0.25, "8632": 0.3333333333333333, "8635": 0.0, "8702": 1.0, "8779": 0.09090909090909091, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.1, "8934": 1.0, "8937": 0.16666666666666666, "8947": 0.2, "8959": 0.2, "8970": 0.5, "8974": 1.0, "8982": 0.0, "9060": 0.3333333333333333, "9088": 0.0, "9108": 0.0, "9115": 0.25, "9126": 0.0, "9164": 0.14285714285714285, "9174": 0.07142857142857142, "9188": 1.0, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.14285714285714285, "9329": 1.0, "9332": 0.25, "9381": 0.5, "9385": 0.16666666666666666, "9391": 0.3333333333333333, "9403": 0.0, "9481": 0.3333333333333333, "9487": 0.08333333333333333, "9548": 0.3333333333333333, "9556": 1.0, "9565": 1.0, "9598": 0.16666666666666666, "9617": 0.16666666666666666, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.3333333333333333, "9646": 0.3333333333333333, "9668": 1.0, "9701": 0.0, "9733": 0.2, "9735": 0.14285714285714285, "9737": 1.0, "9771": 0.0, "9808": 0.5, "9824": 1.0, "9871": 0.5, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 1.0, "10034": 0.5, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.25, "10137": 0.14285714285714285, "10152": 1.0, "10183": 0.3333333333333333, "10213": 1.0, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.2, "10462": 0.0, "10482": 0.0, "10497": 1.0, "10526": 0.14285714285714285, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 0.5, "10628": 0.1111111111111111, "10639": 0.5, "10645": 0.5, "10674": 1.0, "10710": 0.125, "10734": 1.0, "10792": 1.0, "10808": 0.2, "10809": 1.0, "10812": 1.0, "10827": 0.25, "10845": 1.0, "10912": 0.08333333333333333, "10932": 1.0, "10975": 0.0, "10979": 1.0, "10994": 0.3333333333333333, "11039": 0.5, "11054": 1.0, "11088": 0.25}}} diff --git a/evals/benchmark/results/fiqa/ir-w0.5.jsonl b/evals/benchmark/results/fiqa/ir-w0.5.jsonl new file mode 100644 index 000000000..dfbd9f999 --- /dev/null +++ b/evals/benchmark/results/fiqa/ir-w0.5.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "w0.5", "aggregated": {"nDCG@10": 0.4333, "Recall@20": 0.6186, "MRR@10": 0.5053}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 0.3562071871080222, "18": 0.6309297535714575, "26": 0.23719771276929622, "34": 0.0, "42": 0.46927872602275644, "56": 0.3562071871080222, "68": 0.0, "89": 0.286381299268402, "90": 0.6309297535714575, "94": 1.0, "98": 0.6131471927654584, "104": 0.6131471927654584, "106": 0.5, "109": 1.0, "475": 1.0, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.3333333333333333, "559": 0.0, "570": 0.0, "585": 0.2640681225725909, "588": 0.448643819352159, "594": 0.6131471927654584, "603": 0.0, "604": 0.3235866969737877, "620": 0.0, "622": 0.38685280723454163, "659": 0.43828689407543014, "672": 0.0, "684": 0.0, "687": 0.19342640361727081, "689": 0.0, "691": 0.6309297535714575, "699": 1.0, "701": 0.13565197343244778, "715": 0.0, "721": 1.0, "744": 0.18154179253735267, "750": 0.8503449055347546, "753": 0.38685280723454163, "766": 0.18154179253735267, "776": 0.3557772116892465, "810": 0.3333333333333333, "813": 0.20438239758848611, "849": 0.3333333333333333, "852": 0.7653606369886217, "853": 0.0, "858": 0.0, "859": 0.38685280723454163, "864": 0.7247145167543899, "879": 0.6309297535714575, "885": 0.19342640361727081, "895": 1.0, "904": 1.0, "928": 0.6131471927654584, "929": 1.0, "932": 0.3065735963827292, "939": 0.5, "945": 0.3010299956639812, "957": 0.7653606369886217, "988": 0.0, "1074": 0.6309297535714575, "1085": 0.0, "1090": 0.23719771276929622, "1150": 0.0, "1157": 0.6131471927654584, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 0.38685280723454163, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.559008518493208, "1310": 1.0, "1321": 0.0, "1322": 0.24630238874073, "1391": 0.18154179253735267, "1393": 0.30260241349881345, "1415": 0.9709286432396583, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.431733884398313, "1670": 0.7653606369886217, "1676": 0.5101671483174705, "1736": 0.5531464700081437, "1748": 0.6049306994552042, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.286381299268402, "1824": 0.31546487678572877, "1826": 1.0, "1832": 0.5, "1871": 0.6713527276121545, "1877": 1.0, "1889": 0.0, "1915": 0.8772153153380493, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.21398626473452756, "2010": 0.8194270280062366, "2051": 0.0, "2070": 0.18154179253735267, "2075": 0.4880470105041527, "2076": 0.5706417189553201, "2088": 0.0, "2108": 0.16716045496620227, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.7526136409516659, "2204": 0.9830168297915423, "2264": 0.3065735963827292, "2296": 0.33627415762678553, "2306": 0.6131471927654584, "2316": 1.0, "2318": 0.31546487678572877, "2330": 0.6131471927654584, "2334": 0.46927872602275644, "2348": 0.43231813227099475, "2376": 0.8910635073822442, "2383": 0.6131471927654584, "2384": 0.6309297535714575, "2385": 0.6131471927654584, "2388": 1.0, "2395": 1.0, "2398": 0.0, "2399": 1.0, "2400": 0.5307212739772434, "2407": 0.24630238874073, "2416": 0.9058653015743079, "2423": 0.3576223542196109, "2443": 0.0, "2445": 1.0, "2460": 0.9469024295259745, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.43067655807339306, "2513": 0.0, "2516": 0.5585075862632192, "2549": 0.6131471927654584, "2551": 1.0, "2568": 0.25288473642100684, "2579": 0.28201326940239274, "2580": 0.46927872602275644, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.8854598815714874, "2598": 0.8503449055347546, "2648": 1.0, "2676": 0.5, "2685": 0.35079429740281753, "2695": 1.0, "2713": 0.38685280723454163, "2724": 0.8175295903539445, "2737": 1.0, "2747": 0.5, "2749": 0.8772153153380493, "2790": 0.47997295436377346, "2801": 0.6131471927654584, "2856": 0.7095272044910244, "2857": 0.6595629128335778, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.3010299956639812, "2923": 0.8207658584763088, "2964": 0.0, "2968": 0.8772153153380493, "2994": 0.46927872602275644, "3006": 0.25909036127391766, "3008": 0.24630238874073, "3014": 1.0, "3033": 0.38685280723454163, "3039": 0.38685280723454163, "3049": 0.24630238874073, "3051": 1.0, "3067": 0.0, "3085": 0.19342640361727081, "3091": 0.9020870746500321, "3103": 0.6309297535714575, "3115": 0.4935232796777481, "3125": 1.0, "3148": 0.5531464700081437, "3149": 0.0, "3177": 0.15642624200758548, "3179": 0.8503449055347546, "3186": 1.0, "3189": 0.0, "3254": 0.6713860725233041, "3264": 0.8048099750039491, "3357": 1.0, "3369": 0.0, "3394": 0.5805485932475565, "3404": 0.3932591258696538, "3405": 0.0, "3446": 0.5669646403403741, "3451": 0.07945707943276742, "3453": 0.5706417189553201, "3480": 1.0, "3490": 0.2890648263178879, "3500": 0.644824486427155, "3503": 0.6183313187362977, "3512": 0.8503449055347546, "3528": 0.6309297535714575, "3530": 0.4776237035032179, "3534": 0.0, "3566": 0.8194270280062366, "3569": 0.5, "3594": 0.123151194370365, "3612": 0.11751610475642714, "3615": 0.45749452618986164, "3625": 0.20210734650054757, "3682": 0.20438239758848611, "3683": 0.5982291239616433, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.0, "3759": 0.0, "3767": 0.2716774977597197, "3771": 0.19632790425573848, "3781": 0.9197207891481876, "3789": 0.8048099750039491, "3791": 0.431733884398313, "3801": 0.0, "3822": 0.0, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5517854393872873, "3932": 0.0, "3934": 0.16812753627111746, "3995": 0.0, "4007": 0.7039180890341347, "4011": 0.9674679834891693, "4019": 0.31608365985743925, "4031": 0.0, "4037": 0.18457569677956817, "4047": 0.8318724637288826, "4071": 0.0, "4084": 0.5012658353418871, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.39233405721184117, "4153": 0.31546487678572877, "4179": 0.6309297535714575, "4188": 0.0, "4205": 0.4525081529734507, "4233": 0.8687949224876582, "4265": 0.7751482523375255, "4286": 0.6131471927654584, "4289": 0.23719771276929622, "4306": 0.7598336331031966, "4312": 0.7237478018511487, "4335": 0.8318724637288826, "4339": 1.0, "4394": 0.0, "4409": 0.19518900079066107, "4411": 0.46927872602275644, "4414": 0.8315546295836225, "4415": 0.0, "4433": 0.0, "4447": 1.0, "4464": 0.5, "4465": 0.2960819109658652, "4484": 0.6309297535714575, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.4034698846650846, "4523": 0.21398626473452756, "4539": 0.21840743681816419, "4571": 0.7653606369886217, "4600": 1.0, "4605": 0.5585830187272559, "4615": 0.4909156065077737, "4640": 0.0, "4641": 0.252016380211836, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75369761125927, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.6131471927654584, "4813": 1.0, "4823": 0.46927872602275644, "4827": 0.3562071871080222, "4837": 0.0, "4844": 1.0, "4845": 0.7653606369886217, "4846": 0.0, "4863": 0.49818925746641285, "4865": 0.0, "4920": 1.0, "4942": 0.31546487678572877, "4946": 1.0, "4955": 0.0, "4962": 0.6131471927654584, "4968": 0.6309297535714575, "4981": 0.7039180890341347, "4999": 0.5294362295028773, "5021": 0.0, "5030": 0.0, "5045": 0.3010299956639812, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.6309297535714575, "5080": 0.0, "5083": 0.23719771276929622, "5085": 1.0, "5086": 1.0, "5090": 0.2640681225725909, "5125": 1.0, "5134": 0.38685280723454163, "5150": 0.0, "5155": 1.0, "5172": 0.0, "5178": 0.252016380211836, "5185": 0.0, "5196": 0.2960819109658652, "5206": 0.0, "5228": 0.31546487678572877, "5231": 0.0, "5241": 0.44615333764087994, "5254": 0.6131471927654584, "5255": 1.0, "5264": 0.6843515475204855, "5271": 0.41618115554873086, "5331": 1.0, "5343": 0.3333333333333333, "5347": 1.0, "5356": 0.1208113026994942, "5369": 0.0, "5374": 0.3010299956639812, "5380": 1.0, "5402": 0.0, "5410": 0.2960819109658652, "5422": 0.24630238874073, "5427": 0.23719771276929622, "5460": 0.0, "5464": 0.16716045496620227, "5503": 0.6131471927654584, "5505": 1.0, "5511": 0.1610425878239398, "5534": 0.38685280723454163, "5549": 0.0, "5585": 0.31546487678572877, "5592": 1.0, "5616": 0.3562071871080222, "5620": 0.0, "5646": 0.9217868789962071, "5653": 1.0, "5683": 0.6934264036172708, "5710": 0.0, "5741": 0.0, "5763": 0.23463936301137822, "5782": 0.4371994911049732, "5790": 0.0, "5808": 0.5, "5853": 0.21078558563971425, "5862": 0.29127873064148246, "5888": 0.2640681225725909, "5903": 0.0, "5906": 0.44130740935663865, "5940": 0.0, "5951": 0.42750379661745125, "5970": 0.23463936301137822, "5981": 0.9896062251871525, "5993": 0.31488013066763093, "6002": 0.7788065869851872, "6004": 0.0, "6005": 0.5388856921828065, "6009": 0.0, "6041": 0.7668091220635322, "6080": 0.6131471927654584, "6110": 0.41918605213740834, "6121": 0.3065735963827292, "6122": 0.46927872602275644, "6131": 0.5810820381115676, "6133": 0.6131471927654584, "6142": 0.6131471927654584, "6146": 0.8315546295836225, "6199": 0.5135312443624667, "6219": 1.0, "6221": 0.0, "6252": 0.0, "6262": 0.6713860725233041, "6278": 0.23719771276929622, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.3562071871080222, "6467": 0.0, "6468": 0.6131471927654584, "6479": 1.0, "6525": 0.49818925746641285, "6554": 0.6131471927654584, "6562": 0.11751610475642714, "6611": 0.7903864795495061, "6612": 0.16716045496620227, "6625": 0.3010299956639812, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8503449055347546, "6679": 0.4632423659320675, "6683": 0.8772153153380493, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.3065735963827292, "6787": 0.0, "6792": 0.0, "6800": 0.43067655807339306, "6803": 0.5205067333228022, "6807": 1.0, "6814": 0.0, "6832": 0.430624116386567, "6835": 0.6131471927654584, "6849": 0.43067655807339306, "6862": 1.0, "6867": 0.22471947398559278, "6875": 0.0, "6890": 0.5012658353418871, "6891": 0.617319681505689, "6896": 0.0, "6901": 0.21840743681816419, "6907": 0.0, "6909": 0.0, "6959": 0.38685280723454163, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 0.8772153153380493, "7096": 1.0, "7098": 0.6131471927654584, "7105": 0.38685280723454163, "7109": 0.23463936301137822, "7124": 0.6525874238732422, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.3562071871080222, "7188": 0.31546487678572877, "7205": 1.0, "7206": 0.0, "7218": 0.5, "7221": 0.0, "7269": 0.0, "7279": 0.44229834886928765, "7295": 0.0, "7311": 0.0, "7326": 0.0, "7329": 0.46845052016107697, "7344": 0.6131471927654584, "7345": 0.15642624200758548, "7377": 1.0, "7431": 0.0, "7441": 0.20210734650054757, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.14606834984270645, "7467": 0.6309297535714575, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.16716045496620227, "7529": 0.38685280723454163, "7533": 0.0, "7534": 0.46927872602275644, "7590": 0.5714285040141098, "7592": 0.0, "7594": 0.3333333333333333, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.123151194370365, "7702": 0.38685280723454163, "7705": 0.49818925746641285, "7734": 0.6131471927654584, "7747": 0.21840743681816419, "7754": 0.0, "7758": 0.6309297535714575, "7801": 1.0, "7803": 0.19342640361727081, "7823": 0.6105456988825855, "7876": 0.43067655807339306, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "7936": 0.39106560501896365, "7992": 0.38685280723454163, "8002": 0.6257049680303419, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.31546487678572877, "8040": 1.0, "8072": 0.6508205185601091, "8079": 0.7039180890341347, "8102": 0.11284514134893527, "8116": 0.45749452618986164, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.6131471927654584, "8275": 0.43067655807339306, "8296": 0.8315546295836225, "8332": 0.9060254355346823, "8351": 0.6131471927654584, "8378": 0.1480409554829326, "8456": 0.6049306994552042, "8475": 0.7957503936198023, "8507": 0.0, "8512": 1.0, "8513": 0.0, "8532": 0.9325210919548239, "8537": 0.3562071871080222, "8539": 0.0, "8544": 0.6131471927654584, "8592": 0.23463936301137822, "8632": 0.2640681225725909, "8635": 0.0, "8702": 0.7653606369886217, "8779": 0.0, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.31546487678572877, "8934": 0.8065735963827293, "8937": 0.3562071871080222, "8947": 0.23719771276929622, "8959": 0.43067655807339306, "8970": 0.6509209298071326, "8974": 0.41253177989255346, "8982": 0.0, "9060": 0.38685280723454163, "9088": 0.0, "9108": 0.0, "9115": 0.5256940434743352, "9126": 0.0, "9164": 0.1480409554829326, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.20438239758848611, "9329": 1.0, "9332": 0.3562071871080222, "9381": 0.5706417189553201, "9385": 0.3562071871080222, "9391": 0.5143371794949736, "9403": 0.0, "9481": 0.6240505200038379, "9487": 0.0, "9548": 0.5, "9556": 1.0, "9565": 1.0, "9598": 0.3562071871080222, "9617": 0.3152014104491349, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.6309297535714575, "9646": 0.45749452618986164, "9668": 0.6508205185601091, "9701": 0.0, "9733": 0.18154179253735267, "9735": 0.3333333333333333, "9737": 0.7653606369886217, "9771": 0.0, "9808": 0.2960819109658652, "9824": 1.0, "9871": 0.24630238874073, "9882": 0.0, "9925": 0.8315546295836225, "9929": 0.5714285040141098, "9961": 0.0, "9979": 0.3903800499921017, "10034": 0.3065735963827292, "10039": 0.6309297535714575, "10109": 0.5399294342072939, "10122": 0.19519002499605084, "10136": 0.34337431936037655, "10137": 0.3333333333333333, "10152": 1.0, "10183": 0.3065735963827292, "10213": 0.46927872602275644, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.18154179253735267, "10462": 0.0, "10482": 0.0, "10497": 0.48864468918810133, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 1.0, "10628": 0.3010299956639812, "10639": 0.3120255505658846, "10645": 0.38685280723454163, "10674": 0.7095272044910244, "10710": 0.3333333333333333, "10734": 0.8696762340896295, "10792": 0.46845052016107697, "10808": 0.4652347214527331, "10809": 0.6049306994552042, "10812": 0.9493885684853097, "10827": 0.14606834984270645, "10845": 1.0, "10912": 0.0, "10932": 1.0, "10975": 0.0, "10979": 0.6366824387328317, "10994": 0.5, "11039": 0.315526956404728, "11054": 1.0, "11088": 0.43067655807339306}, "Recall@20": {"8": 0.5, "15": 1.0, "18": 1.0, "26": 0.5, "34": 0.0, "42": 0.3333333333333333, "56": 1.0, "68": 0.0, "89": 0.5, "90": 1.0, "94": 1.0, "98": 0.5, "104": 0.5, "106": 1.0, "109": 1.0, "475": 1.0, "503": 1.0, "504": 0.3333333333333333, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 1.0, "585": 0.5, "588": 1.0, "594": 1.0, "603": 0.0, "604": 1.0, "620": 0.2, "622": 0.5, "659": 0.7, "672": 0.5, "684": 1.0, "687": 0.5, "689": 0.0, "691": 1.0, "699": 1.0, "701": 0.3333333333333333, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.3333333333333333, "776": 0.25, "810": 1.0, "813": 1.0, "849": 1.0, "852": 0.6666666666666666, "853": 0.5, "858": 0.0, "859": 0.5, "864": 0.6666666666666666, "879": 1.0, "885": 0.5, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.5, "939": 1.0, "945": 1.0, "957": 0.6666666666666666, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.5, "1150": 0.0, "1157": 0.5, "1159": 0.0, "1198": 1.0, "1230": 1.0, "1281": 1.0, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.75, "1310": 1.0, "1321": 0.0, "1322": 0.25, "1391": 0.6666666666666666, "1393": 0.5, "1415": 1.0, "1416": 1.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 1.0, "1670": 0.6666666666666666, "1676": 1.0, "1736": 0.4, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 1.0, "1826": 1.0, "1832": 1.0, "1871": 0.75, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.4, "2010": 1.0, "2051": 1.0, "2070": 0.6666666666666666, "2075": 0.6666666666666666, "2076": 1.0, "2088": 0.0, "2108": 0.3333333333333333, "2118": 0.0, "2154": 0.0, "2181": 0.5, "2183": 0.8333333333333334, "2204": 1.0, "2264": 0.5, "2296": 0.2222222222222222, "2306": 0.5, "2316": 1.0, "2318": 1.0, "2330": 0.5, "2334": 0.6666666666666666, "2348": 0.26666666666666666, "2376": 1.0, "2383": 0.5, "2384": 1.0, "2385": 0.5, "2388": 1.0, "2395": 1.0, "2398": 0.2, "2399": 1.0, "2400": 0.6666666666666666, "2407": 0.5, "2416": 1.0, "2423": 0.8571428571428571, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.3333333333333333, "2472": 0.0, "2486": 1.0, "2498": 1.0, "2513": 1.0, "2516": 0.75, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.5, "2580": 0.3333333333333333, "2587": 1.0, "2589": 0.6666666666666666, "2590": 0.6666666666666666, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 0.25, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 0.42857142857142855, "2801": 1.0, "2856": 0.75, "2857": 0.75, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 1.0, "2923": 0.8, "2964": 0.5, "2968": 1.0, "2994": 0.3333333333333333, "3006": 0.5, "3008": 0.25, "3014": 1.0, "3033": 0.5, "3039": 1.0, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 1.0, "3091": 0.8571428571428571, "3103": 1.0, "3115": 0.5, "3125": 1.0, "3148": 0.6, "3149": 0.0, "3177": 0.6666666666666666, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.6666666666666666, "3264": 0.75, "3357": 1.0, "3369": 0.16666666666666666, "3394": 0.75, "3404": 0.42857142857142855, "3405": 1.0, "3446": 0.8, "3451": 0.42857142857142855, "3453": 1.0, "3480": 1.0, "3490": 1.0, "3500": 0.5, "3503": 0.7142857142857143, "3512": 1.0, "3528": 1.0, "3530": 0.6666666666666666, "3534": 0.0, "3566": 1.0, "3569": 1.0, "3594": 0.25, "3612": 0.75, "3615": 1.0, "3625": 0.3333333333333333, "3682": 1.0, "3683": 0.6666666666666666, "3694": 0.5, "3724": 0.0, "3735": 1.0, "3759": 0.0, "3767": 0.4, "3771": 0.3333333333333333, "3781": 1.0, "3789": 0.75, "3791": 0.6666666666666666, "3801": 0.0, "3822": 0.25, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 0.6666666666666666, "4011": 1.0, "4019": 0.4, "4031": 0.0, "4037": 0.5, "4047": 0.75, "4071": 0.0, "4084": 1.0, "4102": 0.25, "4103": 0.0, "4105": 0.0, "4116": 0.5, "4125": 0.0, "4142": 0.75, "4153": 1.0, "4179": 1.0, "4188": 1.0, "4205": 0.6666666666666666, "4233": 0.8, "4265": 0.6666666666666666, "4286": 0.5, "4289": 0.5, "4306": 0.75, "4312": 0.8571428571428571, "4335": 0.75, "4339": 1.0, "4394": 0.0, "4409": 0.2, "4411": 0.6666666666666666, "4414": 1.0, "4415": 0.0, "4433": 0.5, "4447": 1.0, "4464": 1.0, "4465": 0.6666666666666666, "4484": 1.0, "4499": 0.3333333333333333, "4500": 0.5, "4504": 1.0, "4514": 0.5, "4523": 0.2, "4539": 0.5, "4571": 0.6666666666666666, "4600": 1.0, "4605": 0.7142857142857143, "4615": 0.6666666666666666, "4640": 0.0, "4641": 0.6, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.6666666666666666, "4846": 0.0, "4863": 1.0, "4865": 0.0, "4920": 1.0, "4942": 1.0, "4946": 1.0, "4955": 0.0, "4962": 0.5, "4968": 1.0, "4981": 0.6666666666666666, "4999": 0.75, "5021": 0.0, "5030": 0.0, "5045": 1.0, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 1.0, "5080": 0.0, "5083": 0.5, "5085": 1.0, "5086": 1.0, "5090": 0.5, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 1.0, "5178": 0.4, "5185": 0.0, "5196": 0.3333333333333333, "5206": 0.0, "5228": 1.0, "5231": 1.0, "5241": 0.4, "5254": 0.5, "5255": 1.0, "5264": 0.6, "5271": 1.0, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.4, "5369": 0.0, "5374": 1.0, "5380": 1.0, "5402": 0.5, "5410": 0.3333333333333333, "5422": 0.75, "5427": 0.5, "5460": 0.0, "5464": 0.3333333333333333, "5503": 0.5, "5505": 1.0, "5511": 0.3, "5534": 0.5, "5549": 0.0, "5585": 1.0, "5592": 1.0, "5616": 1.0, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.5, "5763": 0.6666666666666666, "5782": 0.4, "5790": 0.0, "5808": 1.0, "5853": 0.375, "5862": 0.5, "5888": 0.5, "5903": 0.0, "5906": 1.0, "5940": 0.0, "5951": 0.5555555555555556, "5970": 0.6666666666666666, "5981": 1.0, "5993": 0.2, "6002": 0.9090909090909091, "6004": 0.0, "6005": 0.38461538461538464, "6009": 1.0, "6041": 0.75, "6080": 0.5, "6110": 0.375, "6121": 0.5, "6122": 0.3333333333333333, "6131": 0.4166666666666667, "6133": 0.5, "6142": 0.5, "6146": 1.0, "6199": 0.5, "6219": 1.0, "6221": 0.125, "6252": 0.0, "6262": 0.6666666666666666, "6278": 1.0, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 1.0, "6467": 0.0, "6468": 0.5, "6479": 1.0, "6525": 0.6666666666666666, "6554": 0.5, "6562": 0.5, "6611": 1.0, "6612": 0.3333333333333333, "6625": 1.0, "6629": 0.0, "6635": 0.5, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 1.0, "6683": 1.0, "6713": 0.5, "6715": 1.0, "6746": 0.5, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.75, "6807": 1.0, "6814": 0.0, "6832": 1.0, "6835": 0.5, "6849": 1.0, "6862": 1.0, "6867": 0.42857142857142855, "6875": 0.0, "6890": 1.0, "6891": 0.6666666666666666, "6896": 0.0, "6901": 0.5, "6907": 0.0, "6909": 0.0, "6959": 1.0, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 1.0, "7109": 0.6666666666666666, "7124": 0.75, "7141": 0.5, "7145": 0.3333333333333333, "7178": 1.0, "7188": 1.0, "7205": 1.0, "7206": 0.0, "7218": 1.0, "7221": 0.0, "7269": 1.0, "7279": 0.75, "7295": 0.0, "7311": 1.0, "7326": 0.0, "7329": 1.0, "7344": 0.5, "7345": 0.6666666666666666, "7377": 1.0, "7431": 0.0, "7441": 0.3333333333333333, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.4, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 1.0, "7513": 0.6666666666666666, "7529": 0.5, "7533": 0.5, "7534": 0.3333333333333333, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.5, "7674": 0.3333333333333333, "7700": 0.25, "7702": 1.0, "7705": 0.6666666666666666, "7734": 0.5, "7747": 0.5, "7754": 1.0, "7758": 1.0, "7801": 1.0, "7803": 0.5, "7823": 0.6666666666666666, "7876": 1.0, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.16666666666666666, "7928": 0.25, "7936": 0.6666666666666666, "7992": 1.0, "8002": 0.6666666666666666, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 1.0, "8040": 1.0, "8072": 0.6666666666666666, "8079": 1.0, "8102": 0.25, "8116": 1.0, "8121": 1.0, "8202": 0.0, "8230": 1.0, "8247": 0.0, "8271": 0.5, "8275": 1.0, "8296": 1.0, "8332": 1.0, "8351": 0.5, "8378": 0.3333333333333333, "8456": 0.6666666666666666, "8475": 0.8571428571428571, "8507": 0.3333333333333333, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 1.0, "8539": 0.25, "8544": 0.5, "8592": 0.6666666666666666, "8632": 1.0, "8635": 0.0, "8702": 0.6666666666666666, "8779": 1.0, "8789": 0.6666666666666666, "8795": 1.0, "8832": 1.0, "8834": 0.5, "8855": 0.0, "8874": 1.0, "8934": 1.0, "8937": 1.0, "8947": 0.5, "8959": 1.0, "8970": 1.0, "8974": 0.25, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 1.0, "9126": 0.0, "9164": 0.3333333333333333, "9174": 0.2, "9188": 0.5, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 1.0, "9381": 1.0, "9385": 1.0, "9391": 0.75, "9403": 0.0, "9481": 1.0, "9487": 1.0, "9548": 1.0, "9556": 1.0, "9565": 1.0, "9598": 1.0, "9617": 0.6666666666666666, "9633": 0.5, "9643": 1.0, "9644": 1.0, "9646": 1.0, "9668": 1.0, "9701": 0.0, "9733": 0.3333333333333333, "9735": 1.0, "9737": 0.6666666666666666, "9771": 0.0, "9808": 0.3333333333333333, "9824": 1.0, "9871": 0.25, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 0.5, "10034": 0.5, "10039": 1.0, "10109": 0.42857142857142855, "10122": 0.5, "10136": 0.6666666666666666, "10137": 1.0, "10152": 1.0, "10183": 1.0, "10213": 0.3333333333333333, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.3333333333333333, "10462": 0.0, "10482": 0.0, "10497": 0.7, "10526": 0.5, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 1.0, "10639": 0.4, "10645": 1.0, "10674": 1.0, "10710": 1.0, "10734": 1.0, "10792": 1.0, "10808": 1.0, "10809": 0.6666666666666666, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 1.0, "10932": 1.0, "10975": 0.0, "10979": 0.75, "10994": 1.0, "11039": 0.5, "11054": 1.0, "11088": 1.0}, "MRR@10": {"8": 1.0, "15": 0.16666666666666666, "18": 0.5, "26": 0.2, "34": 0.0, "42": 1.0, "56": 0.16666666666666666, "68": 0.0, "89": 0.5, "90": 0.5, "94": 1.0, "98": 1.0, "104": 1.0, "106": 0.3333333333333333, "109": 1.0, "475": 1.0, "503": 0.08333333333333333, "504": 0.05555555555555555, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.14285714285714285, "559": 0.0, "570": 0.06666666666666667, "585": 0.25, "588": 0.25, "594": 1.0, "603": 0.0, "604": 0.16666666666666666, "620": 0.08333333333333333, "622": 0.5, "659": 1.0, "672": 0.07692307692307693, "684": 0.05555555555555555, "687": 0.125, "689": 0.0, "691": 0.5, "699": 1.0, "701": 0.1, "715": 0.0, "721": 1.0, "744": 0.2, "750": 1.0, "753": 0.5, "766": 0.2, "776": 1.0, "810": 0.14285714285714285, "813": 0.14285714285714285, "849": 0.14285714285714285, "852": 1.0, "853": 0.09090909090909091, "858": 0.0, "859": 0.5, "864": 1.0, "879": 0.5, "885": 0.125, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.3333333333333333, "939": 0.3333333333333333, "945": 0.1111111111111111, "957": 1.0, "988": 0.0, "1074": 0.5, "1085": 0.0, "1090": 0.2, "1150": 0.0, "1157": 1.0, "1159": 0.0, "1198": 1.0, "1230": 0.07142857142857142, "1281": 0.2, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.5, "1310": 1.0, "1321": 0.0, "1322": 0.5, "1391": 0.2, "1393": 1.0, "1415": 1.0, "1416": 0.058823529411764705, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.5, "1670": 1.0, "1676": 0.5, "1736": 1.0, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 0.125, "1826": 1.0, "1832": 0.3333333333333333, "1871": 1.0, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.5, "2010": 1.0, "2051": 0.07142857142857142, "2070": 0.2, "2075": 1.0, "2076": 0.3333333333333333, "2088": 0.0, "2108": 0.16666666666666666, "2118": 0.0, "2154": 0.0, "2181": 0.05263157894736842, "2183": 1.0, "2204": 1.0, "2264": 0.3333333333333333, "2296": 1.0, "2306": 1.0, "2316": 1.0, "2318": 0.125, "2330": 1.0, "2334": 1.0, "2348": 1.0, "2376": 1.0, "2383": 1.0, "2384": 0.5, "2385": 1.0, "2388": 1.0, "2395": 1.0, "2398": 0.08333333333333333, "2399": 1.0, "2400": 0.5, "2407": 0.5, "2416": 1.0, "2423": 1.0, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0625, "2472": 0.0, "2486": 1.0, "2498": 0.25, "2513": 0.0625, "2516": 1.0, "2549": 1.0, "2551": 1.0, "2568": 0.5, "2579": 0.5, "2580": 1.0, "2587": 1.0, "2589": 1.0, "2590": 1.0, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 0.3333333333333333, "2685": 1.0, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 0.3333333333333333, "2749": 1.0, "2790": 1.0, "2801": 1.0, "2856": 1.0, "2857": 1.0, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.1111111111111111, "2923": 1.0, "2964": 0.07692307692307693, "2968": 1.0, "2994": 1.0, "3006": 0.3333333333333333, "3008": 0.5, "3014": 1.0, "3033": 0.5, "3039": 0.2, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 0.125, "3091": 1.0, "3103": 0.5, "3115": 1.0, "3125": 1.0, "3148": 1.0, "3149": 0.0, "3177": 0.14285714285714285, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 1.0, "3264": 1.0, "3357": 1.0, "3369": 0.09090909090909091, "3394": 0.5, "3404": 1.0, "3405": 0.09090909090909091, "3446": 1.0, "3451": 0.1, "3453": 0.3333333333333333, "3480": 1.0, "3490": 0.1, "3500": 1.0, "3503": 0.5, "3512": 1.0, "3528": 0.5, "3530": 0.5, "3534": 0.0, "3566": 1.0, "3569": 0.3333333333333333, "3594": 0.125, "3612": 0.1111111111111111, "3615": 0.25, "3625": 0.25, "3682": 0.14285714285714285, "3683": 1.0, "3694": 1.0, "3724": 0.0, "3735": 0.09090909090909091, "3759": 0.0, "3767": 0.3333333333333333, "3771": 0.14285714285714285, "3781": 1.0, "3789": 1.0, "3791": 0.5, "3801": 0.0, "3822": 0.05263157894736842, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 1.0, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 1.0, "4011": 1.0, "4019": 0.5, "4031": 0.0, "4037": 0.1111111111111111, "4047": 1.0, "4071": 0.0, "4084": 0.25, "4102": 0.06666666666666667, "4103": 0.0, "4105": 0.0, "4116": 1.0, "4125": 0.0, "4142": 0.16666666666666666, "4153": 0.125, "4179": 0.5, "4188": 0.0625, "4205": 0.5, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 0.2, "4306": 1.0, "4312": 1.0, "4335": 1.0, "4339": 1.0, "4394": 0.0, "4409": 0.3333333333333333, "4411": 1.0, "4414": 1.0, "4415": 0.0, "4433": 0.09090909090909091, "4447": 1.0, "4464": 0.3333333333333333, "4465": 0.5, "4484": 0.5, "4499": 0.05555555555555555, "4500": 0.07142857142857142, "4504": 1.0, "4514": 1.0, "4523": 0.5, "4539": 0.16666666666666666, "4571": 1.0, "4600": 1.0, "4605": 1.0, "4615": 0.5, "4640": 0.0, "4641": 0.2, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 1.0, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 0.16666666666666666, "4837": 0.0, "4844": 1.0, "4845": 1.0, "4846": 0.0, "4863": 0.5, "4865": 0.0, "4920": 1.0, "4942": 0.125, "4946": 1.0, "4955": 0.0, "4962": 1.0, "4968": 0.5, "4981": 1.0, "4999": 1.0, "5021": 0.0, "5030": 0.0, "5045": 0.1111111111111111, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.5, "5080": 0.0, "5083": 0.2, "5085": 1.0, "5086": 1.0, "5090": 0.25, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 0.09090909090909091, "5178": 0.2, "5185": 0.0, "5196": 0.5, "5206": 0.0, "5228": 0.125, "5231": 0.058823529411764705, "5241": 1.0, "5254": 1.0, "5255": 1.0, "5264": 1.0, "5271": 0.3333333333333333, "5331": 1.0, "5343": 0.14285714285714285, "5347": 1.0, "5356": 0.16666666666666666, "5369": 0.0, "5374": 0.1111111111111111, "5380": 1.0, "5402": 0.0625, "5410": 0.5, "5422": 0.5, "5427": 0.2, "5460": 0.0, "5464": 0.16666666666666666, "5503": 1.0, "5505": 1.0, "5511": 0.25, "5534": 0.5, "5549": 0.0, "5585": 0.125, "5592": 1.0, "5616": 0.16666666666666666, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 0.5, "5710": 0.0, "5741": 0.0625, "5763": 0.3333333333333333, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.25, "5888": 0.25, "5903": 0.0, "5906": 0.25, "5940": 0.0, "5951": 0.5, "5970": 0.3333333333333333, "5981": 1.0, "5993": 1.0, "6002": 1.0, "6004": 0.0, "6005": 1.0, "6009": 0.09090909090909091, "6041": 1.0, "6080": 1.0, "6110": 1.0, "6121": 0.3333333333333333, "6122": 1.0, "6131": 1.0, "6133": 1.0, "6142": 1.0, "6146": 1.0, "6199": 1.0, "6219": 1.0, "6221": 0.05, "6252": 0.0, "6262": 1.0, "6278": 0.2, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.16666666666666666, "6467": 0.0, "6468": 1.0, "6479": 1.0, "6525": 0.5, "6554": 1.0, "6562": 0.1111111111111111, "6611": 1.0, "6612": 0.16666666666666666, "6625": 0.1111111111111111, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 1.0, "6713": 1.0, "6715": 1.0, "6746": 0.3333333333333333, "6787": 0.0, "6792": 0.0, "6800": 0.25, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.2, "6835": 1.0, "6849": 0.25, "6862": 1.0, "6867": 0.25, "6875": 0.0, "6890": 0.25, "6891": 1.0, "6896": 0.0, "6901": 0.16666666666666666, "6907": 0.0, "6909": 0.0, "6959": 0.5, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 0.2, "7109": 0.3333333333333333, "7124": 1.0, "7141": 0.0625, "7145": 0.1, "7178": 0.16666666666666666, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.3333333333333333, "7221": 0.0, "7269": 0.06666666666666667, "7279": 0.25, "7295": 0.0, "7311": 0.09090909090909091, "7326": 0.0, "7329": 0.25, "7344": 1.0, "7345": 0.14285714285714285, "7377": 1.0, "7431": 0.0, "7441": 0.25, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.25, "7467": 0.5, "7484": 1.0, "7509": 0.0, "7512": 0.0625, "7513": 0.16666666666666666, "7529": 0.5, "7533": 0.08333333333333333, "7534": 1.0, "7590": 0.5, "7592": 0.0, "7594": 0.14285714285714285, "7622": 0.0, "7633": 1.0, "7674": 0.0625, "7700": 0.125, "7702": 0.5, "7705": 0.5, "7734": 1.0, "7747": 0.16666666666666666, "7754": 0.08333333333333333, "7758": 0.5, "7801": 1.0, "7803": 0.125, "7823": 1.0, "7876": 0.25, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.5, "7928": 0.5, "7936": 0.3333333333333333, "7992": 0.5, "8002": 1.0, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.125, "8040": 1.0, "8072": 1.0, "8079": 1.0, "8102": 0.1, "8116": 0.25, "8121": 1.0, "8202": 0.0, "8230": 0.0625, "8247": 0.0, "8271": 1.0, "8275": 0.25, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.125, "8456": 1.0, "8475": 1.0, "8507": 0.09090909090909091, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 0.16666666666666666, "8539": 0.09090909090909091, "8544": 1.0, "8592": 0.3333333333333333, "8632": 0.25, "8635": 0.0, "8702": 1.0, "8779": 0.09090909090909091, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.125, "8934": 1.0, "8937": 0.16666666666666666, "8947": 0.2, "8959": 0.25, "8970": 0.5, "8974": 1.0, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 0.25, "9126": 0.0, "9164": 0.125, "9174": 0.07142857142857142, "9188": 1.0, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.14285714285714285, "9329": 1.0, "9332": 0.16666666666666666, "9381": 0.3333333333333333, "9385": 0.16666666666666666, "9391": 0.3333333333333333, "9403": 0.0, "9481": 0.5, "9487": 0.08333333333333333, "9548": 0.3333333333333333, "9556": 1.0, "9565": 1.0, "9598": 0.16666666666666666, "9617": 0.16666666666666666, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.5, "9646": 0.25, "9668": 1.0, "9701": 0.0, "9733": 0.2, "9735": 0.14285714285714285, "9737": 1.0, "9771": 0.0, "9808": 0.5, "9824": 1.0, "9871": 0.5, "9882": 0.0, "9925": 1.0, "9929": 0.5, "9961": 0.0, "9979": 1.0, "10034": 0.3333333333333333, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.25, "10137": 0.14285714285714285, "10152": 1.0, "10183": 0.3333333333333333, "10213": 1.0, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.2, "10462": 0.0, "10482": 0.0, "10497": 1.0, "10526": 0.14285714285714285, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 0.1111111111111111, "10639": 0.5, "10645": 0.5, "10674": 1.0, "10710": 0.14285714285714285, "10734": 1.0, "10792": 0.25, "10808": 0.2, "10809": 1.0, "10812": 1.0, "10827": 0.25, "10845": 1.0, "10912": 0.08333333333333333, "10932": 1.0, "10975": 0.0, "10979": 1.0, "10994": 0.3333333333333333, "11039": 0.5, "11054": 1.0, "11088": 0.25}}} diff --git a/evals/benchmark/results/fiqa/ir-w0.75.jsonl b/evals/benchmark/results/fiqa/ir-w0.75.jsonl new file mode 100644 index 000000000..8d217a03c --- /dev/null +++ b/evals/benchmark/results/fiqa/ir-w0.75.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "w0.75", "aggregated": {"nDCG@10": 0.4289, "Recall@20": 0.6186, "MRR@10": 0.4986}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 0.3562071871080222, "18": 0.6309297535714575, "26": 0.23719771276929622, "34": 0.0, "42": 0.46927872602275644, "56": 0.3562071871080222, "68": 0.0, "89": 0.286381299268402, "90": 0.6309297535714575, "94": 1.0, "98": 0.6131471927654584, "104": 0.6131471927654584, "106": 0.5, "109": 1.0, "475": 1.0, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.3333333333333333, "559": 0.0, "570": 0.0, "585": 0.2640681225725909, "588": 0.5714285040141098, "594": 0.6131471927654584, "603": 0.0, "604": 0.3235866969737877, "620": 0.0, "622": 0.38685280723454163, "659": 0.43828689407543014, "672": 0.0, "684": 0.0, "687": 0.19342640361727081, "689": 0.0, "691": 0.6309297535714575, "699": 1.0, "701": 0.13565197343244778, "715": 0.0, "721": 1.0, "744": 0.18154179253735267, "750": 0.8503449055347546, "753": 0.38685280723454163, "766": 0.18154179253735267, "776": 0.3557772116892465, "810": 0.3333333333333333, "813": 0.20438239758848611, "849": 0.3333333333333333, "852": 0.7653606369886217, "853": 0.0, "858": 0.0, "859": 0.38685280723454163, "864": 0.7247145167543899, "879": 0.6309297535714575, "885": 0.19342640361727081, "895": 1.0, "904": 1.0, "928": 0.6131471927654584, "929": 1.0, "932": 0.3065735963827292, "939": 0.5, "945": 0.3010299956639812, "957": 0.7039180890341347, "988": 0.0, "1074": 0.6309297535714575, "1085": 0.0, "1090": 0.23719771276929622, "1150": 0.0, "1157": 0.6131471927654584, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 0.38685280723454163, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.5319460297682747, "1310": 1.0, "1321": 0.0, "1322": 0.24630238874073, "1391": 0.18154179253735267, "1393": 0.19092086617893467, "1415": 0.9828920819566879, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.431733884398313, "1670": 0.7653606369886217, "1676": 0.6542448095688422, "1736": 0.5531464700081437, "1748": 0.6049306994552042, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.286381299268402, "1824": 0.31546487678572877, "1826": 1.0, "1832": 0.5, "1871": 0.6422813708518126, "1877": 1.0, "1889": 0.0, "1915": 0.8772153153380493, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.21398626473452756, "2010": 0.8194270280062366, "2051": 0.0, "2070": 0.23463936301137822, "2075": 0.4880470105041527, "2076": 0.5706417189553201, "2088": 0.0, "2108": 0.16716045496620227, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.7526136409516659, "2204": 0.9830168297915423, "2264": 0.38685280723454163, "2296": 0.33627415762678553, "2306": 0.6131471927654584, "2316": 1.0, "2318": 0.31546487678572877, "2330": 0.6131471927654584, "2334": 0.46927872602275644, "2348": 0.43231813227099475, "2376": 0.8910635073822442, "2383": 0.6131471927654584, "2384": 0.6309297535714575, "2385": 0.6131471927654584, "2388": 1.0, "2395": 1.0, "2398": 0.0, "2399": 1.0, "2400": 0.5307212739772434, "2407": 0.24630238874073, "2416": 0.9058653015743079, "2423": 0.3576223542196109, "2443": 0.0, "2445": 1.0, "2460": 0.9469024295259745, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.43067655807339306, "2513": 0.0, "2516": 0.5585075862632192, "2549": 0.6131471927654584, "2551": 1.0, "2568": 0.21689524588991285, "2579": 0.2423936099728648, "2580": 0.46927872602275644, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.8854598815714874, "2598": 0.8503449055347546, "2648": 1.0, "2676": 0.5, "2685": 0.35079429740281753, "2695": 1.0, "2713": 0.6131471927654584, "2724": 0.8175295903539445, "2737": 0.6309297535714575, "2747": 0.5, "2749": 0.8772153153380493, "2790": 0.47997295436377346, "2801": 0.6131471927654584, "2856": 0.7095272044910244, "2857": 0.6595629128335778, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.3010299956639812, "2923": 0.8207658584763088, "2964": 0.0, "2968": 0.6509209298071326, "2994": 0.46927872602275644, "3006": 0.25909036127391766, "3008": 0.24630238874073, "3014": 1.0, "3033": 0.3065735963827292, "3039": 0.43067655807339306, "3049": 0.24630238874073, "3051": 0.9197207891481876, "3067": 0.0, "3085": 0.19342640361727081, "3091": 0.9020870746500321, "3103": 0.5, "3115": 0.4935232796777481, "3125": 0.6309297535714575, "3148": 0.5531464700081437, "3149": 0.0, "3177": 0.15642624200758548, "3179": 0.8315546295836225, "3186": 1.0, "3189": 0.0, "3254": 0.6713860725233041, "3264": 0.8048099750039491, "3357": 1.0, "3369": 0.0, "3394": 0.5805485932475565, "3404": 0.3932591258696538, "3405": 0.0, "3446": 0.4340327988596634, "3451": 0.07945707943276742, "3453": 0.5706417189553201, "3480": 1.0, "3490": 0.2890648263178879, "3500": 0.644824486427155, "3503": 0.6183313187362977, "3512": 0.8503449055347546, "3528": 0.6309297535714575, "3530": 0.4776237035032179, "3534": 0.0, "3566": 0.8194270280062366, "3569": 0.5, "3594": 0.123151194370365, "3612": 0.11751610475642714, "3615": 0.430624116386567, "3625": 0.20210734650054757, "3682": 0.20438239758848611, "3683": 0.5982291239616433, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.0, "3759": 0.0, "3767": 0.2716774977597197, "3771": 0.19632790425573848, "3781": 0.9197207891481876, "3789": 0.75369761125927, "3791": 0.431733884398313, "3801": 0.0, "3822": 0.0, "3829": 0.0, "3830": 0.6309297535714575, "3837": 0.6309297535714575, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5517854393872873, "3932": 0.0, "3934": 0.16812753627111746, "3995": 0.0, "4007": 0.7653606369886217, "4011": 0.9674679834891693, "4019": 0.31608365985743925, "4031": 0.0, "4037": 0.18457569677956817, "4047": 0.8318724637288826, "4071": 0.0, "4084": 0.5012658353418871, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.39233405721184117, "4153": 0.31546487678572877, "4179": 0.6309297535714575, "4188": 0.0, "4205": 0.4525081529734507, "4233": 0.8687949224876582, "4265": 0.7751482523375255, "4286": 0.6131471927654584, "4289": 0.23719771276929622, "4306": 0.7598336331031966, "4312": 0.7837042816946693, "4335": 0.8318724637288826, "4339": 1.0, "4394": 0.0, "4409": 0.19518900079066107, "4411": 0.46927872602275644, "4414": 0.8315546295836225, "4415": 0.0, "4433": 0.0, "4447": 1.0, "4464": 0.5, "4465": 0.2960819109658652, "4484": 0.6309297535714575, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.4034698846650846, "4523": 0.21398626473452756, "4539": 0.21840743681816419, "4571": 0.7653606369886217, "4600": 1.0, "4605": 0.5585830187272559, "4615": 0.4816421678943211, "4640": 0.0, "4641": 0.252016380211836, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75369761125927, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.6131471927654584, "4813": 1.0, "4823": 0.46927872602275644, "4827": 0.3562071871080222, "4837": 0.0, "4844": 1.0, "4845": 0.7653606369886217, "4846": 0.0, "4863": 0.49818925746641285, "4865": 0.0, "4920": 1.0, "4942": 0.31546487678572877, "4946": 1.0, "4955": 0.0, "4962": 0.6131471927654584, "4968": 0.6309297535714575, "4981": 0.7653606369886217, "4999": 0.5294362295028773, "5021": 0.0, "5030": 0.0, "5045": 0.3010299956639812, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.5, "5080": 0.0, "5083": 0.23719771276929622, "5085": 1.0, "5086": 0.6309297535714575, "5090": 0.2640681225725909, "5125": 1.0, "5134": 0.38685280723454163, "5150": 0.0, "5155": 1.0, "5172": 0.0, "5178": 0.252016380211836, "5185": 0.0, "5196": 0.2960819109658652, "5206": 0.0, "5228": 0.31546487678572877, "5231": 0.0, "5241": 0.44615333764087994, "5254": 0.6131471927654584, "5255": 1.0, "5264": 0.6843515475204855, "5271": 0.41618115554873086, "5331": 1.0, "5343": 0.3333333333333333, "5347": 1.0, "5356": 0.1208113026994942, "5369": 0.0, "5374": 0.3010299956639812, "5380": 1.0, "5402": 0.0, "5410": 0.2960819109658652, "5422": 0.19519002499605084, "5427": 0.23719771276929622, "5460": 0.0, "5464": 0.16716045496620227, "5503": 0.38685280723454163, "5505": 1.0, "5511": 0.1610425878239398, "5534": 0.38685280723454163, "5549": 0.0, "5585": 0.31546487678572877, "5592": 1.0, "5616": 0.3562071871080222, "5620": 0.0, "5646": 0.9217868789962071, "5653": 1.0, "5683": 0.9197207891481876, "5710": 0.0, "5741": 0.0, "5763": 0.23463936301137822, "5782": 0.4371994911049732, "5790": 0.0, "5808": 0.5, "5853": 0.21078558563971425, "5862": 0.29127873064148246, "5888": 0.2640681225725909, "5903": 0.0, "5906": 0.44130740935663865, "5940": 0.0, "5951": 0.42030067999766585, "5970": 0.23463936301137822, "5981": 0.9896062251871525, "5993": 0.31488013066763093, "6002": 0.762416491594312, "6004": 0.0, "6005": 0.5388856921828065, "6009": 0.0, "6041": 0.7668091220635322, "6080": 0.6131471927654584, "6110": 0.41918605213740834, "6121": 0.3065735963827292, "6122": 0.46927872602275644, "6131": 0.5810820381115676, "6133": 0.6131471927654584, "6142": 0.6131471927654584, "6146": 0.8315546295836225, "6199": 0.5135312443624667, "6219": 1.0, "6221": 0.0, "6252": 0.0, "6262": 0.49818925746641285, "6278": 0.2640681225725909, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.38685280723454163, "6467": 0.0, "6468": 0.6131471927654584, "6479": 1.0, "6525": 0.49818925746641285, "6554": 0.6131471927654584, "6562": 0.11751610475642714, "6611": 0.7903864795495061, "6612": 0.16716045496620227, "6625": 0.0, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8503449055347546, "6679": 0.4632423659320675, "6683": 0.8772153153380493, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.2640681225725909, "6787": 0.0, "6792": 0.0, "6800": 0.43067655807339306, "6803": 0.5135312443624667, "6807": 1.0, "6814": 0.0, "6832": 0.430624116386567, "6835": 0.6131471927654584, "6849": 0.5, "6862": 1.0, "6867": 0.22471947398559278, "6875": 0.0, "6890": 0.5012658353418871, "6891": 0.617319681505689, "6896": 0.0, "6901": 0.21840743681816419, "6907": 0.0, "6909": 0.0, "6959": 0.38685280723454163, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 0.8503449055347546, "7096": 0.6309297535714575, "7098": 0.6131471927654584, "7105": 0.38685280723454163, "7109": 0.2960819109658652, "7124": 0.5085097626218706, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.3562071871080222, "7188": 0.31546487678572877, "7205": 1.0, "7206": 0.0, "7218": 0.43067655807339306, "7221": 0.0, "7269": 0.0, "7279": 0.44229834886928765, "7295": 0.0, "7311": 0.0, "7326": 0.0, "7329": 0.46845052016107697, "7344": 0.6131471927654584, "7345": 0.15642624200758548, "7377": 1.0, "7431": 0.0, "7441": 0.20210734650054757, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.14606834984270645, "7467": 0.6309297535714575, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.16716045496620227, "7529": 0.3065735963827292, "7533": 0.0, "7534": 0.46927872602275644, "7590": 0.7977228895450266, "7592": 0.0, "7594": 0.3333333333333333, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.123151194370365, "7702": 0.38685280723454163, "7705": 0.49818925746641285, "7734": 0.6131471927654584, "7747": 0.20438239758848611, "7754": 0.0, "7758": 0.6309297535714575, "7801": 1.0, "7803": 0.19342640361727081, "7823": 0.6105456988825855, "7876": 0.38685280723454163, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "7936": 0.40179981797758046, "7992": 0.38685280723454163, "8002": 0.6257049680303419, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.31546487678572877, "8040": 1.0, "8072": 0.4776237035032179, "8079": 0.7039180890341347, "8102": 0.11284514134893527, "8116": 0.45749452618986164, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.6131471927654584, "8275": 0.43067655807339306, "8296": 0.8315546295836225, "8332": 0.9060254355346823, "8351": 0.6131471927654584, "8378": 0.13565197343244778, "8456": 0.6049306994552042, "8475": 0.7957503936198023, "8507": 0.0, "8512": 1.0, "8513": 0.0, "8532": 0.9325210919548239, "8537": 0.3562071871080222, "8539": 0.0, "8544": 0.6131471927654584, "8592": 0.23463936301137822, "8632": 0.21840743681816419, "8635": 0.0, "8702": 0.7653606369886217, "8779": 0.17723928678404774, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.3333333333333333, "8934": 0.8065735963827293, "8937": 0.3562071871080222, "8947": 0.23719771276929622, "8959": 0.43067655807339306, "8970": 0.8772153153380493, "8974": 0.41253177989255346, "8982": 0.0, "9060": 0.6131471927654584, "9088": 0.0, "9108": 0.0, "9115": 0.5256940434743352, "9126": 0.0, "9164": 0.1480409554829326, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.20438239758848611, "9329": 1.0, "9332": 0.3562071871080222, "9381": 0.5706417189553201, "9385": 0.3562071871080222, "9391": 0.5143371794949736, "9403": 0.0, "9481": 0.6240505200038379, "9487": 0.0, "9548": 0.43067655807339306, "9556": 1.0, "9565": 1.0, "9598": 0.3562071871080222, "9617": 0.3152014104491349, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.6309297535714575, "9646": 0.45749452618986164, "9668": 0.6508205185601091, "9701": 0.0, "9733": 0.18154179253735267, "9735": 0.3333333333333333, "9737": 0.7653606369886217, "9771": 0.0, "9808": 0.2960819109658652, "9824": 1.0, "9871": 0.24630238874073, "9882": 0.0, "9925": 0.8315546295836225, "9929": 0.5714285040141098, "9961": 0.0, "9979": 0.3903800499921017, "10034": 0.3065735963827292, "10039": 0.6309297535714575, "10109": 0.5399294342072939, "10122": 0.19519002499605084, "10136": 0.34337431936037655, "10137": 0.3333333333333333, "10152": 1.0, "10183": 0.3065735963827292, "10213": 0.46927872602275644, "10246": 0.0, "10267": 0.0, "10414": 0.9197207891481876, "10447": 0.18154179253735267, "10462": 0.0, "10482": 0.0, "10497": 0.49828993591603105, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 1.0, "10628": 0.3010299956639812, "10639": 0.3120255505658846, "10645": 0.38685280723454163, "10674": 0.7095272044910244, "10710": 0.3333333333333333, "10734": 0.8486987932505933, "10792": 0.4227898344066503, "10808": 0.4652347214527331, "10809": 0.6049306994552042, "10812": 0.9619991470595832, "10827": 0.14606834984270645, "10845": 1.0, "10912": 0.0, "10932": 1.0, "10975": 0.0, "10979": 0.6366824387328317, "10994": 0.4911492931622974, "11039": 0.315526956404728, "11054": 1.0, "11088": 0.43067655807339306}, "Recall@20": {"8": 0.5, "15": 1.0, "18": 1.0, "26": 0.5, "34": 0.0, "42": 0.3333333333333333, "56": 1.0, "68": 0.0, "89": 0.5, "90": 1.0, "94": 1.0, "98": 0.5, "104": 0.5, "106": 1.0, "109": 1.0, "475": 1.0, "503": 1.0, "504": 0.3333333333333333, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 1.0, "585": 0.5, "588": 1.0, "594": 1.0, "603": 0.0, "604": 1.0, "620": 0.2, "622": 0.5, "659": 0.7, "672": 0.5, "684": 1.0, "687": 0.5, "689": 0.0, "691": 1.0, "699": 1.0, "701": 0.3333333333333333, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.3333333333333333, "776": 0.25, "810": 1.0, "813": 1.0, "849": 1.0, "852": 0.6666666666666666, "853": 0.5, "858": 0.0, "859": 0.5, "864": 0.6666666666666666, "879": 1.0, "885": 0.5, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.5, "939": 1.0, "945": 1.0, "957": 0.6666666666666666, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.5, "1150": 0.0, "1157": 0.5, "1159": 0.0, "1198": 1.0, "1230": 1.0, "1281": 1.0, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.75, "1310": 1.0, "1321": 0.0, "1322": 0.25, "1391": 0.6666666666666666, "1393": 0.5, "1415": 1.0, "1416": 1.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 1.0, "1670": 0.6666666666666666, "1676": 1.0, "1736": 0.4, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 1.0, "1826": 1.0, "1832": 1.0, "1871": 0.75, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.4, "2010": 1.0, "2051": 1.0, "2070": 0.6666666666666666, "2075": 0.6666666666666666, "2076": 1.0, "2088": 0.0, "2108": 0.3333333333333333, "2118": 0.0, "2154": 0.0, "2181": 0.5, "2183": 0.8333333333333334, "2204": 1.0, "2264": 0.5, "2296": 0.2222222222222222, "2306": 0.5, "2316": 1.0, "2318": 1.0, "2330": 0.5, "2334": 0.6666666666666666, "2348": 0.26666666666666666, "2376": 1.0, "2383": 0.5, "2384": 1.0, "2385": 0.5, "2388": 1.0, "2395": 1.0, "2398": 0.2, "2399": 1.0, "2400": 0.6666666666666666, "2407": 0.5, "2416": 1.0, "2423": 0.8571428571428571, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.3333333333333333, "2472": 0.0, "2486": 1.0, "2498": 1.0, "2513": 1.0, "2516": 0.75, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.5, "2580": 0.3333333333333333, "2587": 1.0, "2589": 0.6666666666666666, "2590": 0.6666666666666666, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 0.25, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 0.42857142857142855, "2801": 1.0, "2856": 0.75, "2857": 0.75, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 1.0, "2923": 0.8, "2964": 0.5, "2968": 1.0, "2994": 0.3333333333333333, "3006": 0.5, "3008": 0.25, "3014": 1.0, "3033": 0.5, "3039": 1.0, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 1.0, "3091": 0.8571428571428571, "3103": 1.0, "3115": 0.5, "3125": 1.0, "3148": 0.6, "3149": 0.0, "3177": 0.6666666666666666, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.6666666666666666, "3264": 0.75, "3357": 1.0, "3369": 0.16666666666666666, "3394": 0.75, "3404": 0.42857142857142855, "3405": 1.0, "3446": 0.8, "3451": 0.42857142857142855, "3453": 1.0, "3480": 1.0, "3490": 1.0, "3500": 0.5, "3503": 0.7142857142857143, "3512": 1.0, "3528": 1.0, "3530": 0.6666666666666666, "3534": 0.0, "3566": 1.0, "3569": 1.0, "3594": 0.25, "3612": 0.75, "3615": 1.0, "3625": 0.3333333333333333, "3682": 1.0, "3683": 0.6666666666666666, "3694": 0.5, "3724": 0.0, "3735": 1.0, "3759": 0.0, "3767": 0.4, "3771": 0.3333333333333333, "3781": 1.0, "3789": 0.75, "3791": 0.6666666666666666, "3801": 0.0, "3822": 0.25, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 0.6666666666666666, "4011": 1.0, "4019": 0.4, "4031": 0.0, "4037": 0.5, "4047": 0.75, "4071": 0.0, "4084": 1.0, "4102": 0.25, "4103": 0.0, "4105": 0.0, "4116": 0.5, "4125": 0.0, "4142": 0.75, "4153": 1.0, "4179": 1.0, "4188": 1.0, "4205": 0.6666666666666666, "4233": 0.8, "4265": 0.6666666666666666, "4286": 0.5, "4289": 0.5, "4306": 0.75, "4312": 0.8571428571428571, "4335": 0.75, "4339": 1.0, "4394": 0.0, "4409": 0.2, "4411": 0.6666666666666666, "4414": 1.0, "4415": 0.0, "4433": 0.5, "4447": 1.0, "4464": 1.0, "4465": 0.6666666666666666, "4484": 1.0, "4499": 0.3333333333333333, "4500": 0.5, "4504": 1.0, "4514": 0.5, "4523": 0.2, "4539": 0.5, "4571": 0.6666666666666666, "4600": 1.0, "4605": 0.7142857142857143, "4615": 0.6666666666666666, "4640": 0.0, "4641": 0.6, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.6666666666666666, "4846": 0.0, "4863": 1.0, "4865": 0.0, "4920": 1.0, "4942": 1.0, "4946": 1.0, "4955": 0.0, "4962": 0.5, "4968": 1.0, "4981": 0.6666666666666666, "4999": 0.75, "5021": 0.0, "5030": 0.0, "5045": 1.0, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 1.0, "5080": 0.0, "5083": 0.5, "5085": 1.0, "5086": 1.0, "5090": 0.5, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 1.0, "5178": 0.4, "5185": 0.0, "5196": 0.3333333333333333, "5206": 0.0, "5228": 1.0, "5231": 1.0, "5241": 0.4, "5254": 0.5, "5255": 1.0, "5264": 0.6, "5271": 1.0, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.4, "5369": 0.0, "5374": 1.0, "5380": 1.0, "5402": 0.5, "5410": 0.3333333333333333, "5422": 0.75, "5427": 0.5, "5460": 0.0, "5464": 0.3333333333333333, "5503": 0.5, "5505": 1.0, "5511": 0.3, "5534": 0.5, "5549": 0.0, "5585": 1.0, "5592": 1.0, "5616": 1.0, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.5, "5763": 0.6666666666666666, "5782": 0.4, "5790": 0.0, "5808": 1.0, "5853": 0.375, "5862": 0.5, "5888": 0.5, "5903": 0.0, "5906": 1.0, "5940": 0.0, "5951": 0.5555555555555556, "5970": 0.6666666666666666, "5981": 1.0, "5993": 0.2, "6002": 0.9090909090909091, "6004": 0.0, "6005": 0.38461538461538464, "6009": 1.0, "6041": 0.75, "6080": 0.5, "6110": 0.375, "6121": 0.5, "6122": 0.3333333333333333, "6131": 0.4166666666666667, "6133": 0.5, "6142": 0.5, "6146": 1.0, "6199": 0.5, "6219": 1.0, "6221": 0.125, "6252": 0.0, "6262": 0.6666666666666666, "6278": 1.0, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 1.0, "6467": 0.0, "6468": 0.5, "6479": 1.0, "6525": 0.6666666666666666, "6554": 0.5, "6562": 0.5, "6611": 1.0, "6612": 0.3333333333333333, "6625": 1.0, "6629": 0.0, "6635": 0.5, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 1.0, "6683": 1.0, "6713": 0.5, "6715": 1.0, "6746": 0.5, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.75, "6807": 1.0, "6814": 0.0, "6832": 1.0, "6835": 0.5, "6849": 1.0, "6862": 1.0, "6867": 0.42857142857142855, "6875": 0.0, "6890": 1.0, "6891": 0.6666666666666666, "6896": 0.0, "6901": 0.5, "6907": 0.0, "6909": 0.0, "6959": 1.0, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 1.0, "7109": 0.6666666666666666, "7124": 0.75, "7141": 0.5, "7145": 0.3333333333333333, "7178": 1.0, "7188": 1.0, "7205": 1.0, "7206": 0.0, "7218": 1.0, "7221": 0.0, "7269": 1.0, "7279": 0.75, "7295": 0.0, "7311": 1.0, "7326": 0.0, "7329": 1.0, "7344": 0.5, "7345": 0.6666666666666666, "7377": 1.0, "7431": 0.0, "7441": 0.3333333333333333, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.4, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 1.0, "7513": 0.6666666666666666, "7529": 0.5, "7533": 0.5, "7534": 0.3333333333333333, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.5, "7674": 0.3333333333333333, "7700": 0.25, "7702": 1.0, "7705": 0.6666666666666666, "7734": 0.5, "7747": 0.5, "7754": 1.0, "7758": 1.0, "7801": 1.0, "7803": 0.5, "7823": 0.6666666666666666, "7876": 1.0, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.16666666666666666, "7928": 0.25, "7936": 0.6666666666666666, "7992": 1.0, "8002": 0.6666666666666666, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 1.0, "8040": 1.0, "8072": 0.6666666666666666, "8079": 1.0, "8102": 0.25, "8116": 1.0, "8121": 1.0, "8202": 0.0, "8230": 1.0, "8247": 0.0, "8271": 0.5, "8275": 1.0, "8296": 1.0, "8332": 1.0, "8351": 0.5, "8378": 0.3333333333333333, "8456": 0.6666666666666666, "8475": 0.8571428571428571, "8507": 0.3333333333333333, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 1.0, "8539": 0.25, "8544": 0.5, "8592": 0.6666666666666666, "8632": 1.0, "8635": 0.0, "8702": 0.6666666666666666, "8779": 1.0, "8789": 0.6666666666666666, "8795": 1.0, "8832": 1.0, "8834": 0.5, "8855": 0.0, "8874": 1.0, "8934": 1.0, "8937": 1.0, "8947": 0.5, "8959": 1.0, "8970": 1.0, "8974": 0.25, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 1.0, "9126": 0.0, "9164": 0.3333333333333333, "9174": 0.2, "9188": 0.5, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 1.0, "9381": 1.0, "9385": 1.0, "9391": 0.75, "9403": 0.0, "9481": 1.0, "9487": 1.0, "9548": 1.0, "9556": 1.0, "9565": 1.0, "9598": 1.0, "9617": 0.6666666666666666, "9633": 0.5, "9643": 1.0, "9644": 1.0, "9646": 1.0, "9668": 1.0, "9701": 0.0, "9733": 0.3333333333333333, "9735": 1.0, "9737": 0.6666666666666666, "9771": 0.0, "9808": 0.3333333333333333, "9824": 1.0, "9871": 0.25, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 0.0, "9979": 0.5, "10034": 0.5, "10039": 1.0, "10109": 0.42857142857142855, "10122": 0.5, "10136": 0.6666666666666666, "10137": 1.0, "10152": 1.0, "10183": 1.0, "10213": 0.3333333333333333, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.3333333333333333, "10462": 0.0, "10482": 0.0, "10497": 0.7, "10526": 0.5, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 1.0, "10639": 0.4, "10645": 1.0, "10674": 1.0, "10710": 1.0, "10734": 1.0, "10792": 1.0, "10808": 1.0, "10809": 0.6666666666666666, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 1.0, "10932": 1.0, "10975": 0.0, "10979": 0.75, "10994": 1.0, "11039": 0.5, "11054": 1.0, "11088": 1.0}, "MRR@10": {"8": 1.0, "15": 0.16666666666666666, "18": 0.5, "26": 0.2, "34": 0.0, "42": 1.0, "56": 0.16666666666666666, "68": 0.0, "89": 0.5, "90": 0.5, "94": 1.0, "98": 1.0, "104": 1.0, "106": 0.3333333333333333, "109": 1.0, "475": 1.0, "503": 0.08333333333333333, "504": 0.05555555555555555, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.14285714285714285, "559": 0.0, "570": 0.06666666666666667, "585": 0.25, "588": 0.5, "594": 1.0, "603": 0.0, "604": 0.16666666666666666, "620": 0.08333333333333333, "622": 0.5, "659": 1.0, "672": 0.07692307692307693, "684": 0.05555555555555555, "687": 0.125, "689": 0.0, "691": 0.5, "699": 1.0, "701": 0.1, "715": 0.0, "721": 1.0, "744": 0.2, "750": 1.0, "753": 0.5, "766": 0.2, "776": 1.0, "810": 0.14285714285714285, "813": 0.14285714285714285, "849": 0.14285714285714285, "852": 1.0, "853": 0.09090909090909091, "858": 0.0, "859": 0.5, "864": 1.0, "879": 0.5, "885": 0.125, "895": 1.0, "904": 1.0, "928": 1.0, "929": 1.0, "932": 0.3333333333333333, "939": 0.3333333333333333, "945": 0.1111111111111111, "957": 1.0, "988": 0.0, "1074": 0.5, "1085": 0.0, "1090": 0.2, "1150": 0.0, "1157": 1.0, "1159": 0.0, "1198": 1.0, "1230": 0.07142857142857142, "1281": 0.2, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.5, "1310": 1.0, "1321": 0.0, "1322": 0.5, "1391": 0.2, "1393": 0.5, "1415": 1.0, "1416": 0.058823529411764705, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.5, "1670": 1.0, "1676": 1.0, "1736": 1.0, "1748": 1.0, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.5, "1824": 0.125, "1826": 1.0, "1832": 0.3333333333333333, "1871": 1.0, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.5, "2010": 1.0, "2051": 0.07142857142857142, "2070": 0.3333333333333333, "2075": 1.0, "2076": 0.3333333333333333, "2088": 0.0, "2108": 0.16666666666666666, "2118": 0.0, "2154": 0.0, "2181": 0.05263157894736842, "2183": 1.0, "2204": 1.0, "2264": 0.5, "2296": 1.0, "2306": 1.0, "2316": 1.0, "2318": 0.125, "2330": 1.0, "2334": 1.0, "2348": 1.0, "2376": 1.0, "2383": 1.0, "2384": 0.5, "2385": 1.0, "2388": 1.0, "2395": 1.0, "2398": 0.08333333333333333, "2399": 1.0, "2400": 0.5, "2407": 0.5, "2416": 1.0, "2423": 1.0, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0625, "2472": 0.0, "2486": 1.0, "2498": 0.25, "2513": 0.0625, "2516": 1.0, "2549": 1.0, "2551": 1.0, "2568": 0.3333333333333333, "2579": 0.3333333333333333, "2580": 1.0, "2587": 1.0, "2589": 1.0, "2590": 1.0, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 0.3333333333333333, "2685": 1.0, "2695": 1.0, "2713": 1.0, "2724": 1.0, "2737": 0.5, "2747": 0.3333333333333333, "2749": 1.0, "2790": 1.0, "2801": 1.0, "2856": 1.0, "2857": 1.0, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.1111111111111111, "2923": 1.0, "2964": 0.07692307692307693, "2968": 0.5, "2994": 1.0, "3006": 0.3333333333333333, "3008": 0.5, "3014": 1.0, "3033": 0.3333333333333333, "3039": 0.25, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 0.125, "3091": 1.0, "3103": 0.3333333333333333, "3115": 1.0, "3125": 0.5, "3148": 1.0, "3149": 0.0, "3177": 0.14285714285714285, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 1.0, "3264": 1.0, "3357": 1.0, "3369": 0.09090909090909091, "3394": 0.5, "3404": 1.0, "3405": 0.09090909090909091, "3446": 0.5, "3451": 0.1, "3453": 0.3333333333333333, "3480": 1.0, "3490": 0.1, "3500": 1.0, "3503": 0.5, "3512": 1.0, "3528": 0.5, "3530": 0.5, "3534": 0.0, "3566": 1.0, "3569": 0.3333333333333333, "3594": 0.125, "3612": 0.1111111111111111, "3615": 0.2, "3625": 0.25, "3682": 0.14285714285714285, "3683": 1.0, "3694": 1.0, "3724": 0.0, "3735": 0.09090909090909091, "3759": 0.0, "3767": 0.3333333333333333, "3771": 0.14285714285714285, "3781": 1.0, "3789": 1.0, "3791": 0.5, "3801": 0.0, "3822": 0.05263157894736842, "3829": 0.0, "3830": 0.5, "3837": 0.5, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 1.0, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 1.0, "4011": 1.0, "4019": 0.5, "4031": 0.0, "4037": 0.1111111111111111, "4047": 1.0, "4071": 0.0, "4084": 0.25, "4102": 0.06666666666666667, "4103": 0.0, "4105": 0.0, "4116": 1.0, "4125": 0.0, "4142": 0.16666666666666666, "4153": 0.125, "4179": 0.5, "4188": 0.0625, "4205": 0.5, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 0.2, "4306": 1.0, "4312": 1.0, "4335": 1.0, "4339": 1.0, "4394": 0.0, "4409": 0.3333333333333333, "4411": 1.0, "4414": 1.0, "4415": 0.0, "4433": 0.09090909090909091, "4447": 1.0, "4464": 0.3333333333333333, "4465": 0.5, "4484": 0.5, "4499": 0.05555555555555555, "4500": 0.07142857142857142, "4504": 1.0, "4514": 1.0, "4523": 0.5, "4539": 0.16666666666666666, "4571": 1.0, "4600": 1.0, "4605": 1.0, "4615": 0.5, "4640": 0.0, "4641": 0.2, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 1.0, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 0.16666666666666666, "4837": 0.0, "4844": 1.0, "4845": 1.0, "4846": 0.0, "4863": 0.5, "4865": 0.0, "4920": 1.0, "4942": 0.125, "4946": 1.0, "4955": 0.0, "4962": 1.0, "4968": 0.5, "4981": 1.0, "4999": 1.0, "5021": 0.0, "5030": 0.0, "5045": 0.1111111111111111, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.3333333333333333, "5080": 0.0, "5083": 0.2, "5085": 1.0, "5086": 0.5, "5090": 0.25, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 0.09090909090909091, "5178": 0.2, "5185": 0.0, "5196": 0.5, "5206": 0.0, "5228": 0.125, "5231": 0.058823529411764705, "5241": 1.0, "5254": 1.0, "5255": 1.0, "5264": 1.0, "5271": 0.3333333333333333, "5331": 1.0, "5343": 0.14285714285714285, "5347": 1.0, "5356": 0.16666666666666666, "5369": 0.0, "5374": 0.1111111111111111, "5380": 1.0, "5402": 0.0625, "5410": 0.5, "5422": 0.3333333333333333, "5427": 0.2, "5460": 0.0, "5464": 0.16666666666666666, "5503": 0.5, "5505": 1.0, "5511": 0.25, "5534": 0.5, "5549": 0.0, "5585": 0.125, "5592": 1.0, "5616": 0.16666666666666666, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.0625, "5763": 0.3333333333333333, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.25, "5888": 0.25, "5903": 0.0, "5906": 0.25, "5940": 0.0, "5951": 0.5, "5970": 0.3333333333333333, "5981": 1.0, "5993": 1.0, "6002": 1.0, "6004": 0.0, "6005": 1.0, "6009": 0.09090909090909091, "6041": 1.0, "6080": 1.0, "6110": 1.0, "6121": 0.3333333333333333, "6122": 1.0, "6131": 1.0, "6133": 1.0, "6142": 1.0, "6146": 1.0, "6199": 1.0, "6219": 1.0, "6221": 0.05, "6252": 0.0, "6262": 0.5, "6278": 0.25, "6395": 0.0, "6410": 0.0, "6420": 1.0, "6441": 0.2, "6467": 0.0, "6468": 1.0, "6479": 1.0, "6525": 0.5, "6554": 1.0, "6562": 0.1111111111111111, "6611": 1.0, "6612": 0.16666666666666666, "6625": 0.08333333333333333, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 1.0, "6713": 1.0, "6715": 1.0, "6746": 0.25, "6787": 0.0, "6792": 0.0, "6800": 0.25, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.2, "6835": 1.0, "6849": 0.3333333333333333, "6862": 1.0, "6867": 0.25, "6875": 0.0, "6890": 0.25, "6891": 1.0, "6896": 0.0, "6901": 0.16666666666666666, "6907": 0.0, "6909": 0.0, "6959": 0.5, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.0, "7080": 1.0, "7096": 0.5, "7098": 1.0, "7105": 0.2, "7109": 0.5, "7124": 0.5, "7141": 0.0625, "7145": 0.1, "7178": 0.16666666666666666, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.06666666666666667, "7279": 0.25, "7295": 0.0, "7311": 0.09090909090909091, "7326": 0.0, "7329": 0.25, "7344": 1.0, "7345": 0.14285714285714285, "7377": 1.0, "7431": 0.0, "7441": 0.25, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.25, "7467": 0.5, "7484": 1.0, "7509": 0.0, "7512": 0.0625, "7513": 0.16666666666666666, "7529": 0.3333333333333333, "7533": 0.08333333333333333, "7534": 1.0, "7590": 1.0, "7592": 0.0, "7594": 0.14285714285714285, "7622": 0.0, "7633": 1.0, "7674": 0.0625, "7700": 0.125, "7702": 0.5, "7705": 0.5, "7734": 1.0, "7747": 0.14285714285714285, "7754": 0.08333333333333333, "7758": 0.5, "7801": 1.0, "7803": 0.125, "7823": 1.0, "7876": 0.2, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.5, "7928": 0.5, "7936": 0.3333333333333333, "7992": 0.5, "8002": 1.0, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.125, "8040": 1.0, "8072": 0.5, "8079": 1.0, "8102": 0.1, "8116": 0.25, "8121": 1.0, "8202": 0.0, "8230": 0.0625, "8247": 0.0, "8271": 1.0, "8275": 0.25, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.1, "8456": 1.0, "8475": 1.0, "8507": 0.09090909090909091, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 0.16666666666666666, "8539": 0.09090909090909091, "8544": 1.0, "8592": 0.3333333333333333, "8632": 0.16666666666666666, "8635": 0.0, "8702": 1.0, "8779": 0.1, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.14285714285714285, "8934": 1.0, "8937": 0.16666666666666666, "8947": 0.2, "8959": 0.25, "8970": 1.0, "8974": 1.0, "8982": 0.0, "9060": 1.0, "9088": 0.0, "9108": 0.0, "9115": 0.25, "9126": 0.0, "9164": 0.125, "9174": 0.07142857142857142, "9188": 1.0, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.14285714285714285, "9329": 1.0, "9332": 0.16666666666666666, "9381": 0.3333333333333333, "9385": 0.16666666666666666, "9391": 0.3333333333333333, "9403": 0.0, "9481": 0.5, "9487": 0.08333333333333333, "9548": 0.25, "9556": 1.0, "9565": 1.0, "9598": 0.16666666666666666, "9617": 0.16666666666666666, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.5, "9646": 0.25, "9668": 1.0, "9701": 0.0, "9733": 0.2, "9735": 0.14285714285714285, "9737": 1.0, "9771": 0.0, "9808": 0.5, "9824": 1.0, "9871": 0.5, "9882": 0.0, "9925": 1.0, "9929": 0.5, "9961": 0.0, "9979": 1.0, "10034": 0.3333333333333333, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.25, "10137": 0.14285714285714285, "10152": 1.0, "10183": 0.3333333333333333, "10213": 1.0, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.2, "10462": 0.0, "10482": 0.0, "10497": 1.0, "10526": 0.14285714285714285, "10547": 0.0, "10558": 0.0, "10596": 1.0, "10601": 1.0, "10628": 0.1111111111111111, "10639": 0.5, "10645": 0.5, "10674": 1.0, "10710": 0.14285714285714285, "10734": 1.0, "10792": 0.16666666666666666, "10808": 0.2, "10809": 1.0, "10812": 1.0, "10827": 0.25, "10845": 1.0, "10912": 0.08333333333333333, "10932": 1.0, "10975": 0.0, "10979": 1.0, "10994": 0.3333333333333333, "11039": 0.5, "11054": 1.0, "11088": 0.25}}} diff --git a/evals/benchmark/results/fiqa/ir-w1.0.jsonl b/evals/benchmark/results/fiqa/ir-w1.0.jsonl new file mode 100644 index 000000000..750245bf2 --- /dev/null +++ b/evals/benchmark/results/fiqa/ir-w1.0.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "w1.0", "aggregated": {"nDCG@10": 0.4033, "Recall@20": 0.5802, "MRR@10": 0.4777}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 0.3562071871080222, "18": 0.6309297535714575, "26": 0.20438239758848611, "34": 0.0, "42": 0.46927872602275644, "56": 0.3333333333333333, "68": 0.0, "89": 0.27839258028034286, "90": 0.5, "94": 1.0, "98": 0.6131471927654584, "104": 0.38685280723454163, "106": 0.43067655807339306, "109": 1.0, "475": 0.6309297535714575, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.3333333333333333, "559": 0.0, "570": 0.0, "585": 0.23719771276929622, "588": 0.5640920940185894, "594": 0.6131471927654584, "603": 0.0, "604": 0.2769189462922768, "620": 0.0, "622": 0.38685280723454163, "659": 0.3785988060390612, "672": 0.0, "684": 0.0, "687": 0.0, "689": 0.0, "691": 0.6309297535714575, "699": 1.0, "701": 0.0, "715": 0.0, "721": 1.0, "744": 0.16716045496620227, "750": 0.8503449055347546, "753": 0.3065735963827292, "766": 0.1480409554829326, "776": 0.3499667779514209, "810": 0.2890648263178879, "813": 0.17723928678404774, "849": 0.31546487678572877, "852": 0.7653606369886217, "853": 0.0, "858": 0.0, "859": 0.3065735963827292, "864": 0.706046305905179, "879": 0.6309297535714575, "885": 0.0, "895": 1.0, "904": 0.6309297535714575, "928": 0.6131471927654584, "929": 1.0, "932": 0.3065735963827292, "939": 0.5, "945": 0.3010299956639812, "957": 0.7039180890341347, "988": 0.0, "1074": 0.5, "1085": 0.0, "1090": 0.21840743681816419, "1150": 0.0, "1157": 0.6131471927654584, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 0.38685280723454163, "1284": 1.0, "1297": 1.0, "1306": 0.3638184934971571, "1309": 0.4144299250118475, "1310": 1.0, "1321": 0.0, "1322": 0.19519002499605084, "1391": 0.1480409554829326, "1393": 0.19092086617893467, "1415": 0.9828920819566879, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.23463936301137822, "1670": 0.7653606369886217, "1676": 0.6713527276121545, "1736": 0.5531464700081437, "1748": 0.46927872602275644, "1783": 0.0, "1812": 0.21840743681816419, "1815": 1.0, "1819": 0.19092086617893467, "1824": 0.0, "1826": 1.0, "1832": 0.5, "1871": 0.5205067333228022, "1877": 1.0, "1889": 0.0, "1915": 0.8772153153380493, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.38356636737133565, "2010": 0.812653045383133, "2051": 0.0, "2070": 0.23463936301137822, "2075": 0.48384710931773217, "2076": 0.5437713091520254, "2088": 0.0, "2108": 0.14126697285982898, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.5499887725471476, "2204": 0.8987025955356565, "2264": 0.38685280723454163, "2296": 0.419999071625979, "2306": 0.6131471927654584, "2316": 1.0, "2318": 0.31546487678572877, "2330": 0.6131471927654584, "2334": 0.2960819109658652, "2348": 0.42257499837058643, "2376": 0.8910635073822442, "2383": 0.6131471927654584, "2384": 0.6309297535714575, "2385": 0.6131471927654584, "2388": 1.0, "2395": 1.0, "2398": 0.0, "2399": 1.0, "2400": 0.5307212739772434, "2407": 0.24630238874073, "2416": 0.8796542634124673, "2423": 0.27487633291429087, "2443": 0.0, "2445": 1.0, "2460": 0.8854598815714874, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.3333333333333333, "2513": 0.0, "2516": 0.5585075862632192, "2549": 0.6131471927654584, "2551": 0.8385465274895063, "2568": 0.13743816645714543, "2579": 0.13032376591037062, "2580": 0.7039180890341347, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.8854598815714874, "2598": 0.8065735963827293, "2648": 1.0, "2676": 0.5, "2685": 0.32908604348504067, "2695": 1.0, "2713": 0.6131471927654584, "2724": 0.8065735963827293, "2737": 0.6309297535714575, "2747": 0.5, "2749": 0.8503449055347546, "2790": 0.47600514717497383, "2801": 0.6131471927654584, "2856": 0.6804558477306826, "2857": 0.5032251913410369, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.0, "2923": 0.6843515475204855, "2964": 0.0, "2968": 0.6509209298071326, "2994": 0.46927872602275644, "3006": 0.2521686779156779, "3008": 0.19519002499605084, "3014": 0.8772153153380493, "3033": 0.3065735963827292, "3039": 0.43067655807339306, "3049": 0.19519002499605084, "3051": 0.9197207891481876, "3067": 0.0, "3085": 0.0, "3091": 0.6969904532005495, "3103": 0.5, "3115": 0.4935232796777481, "3125": 0.6309297535714575, "3148": 0.5531464700081437, "3149": 0.0, "3177": 0.15642624200758548, "3179": 0.8175295903539445, "3186": 1.0, "3189": 0.0, "3254": 0.6508205185601091, "3264": 0.5646436081071458, "3357": 1.0, "3369": 0.0, "3394": 0.5272750663607827, "3404": 0.3615901614084106, "3405": 0.0, "3446": 0.42913706161531123, "3451": 0.0, "3453": 0.6509209298071326, "3480": 0.9828920819566879, "3490": 0.0, "3500": 0.644824486427155, "3503": 0.5355852974309776, "3512": 0.8503449055347546, "3528": 0.6309297535714575, "3530": 0.37590633587120725, "3534": 0.0, "3566": 0.6257049680303419, "3569": 0.5, "3594": 0.0, "3612": 0.0, "3615": 0.42177340954886444, "3625": 0.20210734650054757, "3682": 0.20438239758848611, "3683": 0.41966500663677697, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.0, "3759": 0.0, "3767": 0.16958010263680806, "3771": 0.1919598743897292, "3781": 0.8772153153380493, "3789": 0.8048099750039491, "3791": 0.431733884398313, "3801": 0.2640681225725909, "3822": 0.0, "3829": 0.0, "3830": 0.6309297535714575, "3837": 0.6309297535714575, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.45186484096594276, "3932": 0.0, "3934": 0.16812753627111746, "3995": 0.0, "4007": 0.7653606369886217, "4011": 0.9674679834891693, "4019": 0.21398626473452756, "4031": 0.0, "4037": 0.0, "4047": 0.8318724637288826, "4071": 0.0, "4084": 0.46845052016107697, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.2476427880871277, "4153": 0.2890648263178879, "4179": 0.6309297535714575, "4188": 0.0, "4205": 0.23463936301137822, "4233": 0.8687949224876582, "4265": 0.7247145167543899, "4286": 0.6131471927654584, "4289": 0.23719771276929622, "4306": 0.5855700749881525, "4312": 0.7837042816946693, "4335": 0.8048099750039491, "4339": 1.0, "4394": 0.0, "4409": 0.1610425878239398, "4411": 0.46927872602275644, "4414": 0.7903864795495061, "4415": 0.0, "4433": 0.0, "4447": 1.0, "4464": 0.43067655807339306, "4465": 0.20210734650054757, "4484": 0.6309297535714575, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.4034698846650846, "4523": 0.16958010263680806, "4539": 0.21840743681816419, "4571": 0.7039180890341347, "4600": 0.6309297535714575, "4605": 0.4728384582492843, "4615": 0.47472048453608134, "4640": 0.0, "4641": 0.23819820987960558, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75369761125927, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.6131471927654584, "4813": 1.0, "4823": 0.46927872602275644, "4827": 0.3562071871080222, "4837": 0.0, "4844": 1.0, "4845": 0.6713860725233041, "4846": 0.0, "4863": 0.4632423659320675, "4865": 0.0, "4920": 1.0, "4942": 0.0, "4946": 1.0, "4955": 0.0, "4962": 0.6131471927654584, "4968": 0.6309297535714575, "4981": 0.7653606369886217, "4999": 0.5205067333228022, "5021": 0.0, "5030": 0.0, "5045": 0.0, "5054": 0.0, "5061": 0.0, "5064": 0.9197207891481876, "5067": 0.5, "5080": 0.0, "5083": 0.23719771276929622, "5085": 0.6309297535714575, "5086": 0.6309297535714575, "5090": 0.23719771276929622, "5125": 1.0, "5134": 0.3065735963827292, "5150": 0.0, "5155": 1.0, "5172": 0.0, "5178": 0.23330247263525344, "5185": 0.0, "5196": 0.2960819109658652, "5206": 0.0, "5228": 0.3010299956639812, "5231": 0.0, "5241": 0.3391602052736161, "5254": 0.6131471927654584, "5255": 1.0, "5264": 0.6739577727076379, "5271": 0.36926780146674987, "5331": 1.0, "5343": 0.0, "5347": 1.0, "5356": 0.09803928583135704, "5369": 0.0, "5374": 0.0, "5380": 1.0, "5402": 0.0, "5410": 0.2960819109658652, "5422": 0.16812753627111746, "5427": 0.21840743681816419, "5460": 0.0, "5464": 0.15642624200758548, "5503": 0.38685280723454163, "5505": 1.0, "5511": 0.07839826897867533, "5534": 0.3065735963827292, "5549": 0.0, "5585": 0.2890648263178879, "5592": 1.0, "5616": 0.2890648263178879, "5620": 0.0, "5646": 0.9010126104210695, "5653": 1.0, "5683": 0.9197207891481876, "5710": 0.0, "5741": 0.0, "5763": 0.23463936301137822, "5782": 0.3391602052736161, "5790": 0.0, "5808": 0.5, "5853": 0.12647135138382856, "5862": 0.32531670832675136, "5888": 0.3065735963827292, "5903": 0.0, "5906": 0.2640681225725909, "5940": 0.0, "5951": 0.417488320194876, "5970": 0.20210734650054757, "5981": 0.9896062251871525, "5993": 0.31488013066763093, "6002": 0.762416491594312, "6004": 0.0, "6005": 0.5388856921828065, "6009": 0.0, "6041": 0.7668091220635322, "6080": 0.6131471927654584, "6110": 0.4273569456759105, "6121": 0.2640681225725909, "6122": 0.46927872602275644, "6131": 0.43735247915031, "6133": 0.6131471927654584, "6142": 0.6131471927654584, "6146": 0.8315546295836225, "6199": 0.3903800499921017, "6219": 1.0, "6221": 0.0, "6252": 0.0, "6262": 0.4367467095119258, "6278": 0.3065735963827292, "6395": 0.0, "6410": 0.3562071871080222, "6420": 1.0, "6441": 0.38685280723454163, "6467": 0.0, "6468": 0.6131471927654584, "6479": 1.0, "6525": 0.49818925746641285, "6554": 0.6131471927654584, "6562": 0.0, "6611": 0.7903864795495061, "6612": 0.15642624200758548, "6625": 0.0, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7039180890341347, "6668": 0.8175295903539445, "6679": 0.4525081529734507, "6683": 0.8315546295836225, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.2640681225725909, "6787": 0.0, "6792": 0.0, "6800": 0.38685280723454163, "6803": 0.5135312443624667, "6807": 1.0, "6814": 0.0, "6832": 0.21840743681816419, "6835": 0.6131471927654584, "6849": 0.5, "6862": 1.0, "6867": 0.19796212533499344, "6875": 0.0, "6890": 0.48247555939075504, "6891": 0.46927872602275644, "6896": 0.0, "6901": 0.18457569677956817, "6907": 0.0, "6909": 0.0, "6959": 0.2640681225725909, "6985": 1.0, "7017": 0.0, "7068": 0.9197207891481876, "7071": 0.0, "7080": 0.8503449055347546, "7096": 0.6309297535714575, "7098": 0.6131471927654584, "7105": 0.3562071871080222, "7109": 0.2960819109658652, "7124": 0.3764290720714305, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.3333333333333333, "7188": 0.0, "7205": 1.0, "7206": 0.0, "7218": 0.43067655807339306, "7221": 0.0, "7269": 0.0, "7279": 0.3071837157818931, "7295": 0.0, "7311": 0.0, "7326": 0.0, "7329": 0.45749452618986164, "7344": 0.6131471927654584, "7345": 0.0, "7377": 1.0, "7431": 0.0, "7441": 0.16716045496620227, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.11305340175787204, "7467": 0.43067655807339306, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.14126697285982898, "7529": 0.2640681225725909, "7533": 0.0, "7534": 0.46927872602275644, "7590": 0.7977228895450266, "7592": 0.0, "7594": 0.3333333333333333, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.0, "7702": 0.38685280723454163, "7705": 0.4367467095119258, "7734": 0.6131471927654584, "7747": 0.20438239758848611, "7754": 0.0, "7758": 0.5, "7801": 1.0, "7803": 0.18457569677956817, "7823": 0.6049306994552042, "7876": 0.38685280723454163, "7879": 0.0, "7880": 0.2640681225725909, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "7936": 0.39106560501896365, "7992": 0.38685280723454163, "8002": 0.431733884398313, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.0, "8040": 1.0, "8072": 0.4776237035032179, "8079": 0.6713860725233041, "8102": 0.0, "8116": 0.448643819352159, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.6131471927654584, "8275": 0.43067655807339306, "8296": 0.8315546295836225, "8332": 0.9060254355346823, "8351": 0.6131471927654584, "8378": 0.13565197343244778, "8456": 0.46927872602275644, "8475": 0.7957503936198023, "8507": 0.0, "8512": 0.5, "8513": 0.0, "8532": 0.9066276098484507, "8537": 0.31546487678572877, "8539": 0.0, "8544": 0.6131471927654584, "8592": 0.23463936301137822, "8632": 0.20438239758848611, "8635": 0.0, "8702": 0.7653606369886217, "8779": 0.0, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.19092086617893467, "8855": 0.0, "8874": 0.38685280723454163, "8934": 0.7903864795495061, "8937": 0.3562071871080222, "8947": 0.23719771276929622, "8959": 0.43067655807339306, "8970": 0.8503449055347546, "8974": 0.37941405415148566, "8982": 0.0, "9060": 0.6131471927654584, "9088": 0.0, "9108": 0.0, "9115": 0.49141527484330916, "9126": 0.0, "9164": 0.1480409554829326, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.19342640361727081, "9329": 1.0, "9332": 0.3562071871080222, "9381": 0.4415801103577823, "9385": 0.3562071871080222, "9391": 0.4573973988771914, "9403": 0.0, "9481": 0.6240505200038379, "9487": 0.0, "9548": 0.38685280723454163, "9556": 1.0, "9565": 1.0, "9598": 0.31546487678572877, "9617": 0.16716045496620227, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.6309297535714575, "9646": 0.42177340954886444, "9668": 0.6508205185601091, "9701": 0.0, "9733": 0.16716045496620227, "9735": 0.3333333333333333, "9737": 0.9066276098484507, "9771": 0.0, "9808": 0.2960819109658652, "9824": 1.0, "9871": 0.24630238874073, "9882": 0.0, "9925": 0.8315546295836225, "9929": 0.3065735963827292, "9961": 0.2890648263178879, "9979": 0.3903800499921017, "10034": 0.2640681225725909, "10039": 0.6309297535714575, "10109": 0.499028327865556, "10122": 0.19519002499605084, "10136": 0.15642624200758548, "10137": 0.2890648263178879, "10152": 1.0, "10183": 0.21840743681816419, "10213": 0.46927872602275644, "10246": 0.0, "10267": 0.0, "10414": 0.8772153153380493, "10447": 0.20210734650054757, "10462": 0.0, "10482": 0.0, "10497": 0.49828993591603105, "10526": 0.19342640361727081, "10547": 0.0, "10558": 0.0, "10596": 0.9565912771023182, "10601": 1.0, "10628": 0.2890648263178879, "10639": 0.21398626473452756, "10645": 0.38685280723454163, "10674": 0.6886342695939197, "10710": 0.3333333333333333, "10734": 0.8486987932505933, "10792": 0.39780880120575696, "10808": 0.15642624200758548, "10809": 0.2960819109658652, "10812": 0.9709286432396583, "10827": 0.13120507751234178, "10845": 1.0, "10912": 0.0, "10932": 1.0, "10975": 0.0, "10979": 0.6366824387328317, "10994": 0.4911492931622974, "11039": 0.20261469210121208, "11054": 1.0, "11088": 0.3333333333333333}, "Recall@20": {"8": 0.5, "15": 1.0, "18": 1.0, "26": 0.5, "34": 0.0, "42": 0.3333333333333333, "56": 1.0, "68": 0.0, "89": 0.5, "90": 1.0, "94": 1.0, "98": 0.5, "104": 0.5, "106": 1.0, "109": 1.0, "475": 1.0, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 1.0, "559": 0.0, "570": 0.0, "585": 0.5, "588": 1.0, "594": 0.5, "603": 0.0, "604": 0.6666666666666666, "620": 0.2, "622": 0.5, "659": 0.7, "672": 0.5, "684": 0.0, "687": 0.5, "689": 0.0, "691": 1.0, "699": 1.0, "701": 0.3333333333333333, "715": 0.0, "721": 1.0, "744": 0.3333333333333333, "750": 1.0, "753": 0.5, "766": 0.3333333333333333, "776": 0.25, "810": 1.0, "813": 0.5, "849": 1.0, "852": 1.0, "853": 0.5, "858": 0.0, "859": 0.5, "864": 0.6666666666666666, "879": 1.0, "885": 0.5, "895": 1.0, "904": 1.0, "928": 0.5, "929": 1.0, "932": 0.5, "939": 1.0, "945": 1.0, "957": 0.6666666666666666, "988": 0.0, "1074": 1.0, "1085": 0.0, "1090": 0.5, "1150": 0.0, "1157": 0.5, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 1.0, "1284": 1.0, "1297": 1.0, "1306": 0.5, "1309": 0.75, "1310": 1.0, "1321": 0.0, "1322": 0.25, "1391": 0.3333333333333333, "1393": 0.5, "1415": 1.0, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 1.0, "1670": 0.6666666666666666, "1676": 1.0, "1736": 0.4, "1748": 0.6666666666666666, "1783": 0.0, "1812": 0.5, "1815": 1.0, "1819": 0.3333333333333333, "1824": 1.0, "1826": 1.0, "1832": 1.0, "1871": 0.75, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.4, "2010": 1.0, "2051": 0.0, "2070": 0.6666666666666666, "2075": 0.5555555555555556, "2076": 1.0, "2088": 0.0, "2108": 0.3333333333333333, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.6666666666666666, "2204": 1.0, "2264": 0.5, "2296": 0.3333333333333333, "2306": 0.5, "2316": 1.0, "2318": 1.0, "2330": 0.5, "2334": 1.0, "2348": 0.3333333333333333, "2376": 1.0, "2383": 0.5, "2384": 1.0, "2385": 0.5, "2388": 1.0, "2395": 1.0, "2398": 0.2, "2399": 1.0, "2400": 0.6666666666666666, "2407": 0.25, "2416": 1.0, "2423": 0.5714285714285714, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 1.0, "2513": 0.0, "2516": 0.5, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.3333333333333333, "2580": 0.6666666666666666, "2587": 1.0, "2589": 0.6666666666666666, "2590": 0.3333333333333333, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 1.0, "2685": 0.25, "2695": 1.0, "2713": 0.5, "2724": 1.0, "2737": 1.0, "2747": 1.0, "2749": 1.0, "2790": 0.42857142857142855, "2801": 1.0, "2856": 0.75, "2857": 0.75, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 1.0, "2923": 0.8, "2964": 0.5, "2968": 1.0, "2994": 0.3333333333333333, "3006": 0.3333333333333333, "3008": 0.25, "3014": 1.0, "3033": 0.5, "3039": 1.0, "3049": 0.5, "3051": 1.0, "3067": 0.0, "3085": 0.5, "3091": 0.8571428571428571, "3103": 1.0, "3115": 0.3333333333333333, "3125": 1.0, "3148": 0.6, "3149": 0.0, "3177": 0.3333333333333333, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.6666666666666666, "3264": 0.75, "3357": 1.0, "3369": 0.16666666666666666, "3394": 0.75, "3404": 0.2857142857142857, "3405": 1.0, "3446": 0.6, "3451": 0.14285714285714285, "3453": 1.0, "3480": 1.0, "3490": 1.0, "3500": 0.5, "3503": 0.7142857142857143, "3512": 1.0, "3528": 1.0, "3530": 0.6666666666666666, "3534": 0.0, "3566": 1.0, "3569": 1.0, "3594": 0.25, "3612": 0.25, "3615": 1.0, "3625": 0.3333333333333333, "3682": 0.5, "3683": 0.6666666666666666, "3694": 0.5, "3724": 0.0, "3735": 0.6666666666666666, "3759": 0.0, "3767": 0.4, "3771": 0.3333333333333333, "3781": 1.0, "3789": 0.75, "3791": 0.6666666666666666, "3801": 0.5, "3822": 0.0, "3829": 0.0, "3830": 1.0, "3837": 1.0, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 0.5, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 0.6666666666666666, "4011": 1.0, "4019": 0.4, "4031": 0.0, "4037": 0.5, "4047": 0.75, "4071": 0.0, "4084": 1.0, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.5, "4125": 0.0, "4142": 0.75, "4153": 1.0, "4179": 1.0, "4188": 0.0, "4205": 0.6666666666666666, "4233": 0.8, "4265": 0.6666666666666666, "4286": 0.5, "4289": 0.5, "4306": 0.75, "4312": 0.8571428571428571, "4335": 0.75, "4339": 1.0, "4394": 0.0, "4409": 0.2, "4411": 0.6666666666666666, "4414": 1.0, "4415": 0.0, "4433": 0.5, "4447": 1.0, "4464": 1.0, "4465": 0.3333333333333333, "4484": 1.0, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 0.5, "4523": 0.2, "4539": 0.5, "4571": 0.6666666666666666, "4600": 1.0, "4605": 0.5714285714285714, "4615": 0.6666666666666666, "4640": 0.0, "4641": 0.4, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 0.75, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 0.5, "4813": 1.0, "4823": 0.3333333333333333, "4827": 1.0, "4837": 0.0, "4844": 1.0, "4845": 0.6666666666666666, "4846": 0.0, "4863": 0.6666666666666666, "4865": 0.0, "4920": 1.0, "4942": 1.0, "4946": 1.0, "4955": 0.0, "4962": 0.5, "4968": 1.0, "4981": 0.6666666666666666, "4999": 0.5, "5021": 0.0, "5030": 0.0, "5045": 1.0, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 1.0, "5080": 0.0, "5083": 0.5, "5085": 1.0, "5086": 1.0, "5090": 0.5, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 0.5, "5178": 0.4, "5185": 0.0, "5196": 0.3333333333333333, "5206": 0.0, "5228": 1.0, "5231": 0.0, "5241": 0.4, "5254": 0.5, "5255": 1.0, "5264": 0.6, "5271": 0.6666666666666666, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.2, "5369": 0.0, "5374": 1.0, "5380": 1.0, "5402": 0.0, "5410": 0.3333333333333333, "5422": 0.75, "5427": 0.5, "5460": 0.0, "5464": 0.3333333333333333, "5503": 0.5, "5505": 1.0, "5511": 0.2, "5534": 0.5, "5549": 0.0, "5585": 1.0, "5592": 1.0, "5616": 1.0, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.0, "5763": 0.3333333333333333, "5782": 0.4, "5790": 0.0, "5808": 1.0, "5853": 0.25, "5862": 0.75, "5888": 0.5, "5903": 0.0, "5906": 1.0, "5940": 0.0, "5951": 0.6666666666666666, "5970": 0.3333333333333333, "5981": 1.0, "5993": 0.13333333333333333, "6002": 0.8181818181818182, "6004": 0.0, "6005": 0.38461538461538464, "6009": 1.0, "6041": 0.75, "6080": 0.5, "6110": 0.5, "6121": 0.5, "6122": 0.3333333333333333, "6131": 0.4166666666666667, "6133": 0.5, "6142": 0.5, "6146": 1.0, "6199": 0.5, "6219": 1.0, "6221": 0.0, "6252": 0.0, "6262": 0.6666666666666666, "6278": 1.0, "6395": 0.0, "6410": 1.0, "6420": 1.0, "6441": 1.0, "6467": 0.0, "6468": 0.5, "6479": 1.0, "6525": 0.6666666666666666, "6554": 0.5, "6562": 0.25, "6611": 1.0, "6612": 0.3333333333333333, "6625": 1.0, "6629": 0.0, "6635": 0.5, "6644": 0.0, "6647": 0.6666666666666666, "6668": 1.0, "6679": 0.6666666666666666, "6683": 1.0, "6713": 0.5, "6715": 1.0, "6746": 0.5, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.5, "6807": 1.0, "6814": 0.0, "6832": 1.0, "6835": 0.5, "6849": 1.0, "6862": 1.0, "6867": 0.2857142857142857, "6875": 1.0, "6890": 1.0, "6891": 0.6666666666666666, "6896": 0.0, "6901": 0.5, "6907": 0.0, "6909": 0.0, "6959": 0.5, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.5, "7080": 1.0, "7096": 1.0, "7098": 1.0, "7105": 1.0, "7109": 0.6666666666666666, "7124": 0.75, "7141": 0.0, "7145": 0.3333333333333333, "7178": 1.0, "7188": 1.0, "7205": 1.0, "7206": 0.0, "7218": 1.0, "7221": 0.0, "7269": 1.0, "7279": 0.75, "7295": 0.0, "7311": 1.0, "7326": 0.0, "7329": 1.0, "7344": 0.5, "7345": 0.3333333333333333, "7377": 1.0, "7431": 0.0, "7441": 0.6666666666666666, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.4, "7467": 1.0, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.3333333333333333, "7529": 0.5, "7533": 0.5, "7534": 0.3333333333333333, "7590": 1.0, "7592": 0.0, "7594": 1.0, "7622": 0.0, "7633": 0.25, "7674": 0.0, "7700": 0.25, "7702": 1.0, "7705": 0.6666666666666666, "7734": 0.5, "7747": 0.5, "7754": 1.0, "7758": 1.0, "7801": 1.0, "7803": 0.5, "7823": 0.6666666666666666, "7876": 1.0, "7879": 0.0, "7880": 0.5, "7911": 1.0, "7925": 0.16666666666666666, "7928": 0.25, "7936": 0.6666666666666666, "7992": 0.5, "8002": 0.6666666666666666, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 1.0, "8040": 1.0, "8072": 0.6666666666666666, "8079": 1.0, "8102": 0.25, "8116": 1.0, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 0.5, "8275": 1.0, "8296": 1.0, "8332": 1.0, "8351": 0.5, "8378": 0.3333333333333333, "8456": 0.6666666666666666, "8475": 0.7142857142857143, "8507": 0.0, "8512": 1.0, "8513": 0.0, "8532": 1.0, "8537": 1.0, "8539": 0.25, "8544": 0.5, "8592": 0.6666666666666666, "8632": 1.0, "8635": 0.0, "8702": 0.6666666666666666, "8779": 1.0, "8789": 0.6666666666666666, "8795": 1.0, "8832": 1.0, "8834": 0.3333333333333333, "8855": 0.0, "8874": 1.0, "8934": 1.0, "8937": 1.0, "8947": 0.5, "8959": 1.0, "8970": 1.0, "8974": 0.25, "8982": 0.0, "9060": 0.5, "9088": 0.0, "9108": 0.0, "9115": 1.0, "9126": 0.0, "9164": 0.3333333333333333, "9174": 0.0, "9188": 0.5, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.5, "9329": 1.0, "9332": 1.0, "9381": 1.0, "9385": 1.0, "9391": 0.75, "9403": 0.0, "9481": 1.0, "9487": 1.0, "9548": 1.0, "9556": 1.0, "9565": 1.0, "9598": 1.0, "9617": 0.6666666666666666, "9633": 0.5, "9643": 1.0, "9644": 1.0, "9646": 1.0, "9668": 0.6666666666666666, "9701": 0.0, "9733": 0.3333333333333333, "9735": 1.0, "9737": 1.0, "9771": 0.0, "9808": 0.3333333333333333, "9824": 1.0, "9871": 0.25, "9882": 0.0, "9925": 1.0, "9929": 1.0, "9961": 1.0, "9979": 0.5, "10034": 0.5, "10039": 1.0, "10109": 0.42857142857142855, "10122": 0.25, "10136": 0.6666666666666666, "10137": 1.0, "10152": 1.0, "10183": 0.5, "10213": 0.3333333333333333, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.3333333333333333, "10462": 0.0, "10482": 0.0, "10497": 0.5, "10526": 0.5, "10547": 0.0, "10558": 0.5, "10596": 1.0, "10601": 1.0, "10628": 1.0, "10639": 0.4, "10645": 1.0, "10674": 1.0, "10710": 1.0, "10734": 0.8333333333333334, "10792": 1.0, "10808": 1.0, "10809": 0.6666666666666666, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 1.0, "10932": 1.0, "10975": 0.0, "10979": 0.5, "10994": 1.0, "11039": 0.375, "11054": 1.0, "11088": 1.0}, "MRR@10": {"8": 1.0, "15": 0.16666666666666666, "18": 0.5, "26": 0.14285714285714285, "34": 0.0, "42": 1.0, "56": 0.14285714285714285, "68": 0.0, "89": 0.5, "90": 0.3333333333333333, "94": 1.0, "98": 1.0, "104": 0.5, "106": 0.25, "109": 1.0, "475": 0.5, "503": 0.0, "504": 0.0, "515": 1.0, "529": 0.0, "547": 0.0, "549": 0.14285714285714285, "559": 0.0, "570": 0.0, "585": 0.2, "588": 0.5, "594": 1.0, "603": 0.0, "604": 0.1111111111111111, "620": 0.058823529411764705, "622": 0.5, "659": 1.0, "672": 0.058823529411764705, "684": 0.0, "687": 0.08333333333333333, "689": 0.0, "691": 0.5, "699": 1.0, "701": 0.058823529411764705, "715": 0.0, "721": 1.0, "744": 0.16666666666666666, "750": 1.0, "753": 0.3333333333333333, "766": 0.125, "776": 1.0, "810": 0.1, "813": 0.1, "849": 0.125, "852": 1.0, "853": 0.07142857142857142, "858": 0.0, "859": 0.3333333333333333, "864": 1.0, "879": 0.5, "885": 0.08333333333333333, "895": 1.0, "904": 0.5, "928": 1.0, "929": 1.0, "932": 0.3333333333333333, "939": 0.3333333333333333, "945": 0.1111111111111111, "957": 1.0, "988": 0.0, "1074": 0.3333333333333333, "1085": 0.0, "1090": 0.16666666666666666, "1150": 0.0, "1157": 1.0, "1159": 0.0, "1198": 1.0, "1230": 0.0, "1281": 0.2, "1284": 1.0, "1297": 1.0, "1306": 0.5, "1309": 0.5, "1310": 1.0, "1321": 0.0, "1322": 0.3333333333333333, "1391": 0.125, "1393": 0.5, "1415": 1.0, "1416": 0.0, "1441": 1.0, "1451": 1.0, "1469": 1.0, "1530": 0.3333333333333333, "1670": 1.0, "1676": 1.0, "1736": 1.0, "1748": 1.0, "1783": 0.0, "1812": 0.16666666666666666, "1815": 1.0, "1819": 0.5, "1824": 0.08333333333333333, "1826": 1.0, "1832": 0.3333333333333333, "1871": 1.0, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.5, "2010": 1.0, "2051": 0.0, "2070": 0.3333333333333333, "2075": 1.0, "2076": 0.3333333333333333, "2088": 0.0, "2108": 0.1111111111111111, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 1.0, "2204": 1.0, "2264": 0.5, "2296": 1.0, "2306": 1.0, "2316": 1.0, "2318": 0.125, "2330": 1.0, "2334": 0.5, "2348": 1.0, "2376": 1.0, "2383": 1.0, "2384": 0.5, "2385": 1.0, "2388": 1.0, "2395": 1.0, "2398": 0.05555555555555555, "2399": 1.0, "2400": 0.5, "2407": 0.5, "2416": 1.0, "2423": 1.0, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.14285714285714285, "2513": 0.0, "2516": 1.0, "2549": 1.0, "2551": 1.0, "2568": 0.3333333333333333, "2579": 0.25, "2580": 1.0, "2587": 1.0, "2589": 1.0, "2590": 1.0, "2593": 1.0, "2598": 1.0, "2648": 1.0, "2676": 0.3333333333333333, "2685": 1.0, "2695": 1.0, "2713": 1.0, "2724": 1.0, "2737": 0.5, "2747": 0.3333333333333333, "2749": 1.0, "2790": 1.0, "2801": 1.0, "2856": 1.0, "2857": 1.0, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.07692307692307693, "2923": 1.0, "2964": 0.05263157894736842, "2968": 0.5, "2994": 1.0, "3006": 0.3333333333333333, "3008": 0.3333333333333333, "3014": 1.0, "3033": 0.3333333333333333, "3039": 0.25, "3049": 0.3333333333333333, "3051": 1.0, "3067": 0.0, "3085": 0.09090909090909091, "3091": 1.0, "3103": 0.3333333333333333, "3115": 1.0, "3125": 0.5, "3148": 1.0, "3149": 0.0, "3177": 0.14285714285714285, "3179": 1.0, "3186": 1.0, "3189": 0.0, "3254": 1.0, "3264": 0.5, "3357": 1.0, "3369": 0.058823529411764705, "3394": 0.5, "3404": 1.0, "3405": 0.09090909090909091, "3446": 0.5, "3451": 0.05263157894736842, "3453": 0.5, "3480": 1.0, "3490": 0.0625, "3500": 1.0, "3503": 0.5, "3512": 1.0, "3528": 0.5, "3530": 0.3333333333333333, "3534": 0.0, "3566": 1.0, "3569": 0.3333333333333333, "3594": 0.07142857142857142, "3612": 0.058823529411764705, "3615": 0.2, "3625": 0.25, "3682": 0.14285714285714285, "3683": 1.0, "3694": 1.0, "3724": 0.0, "3735": 0.08333333333333333, "3759": 0.0, "3767": 0.3333333333333333, "3771": 0.14285714285714285, "3781": 1.0, "3789": 1.0, "3791": 0.5, "3801": 0.25, "3822": 0.0, "3829": 0.0, "3830": 0.5, "3837": 0.5, "3859": 0.0, "3875": 1.0, "3888": 0.0, "3909": 1.0, "3932": 0.0, "3934": 0.25, "3995": 0.0, "4007": 1.0, "4011": 1.0, "4019": 0.5, "4031": 0.0, "4037": 0.09090909090909091, "4047": 1.0, "4071": 0.0, "4084": 0.25, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 1.0, "4125": 0.0, "4142": 0.14285714285714285, "4153": 0.1, "4179": 0.5, "4188": 0.0, "4205": 0.3333333333333333, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 0.2, "4306": 1.0, "4312": 1.0, "4335": 1.0, "4339": 1.0, "4394": 0.0, "4409": 0.25, "4411": 1.0, "4414": 1.0, "4415": 0.0, "4433": 0.06666666666666667, "4447": 1.0, "4464": 0.25, "4465": 0.25, "4484": 0.5, "4499": 0.0, "4500": 0.0, "4504": 1.0, "4514": 1.0, "4523": 0.3333333333333333, "4539": 0.16666666666666666, "4571": 1.0, "4600": 0.5, "4605": 1.0, "4615": 0.5, "4640": 0.0, "4641": 0.2, "4678": 0.0, "4681": 1.0, "4700": 1.0, "4714": 1.0, "4756": 0.0, "4767": 0.0, "4775": 0.0, "4777": 0.0, "4785": 1.0, "4804": 1.0, "4813": 1.0, "4823": 1.0, "4827": 0.16666666666666666, "4837": 0.0, "4844": 1.0, "4845": 1.0, "4846": 0.0, "4863": 0.5, "4865": 0.0, "4920": 1.0, "4942": 0.07142857142857142, "4946": 1.0, "4955": 0.0, "4962": 1.0, "4968": 0.5, "4981": 1.0, "4999": 1.0, "5021": 0.0, "5030": 0.0, "5045": 0.07692307692307693, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.3333333333333333, "5080": 0.0, "5083": 0.2, "5085": 0.5, "5086": 0.5, "5090": 0.2, "5125": 1.0, "5134": 0.3333333333333333, "5150": 0.0, "5155": 1.0, "5172": 0.05555555555555555, "5178": 0.2, "5185": 0.0, "5196": 0.5, "5206": 0.0, "5228": 0.1111111111111111, "5231": 0.0, "5241": 1.0, "5254": 1.0, "5255": 1.0, "5264": 1.0, "5271": 0.25, "5331": 1.0, "5343": 0.08333333333333333, "5347": 1.0, "5356": 0.1, "5369": 0.0, "5374": 0.07692307692307693, "5380": 1.0, "5402": 0.0, "5410": 0.5, "5422": 0.25, "5427": 0.16666666666666666, "5460": 0.0, "5464": 0.14285714285714285, "5503": 0.5, "5505": 1.0, "5511": 0.16666666666666666, "5534": 0.3333333333333333, "5549": 0.0, "5585": 0.1, "5592": 1.0, "5616": 0.1, "5620": 0.0, "5646": 1.0, "5653": 1.0, "5683": 1.0, "5710": 0.0, "5741": 0.0, "5763": 0.3333333333333333, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.3333333333333333, "5888": 0.3333333333333333, "5903": 0.0, "5906": 0.25, "5940": 0.0, "5951": 0.5, "5970": 0.25, "5981": 1.0, "5993": 1.0, "6002": 1.0, "6004": 0.0, "6005": 1.0, "6009": 0.07692307692307693, "6041": 1.0, "6080": 1.0, "6110": 1.0, "6121": 0.25, "6122": 1.0, "6131": 1.0, "6133": 1.0, "6142": 1.0, "6146": 1.0, "6199": 1.0, "6219": 1.0, "6221": 0.0, "6252": 0.0, "6262": 0.3333333333333333, "6278": 0.3333333333333333, "6395": 0.0, "6410": 0.16666666666666666, "6420": 1.0, "6441": 0.2, "6467": 0.0, "6468": 1.0, "6479": 1.0, "6525": 0.5, "6554": 1.0, "6562": 0.07142857142857142, "6611": 1.0, "6612": 0.14285714285714285, "6625": 0.08333333333333333, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 1.0, "6713": 1.0, "6715": 1.0, "6746": 0.25, "6787": 0.0, "6792": 0.0, "6800": 0.2, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.16666666666666666, "6835": 1.0, "6849": 0.3333333333333333, "6862": 1.0, "6867": 0.2, "6875": 0.058823529411764705, "6890": 0.25, "6891": 1.0, "6896": 0.0, "6901": 0.1111111111111111, "6907": 0.0, "6909": 0.0, "6959": 0.25, "6985": 1.0, "7017": 0.0, "7068": 1.0, "7071": 0.05263157894736842, "7080": 1.0, "7096": 0.5, "7098": 1.0, "7105": 0.16666666666666666, "7109": 0.5, "7124": 0.5, "7141": 0.0, "7145": 0.1, "7178": 0.14285714285714285, "7188": 0.08333333333333333, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.05, "7279": 0.25, "7295": 0.0, "7311": 0.05, "7326": 0.0, "7329": 0.25, "7344": 1.0, "7345": 0.07692307692307693, "7377": 1.0, "7431": 0.0, "7441": 0.16666666666666666, "7445": 0.0, "7448": 1.0, "7456": 0.0, "7463": 0.14285714285714285, "7467": 0.25, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.1111111111111111, "7529": 0.25, "7533": 0.05263157894736842, "7534": 1.0, "7590": 1.0, "7592": 0.0, "7594": 0.14285714285714285, "7622": 0.0, "7633": 1.0, "7674": 0.0, "7700": 0.08333333333333333, "7702": 0.5, "7705": 0.3333333333333333, "7734": 1.0, "7747": 0.14285714285714285, "7754": 0.08333333333333333, "7758": 0.3333333333333333, "7801": 1.0, "7803": 0.1111111111111111, "7823": 1.0, "7876": 0.2, "7879": 0.0, "7880": 0.25, "7911": 1.0, "7925": 0.5, "7928": 0.5, "7936": 0.3333333333333333, "7992": 0.5, "8002": 0.5, "8005": 0.0, "8013": 0.0, "8017": 1.0, "8034": 0.07692307692307693, "8040": 1.0, "8072": 0.5, "8079": 1.0, "8102": 0.07142857142857142, "8116": 0.25, "8121": 1.0, "8202": 0.0, "8230": 0.0, "8247": 0.0, "8271": 1.0, "8275": 0.25, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.1, "8456": 1.0, "8475": 1.0, "8507": 0.0, "8512": 0.3333333333333333, "8513": 0.0, "8532": 1.0, "8537": 0.125, "8539": 0.05263157894736842, "8544": 1.0, "8592": 0.3333333333333333, "8632": 0.14285714285714285, "8635": 0.0, "8702": 1.0, "8779": 0.09090909090909091, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 0.5, "8855": 0.0, "8874": 0.2, "8934": 1.0, "8937": 0.16666666666666666, "8947": 0.2, "8959": 0.25, "8970": 1.0, "8974": 1.0, "8982": 0.0, "9060": 1.0, "9088": 0.0, "9108": 0.0, "9115": 0.25, "9126": 0.0, "9164": 0.125, "9174": 0.0, "9188": 1.0, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.125, "9329": 1.0, "9332": 0.16666666666666666, "9381": 0.2, "9385": 0.16666666666666666, "9391": 0.3333333333333333, "9403": 0.0, "9481": 0.5, "9487": 0.07692307692307693, "9548": 0.2, "9556": 1.0, "9565": 1.0, "9598": 0.125, "9617": 0.16666666666666666, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.5, "9646": 0.2, "9668": 1.0, "9701": 0.0, "9733": 0.16666666666666666, "9735": 0.14285714285714285, "9737": 1.0, "9771": 0.0, "9808": 0.5, "9824": 1.0, "9871": 0.5, "9882": 0.0, "9925": 1.0, "9929": 0.3333333333333333, "9961": 0.1, "9979": 1.0, "10034": 0.25, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.14285714285714285, "10137": 0.1, "10152": 1.0, "10183": 0.16666666666666666, "10213": 1.0, "10246": 0.0, "10267": 0.0, "10414": 1.0, "10447": 0.25, "10462": 0.0, "10482": 0.0, "10497": 1.0, "10526": 0.125, "10547": 0.0, "10558": 0.07142857142857142, "10596": 1.0, "10601": 1.0, "10628": 0.1, "10639": 0.5, "10645": 0.5, "10674": 1.0, "10710": 0.14285714285714285, "10734": 1.0, "10792": 0.14285714285714285, "10808": 0.14285714285714285, "10809": 0.5, "10812": 1.0, "10827": 0.2, "10845": 1.0, "10912": 0.058823529411764705, "10932": 1.0, "10975": 0.0, "10979": 1.0, "10994": 0.3333333333333333, "11039": 0.3333333333333333, "11054": 1.0, "11088": 0.14285714285714285}}} diff --git a/evals/benchmark/results/fiqa/qrels.json b/evals/benchmark/results/fiqa/qrels.json new file mode 100644 index 000000000..64af834e7 --- /dev/null +++ b/evals/benchmark/results/fiqa/qrels.json @@ -0,0 +1 @@ +{"8": {"566392": 1, "65404": 1}, "15": {"325273": 1}, "18": {"88124": 1}, "26": {"285255": 1, "350819": 1}, "34": {"599545": 1}, "42": {"272709": 1, "327263": 1, "331981": 1}, "56": {"572690": 1}, "68": {"19183": 1}, "89": {"413229": 1, "590102": 1, "268026": 1, "248624": 1, "508754": 1, "64556": 1}, "90": {"31793": 1}, "94": {"245447": 1}, "98": {"575929": 1, "527522": 1}, "104": {"575869": 1, "523158": 1}, "106": {"76695": 1}, "109": {"73427": 1}, "475": {"366761": 1}, "503": {"367641": 1}, "504": {"500755": 1, "344203": 1, "498751": 1}, "515": {"372909": 1}, "529": {"510701": 1}, "547": {"6349": 1, "278629": 1}, "549": {"214024": 1}, "559": {"246459": 1}, "570": {"363591": 1}, "585": {"140226": 1, "552375": 1}, "588": {"570546": 1, "203710": 1}, "594": {"377322": 1, "534059": 1}, "603": {"456440": 1}, "604": {"451443": 1, "231947": 1, "261622": 1}, "620": {"331332": 1, "417301": 1, "189303": 1, "180673": 1, "487067": 1}, "622": {"179756": 1, "369239": 1}, "659": {"13139": 1, "230908": 1, "584685": 1, "439467": 1, "264297": 1, "235925": 1, "168796": 1, "120279": 1, "365240": 1, "449079": 1}, "672": {"40966": 1, "563025": 1}, "684": {"441120": 1}, "687": {"146021": 1, "268992": 1}, "689": {"411044": 1}, "691": {"395912": 1}, "699": {"107092": 1}, "701": {"288537": 1, "339488": 1, "389446": 1}, "715": {"579763": 1, "546538": 1, "187404": 1}, "721": {"496225": 1}, "744": {"490443": 1, "566480": 1, "78176": 1}, "750": {"419768": 1, "33602": 1}, "753": {"466718": 1, "243503": 1}, "766": {"2996": 1, "387218": 1, "550172": 1}, "776": {"467044": 1, "583640": 1, "597247": 1, "124027": 1, "592680": 1, "10440": 1, "127263": 1, "332373": 1, "220127": 1, "597880": 1, "496899": 1, "591516": 1}, "810": {"30596": 1}, "813": {"106501": 1, "436701": 1}, "849": {"557186": 1}, "852": {"245702": 1, "531288": 1, "431735": 1}, "853": {"260795": 1, "147080": 1}, "858": {"146632": 1, "45185": 1, "122485": 1, "278450": 1}, "859": {"449630": 1, "18749": 1}, "864": {"472924": 1, "30142": 1, "211364": 1, "24890": 1, "566337": 1, "152072": 1}, "879": {"366830": 1}, "885": {"337165": 1, "409184": 1}, "895": {"416268": 1}, "904": {"415514": 1}, "928": {"349866": 1, "11572": 1}, "929": {"367754": 1}, "932": {"48722": 1, "387010": 1}, "939": {"392434": 1}, "945": {"352052": 1}, "957": {"446870": 1, "321500": 1, "540334": 1}, "988": {"226053": 1, "107688": 1}, "1074": {"443960": 1}, "1085": {"467737": 1, "393710": 1}, "1090": {"518896": 1, "203091": 1}, "1150": {"531698": 1, "43603": 1, "353369": 1, "19936": 1}, "1157": {"272425": 1, "405777": 1}, "1159": {"496064": 1}, "1198": {"56718": 1}, "1230": {"191649": 1}, "1281": {"361415": 1}, "1284": {"342411": 1}, "1297": {"171761": 1}, "1306": {"594206": 1, "484437": 1, "204075": 1, "167684": 1}, "1309": {"471630": 1, "156162": 1, "489401": 1, "438869": 1}, "1310": {"535651": 1}, "1321": {"216456": 1, "292065": 1}, "1322": {"399418": 1, "114231": 1, "115552": 1, "64138": 1}, "1391": {"266229": 1, "562176": 1, "440745": 1}, "1393": {"220022": 1, "589398": 1, "532932": 1, "352838": 1, "539133": 1, "352640": 1}, "1415": {"387165": 1, "306144": 1, "66246": 1, "393953": 1}, "1416": {"326717": 1}, "1441": {"178": 1, "414940": 1, "416727": 1, "471123": 1}, "1451": {"538005": 1}, "1469": {"444589": 1}, "1530": {"28764": 1, "313361": 1, "219425": 1}, "1670": {"290887": 1, "393898": 1, "493792": 1}, "1676": {"77245": 1, "394871": 1, "58937": 1, "234436": 1}, "1736": {"399406": 1, "396933": 1, "25543": 1, "562896": 1, "443419": 1}, "1748": {"18001": 1, "528564": 1, "576295": 1}, "1783": {"332314": 1}, "1812": {"530570": 1, "219274": 1}, "1815": {"446928": 1}, "1819": {"376499": 1, "66058": 1, "212713": 1, "267362": 1, "250285": 1, "220691": 1}, "1824": {"244808": 1}, "1826": {"401731": 1, "8057": 1, "181787": 1, "583788": 1}, "1832": {"590276": 1}, "1871": {"175524": 1, "364112": 1, "244185": 1, "444162": 1}, "1877": {"178697": 1}, "1889": {"388713": 1}, "1915": {"318266": 1, "433801": 1}, "1920": {"269943": 1}, "1933": {"183612": 1}, "1948": {"467509": 1}, "1994": {"434846": 1, "565157": 1, "51491": 1, "243356": 1, "156640": 1}, "2010": {"44256": 1, "233877": 1, "174034": 1}, "2051": {"558042": 1}, "2070": {"136438": 1, "363678": 1, "30253": 1}, "2075": {"170042": 1, "44417": 1, "260983": 1, "359580": 1, "60459": 1, "523393": 1, "519619": 1, "301866": 1, "14967": 1}, "2076": {"184646": 1, "278824": 1}, "2088": {"399875": 1, "599524": 1}, "2108": {"525200": 1, "309171": 1, "155389": 1}, "2118": {"411061": 1}, "2154": {"476632": 1}, "2181": {"376631": 1, "397329": 1}, "2183": {"132678": 1, "124427": 1, "571625": 1, "498146": 1, "24994": 1, "24344": 1}, "2204": {"280056": 1, "4066": 1, "174363": 1, "424523": 1, "271514": 1, "50809": 1, "374030": 1, "83922": 1}, "2264": {"534454": 1, "412819": 1}, "2296": {"396853": 1, "106424": 1, "400009": 1, "119298": 1, "83330": 1, "366594": 1, "279897": 1, "253563": 1, "130850": 1}, "2306": {"581889": 1, "315875": 1}, "2316": {"482343": 1, "348955": 1}, "2318": {"428533": 1}, "2330": {"478514": 1, "104221": 1}, "2334": {"228403": 1, "2304": 1, "150650": 1}, "2348": {"211867": 1, "247486": 1, "381757": 1, "447619": 1, "566573": 1, "410166": 1, "211622": 1, "474234": 1, "306430": 1, "268261": 1, "352271": 1, "543714": 1, "146441": 1, "265874": 1, "134864": 1}, "2376": {"64263": 1, "549833": 1, "91545": 1, "324411": 1, "114417": 1, "407455": 1, "402249": 1, "244961": 1}, "2383": {"17215": 1, "232199": 1}, "2384": {"435835": 1}, "2385": {"407654": 1, "373059": 1}, "2388": {"104988": 1}, "2395": {"179066": 1}, "2398": {"118730": 1, "509391": 1, "363810": 1, "224654": 1, "590489": 1}, "2399": {"343489": 1}, "2400": {"456470": 1, "1198": 1, "564271": 1}, "2407": {"294327": 1, "2064": 1, "319734": 1, "173929": 1}, "2416": {"162612": 1, "48569": 1, "105129": 1, "471247": 1}, "2423": {"81106": 1, "396127": 1, "553288": 1, "551954": 1, "529444": 1, "305946": 1, "538023": 1}, "2443": {"305579": 1}, "2445": {"431685": 1}, "2460": {"584337": 1, "549180": 1, "530037": 1}, "2465": {"570680": 1, "81046": 1, "546509": 1}, "2472": {"401125": 1, "370334": 1, "307315": 1}, "2486": {"487791": 1}, "2498": {"365456": 1}, "2513": {"82344": 1}, "2516": {"505678": 1, "199508": 1, "446340": 1, "566602": 1}, "2549": {"58451": 1, "21103": 1}, "2551": {"413832": 1, "450742": 1, "143100": 1}, "2568": {"139047": 1, "388798": 1, "296769": 1, "346042": 1, "108739": 1, "590082": 1, "127353": 1}, "2579": {"197052": 1, "524471": 1, "432808": 1, "191977": 1, "280838": 1, "432020": 1}, "2580": {"344118": 1, "503934": 1, "11988": 1}, "2587": {"89326": 1}, "2589": {"43961": 1, "450577": 1, "468144": 1}, "2590": {"296528": 1, "209493": 1, "589625": 1}, "2593": {"147343": 1, "231614": 1, "528132": 1}, "2598": {"376126": 1, "593029": 1}, "2648": {"307120": 1}, "2676": {"55666": 1}, "2685": {"384532": 1, "154113": 1, "370300": 1, "37900": 1, "382005": 1, "303293": 1, "594182": 1, "468923": 1}, "2695": {"305904": 1}, "2713": {"29372": 1, "388147": 1}, "2724": {"491472": 1, "32172": 1}, "2737": {"426678": 1}, "2747": {"540571": 1}, "2749": {"587192": 1, "207285": 1}, "2790": {"423403": 1, "279329": 1, "27268": 1, "472484": 1, "100483": 1, "469125": 1, "4612": 1}, "2801": {"398856": 1, "475541": 1}, "2856": {"231727": 1, "213331": 1, "110848": 1, "342212": 1}, "2857": {"233732": 1, "501384": 1, "60175": 1, "295864": 1}, "2880": {"533791": 1}, "2885": {"367360": 1, "414692": 1, "359579": 1, "85229": 1, "454810": 1}, "2891": {"31117": 1}, "2895": {"521996": 1, "328691": 1}, "2903": {"527776": 1}, "2923": {"82744": 1, "161667": 1, "46381": 1, "390089": 1, "264271": 1}, "2964": {"302409": 1, "95116": 1}, "2968": {"242124": 1, "388646": 1}, "2994": {"419319": 1, "318491": 1, "569145": 1}, "3006": {"127838": 1, "512096": 1, "269851": 1, "403137": 1, "568473": 1, "328300": 1}, "3008": {"231688": 1, "180192": 1, "407401": 1, "323406": 1}, "3014": {"341399": 1, "273282": 1}, "3033": {"571430": 1, "265866": 1}, "3039": {"136804": 1}, "3049": {"127974": 1, "88477": 1, "582864": 1, "450808": 1}, "3051": {"232063": 1, "591940": 1}, "3067": {"406156": 1, "517299": 1}, "3085": {"248619": 1, "527010": 1}, "3091": {"159936": 1, "108302": 1, "366448": 1, "187739": 1, "534099": 1, "274870": 1, "95778": 1}, "3103": {"176596": 1}, "3115": {"129364": 1, "183869": 1, "234950": 1, "389028": 1, "233562": 1, "316794": 1}, "3125": {"89008": 1}, "3148": {"178127": 1, "584305": 1, "438000": 1, "92888": 1, "172855": 1}, "3149": {"490223": 1, "98112": 1}, "3177": {"17208": 1, "536120": 1, "268289": 1}, "3179": {"150219": 1, "385073": 1}, "3186": {"555486": 1, "545421": 1}, "3189": {"225395": 1, "272840": 1}, "3254": {"484891": 1, "443511": 1, "475756": 1}, "3264": {"598807": 1, "134764": 1, "486525": 1, "260383": 1}, "3357": {"209974": 1}, "3369": {"371886": 1, "163834": 1, "231012": 1, "145716": 1, "411910": 1, "395840": 1}, "3394": {"445971": 1, "342258": 1, "129319": 1, "570664": 1}, "3404": {"442110": 1, "556976": 1, "160301": 1, "488574": 1, "498834": 1, "395483": 1, "277583": 1}, "3405": {"495467": 1}, "3446": {"366685": 1, "211839": 1, "511386": 1, "236899": 1, "323498": 1}, "3451": {"26292": 1, "192307": 1, "276883": 1, "588448": 1, "165970": 1, "490170": 1, "99132": 1}, "3453": {"418626": 1, "233635": 1}, "3480": {"53468": 1, "418352": 1, "221015": 1, "75568": 1}, "3490": {"420529": 1}, "3500": {"273187": 1, "141935": 1, "557478": 1, "174019": 1, "71424": 1, "565409": 1}, "3503": {"345294": 1, "297764": 1, "63091": 1, "177563": 1, "482077": 1, "360621": 1, "89509": 1}, "3512": {"466835": 1, "115042": 1}, "3528": {"345697": 1}, "3530": {"189190": 1, "184299": 1, "239998": 1}, "3534": {"340329": 1}, "3566": {"152286": 1, "99943": 1, "307424": 1}, "3569": {"450135": 1}, "3594": {"246882": 1, "554171": 1, "525247": 1, "490294": 1}, "3612": {"402726": 1, "584291": 1, "259625": 1, "212687": 1}, "3615": {"518379": 1, "335991": 1}, "3625": {"500751": 1, "384469": 1, "414295": 1}, "3682": {"356161": 1, "329662": 1}, "3683": {"276975": 1, "185909": 1, "454501": 1, "565016": 1, "522713": 1, "105973": 1}, "3694": {"282442": 1, "204747": 1}, "3724": {"302512": 1, "273497": 1, "309200": 1, "508921": 1, "434190": 1, "279570": 1, "497216": 1, "552887": 1, "341146": 1, "199970": 1}, "3735": {"330041": 1, "266900": 1, "314478": 1}, "3759": {"527966": 1, "67167": 1, "522358": 1}, "3767": {"368679": 1, "153922": 1, "392060": 1, "520395": 1, "320246": 1}, "3771": {"521712": 1, "128471": 1, "488948": 1, "198349": 1, "217683": 1, "49601": 1}, "3781": {"131959": 1, "413328": 1}, "3789": {"459724": 1, "274573": 1, "492856": 1, "571131": 1}, "3791": {"327432": 1, "577201": 1, "212222": 1}, "3801": {"390529": 1, "307776": 1}, "3822": {"305907": 1, "385090": 1, "418900": 1, "308837": 1}, "3829": {"523850": 1, "291438": 1}, "3830": {"54952": 1}, "3837": {"345533": 1}, "3859": {"230261": 1}, "3875": {"136315": 1, "249859": 1}, "3888": {"307083": 1, "319213": 1, "239632": 1}, "3909": {"404352": 1, "200690": 1, "312248": 1, "404356": 1, "374400": 1, "61586": 1, "514003": 1, "193459": 1, "245616": 1, "353028": 1}, "3932": {"107697": 1, "527443": 1}, "3934": {"457034": 1, "122952": 1, "209604": 1, "201769": 1}, "3995": {"427032": 1, "278734": 1, "297900": 1, "506909": 1, "230208": 1}, "4007": {"556220": 1, "388704": 1, "521657": 1}, "4011": {"136367": 1, "470": 1, "67699": 1}, "4019": {"287991": 1, "379948": 1, "332749": 1, "6881": 1, "125477": 1}, "4031": {"115741": 1}, "4037": {"10275": 1, "298099": 1}, "4047": {"417840": 1, "452175": 1, "77652": 1, "324779": 1}, "4071": {"129875": 1}, "4084": {"250028": 1, "308633": 1}, "4102": {"554734": 1, "241101": 1, "39115": 1, "448699": 1}, "4103": {"440270": 1}, "4105": {"166412": 1, "25096": 1}, "4116": {"234674": 1, "109149": 1}, "4125": {"344648": 1, "72046": 1}, "4142": {"586930": 1, "544020": 1, "203926": 1, "61346": 1}, "4153": {"459596": 1}, "4179": {"278196": 1}, "4188": {"468108": 1}, "4205": {"79777": 1, "134239": 1, "540451": 1}, "4233": {"16270": 1, "590836": 1, "154886": 1, "31377": 1, "187129": 1}, "4265": {"392163": 1, "293111": 1, "140947": 1, "349710": 1, "157553": 1, "93881": 1}, "4286": {"70460": 1, "566069": 1}, "4289": {"288330": 1, "24881": 1}, "4306": {"450694": 1, "221435": 1, "233718": 1, "61819": 1}, "4312": {"116647": 1, "222639": 1, "135845": 1, "167950": 1, "282435": 1, "399149": 1, "507284": 1}, "4335": {"318583": 1, "357013": 1, "322246": 1, "484148": 1}, "4339": {"386531": 1, "488615": 1}, "4394": {"336045": 1, "441582": 1}, "4409": {"426676": 1, "102326": 1, "115066": 1, "499128": 1, "97925": 1, "100306": 1, "245903": 1, "147439": 1, "102088": 1, "360682": 1}, "4411": {"79903": 1, "68239": 1, "116545": 1}, "4414": {"235522": 1, "367137": 1}, "4415": {"238234": 1, "147646": 1, "414188": 1, "67676": 1}, "4433": {"146181": 1, "301580": 1}, "4447": {"286226": 1}, "4464": {"102904": 1}, "4465": {"376575": 1, "344041": 1, "299242": 1}, "4484": {"33990": 1}, "4499": {"323363": 1, "513818": 1, "76996": 1}, "4500": {"163048": 1, "533623": 1}, "4504": {"2981": 1, "566458": 1}, "4514": {"352485": 1, "69485": 1, "337764": 1, "156211": 1, "426270": 1, "209804": 1}, "4523": {"594257": 1, "119165": 1, "393009": 1, "129255": 1, "66626": 1}, "4539": {"370879": 1, "275925": 1}, "4571": {"496857": 1, "282392": 1, "213824": 1}, "4600": {"482415": 1}, "4605": {"41312": 1, "313306": 1, "453941": 1, "504661": 1, "229310": 1, "210759": 1, "400826": 1}, "4615": {"496427": 1, "261900": 1, "262934": 1, "69523": 1, "421365": 1, "596196": 1}, "4640": {"322314": 1, "101369": 1, "540539": 1}, "4641": {"44594": 1, "406219": 1, "319954": 1, "397358": 1, "88327": 1}, "4678": {"305153": 1}, "4681": {"181909": 1, "587959": 1}, "4700": {"345137": 1}, "4714": {"505057": 1, "584450": 1, "450819": 1, "324833": 1}, "4756": {"340254": 1}, "4767": {"280805": 1, "568670": 1, "224057": 1, "22804": 1, "125986": 1}, "4775": {"72021": 1}, "4777": {"590710": 1}, "4785": {"37517": 1}, "4804": {"583651": 1, "104395": 1}, "4813": {"98356": 1}, "4823": {"104726": 1, "362919": 1, "561929": 1}, "4827": {"495791": 1}, "4837": {"531841": 1, "20958": 1}, "4844": {"275257": 1, "192193": 1}, "4845": {"40424": 1, "339928": 1, "41625": 1}, "4846": {"151104": 1, "323749": 1}, "4863": {"87398": 1, "198465": 1, "290562": 1}, "4865": {"100485": 1}, "4920": {"306815": 1, "228341": 1, "82294": 1}, "4942": {"357685": 1}, "4946": {"121690": 1}, "4955": {"581318": 1}, "4962": {"158363": 1, "599925": 1}, "4968": {"387022": 1}, "4981": {"45218": 1, "247894": 1, "102684": 1}, "4999": {"314898": 1, "338803": 1, "9938": 1, "46211": 1}, "5021": {"589285": 1}, "5030": {"215540": 1}, "5045": {"264554": 1}, "5054": {"28119": 1}, "5061": {"23747": 1}, "5064": {"2003": 1, "192811": 1}, "5067": {"547301": 1}, "5080": {"256055": 1}, "5083": {"305509": 1, "138845": 1}, "5085": {"102436": 1}, "5086": {"96606": 1}, "5090": {"436493": 1, "12988": 1}, "5125": {"318728": 1}, "5134": {"158523": 1, "206727": 1}, "5150": {"229937": 1}, "5155": {"462892": 1}, "5172": {"529418": 1, "539165": 1}, "5178": {"240261": 1, "561056": 1, "111815": 1, "393833": 1, "39819": 1}, "5185": {"210236": 1, "317354": 1}, "5196": {"172128": 1, "565745": 1, "114829": 1}, "5206": {"563030": 1, "287157": 1, "28230": 1, "201982": 1, "117276": 1, "300660": 1}, "5228": {"232451": 1}, "5231": {"146188": 1}, "5241": {"376123": 1, "234286": 1, "322157": 1, "344740": 1, "27489": 1}, "5254": {"392851": 1, "402466": 1}, "5255": {"75112": 1, "330453": 1, "412830": 1}, "5264": {"371720": 1, "52579": 1, "505694": 1, "431814": 1, "576564": 1}, "5271": {"58599": 1, "221439": 1, "67663": 1}, "5331": {"200784": 1}, "5343": {"2860": 1}, "5347": {"352930": 1}, "5356": {"279785": 1, "71553": 1, "381362": 1, "312405": 1, "562259": 1}, "5369": {"171339": 1, "44223": 1}, "5374": {"152688": 1}, "5380": {"549254": 1}, "5402": {"491350": 1, "227485": 1}, "5410": {"13975": 1, "507813": 1, "368802": 1}, "5422": {"273906": 1, "79517": 1, "151973": 1, "13513": 1}, "5427": {"200603": 1, "323284": 1}, "5460": {"93248": 1, "184337": 1, "21174": 1, "108514": 1, "463885": 1}, "5464": {"350399": 1, "294549": 1, "86691": 1}, "5503": {"146277": 1, "64279": 1}, "5505": {"100387": 1}, "5511": {"169893": 1, "107898": 1, "529123": 1, "560325": 1, "478426": 1, "383193": 1, "114303": 1, "278699": 1, "12746": 1, "51873": 1}, "5534": {"423272": 1, "421136": 1}, "5549": {"286227": 1, "309361": 1}, "5585": {"300117": 1}, "5592": {"355241": 1}, "5616": {"391291": 1}, "5620": {"448784": 1, "171510": 1, "329552": 1, "548740": 1}, "5646": {"200972": 1, "426510": 1, "516413": 1}, "5653": {"588247": 1}, "5683": {"173026": 1, "448690": 1}, "5710": {"232311": 1}, "5741": {"259081": 1, "25943": 1}, "5763": {"89964": 1, "515361": 1, "462019": 1}, "5782": {"172084": 1, "379891": 1, "319773": 1, "448614": 1, "595455": 1}, "5790": {"134794": 1}, "5808": {"251824": 1}, "5853": {"284318": 1, "476663": 1, "160105": 1, "495699": 1, "439459": 1, "473647": 1, "431811": 1, "424598": 1}, "5862": {"130209": 1, "269898": 1, "170141": 1, "562511": 1}, "5888": {"336792": 1, "540806": 1}, "5903": {"231863": 1}, "5906": {"409907": 1, "15172": 1}, "5940": {"486243": 1, "433827": 1, "93936": 1}, "5951": {"418034": 1, "259777": 1, "31663": 1, "151774": 1, "374480": 1, "473765": 1, "298065": 1, "596834": 1, "497260": 1}, "5970": {"181608": 1, "546568": 1, "168453": 1}, "5981": {"564554": 1, "245532": 1, "171483": 1, "286182": 1, "210439": 1}, "5993": {"94373": 1, "367375": 1, "287571": 1, "224918": 1, "128574": 1, "431212": 1, "272866": 1, "230215": 1, "55084": 1, "160193": 1, "5827": 1, "352638": 1, "63690": 1, "426120": 1, "63501": 1}, "6002": {"404605": 1, "273501": 1, "390642": 1, "359862": 1, "516848": 1, "391819": 1, "34389": 1, "233472": 1, "519346": 1, "593434": 1, "154181": 1}, "6004": {"149555": 1}, "6005": {"135415": 1, "478457": 1, "345895": 1, "73310": 1, "384626": 1, "176498": 1, "149500": 1, "572272": 1, "414288": 1, "507544": 1, "390689": 1, "414534": 1, "270856": 1}, "6009": {"228983": 1}, "6041": {"111091": 1, "425020": 1, "241308": 1, "81655": 1}, "6080": {"164513": 1, "22856": 1}, "6110": {"118039": 1, "331850": 1, "188531": 1, "233379": 1, "94117": 1, "259706": 1, "320450": 1, "226496": 1}, "6121": {"394460": 1, "289231": 1}, "6122": {"496166": 1, "169824": 1, "44344": 1}, "6131": {"326094": 1, "365263": 1, "218088": 1, "252534": 1, "381720": 1, "235452": 1, "170204": 1, "416679": 1, "334111": 1, "2460": 1, "368806": 1, "258465": 1}, "6133": {"7733": 1, "415705": 1}, "6142": {"155461": 1, "209863": 1}, "6146": {"7403": 1, "160125": 1}, "6199": {"414693": 1, "584273": 1, "239214": 1, "169921": 1}, "6219": {"48946": 1, "146924": 1}, "6221": {"128698": 1, "470716": 1, "257248": 1, "519675": 1, "76414": 1, "169688": 1, "455614": 1, "115717": 1}, "6252": {"394551": 1, "160932": 1, "293624": 1, "233294": 1, "243268": 1, "379487": 1, "62868": 1}, "6262": {"34538": 1, "26799": 1, "390877": 1}, "6278": {"138511": 1, "63698": 1}, "6395": {"166227": 1}, "6410": {"471723": 1}, "6420": {"565568": 1, "127452": 1}, "6441": {"254279": 1}, "6467": {"453256": 1, "66834": 1, "23217": 1, "346641": 1, "367313": 1}, "6468": {"548970": 1, "332069": 1}, "6479": {"272008": 1, "404339": 1}, "6525": {"181985": 1, "98150": 1, "106541": 1}, "6554": {"583203": 1, "22469": 1}, "6562": {"135675": 1, "582414": 1, "561344": 1, "501157": 1}, "6611": {"293679": 1, "198764": 1}, "6612": {"254454": 1, "205522": 1, "322900": 1}, "6625": {"88892": 1}, "6629": {"444405": 1}, "6635": {"102449": 1, "587137": 1, "3656": 1, "156358": 1}, "6644": {"175035": 1}, "6647": {"69790": 1, "428017": 1, "462265": 1}, "6668": {"275902": 1, "457294": 1}, "6679": {"242298": 1, "581672": 1, "358492": 1}, "6683": {"592187": 1, "77631": 1}, "6713": {"147853": 1, "357571": 1}, "6715": {"568526": 1, "13732": 1}, "6746": {"210887": 1, "333674": 1}, "6787": {"587120": 1}, "6792": {"485973": 1}, "6800": {"35191": 1}, "6803": {"193012": 1, "544053": 1, "142726": 1, "42620": 1}, "6807": {"332567": 1}, "6814": {"340214": 1, "223206": 1}, "6832": {"377853": 1, "573874": 1}, "6835": {"149305": 1, "102243": 1}, "6849": {"44601": 1}, "6862": {"386796": 1}, "6867": {"443804": 1, "466143": 1, "878": 1, "540799": 1, "502607": 1, "445258": 1, "538750": 1}, "6875": {"224392": 1}, "6890": {"558703": 1, "240196": 1}, "6891": {"277217": 1, "463837": 1, "474351": 1}, "6896": {"251704": 1}, "6901": {"388571": 1, "254474": 1}, "6907": {"251604": 1}, "6909": {"127012": 1}, "6959": {"208331": 1, "205010": 1}, "6985": {"456436": 1}, "7017": {"28271": 1}, "7068": {"61864": 1, "10797": 1}, "7071": {"124230": 1, "238629": 1}, "7080": {"517577": 1, "596518": 1}, "7096": {"482238": 1}, "7098": {"34139": 1, "266898": 1}, "7105": {"72652": 1}, "7109": {"257185": 1, "565501": 1, "447781": 1}, "7124": {"74615": 1, "154725": 1, "558617": 1, "526110": 1}, "7141": {"255927": 1, "132288": 1}, "7145": {"81458": 1, "17923": 1, "116865": 1}, "7178": {"401329": 1}, "7188": {"305346": 1}, "7205": {"159966": 1}, "7206": {"441155": 1, "532211": 1, "553066": 1}, "7218": {"32290": 1}, "7221": {"186578": 1}, "7269": {"486696": 1}, "7279": {"476834": 1, "322456": 1, "81483": 1, "464502": 1}, "7295": {"244749": 1}, "7311": {"323768": 1}, "7326": {"584295": 1}, "7329": {"118520": 1, "325330": 1}, "7344": {"14368": 1, "108403": 1}, "7345": {"508821": 1, "237645": 1, "527080": 1}, "7377": {"579557": 1}, "7431": {"372921": 1}, "7441": {"537418": 1, "514500": 1, "117576": 1}, "7445": {"153178": 1, "104343": 1, "296231": 1}, "7448": {"418150": 1}, "7456": {"65120": 1}, "7463": {"577951": 1, "582005": 1, "105634": 1, "305287": 1, "5152": 1}, "7467": {"193312": 1}, "7484": {"444562": 1}, "7509": {"178303": 1}, "7512": {"191060": 1}, "7513": {"115372": 1, "273861": 1, "567362": 1}, "7529": {"66607": 1, "293626": 1}, "7533": {"162668": 1, "93853": 1}, "7534": {"175821": 1, "89714": 1, "358125": 1}, "7590": {"105165": 1, "222505": 1}, "7592": {"273947": 1}, "7594": {"573899": 1}, "7622": {"253369": 1, "378594": 1}, "7633": {"494727": 1, "442048": 1, "122996": 1, "197839": 1}, "7674": {"193318": 1, "519390": 1, "494295": 1}, "7700": {"273761": 1, "507468": 1, "2653": 1, "179328": 1}, "7702": {"387277": 1, "558924": 1}, "7705": {"539263": 1, "195191": 1, "377429": 1}, "7734": {"226070": 1, "433905": 1}, "7747": {"97729": 1, "296420": 1}, "7754": {"197527": 1}, "7758": {"574327": 1}, "7801": {"252574": 1, "427592": 1}, "7803": {"565926": 1, "157504": 1}, "7823": {"105666": 1, "583549": 1, "451196": 1}, "7876": {"533779": 1}, "7879": {"102029": 1, "372551": 1, "421285": 1}, "7880": {"272790": 1, "85319": 1}, "7911": {"57711": 1, "131996": 1}, "7925": {"318185": 1, "251100": 1, "503912": 1, "310636": 1, "402482": 1, "438974": 1}, "7928": {"480967": 1, "118633": 1, "501504": 1, "499811": 1}, "7936": {"293767": 1, "363043": 1, "336541": 1}, "7992": {"559654": 1, "264476": 1}, "8002": {"118786": 1, "265159": 1, "34767": 1}, "8005": {"48800": 1}, "8013": {"496159": 1, "224231": 1}, "8017": {"97836": 1}, "8034": {"597351": 1}, "8040": {"523058": 1}, "8072": {"394244": 1, "169062": 1, "31465": 1}, "8079": {"108040": 1, "57138": 1, "95278": 1}, "8102": {"552707": 1, "557877": 1, "378173": 1, "90294": 1}, "8116": {"236482": 1, "433032": 1}, "8121": {"432424": 1}, "8202": {"513258": 1, "93971": 1}, "8230": {"319599": 1, "363204": 1}, "8247": {"42521": 1, "475170": 1, "321114": 1, "465313": 1}, "8271": {"415511": 1, "376709": 1}, "8275": {"294867": 1}, "8296": {"78675": 1, "79998": 1}, "8332": {"328794": 1, "232261": 1, "445526": 1}, "8351": {"273142": 1, "472516": 1}, "8378": {"178684": 1, "102237": 1, "125298": 1}, "8456": {"257853": 1, "510875": 1, "486333": 1}, "8475": {"494655": 1, "240562": 1, "293320": 1, "104793": 1, "437427": 1, "444107": 1, "481728": 1}, "8507": {"509819": 1, "370995": 1, "351615": 1}, "8512": {"32811": 1}, "8513": {"270573": 1}, "8532": {"416307": 1, "27401": 1, "320101": 1}, "8537": {"6574": 1}, "8539": {"218728": 1, "292609": 1, "196304": 1, "396038": 1}, "8544": {"214003": 1, "267113": 1}, "8592": {"340264": 1, "441718": 1, "261258": 1}, "8632": {"43497": 1, "213976": 1}, "8635": {"67107": 1, "240215": 1}, "8702": {"135363": 1, "345410": 1, "157759": 1}, "8779": {"180571": 1, "209730": 1}, "8789": {"87349": 1, "70853": 1, "41912": 1}, "8795": {"57297": 1}, "8832": {"94689": 1}, "8834": {"133644": 1, "521095": 1, "12232": 1, "197151": 1, "203139": 1, "569303": 1}, "8855": {"208165": 1, "474296": 1, "312821": 1}, "8874": {"403025": 1}, "8934": {"244334": 1, "116675": 1}, "8937": {"469888": 1}, "8947": {"455398": 1, "461592": 1}, "8959": {"250164": 1}, "8970": {"187583": 1, "96121": 1}, "8974": {"140738": 1, "216365": 1, "523331": 1, "134931": 1, "356595": 1, "170625": 1, "10476": 1, "478242": 1}, "8982": {"454610": 1, "200360": 1}, "9060": {"511093": 1, "40447": 1}, "9088": {"569461": 1, "561377": 1}, "9108": {"272021": 1, "472585": 1}, "9115": {"158520": 1, "207325": 1, "422467": 1}, "9126": {"514831": 1}, "9164": {"305274": 1, "365298": 1, "263390": 1}, "9174": {"431652": 1, "535317": 1, "160218": 1, "544576": 1, "405217": 1}, "9188": {"265167": 1, "580802": 1}, "9245": {"194561": 1}, "9275": {"338754": 1, "14364": 1}, "9291": {"96926": 1, "480315": 1}, "9296": {"435746": 1, "206744": 1}, "9329": {"523913": 1, "326991": 1}, "9332": {"271766": 1}, "9381": {"408123": 1, "384983": 1}, "9385": {"403755": 1}, "9391": {"136515": 1, "283202": 1, "248158": 1, "503637": 1}, "9403": {"6666": 1, "328086": 1, "345199": 1}, "9481": {"30417": 1, "402240": 1}, "9487": {"165544": 1}, "9548": {"297290": 1}, "9556": {"37040": 1}, "9565": {"292559": 1, "478291": 1}, "9598": {"379311": 1}, "9617": {"408524": 1, "364735": 1, "314008": 1}, "9633": {"534418": 1, "585447": 1}, "9643": {"112208": 1}, "9644": {"194605": 1}, "9646": {"556191": 1, "272784": 1}, "9668": {"13260": 1, "42438": 1, "111768": 1}, "9701": {"387141": 1, "357739": 1}, "9733": {"526073": 1, "110163": 1, "38655": 1}, "9735": {"392317": 1}, "9737": {"245082": 1, "419897": 1, "99131": 1}, "9771": {"263955": 1, "28740": 1}, "9808": {"40702": 1, "557582": 1, "431946": 1}, "9824": {"574777": 1}, "9871": {"448890": 1, "76562": 1, "40051": 1, "170594": 1}, "9882": {"65702": 1}, "9925": {"374309": 1, "289120": 1}, "9929": {"266323": 1, "568006": 1}, "9961": {"21311": 1}, "9979": {"538237": 1, "35633": 1, "337243": 1, "35369": 1}, "10034": {"480749": 1, "181942": 1}, "10039": {"67785": 1}, "10109": {"28314": 1, "506374": 1, "93231": 1, "156029": 1, "406974": 1, "499849": 1, "566591": 1}, "10122": {"570787": 1, "139368": 1, "273718": 1, "259084": 1}, "10136": {"526115": 1, "152316": 1, "290930": 1}, "10137": {"57168": 1}, "10152": {"113585": 1}, "10183": {"66858": 1, "314342": 1}, "10213": {"380942": 1, "270221": 1, "545712": 1}, "10246": {"512984": 1, "77573": 1}, "10267": {"17652": 1, "457108": 1, "424511": 1, "328556": 1, "460398": 1}, "10414": {"79807": 1, "303325": 1}, "10447": {"382236": 1, "152096": 1, "300721": 1}, "10462": {"8266": 1, "11378": 1, "35680": 1, "437879": 1, "204035": 1, "581204": 1}, "10482": {"549072": 1}, "10497": {"304284": 1, "147765": 1, "34913": 1, "398622": 1, "575729": 1, "31483": 1, "159880": 1, "71898": 1, "196423": 1, "445230": 1}, "10526": {"39185": 1, "283008": 1}, "10547": {"571306": 1}, "10558": {"222485": 1, "483268": 1}, "10596": {"284235": 1, "316838": 1, "208070": 1, "164008": 1, "413041": 1}, "10601": {"568064": 1}, "10628": {"588116": 1}, "10639": {"431799": 1, "495774": 1, "278453": 1, "163353": 1, "187039": 1}, "10645": {"588607": 1, "22221": 1}, "10674": {"99857": 1, "257241": 1, "543589": 1, "3095": 1}, "10710": {"6771": 1}, "10734": {"589970": 1, "263481": 1, "470289": 1, "225718": 1, "426278": 1, "62882": 1}, "10792": {"195044": 1, "374956": 1}, "10808": {"28291": 1, "487052": 1, "484599": 1}, "10809": {"103362": 1, "286141": 1, "242524": 1}, "10812": {"451935": 1, "46737": 1, "314455": 1, "342756": 1}, "10827": {"160786": 1, "42301": 1, "7748": 1, "107554": 1, "95282": 1}, "10845": {"191588": 1}, "10912": {"518721": 1}, "10932": {"104134": 1}, "10975": {"61022": 1}, "10979": {"148728": 1, "164001": 1, "362762": 1, "121158": 1}, "10994": {"496820": 1, "212394": 1}, "11039": {"53544": 1, "202768": 1, "353625": 1, "293531": 1, "249063": 1, "79363": 1, "330058": 1, "91183": 1}, "11054": {"155053": 1, "321015": 1}, "11088": {"437100": 1}} \ No newline at end of file diff --git a/evals/benchmark/results/fiqa/run-dense.trec.gz b/evals/benchmark/results/fiqa/run-dense.trec.gz new file mode 100644 index 0000000000000000000000000000000000000000..4bcbb23959b4d8a0cc41696571aa422c277b4fe0 GIT binary patch literal 86810 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

4dJR^fI+q3 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 F1^`dZAC3S3 literal 0 HcmV?d00001 diff --git a/evals/benchmark/results/fiqa/run-w0.25.trec.gz b/evals/benchmark/results/fiqa/run-w0.25.trec.gz new file mode 100644 index 0000000000000000000000000000000000000000..f77267400b079566f5969720553f84d793c5d465 GIT binary patch literal 99696 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