Spaces:
Running on Zero
Running on Zero
File size: 4,847 Bytes
e8c5cc2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | """The serving pipeline: retrieve -> fuse -> rerank -> generate.
Shared by the FastAPI app and the Gradio UI so both measure the same thing.
"""
from __future__ import annotations
import time
from typing import Any
from src.api.generate import generate_answer, is_configured
from src.config import device
from src.data.loader import flatten_corpus, load_split, passage_text
from src.retrieval.bm25 import BM25Retriever
from src.retrieval.dense import DenseRetriever
from src.retrieval.fusion import reciprocal_rank_fusion
class ResearchPipeline:
"""Loads every index and model once, then answers questions."""
def __init__(self, cfg: dict[str, Any]) -> None:
self.cfg = cfg
dc = cfg["dataset"]
self.corpus, _queries, _qrels = load_split(dc["url"], dc["split"], dc["download_dir"])
doc_ids, doc_texts = flatten_corpus(self.corpus)
rc = cfg["retrieval"]
cache_dir = cfg["paths"]["cache_dir"]
self.bm25 = BM25Retriever(
k1=rc["bm25"]["k1"], b=rc["bm25"]["b"], stemmer_lang=rc["bm25"]["stemmer"]
)
self.bm25.index(doc_ids, doc_texts, cache_dir=cache_dir)
self.dense = DenseRetriever(
model_name=rc["dense"]["model"],
batch_size=rc["dense"]["batch_size"],
max_length=rc["dense"]["max_length"],
query_prefix=rc["dense"]["query_prefix"],
device=device(),
)
self.dense.index_corpus(doc_ids, doc_texts, cache_dir=cache_dir)
self.reranker, self.backend = self._load_reranker(cfg["reranker"])
self.rrf_k = rc["fusion"]["rrf_k"]
self.retrieve_k = rc["top_k"]
print(f"[pipeline] ready | {len(self.corpus)} docs | reranker backend={self.backend}")
@staticmethod
def _load_reranker(rc: dict[str, Any]) -> tuple[Any, str]:
backend = rc.get("backend", "torch")
if backend == "onnx":
from src.rerank.onnx_runtime import OnnxReranker
return (
OnnxReranker(
onnx_path=rc["model"],
tokenizer_path=rc["tokenizer"],
max_length=rc["max_length"],
batch_size=rc["batch_size"],
),
"onnx",
)
from src.rerank.model import Reranker
return (
Reranker(
model_name_or_path=rc["model"],
max_length=rc["max_length"],
batch_size=rc["batch_size"],
device=device(),
fp16=rc.get("fp16", True) and device() == "cuda",
),
"torch",
)
def retrieve(self, question: str, top_k: int | None = None) -> list[dict[str, Any]]:
"""Retrieve, fuse, and rerank. Returns passages sorted best-first."""
retrieve_k = top_k or self.retrieve_k
pseudo_qid = "q"
query_map = {pseudo_qid: question}
bm25_run = self.bm25.search(query_map, top_k=retrieve_k)
dense_run = self.dense.search(query_map, top_k=retrieve_k)
fused = reciprocal_rank_fusion([bm25_run, dense_run], k=self.rrf_k, top_k=retrieve_k)
reranked, _timings = self.reranker.rerank(query_map, fused, self.corpus, top_k=retrieve_k)
ordered = sorted(reranked[pseudo_qid].items(), key=lambda kv: kv[1], reverse=True)
return [
{
"doc_id": doc_id,
"score": float(score),
"title": self.corpus[doc_id].get("title", ""),
"text": self.corpus[doc_id].get("text", ""),
"full_text": passage_text(self.corpus, doc_id),
}
for doc_id, score in ordered
]
def answer(
self, question: str, top_k_final: int = 5, generate: bool = True
) -> dict[str, Any]:
"""Full pipeline. Returns the answer, its citations, and timings."""
start = time.perf_counter()
passages = self.retrieve(question)[:top_k_final]
retrieval_ms = (time.perf_counter() - start) * 1000.0
answer_text = None
generation_ms = 0.0
if generate:
gen_start = time.perf_counter()
answer_text = generate_answer(question, passages)
generation_ms = (time.perf_counter() - gen_start) * 1000.0
return {
"question": question,
"answer": answer_text,
"citations": [
{k: p[k] for k in ("doc_id", "score", "title", "text")} for p in passages
],
"backend": self.backend,
"generation_configured": is_configured(),
"timing_ms": {
"retrieval_and_rerank": round(retrieval_ms, 1),
"generation": round(generation_ms, 1),
"total": round(retrieval_ms + generation_ms, 1),
},
}
|