code: def compute_all_col_metrics(
      self, event_non_event_count_hist, columns
  ):
      event_non_event_count = event_non_event_count_hist.to_dict(
          columns
      )[0]
      non_event_count_dict = event_non_event_count.get(
          "non_event_count"
      )
      event_count_dict = event_non_event_count.get("event_count")
  
      event_count, non_event_count = {}, {}
      event_rate, non_event_rate = {}, {}
      bin_woe, bin_iv, is_monotonic, iv = {}, {}, {}, {}
      total_event_count, total_non_event_count = None, None
      for col_name in event_count_dict.keys():
          col_event_count = pd.Series(
              {
                  bin_num: int(bin_count.data)
                  for bin_num, bin_count in event_count_dict[
                      col_name
                  ].items()
              }
          )
          col_non_event_count = pd.Series(
              {
                  bin_num: int(bin_count.data)
                  for bin_num, bin_count in non_event_count_dict[
                      col_name
                  ].items()
              }
          )
          if total_event_count is None:
              total_event_count = col_event_count.sum() or 1
              total_non_event_count = col_non_event_count.sum() or 1
          col_event_rate = (
              (col_event_count == 0) * self.adjustment_factor
              + col_event_count / total_event_count
          )
          col_non_event_rate = (
              (col_non_event_count == 0) * self.adjustment_factor
              + col_non_event_count / total_non_event_count
          )
          col_rate_ratio = col_event_rate / col_non_event_rate
          col_bin_woe = col_rate_ratio.apply(lambda v: np.log(v))
          col_bin_iv = (
              col_event_rate - col_non_event_rate
          ) * col_bin_woe
  
          event_count[col_name] = col_event_count.to_dict()
          non_event_count[col_name] = col_non_event_count.to_dict()
          event_rate[col_name] = col_event_rate.to_dict()
          non_event_rate[col_name] = col_non_event_rate.to_dict()
          bin_woe[col_name] = col_bin_woe.to_dict()
          bin_iv[col_name] = col_bin_iv.to_dict()
          is_monotonic[col_name] = (
              col_bin_woe.is_monotonic_increasing
              or col_bin_woe.is_monotonic_decreasing
          )
          iv[col_name] = col_bin_iv[1:].sum()
  
      metrics_summary = {}
  
      metrics_summary["event_count"] = event_count
      metrics_summary["non_event_count"] = non_event_count
      metrics_summary["event_rate"] = event_rate
      metrics_summary["non_event_rate"] = non_event_rate
      metrics_summary["woe"] = bin_woe
      metrics_summary["iv_array"] = bin_iv
      metrics_summary["is_monotonic"] = is_monotonic
      metrics_summary["iv"] = iv
      return metrics_summary, bin_woe
  
imports: import logging
  import numpy
  import pandas
  from fate.arch import Context
  from fate.arch.histogram import HistogramBuilder
  from ..abc.module import HeteroModule, Module
label_desc: Use image node_id 5 for calling the StandardBinning obj's underlying member method code with example usage: obj.compute_all_col_metrics(event_non_event_count_hist, columns) and returns: metrics_summary,  bin_woe