code: def create_evaluation_metrics(problems, model_hparams):
      """Creates the evaluation metrics for the model.
  
      Args:
        problems: List of Problem instances.
        model_hparams: a set of hparams.
  
      Returns:
        dict<metric name, metric function>. The metric functions have signature
        (Tensor predictions, features) -> (metric Tensor, update op), where features
        is a dict with keys {targets}.
  
      Raises:
        ValueError: if the metrics specified by a problem are not recognized (i.e.
          are not defined in the Metrics enum.
      """
  
      def reduce_dimensions(predictions, labels):
          """Reduce dimensions for high-dimensional predictions and labels."""
          # We will treat first dimensions as batch. One example are video frames.
          if len(predictions.get_shape()) > 5:
              predictions_shape = common_layers.shape_list(predictions)
              predictions = tf.reshape(
                  predictions,
                  [
                      predictions_shape[0],
                      predictions_shape[1],
                      -1,
                      predictions_shape[-1],
                  ],
              )
              labels_shape = common_layers.shape_list(labels)
              labels = tf.reshape(
                  labels, [labels_shape[0], labels_shape[1], -1]
              )
          return predictions, labels
  
      def make_problem_specific_metric_fn(metric_fn, weights_fn):
          """Create a metric fn."""
  
          def problem_metric_fn(predictions, features, labels):
              """Metric fn."""
              # Send along the entire features dict if the metric fn has the kwarg
              # "features".
              kwargs = {}
              args, _, keywords, _ = inspect.getargspec(metric_fn)
              if ("features" in args) or keywords:
                  kwargs["features"] = features
  
              predictions, labels = reduce_dimensions(
                  predictions, labels
              )
  
              scores, weights = metric_fn(
                  predictions, labels, weights_fn=weights_fn, **kwargs
              )
              return tf.metrics.mean(scores, weights)
  
          return problem_metric_fn
  
      def make_image_wrapped_metric_fn(metric_fn):
          """Metric fn without tf.metrics.mean."""
  
          def image_wrapped_metric_fn(
              predictions,
              features,
              labels,
              weights_fn=common_layers.weights_all,
          ):
              del weights_fn
              del features
              predictions, labels = reduce_dimensions(
                  predictions, labels
              )
              return metric_fn(predictions, labels, model_hparams)
  
          return image_wrapped_metric_fn
  
      def weights_fn_for_mp(problem_task_id):
          return lambda x: common_layers.weights_multi_problem(
              x, problem_task_id
          )
  
      eval_metrics = {}
      for problem_instance in problems:
          problem_name = problem_instance.name
          if problem_instance.was_reversed:
              problem_name += "_rev"
          metrics = problem_instance.eval_metric_fns(model_hparams)
          if hasattr(model_hparams.problem, "task_list"):
              metrics = model_hparams.problem.eval_metric_fns(
                  model_hparams
              )
  
          tm = problem_instance.get_hparams(model_hparams).modality[
              "targets"
          ]
          if not isinstance(tm, dict):
              tm = {"targets": tm}
  
          for target_name, modality in six.iteritems(tm):
              weights_fn = model_hparams.weights_fn.get(
                  "targets", modalities.get_weights_fn(modality)
              )
              if hasattr(model_hparams.problem, "task_list"):
                  ptid = (
                      problem_instance.task_id
                  )  # pylint: disable=cell-var-from-loop
                  weights_fn = weights_fn_for_mp(ptid)
  
              for metric, metric_fn in six.iteritems(metrics):
                  overload_eval_metric_name = getattr(
                      model_hparams, "overload_eval_metric_name", None
                  )
                  if len(problems) == 1 and overload_eval_metric_name:
                      metric_name = "metrics-%s/%s/%s" % (
                          overload_eval_metric_name,
                          target_name,
                          metric,
                      )
                  else:
                      metric_name = "metrics-%s/%s/%s" % (
                          problem_name,
                          target_name,
                          metric,
                      )
                  if metric == Metrics.IMAGE_SUMMARY:
                      eval_metrics[
                          metric_name
                      ] = make_image_wrapped_metric_fn(metric_fn)
                  else:
                      eval_metrics[
                          metric_name
                      ] = make_problem_specific_metric_fn(
                          metric_fn, weights_fn
                      )
  
      return eval_metrics
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import numpy
  import six
  from tensor2tensor.layers import common_layers
  from tensor2tensor.layers import modalities
  from tensor2tensor.utils import bleu_hook
  from tensor2tensor.utils import contrib
  from tensor2tensor.utils import rouge
  from tensor2tensor.utils import sari_hook
  import tensorflow.compat.v1
  from tensorflow.python.util import tf_inspect
label_desc: Use image node_id 32 for calling a global function with example usage: create_evaluation_metrics(problems, model_hparams) and returns: eval_metrics, predictions,  labels, problem_metric_fn, image_wrapped_metric_fn, function, tf, metric_fn