code: def __init__(self, hparams, **kwargs):
      if hparams.sortish_sampler and hparams.gpus > 1:
          hparams.replace_sampler_ddp = False
      elif hparams.max_tokens_per_batch is not None:
          if hparams.gpus > 1:
              raise NotImplementedError(
                  "Dynamic Batch size does not work for multi-gpu training"
              )
          if hparams.sortish_sampler:
              raise ValueError(
                  "--sortish_sampler and --max_tokens_per_batch may not be used simultaneously"
              )
  
      super().__init__(
          hparams, num_labels=None, mode=self.mode, **kwargs
      )
      use_task_specific_params(self.model, "summarization")
      save_git_info(self.hparams.output_dir)
      self.metrics_save_path = Path(self.output_dir) / "metrics.json"
      self.hparams_save_path = Path(self.output_dir) / "hparams.pkl"
      pickle_save(self.hparams, self.hparams_save_path)
      self.step_count = 0
      self.metrics = defaultdict(list)
      self.model_type = self.config.model_type
      self.vocab_size = (
          self.config.tgt_vocab_size
          if self.model_type == "fsmt"
          else self.config.vocab_size
      )
  
      self.dataset_kwargs: dict = {
          "data_dir": self.hparams.data_dir,
          "max_source_length": self.hparams.max_source_length,
          "prefix": self.model.config.prefix or "",
      }
      n_observations_per_split = {
          "train": self.hparams.n_train,
          "val": self.hparams.n_val,
          "test": self.hparams.n_test,
      }
      self.n_obs = {
          k: v if v >= 0 else None
          for k, v in n_observations_per_split.items()
      }
  
      self.target_lens = {
          "train": self.hparams.max_target_length,
          "val": self.hparams.val_max_target_length,
          "test": self.hparams.test_max_target_length,
      }
      assert (
          self.target_lens["train"] <= self.target_lens["val"]
      ), f"target_lens: {self.target_lens}"
      assert (
          self.target_lens["train"] <= self.target_lens["test"]
      ), f"target_lens: {self.target_lens}"
      if self.hparams.freeze_embeds:
          freeze_embeds(self.model)
      if self.hparams.freeze_encoder:
          freeze_params(self.model.get_encoder())
          assert_all_frozen(self.model.get_encoder())
  
      self.hparams.git_sha = get_git_info()["repo_sha"]
      self.num_workers = hparams.num_workers
      self.decoder_start_token_id = None  # default to config
      if (
          self.model.config.decoder_start_token_id is None
          and isinstance(self.tokenizer, MBartTokenizer)
      ):
          self.decoder_start_token_id = self.tokenizer.lang_code_to_id[
              hparams.tgt_lang
          ]
          self.model.config.decoder_start_token_id = (
              self.decoder_start_token_id
          )
      self.dataset_class = (
          Seq2SeqDataset
          if hasattr(self.tokenizer, "prepare_seq2seq_batch")
          else LegacySeq2SeqDataset
      )
      self.already_saved_batch = False
      self.eval_beams = (
          self.model.config.num_beams
          if self.hparams.eval_beams is None
          else self.hparams.eval_beams
      )
      if self.hparams.eval_max_gen_length is not None:
          self.eval_max_length = self.hparams.eval_max_gen_length
      else:
          self.eval_max_length = self.model.config.max_length
      self.val_metric = (
          self.default_val_metric
          if self.hparams.val_metric is None
          else self.hparams.val_metric
      )
  
imports: import argparse
  import glob
  import logging
  import os
  import sys
  import time
  from collections import defaultdict
  from pathlib import Path
  from typing import Dict, List, Tuple
  import numpy
  import pytorch_lightning
  import torch
  from callbacks import Seq2SeqLoggingCallback, get_checkpoint_callback, get_early_stopping_callback
  from torch import nn
  from torch.utils.data import DataLoader
  from transformers import MBartTokenizer, T5ForConditionalGeneration
  from transformers.models.bart.modeling_bart import shift_tokens_right
  from utils import ROUGE_KEYS, LegacySeq2SeqDataset, Seq2SeqDataset, assert_all_frozen, calculate_bleu, calculate_rouge, check_output_dir, flatten_list, freeze_embeds, freeze_params, get_git_info, label_smoothed_nll_loss, lmap, pickle_save, save_git_info, save_json, use_task_specific_params
  from lightning_base import BaseTransformer, add_generic_args, generic_train
label_desc: Use image node_id 1 to create a new SummarizationModule object from inherited base classes: BaseTransformer with example: obj = SummarizationModule(hparams)