code: def cosine_similarity(
      segmented_topics,
      accumulator,
      topics,
      measure="nlr",
      gamma=1,
      with_std=False,
      with_support=False,
  ):
      """Calculate the indirect cosine measure.
  
      Parameters
      ----------
      segmented_topics: list of lists of (int, `numpy.ndarray`)
          Output from the segmentation module of the segmented topics.
      accumulator: :class:`~gensim.topic_coherence.text_analysis.InvertedIndexAccumulator`
          Output from the probability_estimation module. Is an topics: Topics obtained from the trained topic model.
      measure : str, optional
          Direct confirmation measure to be used. Supported values are "nlr" (normalized log ratio).
      gamma: float, optional
          Gamma value for computing :math:`W'` and :math:`W^{*}` vectors.
      with_std : bool
          True to also include standard deviation across topic segment sets in addition to the mean coherence
          for each topic; default is False.
      with_support : bool
          True to also include support across topic segments. The support is defined as the number of pairwise similarity
          comparisons were used to compute the overall topic coherence.
  
      Returns
      -------
      list
          List of indirect cosine similarity measure for each topic.
  
      Examples
      --------
      .. sourcecode:: pycon
  
          >>> from gensim.corpora.dictionary import Dictionary
          >>> from gensim.topic_coherence import indirect_confirmation_measure, text_analysis
          >>> import numpy as np
          >>>
          >>> # create accumulator
          >>> dictionary = Dictionary()
          >>> dictionary.id2token = {1: 'fake', 2: 'tokens'}
          >>> accumulator = text_analysis.InvertedIndexAccumulator({1, 2}, dictionary)
          >>> accumulator._inverted_index = {0: {2, 3, 4}, 1: {3, 5}}
          >>> accumulator._num_docs = 5
          >>>
          >>> # create topics
          >>> topics = [np.array([1, 2])]
          >>>
          >>> # create segmentation
          >>> segmentation = [[(1, np.array([1, 2])), (2, np.array([1, 2]))]]
          >>> obtained = indirect_confirmation_measure.cosine_similarity(segmentation, accumulator, topics, 'nlr', 1)
          >>> print(obtained[0])
          0.623018926945
  
      """
      context_vectors = ContextVectorComputer(
          measure, topics, accumulator, gamma
      )
  
      topic_coherences = []
      for topic_words, topic_segments in zip(topics, segmented_topics):
          topic_words = tuple(
              topic_words
          )  # because tuples are hashable
          segment_sims = np.zeros(len(topic_segments))
          for i, (w_prime, w_star) in enumerate(topic_segments):
              w_prime_cv = context_vectors[w_prime, topic_words]
              w_star_cv = context_vectors[w_star, topic_words]
              segment_sims[i] = _cossim(w_prime_cv, w_star_cv)
  
          topic_coherences.append(
              aggregate_segment_sims(
                  segment_sims, with_std, with_support
              )
          )
  
      return topic_coherences
  
file_path: gensim/gensim/topic_coherence/indirect_confirmation_measure.py
imports: import itertools
  import logging
  import numpy
  import scipy.sparse
  from gensim.topic_coherence.direct_confirmation_measure import aggregate_segment_sims, log_ratio_measure
label_desc: Use image node_id 2 for calling a global function with example usage: cosine_similarity(segmented_topics, accumulator, topics, measure, gamma, with_std, with_support) and returns: topic_coherences