Add OPERA 1.78M BGE-M3 retrieval corpus (index + meta + README)

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+opera_corpus.index filter=lfs diff=lfs merge=lfs -text
+opera_corpus.meta filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,125 @@
+# OPERA Retrieval Corpus
+
+Prebuilt dense retrieval corpus used by the OPERA inference pipeline
+(*OPERA: A Reinforcement Learning–Enhanced Orchestrated Planner-Executor
+Architecture for Reasoning-Oriented Multi-Hop Retrieval*).
+
+This release contains two files:
+
+| File | Size | Purpose |
+|---|---|---|
+| `opera_corpus.index` | ~7.3 GB | FAISS `IndexFlatIP` over BGE-M3 dense embeddings |
+| `opera_corpus.meta`  | ~150 MB | Pickle list of `{id, title, content}` aligned 1:1 with the FAISS rows |
+
+Total documents: **1,780,294**
+Embedding model: **`BAAI/bge-m3`** (1024-dim, cosine via inner-product on L2-normalized vectors)
+Index type: **FAISS `IndexFlatIP`** (exact search, no quantization)
+
+## Source datasets
+
+The corpus is built from the publicly available Wikipedia paragraphs that
+ship with the three multi-hop QA benchmarks evaluated in the OPERA paper:
+
+- **HotpotQA** (Yang et al., 2018)
+- **2WikiMultiHopQA** (Ho et al., 2020)
+- **MuSiQue** (Trivedi et al., 2022)
+
+For each benchmark we include the paragraphs from the splits that the
+respective release distributes (dev paragraphs from HotpotQA / 2Wiki;
+dev + train paragraphs from MuSiQue). All paragraphs in the corpus come
+from the original benchmark distributions — no external web content was
+added.
+
+The corpus contains plain text only. We do not include benchmark labels
+such as supporting-paragraph flags, decomposed sub-questions, or gold
+answers; if you need those, fetch them directly from the upstream
+datasets.
+
+## Schema
+
+Each record in `opera_corpus.meta` is a Python dict with exactly three
+keys:
+
+```python
+{
+    "id":      "doc_0",                   # sequential, stable across loads
+    "title":   "The Big Short (film)",   # source-document title
+    "content": "The Big Short is a 2015 American ...",
+}
+```
+
+Row `i` in `opera_corpus.meta` corresponds to row `i` of
+`opera_corpus.index`. The row order has been shuffled with a fixed seed
+so that the IDs `doc_0 … doc_1780293` carry no information about which
+dataset a paragraph came from.
+
+## Chunking
+
+Content lengths in the corpus are not uniform: most records are
+paragraph-sized (a few hundred characters), while a smaller portion are
+shorter sentence-window chunks (~30–150 characters) extracted from
+longer paragraphs to improve recall on fine-grained reasoning
+questions. This dual-granularity chunking is a deliberate design choice
+of the dense-retrieval frontend and applies uniformly to the corpus.
+
+If your downstream use case prefers a single granularity, you can
+filter records by `len(record["content"])`.
+
+## Loading
+
+```python
+import pickle, faiss
+
+index = faiss.read_index("opera_corpus.index")
+with open("opera_corpus.meta", "rb") as f:
+    meta = pickle.load(f)
+
+assert index.ntotal == len(meta) == 1780294
+print(meta[0])
+```
+
+See `load_example.py` for an end-to-end retrieval example with BGE-M3.
+
+## Reproducing OPERA inference
+
+The OPERA inference pipeline (planner agent → BGE-M3 retriever →
+analysis-answer agent → rewrite agent → final synthesis) is released
+separately at the OPERA repository. Point its `--index-path` and
+`--metadata-path` flags at the two files in this release, or serve them
+behind the persistent retriever HTTP server shipped with the pipeline.
+
+On the standard 500-question seed42 / seed53 evaluation splits, the
+inference-only pipeline against this corpus reproduces the **OPERA
+(CoT)** row of Table 1 of the paper, i.e. the OPERA architecture
+without MAPGRPO training:
+
+| Split | HotpotQA EM | 2Wiki EM | MuSiQue EM |
+|---|---|---|---|
+| seed42 | 41.8 | 44.0 | 24.0 |
+| seed53 | 42.2 | 42.2 | 20.8 |
+| paper "OPERA (CoT)" | 44.9 | 42.3 | 21.2 |
+
+Headline numbers in Table 1 of the paper (OPERA-MAPGRPO row) require
+MAPGRPO training of the three agents; the training code is not part of
+this release.
+
+## License
+
+The retrieval index and metadata are released for research use only.
+Underlying paragraph text comes from HotpotQA, 2WikiMultiHopQA and
+MuSiQue and remains subject to those datasets' original licenses (each
+of which is derived from Wikipedia under CC-BY-SA). When publishing
+results obtained with this corpus, please cite the OPERA paper as well
+as the original benchmark papers:
+
+- Yang et al., *HotpotQA*, EMNLP 2018.
+- Ho et al., *Constructing a multi-hop QA dataset for comprehensive
+  evaluation of reasoning steps*, COLING 2020.
+- Trivedi et al., *MuSiQue: Multihop Questions via Single-hop Question
+  Composition*, TACL 2022.
+- Chen et al., *BGE M3-Embedding*, 2024.
+
+## Contact
+
+For questions about the corpus or the OPERA pipeline, please open an
+issue on the OPERA GitHub repository.

load_example.py

@@ -0,0 +1,60 @@
+"""
+Minimal end-to-end retrieval example for the OPERA retrieval corpus.
+
+Loads opera_corpus.index + opera_corpus.meta, encodes a query with
+BGE-M3, and prints the top-5 documents.
+
+Requirements:
+    pip install faiss-cpu FlagEmbedding numpy
+    # (or faiss-gpu if you have a CUDA build that matches your stack)
+"""
+
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+
+import faiss
+import numpy as np
+from FlagEmbedding import BGEM3FlagModel
+
+HERE = Path(__file__).resolve().parent
+INDEX_PATH = HERE / "opera_corpus.index"
+META_PATH = HERE / "opera_corpus.meta"
+
+BGE_MODEL = "BAAI/bge-m3"
+
+
+def main(query: str = "Who directed the film The Big Short?", top_k: int = 5) -> None:
+    print(f"loading FAISS index from {INDEX_PATH}")
+    index = faiss.read_index(str(INDEX_PATH))
+
+    print(f"loading metadata from {META_PATH}")
+    with open(META_PATH, "rb") as f:
+        meta = pickle.load(f)
+
+    assert index.ntotal == len(meta), (
+        f"count mismatch: index={index.ntotal} meta={len(meta)}"
+    )
+    print(f"corpus size: {index.ntotal}")
+
+    print(f"loading BGE-M3 ({BGE_MODEL})")
+    model = BGEM3FlagModel(BGE_MODEL, use_fp16=True)
+
+    print(f"encoding query: {query!r}")
+    encoded = model.encode([query], return_dense=True, return_sparse=False, return_colbert_vecs=False)
+    vec = np.asarray(encoded["dense_vecs"], dtype="float32")
+    vec /= np.linalg.norm(vec, axis=1, keepdims=True) + 1e-12
+
+    print(f"searching top-{top_k}")
+    scores, indices = index.search(vec, top_k)
+
+    for rank, (idx, score) in enumerate(zip(indices[0], scores[0]), start=1):
+        rec = meta[int(idx)]
+        snippet = rec["content"][:200].replace("\n", " ")
+        print(f"  #{rank}  score={score:.4f}  {rec['title']!r}")
+        print(f"        {snippet}")
+
+
+if __name__ == "__main__":
+    main()

opera_corpus.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a2ea20f40ee4654c2a7ab8e94084467e411629b300cd33ab6e71237aad07cc3
+size 7292084269

opera_corpus.meta

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:947da7c872a7f453ebf36bf407db7a8117d711a0566745126665dda8aca43faa
+size 412567527