class_docstr: Normalized Mutual Information between two clusterings.
  
  Normalized Mutual Information (NMI) is a normalized version of the Mutual Information (MI) score
  to scale the results between the range of 0 (no mutual information) and 1 (perfectly mutual
  information). In the formula, the mutual information will be normalized by a generalized mean of
  the entropy of true and predicted labels, defined by the `average_method`.
  
  We note that this measure is not adjusted for chance (i.e corrected the effect of result
  agreement solely due to chance); as a result, the Adjusted Mutual Info Score will mostly be preferred.
  However, this metric is still symmetric, which means that switching true and predicted labels will not
  alter the score value. This fact can be useful when the metric is used to measure the agreement between
  two indepedent label solutions on the same dataset, when the ground truth remains unknown.
  
  Another advantage of the metric is that as it is based on the calculation of entropy-related measures,
  it is independent of the permutation of class/cluster labels.
  
  Parameters
  ----------
  cm
      This parameter allows sharing the same confusion
      matrix between multiple metrics. Sharing a confusion matrix reduces the amount of storage
      and computation time.
  
  average_method
      This parameter defines how to compute the normalizer in the denominator.
      Possible options include `min`, `max`, `arithmetic` and `geometric`.
  
  Examples
  --------
  
  >>> from river import metrics
  
  >>> y_true = [1, 1, 2, 2, 3, 3]
  >>> y_pred = [1, 1, 1, 2, 2, 2]
  
  >>> metric = metrics.NormalizedMutualInfo()
  >>> for yt, yp in zip(y_true, y_pred):
  ...     metric.update(yt, yp)
  ...     print(metric.get())
  1.0
  1.0
  0.0
  0.343711
  0.458065
  0.515803
  
  >>> metric
  NormalizedMutualInfo: 0.515804
  
  References
  ----------
  [^1]: Wikipedia contributors. (2021, March 17). Mutual information.
        In Wikipedia, The Free Encyclopedia,
        from https://en.wikipedia.org/w/index.php?title=Mutual_information&oldid=1012714929
code: def get(self):
      n_classes = len([i for i in self.cm.sum_row.values() if i != 0])
      n_clusters = len([i for i in self.cm.sum_col.values() if i != 0])
  
      if (n_classes == n_clusters == 1) or (
          n_classes == n_clusters == 0
      ):
          return 1.0
  
      mutual_info_score = metrics.MutualInfo(self.cm).get()
  
      entropy_true = _entropy(cm=self.cm, y_true=True)
      entropy_pred = _entropy(cm=self.cm, y_true=False)
  
      normalizer = self._generalized_average(entropy_true, entropy_pred)
  
      normalizer = max(normalizer, np.finfo("float64").eps)
  
      return mutual_info_score / normalizer
  
imports: from __future__ import annotations
  import math
  import numpy
  from river import metrics
  from river.metrics.expected_mutual_info import expected_mutual_info
label_desc: Use image node_id 3 for calling the NormalizedMutualInfo obj's underlying member method code with example usage: obj.get() and returns: unknown, int