code: def train_eval_mtl(self, model):
      args = self.args
  
      loss_weights = get_mtl_loss_weights(args, self.targets)
  
      metrics = self.get_metrics()
      model.compile(
          self.get_optimizer(),
          run_eagerly=False,
          metrics=metrics,
          loss_weights=loss_weights,
      )
      callbacks = self.get_callbacks(self.args)
  
      eval_metrics = None
  
      if self.train_loader:
          logging.info("Starting to train the model (fit())")
          fit_kwargs = {}
          # if self.eval_loader:
          #     fit_kwargs = {
          #         "validation_data": self.eval_loader,
          #         "validation_steps": self.args.validation_steps,
          #     }
  
          model.fit(
              self.train_loader,
              epochs=args.epochs,
              batch_size=args.train_batch_size,
              steps_per_epoch=args.train_steps_per_epoch,
              drop_last=True,
              callbacks=callbacks,
              train_metrics_steps=args.train_metrics_steps,
              **fit_kwargs,
          )
  
      if self.eval_loader:
          logging.info("Starting the evaluation the model (evaluate())")
  
          eval_metrics = model.evaluate(
              self.eval_loader,
              batch_size=args.eval_batch_size,
              return_dict=True,
              callbacks=callbacks,
          )
  
          auc_metric_results = {
              k.split("/")[0]: v
              for k, v in eval_metrics.items()
              if "binary_output/auc" in k
          }
  
          auc_metric_results = {
              f"{k}-auc": v for k, v in auc_metric_results.items()
          }
  
          avg_metrics = {
              "auc_avg": np.mean(list(auc_metric_results.values())),
          }
  
          all_metrics = {
              **avg_metrics,
              **auc_metric_results,
              **eval_metrics,
          }
  
          logging.info(f"EVALUATION METRICS: {all_metrics}")
  
          # log final metrics
          self.log_final_metrics(all_metrics)
  
      if self.predict_loader:
          logging.info("Starting to save predictions")
          self.save_predictions(model, self.predict_loader.dataset)
  
      return eval_metrics
  
imports: import json
  import logging
  import os
  from datetime import datetime
  import merlin.models.tf
  import numpy
  import tensorflow
  from merlin.io.dataset import Dataset
  from merlin.models.tf.logging.callbacks import ExamplesPerSecondCallback, WandbLogger
  from merlin.models.tf.transforms.negative_sampling import InBatchNegatives
  from merlin.schema.tags import Tags
  from .args_parsing import Task, parse_arguments
  from .mtl import get_mtl_loss_weights, get_mtl_prediction_tasks
  from .ranking_models import get_model
label_desc: Use image node_id 12 for calling the RankingTrainEvalRunner obj's underlying member method code with example usage: obj.train_eval_mtl(model) and returns: eval_metrics