Spaces:
Running on Zero
Running on Zero
Download src/api/pipeline.py from Kagzy/ResearchOS: direct link, hf CLI and curl.
- Browser
- Download file 4.85 kB
-
https://huggingface.co/spaces/Kagzy/ResearchOS/resolve/main/src/api/pipeline.py
- Command line
-
hf download hf://spaces/Kagzy/ResearchOS/src/api/pipeline.py
-
curl -L -o pipeline.py https://huggingface.co/spaces/Kagzy/ResearchOS/resolve/main/src/api/pipeline.py
4.85 kB
| """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}") | |
| 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), | |
| }, | |
| } | |