code: def classification_report_imbalanced(
      y_true,
      y_pred,
      *,
      labels=None,
      target_names=None,
      sample_weight=None,
      digits=2,
      alpha=0.1,
      output_dict=False,
      zero_division="warn",
  ):
      """Build a classification report based on metrics used with imbalanced dataset.
  
      Specific metrics have been proposed to evaluate the classification
      performed on imbalanced dataset. This report compiles the
      state-of-the-art metrics: precision/recall/specificity, geometric
      mean, and index balanced accuracy of the
      geometric mean.
  
      Read more in the :ref:`User Guide <classification_report>`.
  
      Parameters
      ----------
      y_true : 1d array-like, or label indicator array / sparse matrix
          Ground truth (correct) target values.
  
      y_pred : 1d array-like, or label indicator array / sparse matrix
          Estimated targets as returned by a classifier.
  
      labels : array-like of shape (n_labels,), default=None
          Optional list of label indices to include in the report.
  
      target_names : list of str of shape (n_labels,), default=None
          Optional display names matching the labels (same order).
  
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
  
      digits : int, default=2
          Number of digits for formatting output floating point values.
          When ``output_dict`` is ``True``, this will be ignored and the
          returned values will not be rounded.
  
      alpha : float, default=0.1
          Weighting factor.
  
      output_dict : bool, default=False
          If True, return output as dict.
  
          .. versionadded:: 0.8
  
      zero_division : "warn" or {0, 1}, default="warn"
          Sets the value to return when there is a zero division. If set to
          "warn", this acts as 0, but warnings are also raised.
  
          .. versionadded:: 0.8
  
      Returns
      -------
      report : string / dict
          Text summary of the precision, recall, specificity, geometric mean,
          and index balanced accuracy.
          Dictionary returned if output_dict is True. Dictionary has the
          following structure::
  
              {'label 1': {'pre':0.5,
                           'rec':1.0,
                           ...
                          },
               'label 2': { ... },
                ...
              }
  
      Examples
      --------
      >>> import numpy as np
      >>> from imblearn.metrics import classification_report_imbalanced
      >>> y_true = [0, 1, 2, 2, 2]
      >>> y_pred = [0, 0, 2, 2, 1]
      >>> target_names = ['class 0', 'class 1', 'class 2']
      >>> print(classification_report_imbalanced(y_true, y_pred, \
      target_names=target_names))
                         pre       rec       spe        f1       geo       iba\
         sup
      <BLANKLINE>
          class 0       0.50      1.00      0.75      0.67      0.87      0.77\
           1
          class 1       0.00      0.00      0.75      0.00      0.00      0.00\
           1
          class 2       1.00      0.67      1.00      0.80      0.82      0.64\
           3
      <BLANKLINE>
      avg / total       0.70      0.60      0.90      0.61      0.66      0.54\
           5
      <BLANKLINE>
      """
  
      if labels is None:
          labels = unique_labels(y_true, y_pred)
      else:
          labels = np.asarray(labels)
  
      last_line_heading = "avg / total"
  
      if target_names is None:
          target_names = [f"{label}" for label in labels]
      name_width = max(len(cn) for cn in target_names)
      width = max(name_width, len(last_line_heading), digits)
  
      headers = ["pre", "rec", "spe", "f1", "geo", "iba", "sup"]
      fmt = "%% %ds" % width  # first column: class name
      fmt += "  "
      fmt += " ".join(["% 9s" for _ in headers])
      fmt += "\n"
  
      headers = [""] + headers
      report = fmt % tuple(headers)
      report += "\n"
  
      # Compute the different metrics
      # Precision/recall/f1
      precision, recall, f1, support = precision_recall_fscore_support(
          y_true,
          y_pred,
          labels=labels,
          average=None,
          sample_weight=sample_weight,
          zero_division=zero_division,
      )
      # Specificity
      specificity = specificity_score(
          y_true,
          y_pred,
          labels=labels,
          average=None,
          sample_weight=sample_weight,
      )
      # Geometric mean
      geo_mean = geometric_mean_score(
          y_true,
          y_pred,
          labels=labels,
          average=None,
          sample_weight=sample_weight,
      )
      # Index balanced accuracy
      iba_gmean = make_index_balanced_accuracy(
          alpha=alpha, squared=True
      )(geometric_mean_score)
      iba = iba_gmean(
          y_true,
          y_pred,
          labels=labels,
          average=None,
          sample_weight=sample_weight,
      )
  
      report_dict = {}
      for i, label in enumerate(labels):
          report_dict_label = {}
          values = [target_names[i]]
          for score_name, score_value in zip(
              headers[1:-1],
              [
                  precision[i],
                  recall[i],
                  specificity[i],
                  f1[i],
                  geo_mean[i],
                  iba[i],
              ],
          ):
              values += ["{0:0.{1}f}".format(score_value, digits)]
              report_dict_label[score_name] = score_value
          values += [f"{support[i]}"]
          report_dict_label[headers[-1]] = support[i]
          report += fmt % tuple(values)
  
          report_dict[target_names[i]] = report_dict_label
  
      report += "\n"
  
      # compute averages
      values = [last_line_heading]
      for score_name, score_value in zip(
          headers[1:-1],
          [
              np.average(precision, weights=support),
              np.average(recall, weights=support),
              np.average(specificity, weights=support),
              np.average(f1, weights=support),
              np.average(geo_mean, weights=support),
              np.average(iba, weights=support),
          ],
      ):
          values += ["{0:0.{1}f}".format(score_value, digits)]
          report_dict[f"avg_{score_name}"] = score_value
      values += [f"{np.sum(support)}"]
      report += fmt % tuple(values)
      report_dict["total_support"] = np.sum(support)
  
      if output_dict:
          return report_dict
      return report
  
file_path: imbalanced-learn/imblearn/metrics/_classification.py
imports: import functools
  import numbers
  import warnings
  from inspect import signature
  import numpy
  import scipy
  from sklearn.metrics import mean_absolute_error, precision_recall_fscore_support
  from sklearn.metrics._classification import _check_targets, _prf_divide
  from sklearn.preprocessing import LabelEncoder
  from sklearn.utils.multiclass import unique_labels
  from sklearn.utils.validation import check_consistent_length, column_or_1d
  from ..utils._param_validation import Interval, StrOptions, validate_params
label_desc: Use image node_id 6 for calling a global function with example usage: classification_report_imbalanced(y_true, y_pred) and returns: report, report_dict