code: def main(cfg) -> None:
      logging.info(
          "\n\n************** Experiment configuration ***********"
      )
      logging.info(f"\n{OmegaConf.to_yaml(cfg)}")
  
      megatron_amp_O2 = cfg.model.get("megatron_amp_O2", False)
      plugins = []
      strategy = NLPDDPStrategy(
          no_ddp_communication_hook=True,
          gradient_as_bucket_view=cfg.model.gradient_as_bucket_view,
          find_unused_parameters=False,
      )
      if cfg.trainer.precision in [
          16,
          "16",
          "16-mixed",
          "bf16",
          "bf16-mixed",
      ]:
          scaler = None
          if cfg.trainer.precision in [16, "16", "16-mixed"]:
              scaler = GradScaler(
                  init_scale=cfg.model.get(
                      "native_amp_init_scale", 2**32
                  ),
                  growth_interval=cfg.model.get(
                      "native_amp_growth_interval", 1000
                  ),
                  hysteresis=cfg.model.get("hysteresis", 2),
              )
              # MixedPrecisionPlugin in PTL >= 2.0 requires precision to be 16-mixed or bf16-mixed
              plugin_precision = "16-mixed"
          else:
              plugin_precision = "bf16-mixed"
          if megatron_amp_O2:
              plugins.append(
                  MegatronHalfPrecisionPlugin(
                      precision=plugin_precision,
                      device="cuda",
                      scaler=scaler,
                  )
              )
          else:
              plugins.append(
                  MixedPrecisionPlugin(
                      precision=plugin_precision,
                      device="cuda",
                      scaler=scaler,
                  )
              )
  
      if cfg.get("cluster_type", None) == "BCP":
          plugins.append(TorchElasticEnvironment())
  
      trainer = Trainer(
          plugins=plugins, strategy=strategy, **cfg.trainer
      )
  
      exp_manager(trainer, cfg.exp_manager)
  
      if hasattr(cfg.model.data.validation_ds, "task_name"):
          if cfg.model.restore_from_path:
              t5_cfg = MegatronT5GLUEModel.restore_from(
                  restore_path=cfg.model.restore_from_path,
                  trainer=trainer,
                  return_config=True,
              )
              model = load_from_nemo(
                  MegatronT5GLUEModel,
                  cfg,
                  trainer,
                  t5_cfg,
                  modify_confg_fn=_modify_config,
              )
          else:
              validate_checkpoint_loading_args(
                  cfg.model.pretrained_checkpoint
              )
              model = load_from_checkpoint_dir(
                  MegatronT5GLUEModel,
                  cfg,
                  trainer,
                  modify_confg_fn=_modify_config,
              )
      elif hasattr(cfg.model.data.validation_ds, "file_names"):
          if cfg.model.restore_from_path:
              t5_cfg = MegatronT0Model.restore_from(
                  restore_path=cfg.model.restore_from_path,
                  trainer=trainer,
                  return_config=True,
              )
              model = load_from_nemo(
                  MegatronT0Model,
                  cfg,
                  trainer,
                  t5_cfg,
                  modify_confg_fn=_modify_config,
              )
          else:
              validate_checkpoint_loading_args(
                  cfg.model.pretrained_checkpoint
              )
              model = load_from_checkpoint_dir(
                  MegatronT0Model,
                  cfg,
                  trainer,
                  modify_confg_fn=_modify_config,
              )
      else:
          if cfg.model.restore_from_path:
              t5_cfg = MegatronT5SFTModel.restore_from(
                  restore_path=cfg.model.restore_from_path,
                  trainer=trainer,
                  return_config=True,
              )
              model = load_from_nemo(
                  MegatronT5SFTModel,
                  cfg,
                  trainer,
                  t5_cfg,
                  modify_confg_fn=_modify_config,
              )
          else:
              validate_checkpoint_loading_args(
                  cfg.model.pretrained_checkpoint
              )
              model = load_from_checkpoint_dir(
                  MegatronT5SFTModel,
                  cfg,
                  trainer,
                  modify_confg_fn=_modify_config,
              )
  
      model.freeze()
      trainer.validate(model)
      if hasattr(cfg.model.data, "test_ds"):
          trainer.test(model)
  
file_path: NeMo/examples/nlp/language_modeling/megatron_t5_seq2seq_eval.py
imports: from megatron_t5_seq2seq_finetune import load_from_checkpoint_dir, load_from_nemo, validate_checkpoint_loading_args
  from omegaconf.omegaconf import OmegaConf, open_dict
  from pytorch_lightning import Trainer
  from pytorch_lightning.plugins.environments import TorchElasticEnvironment
  from pytorch_lightning.plugins.precision import MixedPrecisionPlugin
  from nemo.collections.nlp.models.language_modeling.megatron_glue_model import MegatronT5GLUEModel
  from nemo.collections.nlp.models.language_modeling.megatron_t0_model import MegatronT0Model
  from nemo.collections.nlp.models.language_modeling.megatron_t5_sft_model import MegatronT5SFTModel
  from nemo.collections.nlp.parts.nlp_overrides import GradScaler, MegatronHalfPrecisionPlugin, NLPDDPStrategy
  from nemo.core.config import hydra_runner
  from nemo.utils import logging
  from nemo.utils.exp_manager import exp_manager
label_desc: Use image node_id 2 for calling a global function with example usage: main(cfg) without return types