From 12b5035484ca0aecfb140d957ed34f1660dd02dd Mon Sep 17 00:00:00 2001 From: Tobias Perelstein <5562156+tobocop2@users.noreply.github.com> Date: Sat, 18 Jul 2026 02:43:36 -0400 Subject: [PATCH] Retrieval eval + benchmark harness The blind noise-calibrated retrieval eval harness (evals/retrieval) and the preregistered lilbee-vs-baseline benchmark (evals/benchmark) with its Qwen3-0.6B results, split out of the core retrieval work so the harness tooling lives on its own branch instead of cluttering lilbee's core. Runs against a deployed lilbee; imports the public API only. --- evals/__init__.py | 1 + evals/benchmark/README.md | 121 ++++++++ evals/benchmark/RESULTS.md | 107 +++++++ 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/requirements.txt | 10 + .../results-adaptive/fiqa/ir-adm0.15.jsonl | 1 + .../results-adaptive/fiqa/ir-adm0.30.jsonl | 1 + .../results-adaptive/fiqa/ir-adm0.50.jsonl | 1 + .../results-adaptive/fiqa/run-adm0.15.trec.gz | Bin 0 -> 122814 bytes .../fiqa/stats-adm0.15-vs-dense.jsonl | 4 + .../fiqa/stats-adm0.30-vs-dense.jsonl | 4 + .../fiqa/stats-adm0.50-vs-dense.jsonl | 4 + .../results-adaptive/manifest.frozen.json | 87 ++++++ .../nfcorpus/ir-adm0.15.jsonl | 1 + .../nfcorpus/ir-adm0.30.jsonl | 1 + .../nfcorpus/ir-adm0.50.jsonl | 1 + .../nfcorpus/run-adm0.15.trec.gz | Bin 0 -> 49825 bytes .../nfcorpus/stats-adm0.15-vs-dense.jsonl | 4 + .../nfcorpus/stats-adm0.30-vs-dense.jsonl | 4 + .../nfcorpus/stats-adm0.50-vs-dense.jsonl | 4 + .../results-adaptive/scifact/ir-adm0.15.jsonl | 1 + .../results-adaptive/scifact/ir-adm0.30.jsonl | 1 + .../results-adaptive/scifact/ir-adm0.50.jsonl | 1 + .../scifact/run-adm0.15.trec.gz | Bin 0 -> 50745 bytes .../scifact/stats-adm0.15-vs-dense.jsonl | 4 + .../scifact/stats-adm0.30-vs-dense.jsonl | 4 + .../scifact/stats-adm0.50-vs-dense.jsonl | 4 + 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 + evals/benchmark/runfile.py | 93 ++++++ evals/benchmark/stats.py | 120 +++++++ evals/retrieval/README.md | 107 +++++++ evals/retrieval/__init__.py | 1 + evals/retrieval/__main__.py | 6 + evals/retrieval/answers.py | 133 ++++++++ evals/retrieval/blinding.py | 119 +++++++ evals/retrieval/checkpoint.py | 36 +++ evals/retrieval/cli.py | 200 ++++++++++++ evals/retrieval/judging.py | 97 ++++++ evals/retrieval/llm.py | 82 +++++ evals/retrieval/questions.py | 211 +++++++++++++ evals/retrieval/report.py | 57 ++++ evals/retrieval/scoring.py | 130 ++++++++ evals/retrieval/store_scan.py | 137 ++++++++ tests/evals/__init__.py | 0 tests/evals/test_eval_answers.py | 120 +++++++ tests/evals/test_eval_blinding.py | 121 ++++++++ tests/evals/test_eval_checkpoint.py | 40 +++ tests/evals/test_eval_cli.py | 173 +++++++++++ tests/evals/test_eval_judging.py | 69 +++++ tests/evals/test_eval_questions.py | 128 ++++++++ tests/evals/test_eval_report.py | 49 +++ tests/evals/test_eval_scoring.py | 158 ++++++++++ tests/evals/test_eval_store_scan.py | 85 +++++ 108 files changed, 4334 insertions(+) create mode 100644 evals/__init__.py create mode 100644 evals/benchmark/README.md create mode 100644 evals/benchmark/RESULTS.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/requirements.txt create mode 100644 evals/benchmark/results-adaptive/fiqa/ir-adm0.15.jsonl create mode 100644 evals/benchmark/results-adaptive/fiqa/ir-adm0.30.jsonl create mode 100644 evals/benchmark/results-adaptive/fiqa/ir-adm0.50.jsonl create mode 100644 evals/benchmark/results-adaptive/fiqa/run-adm0.15.trec.gz create mode 100644 evals/benchmark/results-adaptive/fiqa/stats-adm0.15-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/fiqa/stats-adm0.30-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/fiqa/stats-adm0.50-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/manifest.frozen.json create mode 100644 evals/benchmark/results-adaptive/nfcorpus/ir-adm0.15.jsonl create mode 100644 evals/benchmark/results-adaptive/nfcorpus/ir-adm0.30.jsonl create mode 100644 evals/benchmark/results-adaptive/nfcorpus/ir-adm0.50.jsonl create mode 100644 evals/benchmark/results-adaptive/nfcorpus/run-adm0.15.trec.gz create mode 100644 evals/benchmark/results-adaptive/nfcorpus/stats-adm0.15-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/nfcorpus/stats-adm0.30-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/nfcorpus/stats-adm0.50-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/ir-adm0.15.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/ir-adm0.30.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/ir-adm0.50.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/run-adm0.15.trec.gz create mode 100644 evals/benchmark/results-adaptive/scifact/stats-adm0.15-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/stats-adm0.30-vs-dense.jsonl create mode 100644 evals/benchmark/results-adaptive/scifact/stats-adm0.50-vs-dense.jsonl 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 create mode 100644 evals/benchmark/runfile.py create mode 100644 evals/benchmark/stats.py create mode 100644 evals/retrieval/README.md create mode 100644 evals/retrieval/__init__.py create mode 100644 evals/retrieval/__main__.py create mode 100644 evals/retrieval/answers.py create mode 100644 evals/retrieval/blinding.py create mode 100644 evals/retrieval/checkpoint.py create mode 100644 evals/retrieval/cli.py create mode 100644 evals/retrieval/judging.py create mode 100644 evals/retrieval/llm.py create mode 100644 evals/retrieval/questions.py create mode 100644 evals/retrieval/report.py create mode 100644 evals/retrieval/scoring.py create mode 100644 evals/retrieval/store_scan.py create mode 100644 tests/evals/__init__.py create mode 100644 tests/evals/test_eval_answers.py create mode 100644 tests/evals/test_eval_blinding.py create mode 100644 tests/evals/test_eval_checkpoint.py create mode 100644 tests/evals/test_eval_cli.py create mode 100644 tests/evals/test_eval_judging.py create mode 100644 tests/evals/test_eval_questions.py create mode 100644 tests/evals/test_eval_report.py create mode 100644 tests/evals/test_eval_scoring.py create mode 100644 tests/evals/test_eval_store_scan.py diff --git a/evals/__init__.py b/evals/__init__.py new file mode 100644 index 000000000..5af0170ea --- /dev/null +++ b/evals/__init__.py @@ -0,0 +1 @@ +"""Version-controlled evaluation harnesses; never shipped with the package.""" 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/RESULTS.md b/evals/benchmark/RESULTS.md new file mode 100644 index 000000000..ff0a34992 --- /dev/null +++ b/evals/benchmark/RESULTS.md @@ -0,0 +1,107 @@ +# 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 +``` + +## Adaptive fusion + +Because no fixed weight wins everywhere, a follow-up run measured `adaptive_fusion` +(the BM25 weight scaled per query by how peaked the vector ranking is) at three +confidence margins, on the same three datasets. Best margin was 0.15. + +| Dataset | dense | w=1.0 | adaptive (m=0.15) | adaptive vs dense | +|---|---|---|---|---| +| NFCorpus | 0.3666 | 0.3732 | 0.3751 | +0.0085, p=0.033, **sig win** | +| SciFact | 0.6981 | 0.7280 | 0.7186 | +0.0205, p=0.009, **sig win** | +| FiQA | 0.4593 | 0.4027 | 0.4410 | −0.0184, p=0.003, sig regression | + +Adaptive fusion is the best single policy found. It beats the fixed w=1.0 default +on all three datasets, keeps the significant NFCorpus and SciFact wins, and gives +the smallest FiQA regression of any config (−0.018 vs −0.056 at w=1.0 and −0.023 +at the best fixed weight). It does not fully erase FiQA's regression — pure dense +still wins there — so the vector-margin confidence signal reduces, but does not +eliminate, the cases where the lexical arm hurts. Run files and stats are under +`results-adaptive/`. + +## 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/__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/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 diff --git a/evals/benchmark/results-adaptive/fiqa/ir-adm0.15.jsonl b/evals/benchmark/results-adaptive/fiqa/ir-adm0.15.jsonl new file mode 100644 index 000000000..bc3cc2dfd --- /dev/null +++ b/evals/benchmark/results-adaptive/fiqa/ir-adm0.15.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "adm0.15", "aggregated": {"nDCG@10": 0.441, "Recall@20": 0.6192, "MRR@10": 0.5143}, "per_query": {"nDCG@10": {"8": 0.6131471927654584, "15": 0.6309297535714575, "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.34870224750355494, "620": 0.0, "622": 0.38685280723454163, "659": 0.5067837010870873, "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.8772153153380493, "753": 0.38685280723454163, "766": 0.18154179253735267, "776": 0.4690000933206748, "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": 1.0, "1085": 0.0, "1090": 0.23719771276929622, "1150": 0.0, "1157": 0.6131471927654584, "1159": 0.0, "1198": 0.6309297535714575, "1230": 0.0, "1281": 0.38685280723454163, "1284": 1.0, "1297": 1.0, "1306": 0.0, "1309": 0.6469523342593044, "1310": 1.0, "1321": 0.0, "1322": 0.24630238874073, "1391": 0.18154179253735267, "1393": 0.30260241349881345, "1415": 0.9178287402913377, "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.6105456988825855, "1783": 0.0, "1812": 0.0, "1815": 1.0, "1819": 0.286381299268402, "1824": 0.31546487678572877, "1826": 0.9828920819566879, "1832": 0.5, "1871": 0.6713527276121545, "1877": 1.0, "1889": 0.0, "1915": 1.0, "1920": 0.0, "1933": 1.0, "1948": 1.0, "1994": 0.21398626473452756, "2010": 0.9325210919548239, "2051": 0.0, "2070": 0.18154179253735267, "2075": 0.40129869165981646, "2076": 0.6934264036172708, "2088": 0.0, "2108": 0.16716045496620227, "2118": 0.0, "2154": 0.0, "2181": 0.0, "2183": 0.7526136409516659, "2204": 0.8984972075197749, "2264": 0.38685280723454163, "2296": 0.33627415762678553, "2306": 0.6131471927654584, "2316": 0.8772153153380493, "2318": 0.3010299956639812, "2330": 0.6131471927654584, "2334": 0.46927872602275644, "2348": 0.43231813227099475, "2376": 0.9830168297915423, "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.8838242945899706, "2423": 0.3576223542196109, "2443": 0.0, "2445": 1.0, "2460": 1.0, "2465": 0.0, "2472": 0.0, "2486": 1.0, "2498": 0.43067655807339306, "2513": 0.0, "2516": 0.6366824387328317, "2549": 0.6131471927654584, "2551": 1.0, "2568": 0.25288473642100684, "2579": 0.2423936099728648, "2580": 0.46927872602275644, "2587": 1.0, "2589": 0.7653606369886217, "2590": 0.46927872602275644, "2593": 0.8854598815714874, "2598": 0.9197207891481876, "2648": 1.0, "2676": 0.5, "2685": 0.35079429740281753, "2695": 1.0, "2713": 0.38685280723454163, "2724": 0.8772153153380493, "2737": 1.0, "2747": 0.5, "2749": 0.8772153153380493, "2790": 0.499028327865556, "2801": 0.6131471927654584, "2856": 0.7095272044910244, "2857": 0.6595629128335778, "2880": 1.0, "2885": 0.0, "2891": 1.0, "2895": 0.0, "2903": 0.3562071871080222, "2923": 0.8207658584763088, "2964": 0.0, "2968": 0.9197207891481876, "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": 1.0, "3186": 1.0, "3189": 0.0, "3254": 0.7039180890341347, "3264": 0.8048099750039491, "3357": 1.0, "3369": 0.0, "3394": 0.5805485932475565, "3404": 0.3932591258696538, "3405": 0.0, "3446": 0.46704774694449785, "3451": 0.07945707943276742, "3453": 0.5706417189553201, "3480": 1.0, "3490": 0.3010299956639812, "3500": 0.644824486427155, "3503": 0.6891341765546151, "3512": 0.9197207891481876, "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.7021799053685303, "3694": 0.6131471927654584, "3724": 0.0, "3735": 0.13565197343244778, "3759": 0.0, "3767": 0.2716774977597197, "3771": 0.4935232796777481, "3781": 0.9197207891481876, "3789": 0.787702056960637, "3791": 0.370291336443826, "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.6364391809889587, "4011": 1.0, "4019": 0.31608365985743925, "4031": 0.0, "4037": 0.18457569677956817, "4047": 0.8048099750039491, "4071": 0.0, "4084": 0.5012658353418871, "4102": 0.0, "4103": 0.0, "4105": 0.0, "4116": 0.6131471927654584, "4125": 0.0, "4142": 0.44927383782962327, "4153": 0.31546487678572877, "4179": 0.6309297535714575, "4188": 0.0, "4205": 0.4525081529734507, "4233": 0.8539316501572937, "4265": 0.7751482523375255, "4286": 0.6131471927654584, "4289": 0.3065735963827292, "4306": 0.7598336331031966, "4312": 0.6370339733570289, "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": 1.0, "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.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.6508205185601091, "4999": 0.5855700749881525, "5021": 0.0, "5030": 0.0, "5045": 0.3010299956639812, "5054": 0.0, "5061": 0.0, "5064": 1.0, "5067": 0.3333333333333333, "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.7227265726449519, "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": 1.0, "5993": 0.31488013066763093, "6002": 0.7720617383222417, "6004": 0.0, "6005": 0.5771493379489847, "6009": 0.0, "6041": 0.6366824387328317, "6080": 0.6131471927654584, "6110": 0.41918605213740834, "6121": 0.38685280723454163, "6122": 0.46927872602275644, "6131": 0.5810820381115676, "6133": 0.6131471927654584, "6142": 0.6131471927654584, "6146": 1.0, "6199": 0.5135312443624667, "6219": 0.6934264036172708, "6221": 0.0, "6252": 0.0, "6262": 0.49818925746641285, "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.6131471927654584, "6562": 0.11751610475642714, "6611": 0.7903864795495061, "6612": 0.16716045496620227, "6625": 0.31546487678572877, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8503449055347546, "6679": 0.5307212739772434, "6683": 0.8503449055347546, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.3065735963827292, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 0.5413996682199069, "6807": 1.0, "6814": 0.0, "6832": 0.430624116386567, "6835": 0.6131471927654584, "6849": 0.3333333333333333, "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": 0.6309297535714575, "7098": 0.6131471927654584, "7105": 0.5, "7109": 0.23463936301137822, "7124": 0.7246262544989281, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.5, "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": 1.0, "7484": 1.0, "7509": 0.0, "7512": 0.0, "7513": 0.16716045496620227, "7529": 0.3065735963827292, "7533": 0.0, "7534": 0.46927872602275644, "7590": 0.9197207891481876, "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": 1.0, "7801": 1.0, "7803": 0.19342640361727081, "7823": 0.617319681505689, "7876": 0.5, "7879": 0.0, "7880": 0.0, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "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.43067655807339306, "8296": 0.9197207891481876, "8332": 0.9060254355346823, "8351": 0.6131471927654584, "8378": 0.1480409554829326, "8456": 0.617319681505689, "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.448643819352159, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.31546487678572877, "8934": 0.8065735963827293, "8937": 0.43067655807339306, "8947": 0.23719771276929622, "8959": 0.38685280723454163, "8970": 0.6934264036172708, "8974": 0.41253177989255346, "8982": 0.0, "9060": 0.6131471927654584, "9088": 0.0, "9108": 0.0, "9115": 0.5833416105149332, "9126": 0.0, "9164": 0.16716045496620227, "9174": 0.0, "9188": 0.6131471927654584, "9245": 0.0, "9275": 0.0, "9291": 0.0, "9296": 0.20438239758848611, "9329": 0.8065735963827293, "9332": 0.43067655807339306, "9381": 0.6934264036172708, "9385": 0.3562071871080222, "9391": 0.5143371794949736, "9403": 0.0, "9481": 0.5706417189553201, "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.8175295903539445, "9929": 0.5714285040141098, "9961": 0.0, "9979": 0.3903800499921017, "10034": 0.38685280723454163, "10039": 0.6309297535714575, "10109": 0.5186511804016661, "10122": 0.19519002499605084, "10136": 0.34337431936037655, "10137": 0.38685280723454163, "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.48864468918810133, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 1.0, "10628": 0.3010299956639812, "10639": 0.21398626473452756, "10645": 0.38685280723454163, "10674": 0.8048099750039491, "10710": 0.3333333333333333, "10734": 0.8696762340896295, "10792": 0.8503449055347546, "10808": 0.3295827480202853, "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.5555555555555556, "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.5, "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.5, "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.07692307692307693, "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.2, "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": 1.0, "1085": 0.0, "1090": 0.2, "1150": 0.0, "1157": 1.0, "1159": 0.0, "1198": 0.5, "1230": 0.06666666666666667, "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.2, "2075": 0.5, "2076": 0.5, "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.1111111111111111, "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.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": 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.16666666666666666, "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.09090909090909091, "3446": 0.5, "3451": 0.1, "3453": 0.3333333333333333, "3480": 1.0, "3490": 0.1111111111111111, "3500": 1.0, "3503": 1.0, "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.1, "3759": 0.0, "3767": 0.3333333333333333, "3771": 1.0, "3781": 1.0, "3789": 1.0, "3791": 0.3333333333333333, "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.25, "4153": 0.125, "4179": 0.5, "4188": 0.0625, "4205": 0.5, "4233": 1.0, "4265": 1.0, "4286": 1.0, "4289": 0.3333333333333333, "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": 1.0, "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.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.14285714285714285, "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.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": 0.5, "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": 1.0, "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": 1.0, "6746": 0.3333333333333333, "6787": 0.0, "6792": 0.0, "6800": 1.0, "6803": 1.0, "6807": 1.0, "6814": 0.0, "6832": 0.2, "6835": 1.0, "6849": 0.14285714285714285, "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.3333333333333333, "7109": 0.3333333333333333, "7124": 1.0, "7141": 0.0625, "7145": 0.1, "7178": 0.3333333333333333, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.07142857142857142, "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": 1.0, "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.16666666666666666, "7754": 0.08333333333333333, "7758": 1.0, "7801": 1.0, "7803": 0.125, "7823": 1.0, "7876": 0.3333333333333333, "7879": 0.0, "7880": 0.06666666666666667, "7911": 1.0, "7925": 0.5, "7928": 0.5, "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.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.25, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.125, "8934": 1.0, "8937": 0.25, "8947": 0.2, "8959": 0.2, "8970": 0.5, "8974": 1.0, "8982": 0.0, "9060": 1.0, "9088": 0.0, "9108": 0.0, "9115": 0.3333333333333333, "9126": 0.0, "9164": 0.16666666666666666, "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.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.5, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.25, "10137": 0.2, "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": 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-adaptive/fiqa/ir-adm0.30.jsonl b/evals/benchmark/results-adaptive/fiqa/ir-adm0.30.jsonl new file mode 100644 index 000000000..faddfe7dd --- /dev/null +++ b/evals/benchmark/results-adaptive/fiqa/ir-adm0.30.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "adm0.30", "aggregated": {"nDCG@10": 0.4323, "Recall@20": 0.6152, "MRR@10": 0.5032}, "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.34870224750355494, "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.5319460297682747, "1310": 1.0, "1321": 0.0, "1322": 0.24630238874073, "1391": 0.18154179253735267, "1393": 0.19092086617893467, "1415": 0.9709286432396583, "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.6105456988825855, "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.6934264036172708, "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.3010299956639812, "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.2214161691338287, "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": 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.43067655807339306, "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.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.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.6324677375730864, "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.370291336443826, "3801": 0.0, "3822": 0.0, "3829": 0.0, "3830": 1.0, "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.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.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.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.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.3065735963827292, "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.38685280723454163, "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.8503449055347546, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.2640681225725909, "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": 0.6309297535714575, "7098": 0.6131471927654584, "7105": 0.38685280723454163, "7109": 0.23463936301137822, "7124": 0.6525874238732422, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.3333333333333333, "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.5714285040141098, "7592": 0.0, "7594": 0.3333333333333333, "7622": 0.0, "7633": 0.3903800499921017, "7674": 0.0, "7700": 0.123151194370365, "7702": 0.38685280723454163, "7705": 0.4367467095119258, "7734": 0.6131471927654584, "7747": 0.20438239758848611, "7754": 0.0, "7758": 0.6309297535714575, "7801": 1.0, "7803": 0.19342640361727081, "7823": 0.6105456988825855, "7876": 0.43067655807339306, "7879": 0.0, "7880": 0.19342640361727081, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "7936": 0.39106560501896365, "7992": 0.38685280723454163, "8002": 0.617319681505689, "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.14126697285982898, "8456": 0.6105456988825855, "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.0, "8789": 0.7653606369886217, "8795": 1.0, "8832": 1.0, "8834": 0.3980628465882808, "8855": 0.0, "8874": 0.3562071871080222, "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.5706417189553201, "9487": 0.0, "9548": 0.38685280723454163, "9556": 1.0, "9565": 1.0, "9598": 0.3562071871080222, "9617": 0.3152014104491349, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.6309297535714575, "9646": 0.448643819352159, "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.5714285040141098, "9961": 0.0, "9979": 0.3903800499921017, "10034": 0.3065735963827292, "10039": 0.6309297535714575, "10109": 0.5399294342072939, "10122": 0.19519002499605084, "10136": 0.34337431936037655, "10137": 0.3562071871080222, "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.49828993591603105, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 1.0, "10628": 0.3010299956639812, "10639": 0.21398626473452756, "10645": 0.38685280723454163, "10674": 0.7095272044910244, "10710": 0.3333333333333333, "10734": 0.8486987932505933, "10792": 0.4415801103577823, "10808": 0.3295827480202853, "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.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.0, "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.3333333333333333, "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.5555555555555556, "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.3333333333333333, "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.6666666666666666, "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.3333333333333333, "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.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.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.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.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.0, "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": 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": 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.25, "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.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.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.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.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.3333333333333333, "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.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": 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.07692307692307693, "504": 0.0, "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.2, "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.06666666666666667, "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.5, "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.1111111111111111, "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.05, "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": 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.25, "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.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.3333333333333333, "3801": 0.07142857142857142, "3822": 0.0, "3829": 0.0, "3830": 1.0, "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.0, "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.0, "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.058823529411764705, "5763": 0.3333333333333333, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.25, "5888": 0.3333333333333333, "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.5, "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.5, "6278": 0.25, "6395": 0.0, "6410": 0.0625, "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.09090909090909091, "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.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": 0.5, "7098": 1.0, "7105": 0.2, "7109": 0.3333333333333333, "7124": 1.0, "7141": 0.0, "7145": 0.1, "7178": 0.14285714285714285, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.07142857142857142, "7279": 0.25, "7295": 0.0, "7311": 0.07692307692307693, "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": 0.5, "7592": 0.0, "7594": 0.14285714285714285, "7622": 0.0, "7633": 1.0, "7674": 0.0, "7700": 0.125, "7702": 0.5, "7705": 0.3333333333333333, "7734": 1.0, "7747": 0.14285714285714285, "7754": 0.08333333333333333, "7758": 0.5, "7801": 1.0, "7803": 0.125, "7823": 1.0, "7876": 0.25, "7879": 0.0, "7880": 0.125, "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.058823529411764705, "8247": 0.0, "8271": 1.0, "8275": 0.25, "8296": 1.0, "8332": 1.0, "8351": 1.0, "8378": 0.1111111111111111, "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.09090909090909091, "8789": 1.0, "8795": 1.0, "8832": 1.0, "8834": 1.0, "8855": 0.0, "8874": 0.16666666666666666, "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.3333333333333333, "9487": 0.08333333333333333, "9548": 0.2, "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.16666666666666666, "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.2, "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-adaptive/fiqa/ir-adm0.50.jsonl b/evals/benchmark/results-adaptive/fiqa/ir-adm0.50.jsonl new file mode 100644 index 000000000..2430e0a27 --- /dev/null +++ b/evals/benchmark/results-adaptive/fiqa/ir-adm0.50.jsonl @@ -0,0 +1 @@ +{"dataset": "fiqa", "run_tag": "adm0.50", "aggregated": {"nDCG@10": 0.4281, "Recall@20": 0.6101, "MRR@10": 0.4972}, "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": 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.2640681225725909, "588": 0.5714285040141098, "594": 0.6131471927654584, "603": 0.0, "604": 0.34870224750355494, "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.0, "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.31546487678572877, "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.6713527276121545, "1736": 0.5531464700081437, "1748": 0.6105456988825855, "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.6934264036172708, "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.3010299956639812, "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.2214161691338287, "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": 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.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.6309297535714575, "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.8048099750039491, "3791": 0.370291336443826, "3801": 0.17723928678404774, "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": 0.6309297535714575, "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.6309297535714575, "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.09478836436955078, "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.3391602052736161, "5790": 0.0, "5808": 0.5, "5853": 0.21078558563971425, "5862": 0.29127873064148246, "5888": 0.3065735963827292, "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.38685280723454163, "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.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.0, "6629": 0.0, "6635": 0.6366824387328317, "6644": 0.0, "6647": 0.7653606369886217, "6668": 0.8503449055347546, "6679": 0.4632423659320675, "6683": 0.6240505200038379, "6713": 0.6131471927654584, "6715": 0.6131471927654584, "6746": 0.2640681225725909, "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.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.6525874238732422, "7141": 0.0, "7145": 0.13565197343244778, "7178": 0.3333333333333333, "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.18154179253735267, "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.4367467095119258, "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.21840743681816419, "7911": 1.0, "7925": 0.19092086617893467, "7928": 0.24630238874073, "7936": 0.40179981797758046, "7992": 0.38685280723454163, "8002": 0.617319681505689, "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.6105456988825855, "8475": 0.7957503936198023, "8507": 0.0, "8512": 0.6309297535714575, "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.38685280723454163, "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.38685280723454163, "9556": 1.0, "9565": 1.0, "9598": 0.3562071871080222, "9617": 0.3152014104491349, "9633": 0.6131471927654584, "9643": 0.5, "9644": 0.6309297535714575, "9646": 0.42177340954886444, "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.3562071871080222, "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.49828993591603105, "10526": 0.20438239758848611, "10547": 0.0, "10558": 0.0, "10596": 0.9427731067700877, "10601": 1.0, "10628": 0.3010299956639812, "10639": 0.21398626473452756, "10645": 0.38685280723454163, "10674": 0.7095272044910244, "10710": 0.3333333333333333, "10734": 0.8486987932505933, "10792": 0.4227898344066503, "10808": 0.3295827480202853, "10809": 0.6049306994552042, "10812": 0.9709286432396583, "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.0, "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": 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": 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.25, "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": 1.0, "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": 1.0, "2070": 0.6666666666666666, "2075": 0.5555555555555556, "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.3333333333333333, "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.25, "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": 0.0, "2516": 0.75, "2549": 0.5, "2551": 1.0, "2568": 0.2857142857142857, "2579": 0.3333333333333333, "2580": 0.6666666666666666, "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.3333333333333333, "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.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.42857142857142855, "3405": 1.0, "3446": 0.8, "3451": 0.2857142857142857, "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": 0.5, "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.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.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.0, "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": 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": 1.0, "5331": 1.0, "5343": 1.0, "5347": 1.0, "5356": 0.2, "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.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": 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.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.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.3333333333333333, "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.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": 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": 0.5, "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": 1.0, "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": 1.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": 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.6, "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": 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": 0.5, "503": 0.06666666666666667, "504": 0.0, "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.2, "620": 0.08333333333333333, "622": 0.5, "659": 1.0, "672": 0.07692307692307693, "684": 0.0, "687": 0.125, "689": 0.0, "691": 0.5, "699": 1.0, "701": 0.07692307692307693, "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.125, "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.05, "1281": 0.2, "1284": 1.0, "1297": 1.0, "1306": 0.07692307692307693, "1309": 0.5, "1310": 1.0, "1321": 0.0, "1322": 0.5, "1391": 0.2, "1393": 0.5, "1415": 1.0, "1416": 0.0, "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.06666666666666667, "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.0625, "2070": 0.3333333333333333, "2075": 1.0, "2076": 0.5, "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.1111111111111111, "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.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": 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": 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.5, "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.3333333333333333, "3801": 0.1, "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.1111111111111111, "4047": 1.0, "4071": 0.0, "4084": 0.25, "4102": 0.0625, "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.0, "4500": 0.058823529411764705, "4504": 1.0, "4514": 1.0, "4523": 0.5, "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.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": 0.5, "5090": 0.25, "5125": 1.0, "5134": 0.5, "5150": 0.0, "5155": 1.0, "5172": 0.08333333333333333, "5178": 0.2, "5185": 0.0, "5196": 0.5, "5206": 0.0, "5228": 0.125, "5231": 0.0, "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.05263157894736842, "5763": 0.3333333333333333, "5782": 1.0, "5790": 0.0, "5808": 0.3333333333333333, "5853": 0.3333333333333333, "5862": 0.25, "5888": 0.3333333333333333, "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.5, "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.5, "6278": 0.25, "6395": 0.0, "6410": 0.09090909090909091, "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.08333333333333333, "6629": 0.0, "6635": 1.0, "6644": 0.0, "6647": 1.0, "6668": 1.0, "6679": 0.5, "6683": 0.5, "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": 1.0, "7141": 0.0, "7145": 0.1, "7178": 0.14285714285714285, "7188": 0.125, "7205": 1.0, "7206": 0.0, "7218": 0.25, "7221": 0.0, "7269": 0.07142857142857142, "7279": 0.25, "7295": 0.0, "7311": 0.0625, "7326": 0.0, "7329": 0.25, "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.25, "7467": 0.5, "7484": 1.0, "7509": 0.0, "7512": 0.0625, "7513": 0.16666666666666666, "7529": 0.3333333333333333, "7533": 0.07692307692307693, "7534": 1.0, "7590": 1.0, "7592": 0.0, "7594": 0.14285714285714285, "7622": 0.0, "7633": 1.0, "7674": 0.0, "7700": 0.125, "7702": 0.5, "7705": 0.3333333333333333, "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.16666666666666666, "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.05263157894736842, "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": 0.5, "8513": 0.0, "8532": 1.0, "8537": 0.16666666666666666, "8539": 0.07142857142857142, "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.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.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.2, "9556": 1.0, "9565": 1.0, "9598": 0.16666666666666666, "9617": 0.16666666666666666, "9633": 1.0, "9643": 0.3333333333333333, "9644": 0.5, "9646": 0.2, "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.05263157894736842, "9979": 1.0, "10034": 0.3333333333333333, "10039": 0.5, "10109": 1.0, "10122": 0.3333333333333333, "10136": 0.25, "10137": 0.16666666666666666, "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.05263157894736842, "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.07692307692307693, "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-adaptive/fiqa/run-adm0.15.trec.gz b/evals/benchmark/results-adaptive/fiqa/run-adm0.15.trec.gz new file mode 100644 index 0000000000000000000000000000000000000000..f4825d81b5231352515d8da131ff1debc59ba522 GIT binary patch literal 122814 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 z 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"W`k3D@jqka8o_ndn|LF-Gq_pf#8 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 literal 0 HcmV?d00001 diff --git a/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.15-vs-dense.jsonl b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.15-vs-dense.jsonl new file mode 100644 index 000000000..5be72eabd --- /dev/null +++ b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.15-vs-dense.jsonl @@ -0,0 +1,4 @@ +{"row_type": "meta", "run_id": "parity-2026-07", "fingerprint": "8abf1d39d4a2bfb065f6b7fedf9a7b7f1bf22d4a5f7ebb3e4f665c1899c131d7", "arm_a": "adm0.15", "arm_b": "dense"} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "nDCG@10", "n": 322, "mean_a": 0.37507950372235543, "mean_b": 0.36660768485593975, "mean_diff": -0.008471818866415706, "ci_low": -0.016166010439983513, "ci_high": -0.0007040087395521865, "p_value": 0.0332966703329667, "significant": true} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "Recall@20", "n": 322, "mean_a": 0.214096312157869, "mean_b": 0.2135261475395606, "mean_diff": -0.0005701646183084199, "ci_low": -0.0014853947990737068, "ci_high": 2.535175560907591e-05, "p_value": 0.24677532246775322, "significant": false} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "MRR@10", "n": 322, "mean_a": 0.603003083010847, "mean_b": 0.5918453065831581, "mean_diff": -0.011157776427688742, "ci_low": -0.037030675849695306, "ci_high": 0.013630450165776251, "p_value": 0.3885611438856114, "significant": false} diff --git a/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.30-vs-dense.jsonl b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.30-vs-dense.jsonl new file mode 100644 index 000000000..3435afab5 --- /dev/null +++ b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.30-vs-dense.jsonl @@ -0,0 +1,4 @@ +{"row_type": "meta", "run_id": "parity-2026-07", "fingerprint": "8abf1d39d4a2bfb065f6b7fedf9a7b7f1bf22d4a5f7ebb3e4f665c1899c131d7", "arm_a": "adm0.30", "arm_b": "dense"} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "nDCG@10", "n": 322, "mean_a": 0.3753092086467289, "mean_b": 0.36660768485593975, "mean_diff": -0.008701523790789157, "ci_low": -0.01705590052967067, "ci_high": -0.00021396123575186536, "p_value": 0.042695730426957304, "significant": true} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "Recall@20", "n": 322, "mean_a": 0.2152929084941406, "mean_b": 0.2135261475395606, "mean_diff": -0.0017667609545799782, "ci_low": -0.003770827067363018, "ci_high": -3.629642821803704e-05, "p_value": 0.06309369063093691, "significant": true} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "MRR@10", "n": 322, "mean_a": 0.5917215618731637, "mean_b": 0.5918453065831581, "mean_diff": 0.0001237447099945421, "ci_low": -0.027058454036428866, "ci_high": 0.02664162761986745, "p_value": 0.9926007399260074, "significant": false} diff --git a/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.50-vs-dense.jsonl b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.50-vs-dense.jsonl new file mode 100644 index 000000000..737336bb7 --- /dev/null +++ b/evals/benchmark/results-adaptive/nfcorpus/stats-adm0.50-vs-dense.jsonl @@ -0,0 +1,4 @@ +{"row_type": "meta", "run_id": "parity-2026-07", "fingerprint": "8abf1d39d4a2bfb065f6b7fedf9a7b7f1bf22d4a5f7ebb3e4f665c1899c131d7", "arm_a": "adm0.50", "arm_b": "dense"} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "nDCG@10", "n": 322, "mean_a": 0.3745430024862999, "mean_b": 0.36660768485593975, "mean_diff": -0.007935317630360133, "ci_low": -0.016730637847947268, "ci_high": 0.0008698032157170701, "p_value": 0.08299170082991701, "significant": false} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "Recall@20", "n": 322, "mean_a": 0.21519576307636726, "mean_b": 0.2135261475395606, "mean_diff": -0.0016696155368066692, "ci_low": -0.0053732193298111994, "ci_high": 0.00199579038719068, "p_value": 0.38906109389061094, "significant": false} +{"row_type": "ir", "dataset": "nfcorpus", "metric": "MRR@10", "n": 322, "mean_a": 0.5887450972078301, "mean_b": 0.5918453065831581, "mean_diff": 0.003100209375328119, "ci_low": -0.024121624934558803, "ci_high": 0.029901906947029343, "p_value": 0.8174182581741826, "significant": false} diff --git a/evals/benchmark/results-adaptive/scifact/ir-adm0.15.jsonl b/evals/benchmark/results-adaptive/scifact/ir-adm0.15.jsonl new file mode 100644 index 000000000..d831cfe12 --- /dev/null +++ b/evals/benchmark/results-adaptive/scifact/ir-adm0.15.jsonl @@ -0,0 +1 @@ +{"dataset": "scifact", "run_tag": "adm0.15", "aggregated": {"nDCG@10": 0.7186, "Recall@20": 0.8667, "MRR@10": 0.6867}, "per_query": {"nDCG@10": {"1": 0.0, "3": 0.5, "5": 1.0, "13": 0.0, "36": 0.2640681225725909, "42": 1.0, "48": 0.5, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.23719771276929622, "72": 0.6309297535714575, "75": 1.0, "94": 0.0, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 0.8850504602968671, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 0.6309297535714575, "163": 1.0, "171": 1.0, "179": 0.9267582364714126, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0, "208": 1.0, "212": 0.5, "213": 0.3333333333333333, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.6309297535714575, "233": 1.0, "236": 1.0, "237": 0.6309297535714575, "238": 0.5, "239": 0.43067655807339306, "248": 1.0, "249": 1.0, "261": 0.5912352048230277, "268": 1.0, "269": 1.0, "274": 1.0, "275": 0.7039180890341347, "279": 1.0, "294": 0.0, "295": 0.6309297535714575, "298": 1.0, "300": 0.0, "303": 0.0, "312": 0.0, "314": 0.3562071871080222, "324": 0.0, "327": 1.0, "338": 1.0, "343": 0.6509209298071326, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.3562071871080222, "385": 0.6934264036172708, "386": 1.0, "388": 0.6309297535714575, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.6309297535714575, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3065735963827292, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.6309297535714575, "508": 0.3010299956639812, "513": 0.6309297535714575, "514": 1.0, "516": 1.0, "517": 0.3333333333333333, "521": 1.0, "525": 1.0, "527": 0.6309297535714575, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.3333333333333333, "536": 1.0, "539": 1.0, "540": 0.38685280723454163, "544": 0.38685280723454163, "549": 1.0, "551": 0.38685280723454163, "552": 1.0, "554": 0.3010299956639812, "560": 0.0, "569": 0.38685280723454163, "575": 1.0, "577": 0.6309297535714575, "578": 1.0, "587": 0.6309297535714575, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.5, "613": 1.0, "619": 0.0, "623": 0.6309297535714575, "628": 1.0, "636": 1.0, "637": 0.6309297535714575, "641": 0.8315546295836225, "644": 1.0, "649": 0.6309297535714575, "659": 0.0, "660": 0.0, "674": 0.6309297535714575, "684": 0.6309297535714575, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.38685280723454163, "728": 0.8772153153380493, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.5, "756": 0.6309297535714575, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.3333333333333333, "784": 1.0, "785": 1.0, "793": 0.43067655807339306, "800": 1.0, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.43067655807339306, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.5, "847": 1.0, "852": 0.6309297535714575, "859": 0.6309297535714575, "870": 0.0, "873": 0.7870111744655099, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.6309297535714575, "1012": 1.0, "1014": 1.0, "1019": 0.6309297535714575, "1020": 0.6309297535714575, "1021": 0.6309297535714575, "1024": 0.5, "1029": 0.9134015924715543, "1041": 0.430624116386567, "1049": 0.3333333333333333, "1062": 1.0, "1086": 1.0, "1088": 1.0, "1089": 1.0, "1099": 0.5, "1100": 0.31546487678572877, "1104": 1.0, "1107": 0.6309297535714575, "1110": 0.2890648263178879, "1121": 1.0, "1130": 1.0, "1132": 0.20438239758848611, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.38685280723454163, "1185": 1.0, "1187": 0.6309297535714575, "1191": 0.38685280723454163, "1194": 1.0, "1196": 0.43067655807339306, "1197": 0.38685280723454163, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.0, "1216": 1.0, "1221": 0.38685280723454163, "1225": 1.0, "1226": 0.3010299956639812, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 0.8278123145308894, "1278": 0.6309297535714575, "1279": 0.0, "1280": 0.3333333333333333, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.6309297535714575, "1320": 0.6309297535714575, "1332": 0.0, "1335": 0.6309297535714575, "1336": 0.6309297535714575, "1337": 1.0, "1339": 1.0, "1344": 0.6309297535714575, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.0, "1368": 0.6309297535714575, "1370": 1.0, "1379": 0.7095272044910244, "1382": 0.5, "1385": 1.0, "1389": 1.0, "1395": 0.5}, "Recall@20": {"1": 0.0, "3": 1.0, "5": 1.0, "13": 0.0, "36": 1.0, "42": 1.0, "48": 1.0, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.5, "72": 1.0, "75": 1.0, "94": 0.0, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0, "208": 1.0, "212": 1.0, "213": 1.0, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 1.0, "233": 1.0, "236": 1.0, "237": 1.0, "238": 1.0, "239": 1.0, "248": 1.0, "249": 1.0, "261": 1.0, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 0.0, "295": 1.0, "298": 1.0, "300": 1.0, "303": 0.0, "312": 0.0, "314": 1.0, "324": 0.0, "327": 1.0, "338": 1.0, "343": 1.0, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 1.0, "385": 1.0, "386": 1.0, "388": 1.0, "399": 1.0, "410": 1.0, "411": 1.0, "415": 1.0, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.5, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 1.0, "508": 1.0, "513": 1.0, "514": 1.0, "516": 1.0, "517": 1.0, "521": 1.0, "525": 1.0, "527": 1.0, "528": 1.0, "532": 1.0, "533": 1.0, "535": 1.0, "536": 1.0, "539": 1.0, "540": 1.0, "544": 1.0, "549": 1.0, "551": 1.0, "552": 1.0, "554": 1.0, "560": 0.0, "569": 1.0, "575": 1.0, "577": 1.0, "578": 1.0, "587": 1.0, "589": 1.0, "593": 1.0, "597": 1.0, "598": 1.0, "613": 1.0, "619": 0.0, "623": 1.0, "628": 1.0, "636": 1.0, "637": 1.0, "641": 1.0, "644": 1.0, "649": 1.0, "659": 0.0, "660": 1.0, "674": 1.0, "684": 1.0, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 1.0, "728": 1.0, "729": 1.0, "742": 1.0, "743": 1.0, "744": 1.0, "756": 1.0, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 1.0, "784": 1.0, "785": 1.0, "793": 1.0, "800": 1.0, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 1.0, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 1.0, "847": 1.0, "852": 1.0, "859": 1.0, "870": 1.0, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 1.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 1.0, "1012": 1.0, "1014": 1.0, "1019": 1.0, "1020": 1.0, "1021": 1.0, "1024": 1.0, "1029": 1.0, "1041": 1.0, "1049": 1.0, "1062": 1.0, "1086": 1.0, "1088": 1.0, "1089": 1.0, "1099": 1.0, "1100": 1.0, "1104": 1.0, "1107": 1.0, "1110": 1.0, "1121": 1.0, "1130": 1.0, "1132": 1.0, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 1.0, "1185": 1.0, "1187": 1.0, "1191": 1.0, "1194": 1.0, "1196": 1.0, "1197": 1.0, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 1.0, "1216": 1.0, "1221": 1.0, "1225": 1.0, "1226": 1.0, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 1.0, "1279": 0.0, "1280": 1.0, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 1.0, "1320": 1.0, "1332": 0.0, "1335": 1.0, "1336": 1.0, "1337": 1.0, "1339": 1.0, "1344": 1.0, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.0, "1368": 1.0, "1370": 1.0, "1379": 1.0, "1382": 1.0, "1385": 1.0, "1389": 1.0, "1395": 1.0}, "MRR@10": {"1": 0.0, "3": 0.3333333333333333, "5": 1.0, "13": 0.0, "36": 0.25, "42": 1.0, "48": 0.3333333333333333, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.2, "72": 0.5, "75": 1.0, "94": 0.0, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 0.5, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0, "208": 1.0, "212": 0.3333333333333333, "213": 0.14285714285714285, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.5, "233": 1.0, "236": 1.0, "237": 0.5, "238": 0.3333333333333333, "239": 0.25, "248": 1.0, "249": 1.0, "261": 0.5, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 0.0, "295": 0.5, "298": 1.0, "300": 0.07692307692307693, "303": 0.0, "312": 0.0, "314": 0.16666666666666666, "324": 0.0, "327": 1.0, "338": 1.0, "343": 0.5, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.16666666666666666, "385": 0.5, "386": 1.0, "388": 0.5, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.5, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3333333333333333, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.5, "508": 0.1111111111111111, "513": 0.5, "514": 1.0, "516": 1.0, "517": 0.14285714285714285, "521": 1.0, "525": 1.0, "527": 0.5, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.14285714285714285, "536": 1.0, "539": 1.0, "540": 0.5, "544": 0.2, "549": 1.0, "551": 0.2, "552": 1.0, "554": 0.1111111111111111, "560": 0.0, "569": 0.2, "575": 1.0, "577": 0.5, "578": 1.0, "587": 0.5, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.3333333333333333, "613": 1.0, "619": 0.0, "623": 0.5, "628": 1.0, "636": 1.0, "637": 0.5, "641": 1.0, "644": 1.0, "649": 0.5, "659": 0.0, "660": 0.07692307692307693, "674": 0.5, "684": 0.5, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.2, "728": 1.0, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.3333333333333333, "756": 0.5, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.14285714285714285, "784": 1.0, "785": 1.0, "793": 0.25, "800": 1.0, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.25, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.3333333333333333, "847": 1.0, "852": 0.5, "859": 0.5, "870": 0.07142857142857142, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0625, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.5, "1012": 1.0, "1014": 1.0, "1019": 0.5, "1020": 0.5, "1021": 0.5, "1024": 0.3333333333333333, "1029": 1.0, "1041": 0.2, "1049": 0.14285714285714285, "1062": 1.0, "1086": 1.0, "1088": 1.0, "1089": 1.0, "1099": 0.3333333333333333, "1100": 0.125, "1104": 1.0, "1107": 0.5, "1110": 0.1, "1121": 1.0, "1130": 1.0, "1132": 0.14285714285714285, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.2, "1185": 1.0, "1187": 0.5, "1191": 0.2, "1194": 1.0, "1196": 0.25, "1197": 0.2, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.07692307692307693, "1216": 1.0, "1221": 0.2, "1225": 1.0, "1226": 0.1111111111111111, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 0.5, "1279": 0.0, "1280": 0.14285714285714285, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.5, "1320": 0.5, "1332": 0.0, "1335": 0.5, "1336": 0.5, "1337": 1.0, "1339": 1.0, "1344": 0.5, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.0, "1368": 0.5, "1370": 1.0, "1379": 1.0, "1382": 0.3333333333333333, "1385": 1.0, "1389": 1.0, "1395": 0.3333333333333333}}} diff --git a/evals/benchmark/results-adaptive/scifact/ir-adm0.30.jsonl b/evals/benchmark/results-adaptive/scifact/ir-adm0.30.jsonl new file mode 100644 index 000000000..ceb56f915 --- /dev/null +++ b/evals/benchmark/results-adaptive/scifact/ir-adm0.30.jsonl @@ -0,0 +1 @@ +{"dataset": "scifact", "run_tag": "adm0.30", "aggregated": {"nDCG@10": 0.7233, "Recall@20": 0.8867, "MRR@10": 0.6937}, "per_query": {"nDCG@10": {"1": 0.0, "3": 0.6309297535714575, "5": 1.0, "13": 0.0, "36": 0.2640681225725909, "42": 1.0, "48": 0.6309297535714575, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.2640681225725909, "72": 0.6309297535714575, "75": 1.0, "94": 0.2890648263178879, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 0.8712322899646365, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 0.7095272044910244, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0, "208": 1.0, "212": 0.5, "213": 0.38685280723454163, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.6309297535714575, "233": 1.0, "236": 1.0, "237": 0.6309297535714575, "238": 0.5, "239": 0.38685280723454163, "248": 1.0, "249": 1.0, "261": 0.46845052016107697, "268": 1.0, "269": 1.0, "274": 1.0, "275": 0.6508205185601091, "279": 1.0, "294": 0.0, "295": 1.0, "298": 1.0, "300": 0.5, "303": 0.0, "312": 0.0, "314": 0.5, "324": 0.0, "327": 1.0, "338": 1.0, "343": 0.6509209298071326, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.3562071871080222, "385": 0.6934264036172708, "386": 1.0, "388": 0.6309297535714575, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.5, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3065735963827292, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.6309297535714575, "508": 0.3010299956639812, "513": 0.6309297535714575, "514": 1.0, "516": 1.0, "517": 0.3333333333333333, "521": 1.0, "525": 1.0, "527": 0.6309297535714575, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.3333333333333333, "536": 1.0, "539": 1.0, "540": 0.38685280723454163, "544": 0.38685280723454163, "549": 1.0, "551": 0.38685280723454163, "552": 1.0, "554": 0.31546487678572877, "560": 0.0, "569": 0.6309297535714575, "575": 1.0, "577": 0.6309297535714575, "578": 1.0, "587": 0.6309297535714575, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.5, "613": 1.0, "619": 0.0, "623": 0.0, "628": 1.0, "636": 1.0, "637": 0.6309297535714575, "641": 0.8065735963827293, "644": 1.0, "649": 1.0, "659": 0.0, "660": 0.31546487678572877, "674": 0.6309297535714575, "684": 0.6309297535714575, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.43067655807339306, "728": 0.8772153153380493, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.6309297535714575, "756": 0.5, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.3333333333333333, "784": 1.0, "785": 1.0, "793": 0.6309297535714575, "800": 0.38685280723454163, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.43067655807339306, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.6309297535714575, "847": 1.0, "852": 1.0, "859": 0.6309297535714575, "870": 0.0, "873": 0.7870111744655099, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.6309297535714575, "1012": 1.0, "1014": 1.0, "1019": 0.6309297535714575, "1020": 0.6309297535714575, "1021": 0.6309297535714575, "1024": 0.6309297535714575, "1029": 0.7653606369886217, "1041": 0.39780880120575696, "1049": 0.3333333333333333, "1062": 1.0, "1086": 1.0, "1088": 0.38685280723454163, "1089": 1.0, "1099": 0.5, "1100": 0.3562071871080222, "1104": 1.0, "1107": 0.6309297535714575, "1110": 0.2890648263178879, "1121": 1.0, "1130": 1.0, "1132": 0.21840743681816419, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.3562071871080222, "1185": 1.0, "1187": 1.0, "1191": 0.38685280723454163, "1194": 1.0, "1196": 0.43067655807339306, "1197": 0.43067655807339306, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.0, "1216": 1.0, "1221": 0.38685280723454163, "1225": 1.0, "1226": 0.3010299956639812, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 0.8278123145308894, "1278": 0.6309297535714575, "1279": 0.0, "1280": 0.31546487678572877, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.6309297535714575, "1320": 0.6309297535714575, "1332": 0.0, "1335": 0.6309297535714575, "1336": 0.6309297535714575, "1337": 1.0, "1339": 1.0, "1344": 0.6309297535714575, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.0, "1368": 0.43067655807339306, "1370": 1.0, "1379": 0.7095272044910244, "1382": 0.5, "1385": 1.0, "1389": 1.0, "1395": 0.5}, "Recall@20": {"1": 0.0, "3": 1.0, "5": 1.0, "13": 0.0, "36": 1.0, "42": 1.0, "48": 1.0, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 1.0, "72": 1.0, "75": 1.0, "94": 1.0, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 1.0, "208": 1.0, "212": 1.0, "213": 1.0, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 1.0, "233": 1.0, "236": 1.0, "237": 1.0, "238": 1.0, "239": 1.0, "248": 1.0, "249": 1.0, "261": 1.0, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 0.0, "295": 1.0, "298": 1.0, "300": 1.0, "303": 0.0, "312": 0.0, "314": 1.0, "324": 1.0, "327": 1.0, "338": 1.0, "343": 1.0, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 1.0, "385": 1.0, "386": 1.0, "388": 1.0, "399": 1.0, "410": 1.0, "411": 1.0, "415": 1.0, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.5, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 1.0, "508": 1.0, "513": 1.0, "514": 1.0, "516": 1.0, "517": 1.0, "521": 1.0, "525": 1.0, "527": 1.0, "528": 1.0, "532": 1.0, "533": 1.0, "535": 1.0, "536": 1.0, "539": 1.0, "540": 1.0, "544": 1.0, "549": 1.0, "551": 1.0, "552": 1.0, "554": 1.0, "560": 0.0, "569": 1.0, "575": 1.0, "577": 1.0, "578": 1.0, "587": 1.0, "589": 1.0, "593": 1.0, "597": 1.0, "598": 1.0, "613": 1.0, "619": 0.5, "623": 1.0, "628": 1.0, "636": 1.0, "637": 1.0, "641": 1.0, "644": 1.0, "649": 1.0, "659": 1.0, "660": 1.0, "674": 1.0, "684": 1.0, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 1.0, "728": 1.0, "729": 1.0, "742": 1.0, "743": 1.0, "744": 1.0, "756": 1.0, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 1.0, "784": 1.0, "785": 1.0, "793": 1.0, "800": 1.0, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 1.0, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 1.0, "847": 1.0, "852": 1.0, "859": 1.0, "870": 1.0, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 1.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 1.0, "1012": 1.0, "1014": 1.0, "1019": 1.0, "1020": 1.0, "1021": 1.0, "1024": 1.0, "1029": 1.0, "1041": 1.0, "1049": 1.0, "1062": 1.0, "1086": 1.0, "1088": 1.0, "1089": 1.0, "1099": 1.0, "1100": 1.0, "1104": 1.0, "1107": 1.0, "1110": 1.0, "1121": 1.0, "1130": 1.0, "1132": 1.0, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 1.0, "1185": 1.0, "1187": 1.0, "1191": 1.0, "1194": 1.0, "1196": 1.0, "1197": 1.0, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 1.0, "1216": 1.0, "1221": 1.0, "1225": 1.0, "1226": 1.0, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 1.0, "1279": 0.0, "1280": 1.0, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 1.0, "1320": 1.0, "1332": 0.0, "1335": 1.0, "1336": 1.0, "1337": 1.0, "1339": 1.0, "1344": 1.0, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 1.0, "1368": 1.0, "1370": 1.0, "1379": 1.0, "1382": 1.0, "1385": 1.0, "1389": 1.0, "1395": 1.0}, "MRR@10": {"1": 0.0, "3": 0.5, "5": 1.0, "13": 0.0, "36": 0.25, "42": 1.0, "48": 0.5, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.25, "72": 0.5, "75": 1.0, "94": 0.1, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0625, "208": 1.0, "212": 0.3333333333333333, "213": 0.2, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.5, "233": 1.0, "236": 1.0, "237": 0.5, "238": 0.3333333333333333, "239": 0.2, "248": 1.0, "249": 1.0, "261": 0.25, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 0.0, "295": 1.0, "298": 1.0, "300": 0.3333333333333333, "303": 0.0, "312": 0.0, "314": 0.3333333333333333, "324": 0.09090909090909091, "327": 1.0, "338": 1.0, "343": 0.5, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.16666666666666666, "385": 0.5, "386": 1.0, "388": 0.5, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.3333333333333333, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3333333333333333, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.5, "508": 0.1111111111111111, "513": 0.5, "514": 1.0, "516": 1.0, "517": 0.14285714285714285, "521": 1.0, "525": 1.0, "527": 0.5, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.14285714285714285, "536": 1.0, "539": 1.0, "540": 0.5, "544": 0.2, "549": 1.0, "551": 0.2, "552": 1.0, "554": 0.125, "560": 0.0, "569": 0.5, "575": 1.0, "577": 0.5, "578": 1.0, "587": 0.5, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.3333333333333333, "613": 1.0, "619": 0.0625, "623": 0.08333333333333333, "628": 1.0, "636": 1.0, "637": 0.5, "641": 1.0, "644": 1.0, "649": 1.0, "659": 0.08333333333333333, "660": 0.125, "674": 0.5, "684": 0.5, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.25, "728": 1.0, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.5, "756": 0.3333333333333333, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.14285714285714285, "784": 1.0, "785": 1.0, "793": 0.5, "800": 0.2, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.25, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.5, "847": 1.0, "852": 1.0, "859": 0.5, "870": 0.07142857142857142, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0625, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.5, "1012": 1.0, "1014": 1.0, "1019": 0.5, "1020": 0.5, "1021": 0.5, "1024": 0.5, "1029": 1.0, "1041": 0.14285714285714285, "1049": 0.14285714285714285, "1062": 1.0, "1086": 1.0, "1088": 0.2, "1089": 1.0, "1099": 0.3333333333333333, "1100": 0.16666666666666666, "1104": 1.0, "1107": 0.5, "1110": 0.1, "1121": 1.0, "1130": 1.0, "1132": 0.16666666666666666, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.16666666666666666, "1185": 1.0, "1187": 1.0, "1191": 0.2, "1194": 1.0, "1196": 0.25, "1197": 0.25, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.07692307692307693, "1216": 1.0, "1221": 0.2, "1225": 1.0, "1226": 0.1111111111111111, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 0.5, "1279": 0.0, "1280": 0.125, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.5, "1320": 0.5, "1332": 0.0, "1335": 0.5, "1336": 0.5, "1337": 1.0, "1339": 1.0, "1344": 0.5, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.0625, "1368": 0.25, "1370": 1.0, "1379": 1.0, "1382": 0.3333333333333333, "1385": 1.0, "1389": 1.0, "1395": 0.3333333333333333}}} diff --git a/evals/benchmark/results-adaptive/scifact/ir-adm0.50.jsonl b/evals/benchmark/results-adaptive/scifact/ir-adm0.50.jsonl new file mode 100644 index 000000000..a893b329c --- /dev/null +++ b/evals/benchmark/results-adaptive/scifact/ir-adm0.50.jsonl @@ -0,0 +1 @@ +{"dataset": "scifact", "run_tag": "adm0.50", "aggregated": {"nDCG@10": 0.7275, "Recall@20": 0.8917, "MRR@10": 0.6966}, "per_query": {"nDCG@10": {"1": 0.0, "3": 1.0, "5": 1.0, "13": 0.0, "36": 0.3065735963827292, "42": 1.0, "48": 0.6309297535714575, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.2640681225725909, "72": 0.6309297535714575, "75": 1.0, "94": 0.3333333333333333, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 0.8712322899646365, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 0.7095272044910244, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.0, "208": 1.0, "212": 0.5, "213": 0.43067655807339306, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.6309297535714575, "233": 1.0, "236": 1.0, "237": 1.0, "238": 0.5, "239": 0.38685280723454163, "248": 1.0, "249": 1.0, "261": 0.46845052016107697, "268": 1.0, "269": 1.0, "274": 1.0, "275": 0.6364391809889587, "279": 1.0, "294": 0.0, "295": 1.0, "298": 1.0, "300": 0.5, "303": 0.0, "312": 0.0, "314": 0.5, "324": 0.3010299956639812, "327": 1.0, "338": 1.0, "343": 0.6509209298071326, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.3562071871080222, "385": 0.6934264036172708, "386": 1.0, "388": 0.6309297535714575, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.5, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3065735963827292, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.6309297535714575, "508": 0.3010299956639812, "513": 0.6309297535714575, "514": 1.0, "516": 1.0, "517": 0.3333333333333333, "521": 1.0, "525": 1.0, "527": 0.6309297535714575, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.3333333333333333, "536": 1.0, "539": 1.0, "540": 0.38685280723454163, "544": 0.38685280723454163, "549": 1.0, "551": 0.38685280723454163, "552": 1.0, "554": 0.3333333333333333, "560": 0.0, "569": 0.6309297535714575, "575": 1.0, "577": 0.6309297535714575, "578": 1.0, "587": 0.6309297535714575, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.43067655807339306, "613": 1.0, "619": 0.0, "623": 0.0, "628": 1.0, "636": 1.0, "637": 0.6309297535714575, "641": 0.8065735963827293, "644": 1.0, "649": 1.0, "659": 0.31546487678572877, "660": 0.38685280723454163, "674": 0.6309297535714575, "684": 1.0, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.43067655807339306, "728": 0.6934264036172708, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.6309297535714575, "756": 0.5, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.3333333333333333, "784": 1.0, "785": 1.0, "793": 0.6309297535714575, "800": 0.38685280723454163, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.43067655807339306, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.6309297535714575, "847": 1.0, "852": 1.0, "859": 0.6309297535714575, "870": 0.0, "873": 0.7870111744655099, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.6309297535714575, "1012": 1.0, "1014": 1.0, "1019": 0.6309297535714575, "1020": 0.6309297535714575, "1021": 0.6309297535714575, "1024": 0.6309297535714575, "1029": 0.7653606369886217, "1041": 0.41183384043543503, "1049": 0.3333333333333333, "1062": 1.0, "1086": 1.0, "1088": 0.38685280723454163, "1089": 1.0, "1099": 0.5, "1100": 0.3562071871080222, "1104": 1.0, "1107": 0.6309297535714575, "1110": 0.0, "1121": 1.0, "1130": 1.0, "1132": 0.21840743681816419, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.3562071871080222, "1185": 1.0, "1187": 1.0, "1191": 0.38685280723454163, "1194": 1.0, "1196": 0.43067655807339306, "1197": 0.43067655807339306, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.0, "1216": 1.0, "1221": 0.38685280723454163, "1225": 1.0, "1226": 0.3010299956639812, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 0.8278123145308894, "1278": 0.6309297535714575, "1279": 0.0, "1280": 0.31546487678572877, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.6309297535714575, "1320": 0.6309297535714575, "1332": 0.0, "1335": 0.6309297535714575, "1336": 0.6309297535714575, "1337": 1.0, "1339": 1.0, "1344": 0.6309297535714575, "1352": 1.0, "1359": 1.0, "1362": 0.0, "1363": 0.2890648263178879, "1368": 0.38685280723454163, "1370": 0.6309297535714575, "1379": 0.6886342695939197, "1382": 0.5, "1385": 1.0, "1389": 1.0, "1395": 0.5}, "Recall@20": {"1": 0.0, "3": 1.0, "5": 1.0, "13": 0.0, "36": 1.0, "42": 1.0, "48": 1.0, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 1.0, "72": 1.0, "75": 1.0, "94": 1.0, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 1.0, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 1.0, "208": 1.0, "212": 1.0, "213": 1.0, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 1.0, "233": 1.0, "236": 1.0, "237": 1.0, "238": 1.0, "239": 1.0, "248": 1.0, "249": 1.0, "261": 1.0, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 1.0, "295": 1.0, "298": 1.0, "300": 1.0, "303": 0.0, "312": 0.0, "314": 1.0, "324": 1.0, "327": 1.0, "338": 1.0, "343": 1.0, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 1.0, "385": 1.0, "386": 1.0, "388": 1.0, "399": 1.0, "410": 1.0, "411": 1.0, "415": 1.0, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.5, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 1.0, "508": 1.0, "513": 1.0, "514": 1.0, "516": 1.0, "517": 1.0, "521": 1.0, "525": 1.0, "527": 1.0, "528": 1.0, "532": 1.0, "533": 1.0, "535": 1.0, "536": 1.0, "539": 1.0, "540": 0.5, "544": 1.0, "549": 1.0, "551": 1.0, "552": 1.0, "554": 1.0, "560": 0.0, "569": 1.0, "575": 1.0, "577": 1.0, "578": 1.0, "587": 1.0, "589": 1.0, "593": 1.0, "597": 1.0, "598": 1.0, "613": 1.0, "619": 0.5, "623": 1.0, "628": 1.0, "636": 1.0, "637": 1.0, "641": 1.0, "644": 1.0, "649": 1.0, "659": 1.0, "660": 1.0, "674": 1.0, "684": 1.0, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 1.0, "728": 1.0, "729": 1.0, "742": 1.0, "743": 1.0, "744": 1.0, "756": 1.0, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 1.0, "784": 1.0, "785": 1.0, "793": 1.0, "800": 1.0, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 1.0, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 1.0, "847": 1.0, "852": 1.0, "859": 1.0, "870": 1.0, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 1.0, "1012": 1.0, "1014": 1.0, "1019": 1.0, "1020": 1.0, "1021": 1.0, "1024": 1.0, "1029": 1.0, "1041": 1.0, "1049": 1.0, "1062": 1.0, "1086": 1.0, "1088": 1.0, "1089": 1.0, "1099": 1.0, "1100": 1.0, "1104": 1.0, "1107": 1.0, "1110": 0.0, "1121": 1.0, "1130": 1.0, "1132": 1.0, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 1.0, "1185": 1.0, "1187": 1.0, "1191": 1.0, "1194": 1.0, "1196": 1.0, "1197": 1.0, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 1.0, "1216": 1.0, "1221": 1.0, "1225": 1.0, "1226": 1.0, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 1.0, "1279": 1.0, "1280": 1.0, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 1.0, "1320": 1.0, "1332": 0.0, "1335": 1.0, "1336": 1.0, "1337": 1.0, "1339": 1.0, "1344": 1.0, "1352": 1.0, "1359": 1.0, "1362": 1.0, "1363": 1.0, "1368": 1.0, "1370": 1.0, "1379": 1.0, "1382": 1.0, "1385": 1.0, "1389": 1.0, "1395": 1.0}, "MRR@10": {"1": 0.0, "3": 1.0, "5": 1.0, "13": 0.0, "36": 0.3333333333333333, "42": 1.0, "48": 0.5, "49": 1.0, "50": 1.0, "51": 1.0, "53": 1.0, "54": 1.0, "56": 1.0, "57": 1.0, "70": 0.25, "72": 0.5, "75": 1.0, "94": 0.14285714285714285, "99": 1.0, "100": 1.0, "113": 1.0, "115": 1.0, "118": 1.0, "124": 1.0, "127": 1.0, "128": 0.07692307692307693, "129": 1.0, "130": 1.0, "132": 0.0, "133": 1.0, "137": 1.0, "141": 1.0, "142": 1.0, "143": 1.0, "146": 1.0, "148": 1.0, "163": 1.0, "171": 1.0, "179": 1.0, "180": 1.0, "183": 1.0, "185": 1.0, "198": 0.08333333333333333, "208": 1.0, "212": 0.3333333333333333, "213": 0.25, "216": 1.0, "217": 1.0, "218": 1.0, "219": 1.0, "230": 1.0, "232": 0.5, "233": 1.0, "236": 1.0, "237": 1.0, "238": 0.3333333333333333, "239": 0.2, "248": 1.0, "249": 1.0, "261": 0.25, "268": 1.0, "269": 1.0, "274": 1.0, "275": 1.0, "279": 1.0, "294": 0.05263157894736842, "295": 1.0, "298": 1.0, "300": 0.3333333333333333, "303": 0.0, "312": 0.0, "314": 0.3333333333333333, "324": 0.1111111111111111, "327": 1.0, "338": 1.0, "343": 0.5, "350": 1.0, "354": 1.0, "362": 1.0, "380": 1.0, "384": 0.16666666666666666, "385": 0.5, "386": 1.0, "388": 0.5, "399": 1.0, "410": 1.0, "411": 1.0, "415": 0.3333333333333333, "421": 0.0, "431": 0.0, "436": 1.0, "437": 0.0, "439": 1.0, "440": 1.0, "443": 1.0, "452": 0.3333333333333333, "475": 0.0, "478": 1.0, "491": 1.0, "501": 1.0, "502": 0.0, "507": 0.5, "508": 0.1111111111111111, "513": 0.5, "514": 1.0, "516": 1.0, "517": 0.14285714285714285, "521": 1.0, "525": 1.0, "527": 0.5, "528": 1.0, "532": 1.0, "533": 1.0, "535": 0.14285714285714285, "536": 1.0, "539": 1.0, "540": 0.5, "544": 0.2, "549": 1.0, "551": 0.2, "552": 1.0, "554": 0.14285714285714285, "560": 0.0, "569": 0.5, "575": 1.0, "577": 0.5, "578": 1.0, "587": 0.5, "589": 1.0, "593": 1.0, "597": 1.0, "598": 0.25, "613": 1.0, "619": 0.0625, "623": 0.08333333333333333, "628": 1.0, "636": 1.0, "637": 0.5, "641": 1.0, "644": 1.0, "649": 1.0, "659": 0.125, "660": 0.2, "674": 0.5, "684": 1.0, "690": 0.0, "691": 1.0, "692": 1.0, "693": 1.0, "700": 1.0, "702": 1.0, "715": 0.0, "716": 0.0, "718": 1.0, "721": 1.0, "723": 1.0, "727": 0.25, "728": 0.5, "729": 1.0, "742": 1.0, "743": 1.0, "744": 0.5, "756": 0.3333333333333333, "759": 1.0, "768": 0.0, "770": 1.0, "775": 0.0, "781": 1.0, "783": 0.14285714285714285, "784": 1.0, "785": 1.0, "793": 0.5, "800": 0.2, "805": 1.0, "808": 1.0, "811": 1.0, "814": 1.0, "820": 0.0, "821": 0.0, "823": 1.0, "830": 0.25, "831": 0.0, "832": 1.0, "834": 0.0, "837": 1.0, "839": 1.0, "845": 0.5, "847": 1.0, "852": 1.0, "859": 0.5, "870": 0.07142857142857142, "873": 1.0, "879": 1.0, "880": 1.0, "882": 1.0, "887": 0.0, "903": 1.0, "904": 1.0, "907": 1.0, "911": 1.0, "913": 0.0, "914": 0.0, "921": 1.0, "922": 1.0, "936": 1.0, "956": 1.0, "957": 1.0, "960": 1.0, "967": 1.0, "971": 1.0, "975": 0.0, "982": 1.0, "985": 1.0, "993": 0.5, "1012": 1.0, "1014": 1.0, "1019": 0.5, "1020": 0.5, "1021": 0.5, "1024": 0.5, "1029": 1.0, "1041": 0.16666666666666666, "1049": 0.14285714285714285, "1062": 1.0, "1086": 1.0, "1088": 0.2, "1089": 1.0, "1099": 0.3333333333333333, "1100": 0.16666666666666666, "1104": 1.0, "1107": 0.5, "1110": 0.0, "1121": 1.0, "1130": 1.0, "1132": 0.16666666666666666, "1137": 1.0, "1140": 1.0, "1144": 1.0, "1146": 1.0, "1150": 1.0, "1163": 1.0, "1175": 0.0, "1179": 0.0, "1180": 0.16666666666666666, "1185": 1.0, "1187": 1.0, "1191": 0.2, "1194": 1.0, "1196": 0.25, "1197": 0.25, "1199": 0.0, "1200": 1.0, "1202": 1.0, "1204": 1.0, "1207": 1.0, "1213": 0.07142857142857142, "1216": 1.0, "1221": 0.2, "1225": 1.0, "1226": 0.1111111111111111, "1232": 1.0, "1241": 1.0, "1245": 1.0, "1259": 1.0, "1262": 1.0, "1266": 1.0, "1270": 1.0, "1271": 1.0, "1272": 1.0, "1273": 1.0, "1274": 1.0, "1278": 0.5, "1279": 0.0625, "1280": 0.125, "1281": 0.0, "1282": 1.0, "1290": 1.0, "1292": 1.0, "1298": 1.0, "1303": 1.0, "1316": 0.0, "1319": 0.5, "1320": 0.5, "1332": 0.0, "1335": 0.5, "1336": 0.5, "1337": 1.0, "1339": 1.0, "1344": 0.5, "1352": 1.0, "1359": 1.0, "1362": 0.08333333333333333, "1363": 0.1, "1368": 0.2, "1370": 0.5, "1379": 1.0, "1382": 0.3333333333333333, "1385": 1.0, "1389": 1.0, "1395": 0.3333333333333333}}} diff --git a/evals/benchmark/results-adaptive/scifact/run-adm0.15.trec.gz b/evals/benchmark/results-adaptive/scifact/run-adm0.15.trec.gz new file mode 100644 index 0000000000000000000000000000000000000000..8351af0c092f78216b3b5928485e5b35e364ca43 GIT binary patch literal 50745 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

lMmuNC=|;@a--VTb6CNq8 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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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