code: def classification_report(
      y_true, y_pred, digits=2, suffix=False, output_dict=False
  ):
      """Build a text report showing the main classification metrics.
  
      Args:
          y_true : 2d array. Ground truth (correct) target values.
          y_pred : 2d array. Estimated targets as returned by a classifier.
          digits : int. Number of digits for formatting output floating point values.
          output_dict : bool(default=False). If True, return output as dict else str.
  
      Returns:
          report : string/dict. Summary of the precision, recall, F1 score for each class.
  
      Examples:
          >>> from seqeval.metrics import classification_report
          >>> y_true = [['O', 'O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
          >>> y_pred = [['O', 'O', 'B-MISC', 'I-MISC', 'I-MISC', 'I-MISC', 'O'], ['B-PER', 'I-PER', 'O']]
          >>> print(classification_report(y_true, y_pred))
                       precision    recall  f1-score   support
          <BLANKLINE>
                 MISC       0.00      0.00      0.00         1
                  PER       1.00      1.00      1.00         1
          <BLANKLINE>
            micro avg       0.50      0.50      0.50         2
            macro avg       0.50      0.50      0.50         2
         weighted avg       0.50      0.50      0.50         2
          <BLANKLINE>
      """
      true_entities = set(get_entities(y_true, suffix))
      pred_entities = set(get_entities(y_pred, suffix))
  
      name_width = 0
      d1 = defaultdict(set)
      d2 = defaultdict(set)
      for e in true_entities:
          d1[e[0]].add((e[1], e[2]))
          name_width = max(name_width, len(e[0]))
      for e in pred_entities:
          d2[e[0]].add((e[1], e[2]))
  
      avg_types = ["micro avg", "macro avg", "weighted avg"]
  
      if output_dict:
          report_dict = dict()
      else:
          avg_width = max([len(x) for x in avg_types])
          width = max(name_width, avg_width, digits)
          headers = ["precision", "recall", "f1-score", "support"]
          head_fmt = "{:>{width}s} " + " {:>9}" * len(headers)
          report = head_fmt.format("", *headers, width=width)
          report += "\n\n"
  
          row_fmt = (
              "{:>{width}s} " + " {:>9.{digits}f}" * 3 + " {:>9}\n"
          )
  
      ps, rs, f1s, s = [], [], [], []
      for type_name in sorted(d1.keys()):
          true_entities = d1[type_name]
          pred_entities = d2[type_name]
          nb_correct = len(true_entities & pred_entities)
          nb_pred = len(pred_entities)
          nb_true = len(true_entities)
  
          p = nb_correct / nb_pred if nb_pred > 0 else 0
          r = nb_correct / nb_true if nb_true > 0 else 0
          f1 = 2 * p * r / (p + r) if p + r > 0 else 0
  
          if output_dict:
              report_dict[type_name] = {
                  "precision": p,
                  "recall": r,
                  "f1-score": f1,
                  "support": nb_true,
              }
          else:
              report += row_fmt.format(
                  *[type_name, p, r, f1, nb_true],
                  width=width,
                  digits=digits,
              )
  
          ps.append(p)
          rs.append(r)
          f1s.append(f1)
          s.append(nb_true)
  
      if not output_dict:
          report += "\n"
  
      # compute averages
      nb_true = np.sum(s)
  
      for avg_type in avg_types:
          if avg_type == "micro avg":
              # micro average
              p = precision_score(y_true, y_pred, suffix=suffix)
              r = recall_score(y_true, y_pred, suffix=suffix)
              f1 = f1_score(y_true, y_pred, suffix=suffix)
          elif avg_type == "macro avg":
              # macro average
              p = np.average(ps)
              r = np.average(rs)
              f1 = np.average(f1s)
          elif avg_type == "weighted avg":
              # weighted average
              p = np.average(ps, weights=s)
              r = np.average(rs, weights=s)
              f1 = np.average(f1s, weights=s)
          else:
              assert False, "unexpected average: {}".format(avg_type)
  
          if output_dict:
              report_dict[avg_type] = {
                  "precision": p,
                  "recall": r,
                  "f1-score": f1,
                  "support": nb_true,
              }
          else:
              report += row_fmt.format(
                  *[avg_type, p, r, f1, nb_true],
                  width=width,
                  digits=digits,
              )
  
      if output_dict:
          return report_dict
      else:
          return report
  
file_path: ktrain/ktrain/text/ner/metrics.py
imports: from __future__ import absolute_import, division, print_function
  import warnings
  from collections import defaultdict
  import numpy
label_desc: Use image node_id 9 for calling a global function with example usage: classification_report(y_true, y_pred, digits, suffix, output_dict) and returns: report_dict, report