code: def get_accuracy(
      self,
      query,
      query_labels,
      reference=None,
      reference_labels=None,
      ref_includes_query=False,
      include=(),
      exclude=(),
  ):
      if reference is None:
          reference = query
          reference_labels = query_labels
          ref_includes_query = True
  
      [query, reference, query_labels, reference_labels] = [
          c_f.numpy_to_torch(x).to(self.device).type(torch.float)
          for x in [query, reference, query_labels, reference_labels]
      ]
  
      if len(query) != len(query_labels) or len(reference) != len(
          reference_labels
      ):
          raise ValueError(
              "embeddings and labels must have the same length"
          )
  
      if ref_includes_query and not (
          torch.allclose(query, reference[: len(query)])
          and torch.allclose(
              query_labels, reference_labels[: len(query)]
          )
      ):
          raise ValueError(
              "When ref_includes_query is True, the first len(query) elements of reference must be equal to query.\n"
              "Likewise, the first len(query_labels) elements of reference_labels must be equal to query_labels.\n"
          )
  
      self.curr_function_dict = self.get_function_dict(include, exclude)
  
      kwargs = {
          "query": query,
          "reference": reference,
          "query_labels": query_labels,
          "reference_labels": reference_labels,
          "ref_includes_query": ref_includes_query,
          "label_comparison_fn": self.label_comparison_fn,
      }
  
      if any(x in self.requires_knn() for x in self.get_curr_metrics()):
          label_counts = get_label_match_counts(
              query_labels, reference_labels, self.label_comparison_fn
          )
          (
              lone_query_labels,
              not_lone_query_mask,
          ) = get_lone_query_labels(
              query_labels,
              label_counts,
              ref_includes_query,
              self.label_comparison_fn,
          )
  
          num_k = self.determine_k(
              label_counts[1], len(reference), ref_includes_query
          )
  
          knn_distances, knn_indices = self.knn_func(
              query, num_k, reference, ref_includes_query
          )
  
          knn_labels = reference_labels[knn_indices]
          if not any(not_lone_query_mask):
              c_f.LOGGER.warning(
                  "None of the query labels are in the reference set."
              )
          kwargs["label_counts"] = label_counts
          kwargs["knn_labels"] = knn_labels
          kwargs["knn_distances"] = knn_distances
          kwargs["lone_query_labels"] = lone_query_labels
          kwargs["not_lone_query_mask"] = not_lone_query_mask
  
      if any(
          x in self.requires_clustering()
          for x in self.get_curr_metrics()
      ):
          kwargs["cluster_labels"] = self.get_cluster_labels(**kwargs)
  
      return self._get_accuracy(self.curr_function_dict, **kwargs)
  
imports: import torch
  from sklearn.metrics import adjusted_mutual_info_score, normalized_mutual_info_score
  from .None import common_functions
  from .inference import FaissKMeans, FaissKNN
label_desc: Use image node_id 14 for calling the AccuracyCalculator obj's underlying member method code with example usage: obj.get_accuracy(query, query_labels, reference, reference_labels, ref_includes_query, include, exclude) and returns: self