import os, argparse, sys, pickle, shutil, subprocess from functools import partial import torch from torch import Tensor import torch.nn.functional as F from torch.nn.parallel import DistributedDataParallel as DDP import torch.distributed import pathlib, datasets import numpy as np from transformers import AutoTokenizer, AutoModel from datasets import load_dataset, concatenate_datasets from sentence_transformers import SentenceTransformer # ALL DOC_ID_KEY = 'docid' DOC_KEY = 'text' QUERY_ID_KEY = 'query_id' QUERY_KEY = 'query' # MMARCO # DOC_ID_KEY = 'id' # DOC_KEY = 'text' # QUERY_ID_KEY = 'id' # QUERY_KEY = 'text' def last_token_pool(last_hidden_states: Tensor, attention_mask: Tensor) -> Tensor: left_padding = (attention_mask[:, -1].sum() == attention_mask.shape[0]) if left_padding: return last_hidden_states[:, -1] else: sequence_lengths = attention_mask.sum(dim=1) - 1 batch_size = last_hidden_states.shape[0] return last_hidden_states[torch.arange(batch_size, device=last_hidden_states.device), sequence_lengths] def average_pool(last_hidden_states: Tensor, attention_mask: Tensor) -> Tensor: last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0) return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None] def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) def embed_corpus(x, model, tokenizer, prefix, pooling, append_eos_token,sentence, max_length=512, normalize=True): doc = x[DOC_KEY] docid = x[DOC_ID_KEY] doc = [f'{prefix}{q}' for q in doc] if sentence: embeddings = model.encode(doc, normalize_embeddings=True, batch_size=len(doc), device=rank) encoding = embeddings return { 'encoding' : encoding, 'id' : docid } if not append_eos_token: batch_dict = tokenizer(doc, max_length=max_length, padding=True, truncation=True, return_tensors='pt').to(rank) else: batch_dict = tokenizer([d+tokenizer.eos_token for d in doc], max_length=max_length, padding=True, truncation=True, return_tensors='pt').to(rank) with torch.no_grad(): with torch.cuda.amp.autocast(): outputs = model(**batch_dict) if pooling == 'eos': embeddings = last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask']) elif pooling == 'average': embeddings = average_pool(outputs.last_hidden_state, batch_dict['attention_mask']) elif pooling == 'cls': embeddings = outputs.last_hidden_state[:, 0] elif pooling == 'mean': embeddings = mean_pooling(outputs, batch_dict['attention_mask']) else: raise Exception("Pooling not defined") if normalize: encoding = F.normalize(embeddings, p=2, dim=1).cpu().detach().numpy() else: encoding = embeddings.cpu().detach().numpy() return { 'encoding' : encoding, 'id' : docid } def embed_queries(x, model, tokenizer, prefix, pooling, append_eos_token, sentence, max_length=512, normalize=True,): query = x[QUERY_KEY] query_id = x[QUERY_ID_KEY] query = [f'{prefix}{q}' for q in query] if sentence: embeddings = model.encode(query, normalize_embeddings=True, batch_size=len(query), device=rank) encoding = embeddings return { 'encoding' : encoding, 'id' : query_id } if not append_eos_token: batch_dict = tokenizer(query, max_length=max_length, padding=True, truncation=True, return_tensors='pt').to(rank) else: batch_dict = tokenizer([q+tokenizer.eos_token for q in query], max_length=max_length, padding=True, truncation=True, return_tensors='pt').to(rank) with torch.no_grad(): with torch.cuda.amp.autocast(): outputs = model(**batch_dict) if pooling == 'eos': embeddings = last_token_pool(outputs.last_hidden_state, batch_dict['attention_mask']) elif pooling == 'average': embeddings = average_pool(outputs.last_hidden_state, batch_dict['attention_mask']) elif pooling == 'cls': embeddings = outputs.last_hidden_state[:, 0] elif pooling == 'mean': embeddings = mean_pooling(outputs, batch_dict['attention_mask']) else: raise Exception("Pooling not defined") if normalize: encoding = F.normalize(embeddings, p=2, dim=1).cpu().detach().numpy() else: encoding = embeddings.cpu().detach().numpy() return { 'encoding' : encoding, 'id' : query_id } def distributed_embedding(ds, embed_function, batch_size, sort=True, value_to_sort='text'): rank = torch.distributed.get_rank() ds_shard_filepaths = [ os.path.join('./CACHE', f"{ds._fingerprint}_subshard_{w}.cache") for w in range(0, world_size) ] print(f"\tworker {rank} saving sub-shard to {ds_shard_filepaths[rank]}") ds_shard = ds.shard( num_shards=world_size, index=rank, contiguous=True, ) if sort: ds_shard = ds_shard.map(lambda x: {'len' : len(x[value_to_sort])}, num_proc=64) ds_shard = ds_shard.sort('len', reverse=True) ds_shard = ds_shard.map(embed_function, batched=True, batch_size=batch_size, remove_columns=ds.column_names, load_from_cache_file=False) ds_shard.save_to_disk(ds_shard_filepaths[rank]) print("rank", rank, "saving:", ds_shard_filepaths[rank]) torch.distributed.barrier() full_dataset = concatenate_datasets( [ds.load_from_disk(p) for p in ds_shard_filepaths] ) torch.distributed.barrier() print("rank", rank, "deleting:", ds_shard_filepaths[rank]) shutil.rmtree(ds_shard_filepaths[rank]) return full_dataset def main(rank, args): warnings.filterwarnings('ignore') datasets.logging.set_verbosity_error() queries = load_dataset(args.queries) queries = queries[args.queries_split] batch_size = args.batch_size corpus = load_dataset(args.corpus) corpus = corpus[args.corpus_split] if args.tokenizer is None: tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True) else: tokenizer = AutoTokenizer.from_pretrained(args.tokenizer, trust_remote_code=True) if args.sentence: model = SentenceTransformer(args.model, device=rank) model.max_seq_length = 512 else: model = AutoModel.from_pretrained(args.model, trust_remote_code=True, attn_implementation="flash_attention_2" if 'gemma' in args.model else None, torch_dtype=torch.bfloat16).to(rank).eval() # model = DDP(model, device_ids=[rank]) if rank == 0: # Create folder if not present pathlib.Path(args.output_dir,).mkdir(parents=True, exist_ok=True) print("-"*10) print('CORPUS embedding...') # Embedding of the corpus corpus_embedding = distributed_embedding(corpus, partial(embed_corpus, model=model, tokenizer=tokenizer, prefix=args.passage_prefix, pooling=args.pooling, append_eos_token=args.append_eos_token, sentence=args.sentence, normalize=args.normalize), batch_size=batch_size, sort=True, value_to_sort='text') # Saving corpus if rank == 0: print('Saving embedding...') with open(os.path.join(args.output_dir,"corpus_emb.pkl"), 'wb') as f: pickle.dump((np.asarray(corpus_embedding['encoding'], dtype=np.float32), corpus_embedding['id']), f) print('Embedding saved!') torch.distributed.barrier() print('QUERIES embedding...') # Embedding of the queries queries_embedding = distributed_embedding(queries, partial(embed_queries, model=model, tokenizer=tokenizer, prefix=args.query_prefix, pooling=args.pooling, append_eos_token=args.append_eos_token, sentence=args.sentence, normalize=args.normalize), batch_size=batch_size, sort=False) # Saving queries if rank == 0: print('Saving embedding...') with open(os.path.join(args.output_dir,"query_emb.pkl"), 'wb') as f: pickle.dump((np.asarray(queries_embedding['encoding'], dtype=np.float32), queries_embedding['id']), f) print('Embedding saved!') if rank == 0: print("-"*10) print('Retrieval...') command = [ "/opt/conda/envs/retrieval/bin/python", "-m", "tevatron.faiss_retriever", "--query_reps", os.path.join(args.output_dir,"query_emb.pkl"), "--passage_reps", os.path.join(args.output_dir,"corpus_emb.pkl"), "--depth", "100", "--batch_size", "-1", "--save_text", "--save_ranking_to", os.path.join(args.output_dir,"rank.txt") ] proc = subprocess.run(command, capture_output=True, text=True) print("Output:", proc.stdout) print('Converting to MARCO format...') command = [ "/opt/conda/envs/retrieval/bin/python", "-m", "tevatron.utils.format.convert_result_to_marco", "--input", os.path.join(args.output_dir,"rank.txt"), "--output", os.path.join(args.output_dir,"rank.txt.marco"), ] proc = subprocess.run(command, capture_output=True, text=True) print("Output:", proc.stdout) print("Computing metrics...") command = [ "/opt/conda/envs/retrieval/bin/python", "-m", "pyserini.eval.trec_eval", "-c", "-M", "100", "-m", "ndcg_cut.10", "-m", "recall.100", "-m", "recip_rank", args.qrels, os.path.join(args.output_dir,"rank.txt.marco"), ] proc = subprocess.run(command, capture_output=True, text=True) print("Output:", proc.stdout) return 'Done' return if __name__ == "__main__": import warnings warnings.filterwarnings('ignore') rank = int(os.environ.get('LOCAL_RANK')) torch.distributed.init_process_group("nccl", rank=rank, world_size=2) world_size = torch.distributed.get_world_size() print('Initialized') parser = argparse.ArgumentParser(description="Evaluation of retrieval embedding model") # Required arguments specified as --options parser.add_argument('--model', type=str, required=True, help='Model to evaluate') parser.add_argument('--batch-size', type=int, required=False, default=256, help="Batch size for eval") parser.add_argument('--pooling', type=str, required=True, help='Pooling to use') parser.add_argument('--append-eos-token', action="store_true", required=False, default=False, help='If append eos to sentences and queries') parser.add_argument('--normalize', type=bool, required=False, default=True, help='If normalize embedding') parser.add_argument('--sentence', action="store_true", required=False, default=False, help='If append eos to sentences and queries') parser.add_argument('--tokenizer', type=str, required=False, default=None, help='Tokenizer of the model') parser.add_argument('--corpus', type=str, required=True, help='Corpus dataset') parser.add_argument('--corpus-split', type=str, required=False, default='dev', help='Corpus split') parser.add_argument('--queries', type=str, required=True, help='Queries dataset') parser.add_argument('--queries-split', type=str, required=False, default='dev', help='Queries split') parser.add_argument('--query-prefix', type=str, required=False, default='query: ', help='Queries prefix') parser.add_argument('--passage-prefix', type=str, required=False, default='passage: ', help='Passages prefix split') parser.add_argument('--output-dir', type=str, required=True, help='Directory where to save results') parser.add_argument('--qrels', type=str, required=True, help='Path to qrels for evaluation') args = parser.parse_args() main(rank, args)