class_docstr: This class evaluates a SentenceTransformer model for the task of re-ranking.
  
  Given a query and a list of documents, it computes the score [query, doc_i] for all possible
  documents and sorts them in decreasing order. Then, MRR@10 and MAP is compute to measure the quality of the ranking.
  
  :param samples: Must be a list and each element is of the form: {'query': '', 'positive': [], 'negative': []}. Query is the search query,
   positive is a list of positive (relevant) documents, negative is a list of negative (irrelevant) documents.
docstr: Computes the metrices in a batched way, by batching all queries and
  all documents together
docstr_tok: ["Computes","the","metrices","in","a","batched","way",",","by","batching","all","queries","and","all","documents","together"]
code: def compute_metrices_batched(self, model):
      """
      Computes the metrices in a batched way, by batching all queries and
      all documents together
      """
      all_mrr_scores = []
      all_ap_scores = []
  
      all_query_embs = model.encode(
          [sample["query"] for sample in self.samples],
          convert_to_tensor=True,
          batch_size=self.batch_size,
          show_progress_bar=self.show_progress_bar,
      )
  
      all_docs = []
  
      for sample in self.samples:
          all_docs.extend(sample["positive"])
          all_docs.extend(sample["negative"])
  
      all_docs_embs = model.encode(
          all_docs,
          convert_to_tensor=True,
          batch_size=self.batch_size,
          show_progress_bar=self.show_progress_bar,
      )
  
      # Compute scores
      query_idx, docs_idx = 0, 0
      for instance in self.samples:
          query_emb = all_query_embs[query_idx]
          query_idx += 1
  
          num_pos = len(instance["positive"])
          num_neg = len(instance["negative"])
          docs_emb = all_docs_embs[
              docs_idx : docs_idx + num_pos + num_neg
          ]
          docs_idx += num_pos + num_neg
  
          if num_pos == 0 or num_neg == 0:
              continue
  
          pred_scores = self.similarity_fct(query_emb, docs_emb)
          if len(pred_scores.shape) > 1:
              pred_scores = pred_scores[0]
  
          pred_scores_argsort = torch.argsort(
              -pred_scores
          )  # Sort in decreasing order
  
          # Compute MRR score
          is_relevant = [True] * num_pos + [False] * num_neg
          mrr_score = 0
          for rank, index in enumerate(
              pred_scores_argsort[0 : self.mrr_at_k]
          ):
              if is_relevant[index]:
                  mrr_score = 1 / (rank + 1)
                  break
          all_mrr_scores.append(mrr_score)
  
          # Compute AP
          all_ap_scores.append(
              average_precision_score(
                  is_relevant, pred_scores.cpu().tolist()
              )
          )
  
      mean_ap = np.mean(all_ap_scores)
      mean_mrr = np.mean(all_mrr_scores)
  
      return {"map": mean_ap, "mrr": mean_mrr}
  
file_path: sentence-transformers/sentence_transformers/evaluation/RerankingEvaluator.py
imports: from .None import SentenceEvaluator
  import logging
  import numpy
  import os
  import csv
  from ..util import cos_sim
  import torch
  from sklearn.metrics import average_precision_score
  import tqdm
label_desc: Use image node_id 4 for calling the RerankingEvaluator obj's underlying member method code with example usage: obj.compute_metrices_batched(model) and returns: dict