""" reproducibility/src/memory_backends.py -------------------------------------- Unified memory backends implementing the agent memory conditions evaluated in NORA: - M1: ChunkedBM25 (500-character recursive chunked unstructured memory, L1) - M2: FullNodeBM25 (Intact full-node document memory, L2) - M3u: StructuredUniformBM25F (Equal field weights, L3u) - M3t: StructuredBM25F (Domain-tuned field weights, L3t) All backends implement the standard interface: backend.search(query_text: str, top_k: int = 5) -> List[dict] where each dict contains: {"node_id": str, "text": str, "score": float, "rank": int} """ import json import re import os import numpy as np from pathlib import Path from rank_bm25 import BM25Okapi # Multi-environment path discovery for processed datasets CURRENT_DIR = Path(__file__).resolve().parent candidates_base = [ CURRENT_DIR.parent / "dataset" / "processed", CURRENT_DIR.parent.parent / "reproducibility" / "dataset" / "processed", CURRENT_DIR.parent.parent / "data" ] DATA_BASE = None for cand in candidates_base: if cand.exists(): DATA_BASE = cand break if DATA_BASE is None: DATA_BASE = CURRENT_DIR.parent / "dataset" / "processed" def tokenize(text: str) -> list: """Verified Bengali character normalizer and tokenizer.""" if not text: return [] text = str(text) text = text.replace('\u09dc', '\u09b0').replace('\u09dd', '\u09b0') # ড়, ঢ় -> র text = text.replace('\u09df', '\u09af').replace('\u09ce', '\u09a4') # য় -> য, ৎ -> ত text = re.sub(r'[^\w\s\u0980-\u09FF]', ' ', text) return text.split() # --- Domain-tuned BM25F field configurations (Paper Table 11) --- DOMAIN_CONFIGS = { "agriculture": { "fields": ["disease_pest_name_bn", "colloquial_aliases_bn", "symptoms_bn", "favorable_conditions_bn", "management_bn", "prevention_bn", "chemical_management_bn", "affected_crop_bn", "content_bn"], "weights": [3.5, 2.0, 1.5, 1.0, 0.8, 0.8, 0.5, 0.5, 1.0], "list_fields": {"colloquial_aliases_bn", "symptoms_bn", "management_bn"}, }, "legal": { "fields": ["act_title_bn", "short_title_bn", "act_no_bn", "preamble_bn", "definitions_bn", "section_titles_bn", "penalties_bn", "powers_bn", "procedures_bn", "content_bn"], "weights": [5.0, 2.0, 0.5, 1.0, 0.8, 0.8, 0.5, 0.5, 0.5, 1.0], "list_fields": {"section_titles_bn"}, }, "education": { "fields": ["experiment_name_bn", "procedure_steps", "observation_conclusion", "apparatus_and_chemicals", "precautions", "full_text_bn"], "weights": [2.0, 3.0, 1.5, 0.8, 0.5, 1.0], "list_fields": {"apparatus_and_chemicals", "procedure_steps"}, }, } def _locate_file(domain: str, filename: str) -> Path: direct = DATA_BASE / domain / filename if direct.exists(): return direct sub = DATA_BASE / domain / "corpus" / filename if sub.exists(): return sub raise FileNotFoundError(f"Could not locate {filename} in {DATA_BASE}/{domain}") class ChunkedBM25: """M1 – Chunked text memory (500-char recursive chunking, L1).""" def __init__(self, domain: str): self.domain = domain chunk_path = _locate_file(domain, "unstructured_chunks.json") with open(chunk_path, encoding="utf-8") as f: raw = json.load(f) self.chunks = [] for c in raw: text = c.get("content_bn", c.get("text", "")) # Store parent node IDs nid = c.get("node_id", "") nids = c.get("node_ids", [nid] if nid else []) self.chunks.append({"text": text, "node_ids": nids, "chunk_id": c.get("chunk_id", "")}) self.corpus_tokens = [tokenize(c["text"]) for c in self.chunks] self.bm25 = BM25Okapi(self.corpus_tokens, k1=1.5, b=0.75) def search(self, query_text: str, top_k: int = 5) -> list: q_tokens = tokenize(query_text) if not q_tokens: return [] scores = self.bm25.get_scores(q_tokens) top_indices = np.argsort(scores)[::-1] results = [] seen_nodes = set() for idx in top_indices: c = self.chunks[idx] primary_nid = c["node_ids"][0] if c["node_ids"] else "unknown" if primary_nid not in seen_nodes: seen_nodes.add(primary_nid) results.append({ "node_id": primary_nid, "all_node_ids": c["node_ids"], "text": c["text"], "score": float(scores[idx]), "rank": len(results) + 1, }) if len(results) == top_k: break return results class FullNodeBM25: """M2 – Full intact node document memory (L2).""" def __init__(self, domain: str): self.domain = domain node_path = _locate_file(domain, "structured_nodes.json") with open(node_path, encoding="utf-8") as f: raw = json.load(f) self.nodes = [] for n in raw: text = n.get("content_bn", n.get("full_text_bn", n.get("content", ""))) self.nodes.append({"node_id": n["node_id"], "text": text}) self.corpus_tokens = [tokenize(n["text"]) for n in self.nodes] self.bm25 = BM25Okapi(self.corpus_tokens, k1=1.5, b=0.75) def search(self, query_text: str, top_k: int = 5) -> list: q_tokens = tokenize(query_text) if not q_tokens: return [] scores = self.bm25.get_scores(q_tokens) top_indices = np.argsort(scores)[::-1][:top_k] return [{ "node_id": self.nodes[idx]["node_id"], "all_node_ids": [self.nodes[idx]["node_id"]], "text": self.nodes[idx]["text"], "score": float(scores[idx]), "rank": rank + 1, } for rank, idx in enumerate(top_indices)] class StructuredBM25F: """M3 – Structured multi-field memory (BM25F, L3).""" def __init__(self, domain: str, uniform_weights: bool = False): self.domain = domain self.uniform_weights = uniform_weights node_path = _locate_file(domain, "structured_nodes.json") with open(node_path, encoding="utf-8") as f: self.raw_nodes = json.load(f) config = DOMAIN_CONFIGS[domain] self.fields = config["fields"] self.weights = [1.0] * len(self.fields) if uniform_weights else config["weights"] self.list_fields = config["list_fields"] # Build field-token corpus self.field_tokens = {f: [] for f in self.fields} self.field_lens = {f: [] for f in self.fields} self.node_ids = [] for node in self.raw_nodes: self.node_ids.append(node["node_id"]) for f in self.fields: val = node.get(f, "") if f in self.list_fields and isinstance(val, list): val = " ".join(val) elif isinstance(val, list): val = " ".join(str(x) for x in val) tokens = tokenize(str(val)) self.field_tokens[f].append(tokens) self.field_lens[f].append(len(tokens)) self.N = len(self.raw_nodes) self.avgdl = {f: float(np.mean(self.field_lens[f])) if self.field_lens[f] else 1.0 for f in self.fields} # Build document-frequency table self.df = {} for f in self.fields: for doc_toks in self.field_tokens[f]: for term in set(doc_toks): self.df[term] = self.df.get(term, 0) + 1 def search(self, query_text: str, top_k: int = 5, k1: float = 1.5, b: float = 0.75) -> list: q_tokens = tokenize(query_text) if not q_tokens: return [] scores = np.zeros(self.N) for term in set(q_tokens): if term not in self.df: continue df_val = self.df[term] idf = np.log((self.N - df_val + 0.5) / (df_val + 0.5) + 1.0) w_tf = np.zeros(self.N) for f_idx, f in enumerate(self.fields): w = self.weights[f_idx] avg = self.avgdl[f] b_f = 0.5 if self.domain == "education" else b lens = np.array(self.field_lens[f], dtype=float) lens_norm = 1.0 - b_f + b_f * (lens / (avg if avg > 0 else 1.0)) tfs = np.array([doc.count(term) for doc in self.field_tokens[f]], dtype=float) w_tf += w * (tfs / np.maximum(lens_norm, 1e-6)) k1_val = 3.0 if self.domain == "education" else k1 scores += idf * ((w_tf * (k1_val + 1.0)) / (k1_val + w_tf + 1e-6)) top_indices = np.argsort(scores)[::-1][:top_k] results = [] for rank, idx in enumerate(top_indices): node = self.raw_nodes[idx] text = node.get("content_bn", node.get("full_text_bn", node.get("content", ""))) results.append({ "node_id": self.node_ids[idx], "all_node_ids": [self.node_ids[idx]], "text": text, "score": float(scores[idx]), "rank": rank + 1, }) return results def build_backend(condition: str, domain: str): """Factory function for memory backends.""" if condition == "M1": return ChunkedBM25(domain) elif condition == "M2": return FullNodeBM25(domain) elif condition == "M3u": return StructuredBM25F(domain, uniform_weights=True) elif condition in ("M3", "M3t"): return StructuredBM25F(domain, uniform_weights=False) else: raise ValueError(f"Unknown memory condition: {condition}")