from typing import List import torch import threading import torch.nn.functional as F from tqdm import tqdm from sentence_transformers import SentenceTransformer try: import faiss except ImportError: print("FAISS INITIALIZATION FAILED") faiss = None try: from langchain_community.retrievers.bm25 import BM25Retriever from langchain_community.retrievers.tfidf import TFIDFRetriever from langchain_core.documents import Document except ImportError: print("LANGCHAIN INITIALIZATION FAILED") BM25Retriever = None TFIDFRetriever = None Document = None # Global cache for retriever models to avoid repeated loading _MODEL_CACHE = {} _MODEL_CACHE_LOCK = threading.RLock() _MODEL_CACHE_LOADING = {} _QWEN_RETRIEVER_MODEL = "Qwen/Qwen3-Embedding-0.6B" _RETRIEVER_USE_FLASH_ATTN = True def _canonicalize_retriever_name(retriever: str) -> str: name = str(retriever or "").strip() lowered = name.lower() if lowered in { "qwen/qwen3-embedding-0.6b", "qwen3-embedding-0.6b", }: return _QWEN_RETRIEVER_MODEL return name def _is_qwen_embedding_retriever(retriever: str) -> bool: return _canonicalize_retriever_name(retriever).lower() == _QWEN_RETRIEVER_MODEL.lower() def set_retriever_flash_attn(enabled: bool) -> None: global _RETRIEVER_USE_FLASH_ATTN enabled = bool(enabled) with _MODEL_CACHE_LOCK: if _RETRIEVER_USE_FLASH_ATTN == enabled: return _RETRIEVER_USE_FLASH_ATTN = enabled qwen_key = _QWEN_RETRIEVER_MODEL.lower() stale_keys = [key for key in _MODEL_CACHE.keys() if qwen_key in str(key).lower()] for key in stale_keys: del _MODEL_CACHE[key] def _load_sentence_transformer(model_name: str, device: str): model_name_lower = model_name.lower() if "qwen3-embedding" in model_name_lower: if torch.cuda.is_available() and torch.cuda.is_bf16_supported(): torch_dtype = torch.bfloat16 else: torch_dtype = torch.float16 model_kwargs = {"torch_dtype": torch_dtype} if str(device).startswith("cuda") and _RETRIEVER_USE_FLASH_ATTN: model_kwargs["attn_implementation"] = "flash_attention_2" return SentenceTransformer( model_name, device=device, model_kwargs=model_kwargs, tokenizer_kwargs={"padding_side": "left"}, ) model_kwargs["device_map"] = "auto" return SentenceTransformer( model_name, device=device, model_kwargs=model_kwargs, tokenizer_kwargs={"padding_side": "left"}, ) return SentenceTransformer(model_name, device=device) def _load_hf_model(model_cls, model_name: str, device: str): """Load HF model on a single device to avoid meta tensor dispatch issues.""" def _load_with_kwargs(**kwargs): return model_cls.from_pretrained(model_name, **kwargs) def _has_meta_params(model): return any(p.is_meta for p in model.parameters()) or any(b.is_meta for b in model.buffers()) def _load_no_map(): try: return _load_with_kwargs(device_map=None, low_cpu_mem_usage=False) except TypeError: return _load_with_kwargs() # First try: normal load on CPU -> move to device. try: model = _load_no_map() model = model.to(device) if not _has_meta_params(model): model.eval() return model except RuntimeError as exc: if "meta tensor" not in str(exc).lower(): raise # Fallback: let HF dispatch directly to device (skip .to()). try: model = _load_with_kwargs(device_map={"": device}, low_cpu_mem_usage=True) model.eval() return model except Exception: pass # Last resort: use to_empty + load_state_dict. model = _load_no_map() if _has_meta_params(model): model = model.to_empty(device=device) state_model = _load_no_map() model.load_state_dict(state_model.state_dict(), strict=False) del state_model else: model = model.to(device) model.eval() return model def mean_pooling(token_embeddings: torch.Tensor, mask: torch.Tensor) -> torch.Tensor: """ token_embeddings: [B, L, D] mask: [B, L] """ token_embeddings = token_embeddings.masked_fill(~mask[..., None].bool(), 0.0) sentence_embeddings = token_embeddings.sum(dim=1) / mask.sum(dim=1)[..., None].clamp(min=1) return sentence_embeddings def init_context_model(retriever: str): """Initialize context encoder with global caching.""" retriever = _canonicalize_retriever_name(retriever) cache_key = f"{retriever}_context" while True: with _MODEL_CACHE_LOCK: if cache_key in _MODEL_CACHE: tokenizer, model = _MODEL_CACHE[cache_key] has_meta = any(p.is_meta for p in model.parameters()) or any(b.is_meta for b in model.buffers()) uses_device_map = bool(getattr(model, "hf_device_map", None)) if has_meta and not uses_device_map: del _MODEL_CACHE[cache_key] print("NO USING CACHE FOR RETRIEVER") else: return tokenizer, model event = _MODEL_CACHE_LOADING.get(cache_key) if event is None: event = threading.Event() _MODEL_CACHE_LOADING[cache_key] = event is_loader = True else: is_loader = False if not is_loader: event.wait() continue break try: device = "cuda" if torch.cuda.is_available() else "cpu" if retriever == 'dpr': from transformers import ( DPRContextEncoder, DPRContextEncoderTokenizer, ) context_tokenizer = DPRContextEncoderTokenizer.from_pretrained( "facebook/dpr-ctx_encoder-single-nq-base" ) context_model = _load_hf_model( DPRContextEncoder, "facebook/dpr-ctx_encoder-single-nq-base", device ) elif retriever == 'contriever': from transformers import AutoTokenizer, AutoModel context_tokenizer = AutoTokenizer.from_pretrained('facebook/contriever') context_model = _load_hf_model(AutoModel, 'facebook/contriever', device) elif retriever == 'dragon': from transformers import AutoTokenizer, AutoModel context_tokenizer = AutoTokenizer.from_pretrained('facebook/dragon-plus-context-encoder') context_model = _load_hf_model(AutoModel, 'facebook/dragon-plus-context-encoder', device) elif _is_qwen_embedding_retriever(retriever): context_tokenizer = None context_model = _load_sentence_transformer(retriever, device) else: raise ValueError(f"Unknown retriever type: {retriever}") except Exception: with _MODEL_CACHE_LOCK: event = _MODEL_CACHE_LOADING.pop(cache_key, None) if event is not None: event.set() raise with _MODEL_CACHE_LOCK: _MODEL_CACHE[cache_key] = (context_tokenizer, context_model) event = _MODEL_CACHE_LOADING.pop(cache_key, None) if event is not None: event.set() return context_tokenizer, context_model def init_query_model(retriever: str): """Initialize query encoder with global caching.""" retriever = _canonicalize_retriever_name(retriever) cache_key = f"{retriever}_query" while True: with _MODEL_CACHE_LOCK: if cache_key in _MODEL_CACHE: tokenizer, model = _MODEL_CACHE[cache_key] has_meta = any(p.is_meta for p in model.parameters()) or any(b.is_meta for b in model.buffers()) uses_device_map = bool(getattr(model, "hf_device_map", None)) if has_meta and not uses_device_map: del _MODEL_CACHE[cache_key] else: return tokenizer, model event = _MODEL_CACHE_LOADING.get(cache_key) if event is None: event = threading.Event() _MODEL_CACHE_LOADING[cache_key] = event is_loader = True else: is_loader = False if not is_loader: event.wait() continue break try: device = "cuda" if torch.cuda.is_available() else "cpu" if retriever == 'dpr': from transformers import ( DPRQuestionEncoder, DPRQuestionEncoderTokenizer, ) question_tokenizer = DPRQuestionEncoderTokenizer.from_pretrained( "facebook/dpr-question_encoder-single-nq-base" ) question_model = _load_hf_model( DPRQuestionEncoder, "facebook/dpr-question_encoder-single-nq-base", device ) elif retriever == 'contriever': from transformers import AutoTokenizer, AutoModel question_tokenizer = AutoTokenizer.from_pretrained('facebook/contriever') question_model = _load_hf_model(AutoModel, 'facebook/contriever', device) elif retriever == 'dragon': from transformers import AutoTokenizer, AutoModel question_tokenizer = AutoTokenizer.from_pretrained('facebook/dragon-plus-query-encoder') question_model = _load_hf_model(AutoModel, 'facebook/dragon-plus-query-encoder', device) elif _is_qwen_embedding_retriever(retriever): question_tokenizer = None question_model = _load_sentence_transformer(retriever, device) else: raise ValueError(f"Unknown retriever type: {retriever}") except Exception: with _MODEL_CACHE_LOCK: event = _MODEL_CACHE_LOADING.pop(cache_key, None) if event is not None: event.set() raise with _MODEL_CACHE_LOCK: _MODEL_CACHE[cache_key] = (question_tokenizer, question_model) event = _MODEL_CACHE_LOADING.pop(cache_key, None) if event is not None: event.set() return question_tokenizer, question_model def get_embeddings(retriever: str, inputs: List[str], mode: str = 'context', batch_size: int = 256) -> torch.Tensor: retriever = _canonicalize_retriever_name(retriever) if mode == 'context': tokenizer, encoder = init_context_model(retriever) else: tokenizer, encoder = init_query_model(retriever) all_embeddings = [] device = "cuda" if torch.cuda.is_available() else "cpu" if _is_qwen_embedding_retriever(retriever): return encoder.encode( inputs, convert_to_numpy=True, batch_size=batch_size, normalize_embeddings=True, ) with torch.no_grad(): for i in tqdm(range(0, len(inputs), batch_size), desc="GET EMBEDDINGS", leave=False): batch_texts = inputs[i:(i + batch_size)] if retriever == 'dpr': enc_inputs = tokenizer( batch_texts, return_tensors="pt", padding=True, truncation=True ).to(device) outputs = encoder(**enc_inputs) embeddings = outputs.pooler_output.detach() embeddings = F.normalize(embeddings, p=2, dim=-1) all_embeddings.append(embeddings) elif retriever == 'contriever': enc_inputs = tokenizer( batch_texts, padding=True, truncation=True, return_tensors='pt' ).to(device) outputs = encoder(**enc_inputs) embeddings = mean_pooling(outputs[0], enc_inputs['attention_mask']) embeddings = F.normalize(embeddings, p=2, dim=-1) all_embeddings.append(embeddings) elif retriever == 'dragon': enc_inputs = tokenizer( batch_texts, padding=True, truncation=True, return_tensors='pt' ).to(device) outputs = encoder(**enc_inputs) embeddings = outputs.last_hidden_state[:, 0, :] all_embeddings.append(embeddings) else: raise ValueError(f"Unknown retriever type: {retriever}") return torch.cat(all_embeddings, dim=0).cpu().numpy() def build_faiss_index( embeddings: torch.Tensor, metric: str = 'ip' ): if faiss is None: raise ImportError("faiss is not installed, please `pip install faiss-gpu` or `faiss-cpu`.") if isinstance(embeddings, torch.Tensor): xb = embeddings.detach().cpu().numpy() else: xb = embeddings xb = xb.astype('float32') dim = xb.shape[1] if metric == 'l2': index = faiss.IndexFlatL2(dim) elif metric == 'ip': index = faiss.IndexFlatIP(dim) faiss.normalize_L2(xb) else: raise ValueError(f"Unknown metric: {metric}") index.add(xb) return index def faiss_knn_search( index, query_embeddings: torch.Tensor, top_k: int = 8, metric: str = 'ip' ): if isinstance(query_embeddings, torch.Tensor): xq = query_embeddings.detach().cpu().numpy() else: xq = query_embeddings xq = xq.astype('float32') if metric == 'ip': faiss.normalize_L2(xq) D, I = index.search(xq, top_k) return D, I def get_sparse_retriever( text_chunks: List[str], retriever: str = 'bm25', num: int = 8, ): if Document is None or BM25Retriever is None or TFIDFRetriever is None: raise ImportError( "langchain_community or langchain_core is not installed. " "Install via `pip install langchain-community langchain-core`." ) documents = [Document(page_content=text) for text in text_chunks] if retriever == 'bm25': retr = BM25Retriever.from_documents(documents, k=num) elif retriever == 'tf-idf': retr = TFIDFRetriever.from_documents(documents, k=num) else: raise ValueError(f"Unknown sparse retriever type: {retriever}") return retr def sparse_neighborhood_search( retriever, query: str, text_chunks: List[str], ) -> List[int]: retrieved_docs = retriever.get_relevant_documents(query) retrieved_indices = [text_chunks.index(doc.page_content) for doc in retrieved_docs] return retrieved_indices if __name__ == '__main__': pass