| from __future__ import annotations |
| import math |
| from collections import defaultdict |
|
|
|
|
| class BM25Retriever: |
| def __init__(self, k1: float = 1.5, b: float = 0.75): |
| self.k1 = k1 |
| self.b = b |
| self.doc_ids: list[str] = [] |
| self.doc_texts: list[str] = [] |
| self.doc_token_lists: list[list[str]] = [] |
| self.avgdl: float = 0.0 |
| self.df: dict[str, int] = defaultdict(int) |
| self.N: int = 0 |
|
|
| def _tokenize(self, text: str) -> list[str]: |
| return text.lower().split() |
|
|
| def build_index(self, sessions: list[dict]) -> None: |
| self.doc_ids = [] |
| self.doc_texts = [] |
| self.doc_token_lists = [] |
| self.df = defaultdict(int) |
|
|
| for sess in sessions: |
| session_id = sess["session_id"] |
| text = self._session_to_text(sess) |
| tokens = self._tokenize(text) |
|
|
| self.doc_ids.append(session_id) |
| self.doc_texts.append(text) |
| self.doc_token_lists.append(tokens) |
|
|
| seen = set() |
| for token in tokens: |
| if token not in seen: |
| self.df[token] += 1 |
| seen.add(token) |
|
|
| self.N = len(self.doc_ids) |
| total_len = sum(len(tl) for tl in self.doc_token_lists) |
| self.avgdl = total_len / self.N if self.N > 0 else 1.0 |
|
|
| def _session_to_text(self, session: dict) -> str: |
| turns = session.get("turns", []) |
| parts = [] |
| for turn in turns: |
| parts.append(f"{turn['role']}: {turn['content']}") |
| return "\n".join(parts) |
|
|
| def _score(self, query_tokens: list[str], doc_idx: int) -> float: |
| doc_tokens = self.doc_token_lists[doc_idx] |
| dl = len(doc_tokens) |
| tf_map: dict[str, int] = defaultdict(int) |
| for t in doc_tokens: |
| tf_map[t] += 1 |
|
|
| score = 0.0 |
| for qt in query_tokens: |
| if qt not in self.df: |
| continue |
| tf = tf_map.get(qt, 0) |
| if tf == 0: |
| continue |
| idf = math.log((self.N - self.df[qt] + 0.5) / (self.df[qt] + 0.5) + 1) |
| tf_norm = (tf * (self.k1 + 1)) / ( |
| tf + self.k1 * (1 - self.b + self.b * dl / self.avgdl) |
| ) |
| score += idf * tf_norm |
| return score |
|
|
| def search(self, query: str, top_k: int = 10) -> list[tuple[str, float]]: |
| query_tokens = self._tokenize(query) |
| scores = [] |
| for i in range(self.N): |
| s = self._score(query_tokens, i) |
| scores.append((self.doc_ids[i], s)) |
| scores.sort(key=lambda x: x[1], reverse=True) |
| return scores[:top_k] |
|
|
| def get_rank(self, query: str, gold_ids: list[str], top_k: int = 50) -> int | None: |
| results = self.search(query, top_k=top_k) |
| for rank, (doc_id, _) in enumerate(results, 1): |
| if doc_id in gold_ids: |
| return rank |
| return None |
|
|
| def recall_at_k(self, query: str, gold_ids: list[str], k: int = 5) -> bool: |
| results = self.search(query, top_k=k) |
| retrieved_ids = {doc_id for doc_id, _ in results} |
| return bool(retrieved_ids & set(gold_ids)) |
|
|
