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),
            },
        }