code: def _build_metrics_set(
      self,
      metrics,
      num_outputs,
      output_names,
      y_true,
      y_pred,
      argument_name,
  ):
      flat_metrics = []
      if isinstance(metrics, dict):
          for name in metrics.keys():
              if name not in output_names:
                  raise ValueError(
                      f"In the dict argument `{argument_name}`, key "
                      f"'{name}' does not correspond to any model "
                      f"output. Received:\n{argument_name}={metrics}"
                  )
      if num_outputs == 1:
          if not metrics:
              flat_metrics.append(None)
          else:
              if isinstance(metrics, dict):
                  metrics = tree.flatten(metrics)
              if not isinstance(metrics, list):
                  metrics = [metrics]
              if not all(is_function_like(m) for m in metrics):
                  raise ValueError(
                      f"Expected all entries in the `{argument_name}` list "
                      f"to be metric objects. Received instead:\n"
                      f"{argument_name}={metrics}"
                  )
              flat_metrics.append(
                  MetricsList(
                      [
                          get_metric(m, y_true[0], y_pred[0])
                          for m in metrics
                          if m is not None
                      ]
                  )
              )
      else:
          if isinstance(metrics, (list, tuple)):
              if len(metrics) != len(y_pred):
                  raise ValueError(
                      "For a model with multiple outputs, "
                      f"when providing the `{argument_name}` argument as a "
                      "list, it should have as many entries as the model has "
                      f"outputs. Received:\n{argument_name}={metrics}\nof "
                      f"length {len(metrics)} whereas the model has "
                      f"{len(y_pred)} outputs."
                  )
              for idx, (mls, yt, yp) in enumerate(
                  zip(metrics, y_true, y_pred)
              ):
                  if not isinstance(mls, list):
                      mls = [mls]
                  name = output_names[idx] if output_names else None
                  if not all(is_function_like(e) for e in mls):
                      raise ValueError(
                          f"All entries in the sublists of the "
                          f"`{argument_name}` list should be metric objects. "
                          f"Found the following sublist with unknown "
                          f"types: {mls}"
                      )
                  flat_metrics.append(
                      MetricsList(
                          [
                              get_metric(m, yt, yp)
                              for m in mls
                              if m is not None
                          ],
                          output_name=name,
                      )
                  )
          elif isinstance(metrics, dict):
              if output_names is None:
                  raise ValueError(
                      f"Argument `{argument_name}` can only be provided as a "
                      "dict when the model also returns a dict of outputs. "
                      f"Received {argument_name}={metrics}"
                  )
              for name in metrics.keys():
                  if not isinstance(metrics[name], list):
                      metrics[name] = [metrics[name]]
                  if not all(
                      is_function_like(e) for e in metrics[name]
                  ):
                      raise ValueError(
                          f"All entries in the sublists of the "
                          f"`{argument_name}` dict should be metric objects. "
                          f"At key '{name}', found the following sublist "
                          f"with unknown types: {metrics[name]}"
                      )
              for name, yt, yp in zip(output_names, y_true, y_pred):
                  if name in metrics:
                      flat_metrics.append(
                          MetricsList(
                              [
                                  get_metric(m, yt, yp)
                                  for m in metrics[name]
                                  if m is not None
                              ],
                              output_name=name,
                          )
                      )
                  else:
                      flat_metrics.append(None)
      return flat_metrics
  
imports: import tree
  from keras import backend
  from keras import losses
  from keras import metrics
  from keras import ops
  from keras.utils.naming import get_object_name
label_desc: Use image node_id 5 for calling the CompileMetrics obj's underlying member method code with example usage: obj._build_metrics_set(metrics, num_outputs, output_names, y_true, y_pred, argument_name) and returns: flat_metrics