import argparse import logging import pickle from typing import Any from omegaconf import DictConfig from tqdm import tqdm from pathlib import Path import numpy as np import torch import transformers from vllm import LLM from transformers import AutoTokenizer, AutoModel from sentence_transformers import SentenceTransformer import contriever.src.slurm import contriever.src.contriever import contriever.src.utils import contriever.src.normalize_text from src.data import fast_load_jsonl_shard import os def get_model(args: DictConfig): model_name_or_path: str = args.model_name_or_path logging.info(f"Loading retriever model from {model_name_or_path}...") if args.get("use_vllm", False): tokenizer = AutoTokenizer.from_pretrained(model_name_or_path) os.environ["VLLM_ATTENTION_BACKEND"] = "XFORMERS" model = LLM( model=model_name_or_path, dtype="auto", # TODO: should respect args.no_fp16 task="embed", enforce_eager=True, ) return model, tokenizer if "contriever" in model_name_or_path: model, tokenizer, _ = contriever.src.contriever.load_retriever( model_name_or_path ) model = model.cuda() # type: ignore if not args.no_fp16: model = model.half() model.eval() elif "dragon" in model_name_or_path: tokenizer_name_or_path = ( args.tokenizer if args.get("tokenizer", None) else model_name_or_path ) tokenizer = AutoTokenizer.from_pretrained(tokenizer_name_or_path) model = AutoModel.from_pretrained(model_name_or_path) model = model.cuda() if not args.no_fp16: model = model.half() model.eval() elif "sentence-transformers" in model_name_or_path: tokenizer = None model = SentenceTransformer(model_name_or_path) model.eval() else: raise AttributeError(f"{model_name_or_path} is not supported!") return model, tokenizer def generate_passage_embeddings(cfg: DictConfig): if "sparse_retriever" not in cfg.model: print(f"No need to run the embedding step for sparse retrieval, skipping...") return args: DictConfig = cfg.datastore.embedding model, tokenizer = get_model(args) for shard_id in map(int, args.shard_ids): embedding_shard_save_path: Path = Path(args.embedding_dir) / ( args.prefix + f"_{shard_id:02d}.pkl" ) if args.get("use_saved_if_exists", True) and embedding_shard_save_path.exists(): print(f"Embeddings exist in {embedding_shard_save_path}") continue shard_passages = fast_load_jsonl_shard(args, shard_id, return_all_passages=True) all_ids, all_embeddings = embed_passages(args, shard_passages, model, tokenizer) assert all_embeddings[0].shape == (cfg.datastore.index.projection_size,), ( f"Embedding shape is {all_embeddings[0].shape}, while index requires {cfg.datastore.index.projection_size}" ) Path(args.embedding_dir).mkdir(parents=True, exist_ok=True) print( f"Saving {len(all_ids)} passage embeddings to {embedding_shard_save_path}." ) with open(embedding_shard_save_path, mode="wb") as file: pickle.dump((all_ids, all_embeddings), file) print( f"Processed {len(all_ids)} passages in the {shard_id}-th (out of {args.num_shards}) shard.\n" f"Written to {embedding_shard_save_path}." ) def embed_passages( args: DictConfig, passages: list[dict[str, Any]], model: Any, tokenizer: transformers.AutoTokenizer, ) -> tuple[list[int], list[np.ndarray]]: def preprocess_text(p: dict[str, Any]) -> str: if args.no_title or "title" not in p: text: str = p["text"] else: text: str = p["title"] + " " + p["text"] if args.lowercase: text = text.lower() if args.normalize_text: text = contriever.src.normalize_text.normalize(text) if "GritLM" in args.model_name_or_path: text = "<|embed|>\n" + text return text all_ids: list[int] = [] all_embeddings: list[np.ndarray] = [] if "sentence-transformers" in args.model_name_or_path: all_texts: list[str] = [] for passage in tqdm(passages): all_ids.append(passage["id"]) all_texts.append(preprocess_text(passage)) with torch.no_grad(): all_embeddings = model.encode( all_texts, batch_size=64 ) # default is 512, but got oom else: if args.get("use_vllm", False): BATCH_SIZE = args.per_gpu_batch_size for batch_idx in tqdm(range(0, len(passages), BATCH_SIZE)): batch = passages[batch_idx : batch_idx + BATCH_SIZE] batch_ids = [p["id"] for p in batch] batch_texts = [preprocess_text(p) for p in batch] outputs = model.embed(batch_texts) batch_embeddings = [output.outputs.embedding for output in outputs] # normalize batch_embeddings = [ embedding / np.linalg.norm(embedding) for embedding in batch_embeddings ] batch_embeddings = np.array(batch_embeddings) all_ids.extend(batch_ids) all_embeddings.append(np.array(batch_embeddings)) all_embeddings = np.concatenate(all_embeddings, axis=0) else: BATCH_SIZE = args.per_gpu_batch_size for batch_idx in tqdm(range(0, len(passages), BATCH_SIZE)): batch = passages[batch_idx : batch_idx + BATCH_SIZE] batch_ids = [p["id"] for p in batch] batch_texts = [preprocess_text(p) for p in batch] with torch.no_grad(): encoded_batch = tokenizer.batch_encode_plus( batch_texts, return_tensors="pt", max_length=args.passage_maxlength, padding=True, truncation=True, ) encoded_batch = {k: v.cuda() for k, v in encoded_batch.items()} batch_embeddings = model( **encoded_batch ) # shape: (batch_size, hidden_size) if "contriever" not in args.model_name_or_path: # assume in hf form batch_embeddings = batch_embeddings.last_hidden_state[:, 0, :] batch_embeddings = batch_embeddings.cpu() all_ids.extend(batch_ids) all_embeddings.append(batch_embeddings) all_embeddings = torch.cat(all_embeddings, dim=0).numpy() return all_ids, all_embeddings def get_sharded_passages(args, all_passages): total_num_passages = len(all_passages) shard_size = total_num_passages // args.num_shards start_idx = args.shard_id * shard_size end_idx = start_idx + shard_size if args.shard_id == args.num_shards - 1: end_idx = total_num_passages passages = all_passages[start_idx:end_idx] print(f"Using {len(passages)} passages from idx {start_idx} to {end_idx}.") return passages if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--raw_data_path", type=str, default=None, help="Path to passages (.jsonl or .tsv file)", ) parser.add_argument( "--embedding_dir", type=str, default="wikipedia_embeddings", help="dir path to save embeddings", ) parser.add_argument( "--prefix", type=str, default="passages", help="prefix path to save embeddings" ) parser.add_argument( "--shard_id", type=int, default=0, help="Id of the current shard" ) parser.add_argument( "--num_shards", type=int, default=1, help="Total number of shards" ) parser.add_argument( "--per_gpu_batch_size", type=int, default=512, help="Batch size for the passage encoder forward pass", ) parser.add_argument( "--chunk_size", type=int, default=512, help="Maximum number of words in a passage, the length will be further cut by passage_maxlength", ) parser.add_argument( "--passage_maxlength", type=int, default=512, help="Maximum number of tokens in a passage", ) parser.add_argument( "--model_name_or_path", type=str, help="path to directory containing model weights and config file", ) parser.add_argument("--no_fp16", action="store_true", help="inference in fp32") parser.add_argument( "--no_title", action="store_true", help="title not added to the passage body" ) parser.add_argument( "--lowercase", action="store_true", help="lowercase text before encoding" ) parser.add_argument( "--normalize_text", action="store_true", help="lowercase text before encoding" ) parser.add_argument( "--use_vllm", action="store_true", help="use vllm for embedding" ) args = parser.parse_args() generate_passage_embeddings(DictConfig(args))