Upload full_eval.py

full_eval.py

@@ -0,0 +1,305 @@
+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)