full_eval.py

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)