gst-code-collection / MemSkill /rag_utils.py
SitongGong's picture
merge code dirs 1031 (part 3)
4c30587 verified
Raw History Blame Contribute Delete
14.7 kB
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