class_docstr: Evaluate a model based on a triplet: (sentence, positive_example, negative_example).
      Checks if distance(sentence, positive_example) < distance(sentence, negative_example).
code: def __call__(
      self,
      model,
      output_path: str = None,
      epoch: int = -1,
      steps: int = -1,
  ) -> float:
      if epoch != -1:
          if steps == -1:
              out_txt = " after epoch {}:".format(epoch)
          else:
              out_txt = " in epoch {} after {} steps:".format(
                  epoch, steps
              )
      else:
          out_txt = ":"
  
      logger.info(
          "TripletEvaluator: Evaluating the model on "
          + self.name
          + " dataset"
          + out_txt
      )
  
      num_triplets = 0
      (
          num_correct_cos_triplets,
          num_correct_manhattan_triplets,
          num_correct_euclidean_triplets,
      ) = (0, 0, 0)
  
      embeddings_anchors = model.encode(
          self.anchors,
          batch_size=self.batch_size,
          show_progress_bar=self.show_progress_bar,
          convert_to_numpy=True,
      )
      embeddings_positives = model.encode(
          self.positives,
          batch_size=self.batch_size,
          show_progress_bar=self.show_progress_bar,
          convert_to_numpy=True,
      )
      embeddings_negatives = model.encode(
          self.negatives,
          batch_size=self.batch_size,
          show_progress_bar=self.show_progress_bar,
          convert_to_numpy=True,
      )
  
      # Cosine distance
      pos_cos_distance = paired_cosine_distances(
          embeddings_anchors, embeddings_positives
      )
      neg_cos_distances = paired_cosine_distances(
          embeddings_anchors, embeddings_negatives
      )
  
      # Manhattan
      pos_manhattan_distance = paired_manhattan_distances(
          embeddings_anchors, embeddings_positives
      )
      neg_manhattan_distances = paired_manhattan_distances(
          embeddings_anchors, embeddings_negatives
      )
  
      # Euclidean
      pos_euclidean_distance = paired_euclidean_distances(
          embeddings_anchors, embeddings_positives
      )
      neg_euclidean_distances = paired_euclidean_distances(
          embeddings_anchors, embeddings_negatives
      )
  
      for idx in range(len(pos_cos_distance)):
          num_triplets += 1
  
          if pos_cos_distance[idx] < neg_cos_distances[idx]:
              num_correct_cos_triplets += 1
  
          if pos_manhattan_distance[idx] < neg_manhattan_distances[idx]:
              num_correct_manhattan_triplets += 1
  
          if pos_euclidean_distance[idx] < neg_euclidean_distances[idx]:
              num_correct_euclidean_triplets += 1
  
      accuracy_cos = num_correct_cos_triplets / num_triplets
      accuracy_manhattan = num_correct_manhattan_triplets / num_triplets
      accuracy_euclidean = num_correct_euclidean_triplets / num_triplets
  
      logger.info(
          "Accuracy Cosine Distance:   \t{:.2f}".format(
              accuracy_cos * 100
          )
      )
      logger.info(
          "Accuracy Manhattan Distance:\t{:.2f}".format(
              accuracy_manhattan * 100
          )
      )
      logger.info(
          "Accuracy Euclidean Distance:\t{:.2f}\n".format(
              accuracy_euclidean * 100
          )
      )
  
      if output_path is not None and self.write_csv:
          csv_path = os.path.join(output_path, self.csv_file)
          if not os.path.isfile(csv_path):
              with open(
                  csv_path, newline="", mode="w", encoding="utf-8"
              ) as f:
                  writer = csv.writer(f)
                  writer.writerow(self.csv_headers)
                  writer.writerow(
                      [
                          epoch,
                          steps,
                          accuracy_cos,
                          accuracy_manhattan,
                          accuracy_euclidean,
                      ]
                  )
  
          else:
              with open(
                  csv_path, newline="", mode="a", encoding="utf-8"
              ) as f:
                  writer = csv.writer(f)
                  writer.writerow(
                      [
                          epoch,
                          steps,
                          accuracy_cos,
                          accuracy_manhattan,
                          accuracy_euclidean,
                      ]
                  )
  
      if self.main_distance_function == SimilarityFunction.COSINE:
          return accuracy_cos
      if self.main_distance_function == SimilarityFunction.MANHATTAN:
          return accuracy_manhattan
      if self.main_distance_function == SimilarityFunction.EUCLIDEAN:
          return accuracy_euclidean
  
      return max(accuracy_cos, accuracy_manhattan, accuracy_euclidean)
  
file_path: sentence-transformers/sentence_transformers/evaluation/TripletEvaluator.py
imports: from .None import SentenceEvaluator, SimilarityFunction
  import logging
  import os
  import csv
  from sklearn.metrics.pairwise import paired_cosine_distances, paired_euclidean_distances, paired_manhattan_distances
  from typing import List
  from ..readers import InputExample
label_desc: Use image node_id 3 for calling the TripletEvaluator obj's underlying member method code with example usage: obj.__call__(model, output_path, epoch, steps) and returns: max, accuracy_cos, accuracy_manhattan, accuracy_euclidean