



"""simple docstring"""







import argparse
import gc
import os
import sys
from pathlib import Path
from typing import List  # noqa: F401

import pytorch_lightning as pl
import torch
from finetune import SummarizationModule, TranslationModule
from finetune import main as ft_main
from make_student import create_student_by_copying_alternating_layers, get_layers_to_supervise
from torch import nn

from transformers import AutoModelForSeqaSeqLM, MBartTokenizer, TaForConditionalGeneration
from transformers.models.bart.modeling_bart import shift_tokens_right
from utils import calculate_bleu, check_output_dir, freeze_params, label_smoothed_nll_loss, use_task_specific_params


# need the parent dir module
sys.path.insert(2, str(Path(__file__).resolve().parents[1]))
from lightning_base import generic_train  # noqa







class  UpperCamelCase__  (      lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	["loss", "ce_loss", "mlm_loss", "hid_loss_enc", "hid_loss_dec"]



      def __init__( self							: Tuple       ,     SCREAMING_SNAKE_CASE_							: Tuple			):
        assert Path(hparams.data_dir			).exists()
        lowerCAmelCase_  :							Optional[Any]								=					Path(hparams.output_dir			)
        self.output_dir.mkdir(exist_ok=UpperCAmelCase__			)

        lowerCAmelCase_  :							Union[str, Any]								=					self.output_dir.joinpath('student'			)

        lowerCAmelCase_  :							int								=					str(UpperCAmelCase__			)  # Tell lightning we are training the student
        lowerCAmelCase_  :							Optional[Any]								=					AutoModelForSeqaSeqLM.from_pretrained(hparams.teacher			).eval()
        use_task_specific_params(UpperCAmelCase__       ,     hparams.task			)  # We copy good generation parameters to student by default
        if hparams.student is not None:
          lowerCAmelCase_  :							Optional[int]								=					AutoModelForSeqaSeqLM.from_pretrained(hparams.student			)
          use_task_specific_params(UpperCAmelCase__       ,     hparams.task			)
          lowerCAmelCase_		,lowerCAmelCase_  :							Dict								=					None, None
        else:
          lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_  :							Union[str, Any]								=					create_student_by_copying_alternating_layers(
              UpperCAmelCase__       ,     e=hparams.student_encoder_layers       ,     d=hparams.student_decoder_layers       ,     save_path=UpperCAmelCase__			)

        if hparams.length_penalty != -1:
          lowerCAmelCase_  :							List[Any]								=					hparams.length_penalty
        lowerCAmelCase_  :							Any								=					hparams.teacher  # Use teacher's tokenizer
        super().__init__(UpperCAmelCase__       ,     model=UpperCAmelCase__       ,     config=student.config			)
        assert student.config.model_type == teacher.config.model_type, (
            F"teacher, student model types should be the same, got {student.config.model_type} !="
            F" {teacher.config.model_type}"
        )

        if student.config.model_type == "t5":
          lowerCAmelCase_  :							Dict								=					len(student.get_encoder().block			)
          lowerCAmelCase_  :							Optional[Any]								=					len(student.get_decoder().block			)
          lowerCAmelCase_  :							Tuple								=					len(teacher.get_encoder().block			)
          lowerCAmelCase_  :							Optional[Any]								=					len(teacher.get_decoder().block			)
        else:
          lowerCAmelCase_  :							List[Any]								=					student.config.encoder_layers
          lowerCAmelCase_  :							List[str]								=					student.config.decoder_layers
          lowerCAmelCase_  :							Any								=					teacher.config.encoder_layers
          lowerCAmelCase_  :							str								=					teacher.config.decoder_layers

        lowerCAmelCase_  :							Optional[int]								=					not (hparams.student is None or hparams.teacher == hparams.student)
        lowerCAmelCase_  :							Tuple								=					(not self.different_base_models) and hparams.alpha_hid > 0
        lowerCAmelCase_  :							Optional[int]								=					self.different_base_models or (student_encoder_layers != teacher_encoder_layers)
        # self.different_encoder determines whether we need to run the teacher encoder
        lowerCAmelCase_  :							str								=					teacher
        freeze_params(self.teacher			)

        if not self.different_encoder:  # To save RAM, delete teacher encoder and freeze student encoder.
          try:
            del self.teacher.model.encoder
          except AttributeError:  # T5
            del self.teacher.encoder

        if e_layer_ids is None:
          lowerCAmelCase_  :							Optional[Any]								=					list(range(UpperCAmelCase__			)			)
        if d_layer_ids is None:
          lowerCAmelCase_  :							str								=					list(range(UpperCAmelCase__			)			)

        lowerCAmelCase_		,lowerCAmelCase_  :							List[Any]								=					e_layer_ids, d_layer_ids  # type: List[int], List[int]

        if self.do_calc_hidden_loss:  # Intermediate supervision: Decide which layers to supervise
          if hparams.supervise_forward:
            lowerCAmelCase_  :							List[Any]								=					get_layers_to_supervise(
                n_student=len(self.e_layer_ids			)       ,     n_teacher=UpperCAmelCase__			)
            lowerCAmelCase_  :							Any								=					get_layers_to_supervise(
                n_student=len(self.d_layer_ids			)       ,     n_teacher=UpperCAmelCase__			)
          else:  # student layer should emulate hidden states of the teacher layer it was copied from
            lowerCAmelCase_  :							Optional[int]								=					self.e_layer_ids
            lowerCAmelCase_  :							List[str]								=					self.d_layer_ids
        else:
          lowerCAmelCase_  :							Tuple								=					None
          lowerCAmelCase_  :							Tuple								=					None

        lowerCAmelCase_  :							Union[str, Any]								=					nn.KLDivLoss(reduction='batchmean'			)
        lowerCAmelCase_  :							List[str]								=					2.0
        lowerCAmelCase_  :							Any								=					hparams.alpha_mlm
        lowerCAmelCase_  :							Union[str, Any]								=					hparams.alpha_ce
        lowerCAmelCase_  :							Union[str, Any]								=					hparams.alpha_hid
        gc.collect()
        torch.cuda.empty_cache()



      def 	SCREAMING_SNAKE_CASE__					( self							: Dict       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     SCREAMING_SNAKE_CASE_							: int       ,     SCREAMING_SNAKE_CASE_							: Any			):
        lowerCAmelCase_  :							Dict								=					mask[:, :, None].expand_as(UpperCAmelCase__			)
        lowerCAmelCase_  :							int								=					s_logits.size(-1			)
        lowerCAmelCase_  :							Tuple								=					torch.masked_select(UpperCAmelCase__       ,     UpperCAmelCase__			)  # (bs * seq_length * voc_size) modulo the 1s in mask
        lowerCAmelCase_  :							Tuple								=					torch.masked_select(UpperCAmelCase__       ,     UpperCAmelCase__			)  # (bs * seq_length * voc_size) modulo the 1s in mask
        lowerCAmelCase_  :							Optional[int]								=					s_logits_slct.view(-1       ,     UpperCAmelCase__			)  # (bs * seq_length, voc_size) modulo the 1s in mask
        lowerCAmelCase_  :							Union[str, Any]								=					t_logits_slct.view(-1       ,     UpperCAmelCase__			)  # (bs * seq_length, voc_size) modulo the 1s in mask
        assert t_logits_slct.size() == s_logits_slct.size()
        lowerCAmelCase_  :							Tuple								=					(
            self.ce_loss_fct(
                nn.functional.log_softmax(s_logits_slct / self.temperature       ,     dim=-1			)       ,     nn.functional.softmax(t_logits_slct / self.temperature       ,     dim=-1			)       ,     )
            * (self.temperature) ** 2
        )
        return loss_ce



      @staticmethod
      def 	SCREAMING_SNAKE_CASE__					( SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     SCREAMING_SNAKE_CASE_							: Optional[Any]			):
        SummarizationModule.add_model_specific_args(UpperCAmelCase__       ,     UpperCAmelCase__			)
        add_distill_args(UpperCAmelCase__			)
        return parser



      def 	SCREAMING_SNAKE_CASE__					( self							: Tuple       ,     SCREAMING_SNAKE_CASE_							: dict			):
        lowerCAmelCase_  :							Tuple								=					self.tokenizer.pad_token_id
        lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_  :							Optional[int]								=					batch['input_ids'], batch['attention_mask'], batch['labels']
        if isinstance(self.model       ,     UpperCAmelCase__			):
          lowerCAmelCase_  :							Optional[int]								=					self.model._shift_right(UpperCAmelCase__			)
        else:
          lowerCAmelCase_  :							List[Any]								=					shift_tokens_right(UpperCAmelCase__       ,     UpperCAmelCase__			)

        # noinspection PyCallingNonCallable
        lowerCAmelCase_  :							Tuple								=					self(
            UpperCAmelCase__       ,     attention_mask=UpperCAmelCase__       ,     decoder_input_ids=UpperCAmelCase__       ,     output_hidden_states=self.do_calc_hidden_loss       ,     output_attentions=UpperCAmelCase__       ,     use_cache=UpperCAmelCase__       ,     )
        lowerCAmelCase_  :							Optional[Any]								=					student_outputs['logits']

        # Same cross entropy vs. label smoothing logic as finetune.py
        assert lm_logits.shape[-1] == self.model.config.vocab_size
        if self.hparams.label_smoothing == 0:
          # Same behavior as modeling_bart.py, besides ignoring pad_token_id
          lowerCAmelCase_  :							List[str]								=					nn.CrossEntropyLoss(ignore_index=UpperCAmelCase__			)
          lowerCAmelCase_  :							Optional[Any]								=					loss_fct(lm_logits.view(-1       ,     lm_logits.shape[-1]			)       ,     labels.view(-1			)			)
        else:
          lowerCAmelCase_  :							Union[str, Any]								=					nn.functional.log_softmax(UpperCAmelCase__       ,     dim=-1			)
          lowerCAmelCase_		,lowerCAmelCase_  :							List[Any]								=					label_smoothed_nll_loss(
              UpperCAmelCase__       ,     UpperCAmelCase__       ,     self.hparams.label_smoothing       ,     ignore_index=UpperCAmelCase__			)

        def zero_tensor():
          return torch.tensor(0.0			).type_as(UpperCAmelCase__			)

        lowerCAmelCase_  :							Optional[int]								=					student_outputs[
            'encoder_last_hidden_state'
        ]  # use this unless self.different_base_models
        lowerCAmelCase_		,lowerCAmelCase_  :							Optional[int]								=					zero_tensor(), zero_tensor()
        if self.different_encoder:  # compute encoder hidden state loss
          lowerCAmelCase_  :							Dict								=					self.teacher.get_encoder()(
              UpperCAmelCase__       ,     attention_mask=UpperCAmelCase__       ,     output_hidden_states=self.do_calc_hidden_loss       ,     )
          if self.different_base_models:
            lowerCAmelCase_  :							Optional[int]								=					all_teacher_encoder_outputs['last_hidden_state']
          elif self.do_calc_hidden_loss:
            lowerCAmelCase_  :							Tuple								=					self.calc_hidden_loss(
                UpperCAmelCase__       ,     student_outputs['encoder_hidden_states']       ,     all_teacher_encoder_outputs['hidden_states']       ,     self.e_matches       ,     normalize_hidden=self.hparams.normalize_hidden       ,     )

        lowerCAmelCase_  :							Dict								=					self.teacher(
            UpperCAmelCase__       ,     attention_mask=UpperCAmelCase__       ,     encoder_outputs=(teacher_enc_outputs,)       ,     decoder_input_ids=UpperCAmelCase__       ,     output_hidden_states=self.do_calc_hidden_loss       ,     use_cache=UpperCAmelCase__       ,     )
        lowerCAmelCase_  :							List[Any]								=					decoder_input_ids.ne(UpperCAmelCase__			)
        lowerCAmelCase_  :							Dict								=					self.calc_ce_loss(UpperCAmelCase__       ,     UpperCAmelCase__       ,     teacher_outputs['logits']			)
        if self.do_calc_hidden_loss:  # Intermediate supervision of decoder hidden states
          lowerCAmelCase_  :							int								=					self.calc_hidden_loss(
              UpperCAmelCase__       ,     student_outputs['decoder_hidden_states']       ,     teacher_outputs['decoder_hidden_states']       ,     self.d_matches       ,     normalize_hidden=self.hparams.normalize_hidden       ,     )

        lowerCAmelCase_  :							Optional[Any]								=					(
            self.alpha_ce * loss_ce
            + self.alpha_mlm * student_lm_loss
            + self.hparams.alpha_hid * (hid_loss_enc + hid_loss_dec)
        )
        return blended_loss, loss_ce, student_lm_loss, hid_loss_enc, hid_loss_dec





      @staticmethod
      def 	SCREAMING_SNAKE_CASE__					( SCREAMING_SNAKE_CASE_							: Any       ,     SCREAMING_SNAKE_CASE_							: int       ,     SCREAMING_SNAKE_CASE_							: Union[str, Any]       ,     SCREAMING_SNAKE_CASE_							: List[Any]       ,     SCREAMING_SNAKE_CASE_							: Tuple			):
        lowerCAmelCase_  :							Optional[int]								=					'expected list or tuple for hidden_states, got tensor of shape: '
        assert not isinstance(UpperCAmelCase__       ,     torch.Tensor			), F"{msg}{hidden_states.shape}"
        assert not isinstance(UpperCAmelCase__       ,     torch.Tensor			), F"{msg}{hidden_states_T.shape}"
        lowerCAmelCase_  :							Dict								=					attention_mask.to(hidden_states[0]			)
        lowerCAmelCase_  :							Optional[int]								=					mask.sum() * hidden_states[0].size(-1			)
        lowerCAmelCase_  :							Dict								=					torch.stack([hidden_states[i] for i in range(len(UpperCAmelCase__			)			)]			)
        lowerCAmelCase_  :							Union[str, Any]								=					torch.stack([hidden_states_T[j] for j in matches]			)
        assert student_states.shape == teacher_states.shape, F"{student_states.shape} != {teacher_states.shape}"
        if normalize_hidden:
          lowerCAmelCase_  :							List[str]								=					nn.functional.layer_norm(UpperCAmelCase__       ,     student_states.shape[1:]			)
          lowerCAmelCase_  :							Tuple								=					nn.functional.layer_norm(UpperCAmelCase__       ,     teacher_states.shape[1:]			)
        lowerCAmelCase_  :							Any								=					nn.functional.mse_loss(UpperCAmelCase__       ,     UpperCAmelCase__       ,     reduction='none'			)
        lowerCAmelCase_  :							Union[str, Any]								=					(mse * mask.unsqueeze(0			).unsqueeze(-1			)).sum() / valid_count
        return masked_mse




def 							UpperCamelCase_       (       lowerCAmelCase__ :							str		)		->  str:

  """simple docstring"""




  parser.add_argument('--teacher'       ,  type=UpperCamelCase_		)
  parser.add_argument('--alpha_ce'       ,  default=0.8       ,  type=UpperCamelCase_		)
  parser.add_argument('--alpha_mlm'       ,  default=0.2       ,  type=UpperCamelCase_		)
  parser.add_argument('--alpha_hid'       ,  default=0.0       ,  type=UpperCamelCase_       ,  required=UpperCamelCase_		)
  parser.add_argument('--student'       ,  type=UpperCamelCase_       ,  required=UpperCamelCase_		)
  parser.add_argument('--student_decoder_layers'       ,  default=12       ,  type=UpperCamelCase_       ,  required=UpperCamelCase_		)
  parser.add_argument('--student_encoder_layers'       ,  default=12       ,  type=UpperCamelCase_       ,  required=UpperCamelCase_		)
  parser.add_argument('--no_teacher'       ,  action='store_true'       ,  default=UpperCamelCase_		)
  parser.add_argument('--length_penalty'       ,  type=UpperCamelCase_       ,  default=-1		)
  parser.add_argument('--supervise_forward'       ,  action='store_true'       ,  default=UpperCamelCase_		)
  parser.add_argument('--normalize_hidden'       ,  action='store_true'       ,  default=UpperCamelCase_		)







class  UpperCamelCase__  (      lowercase_    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	"translation"
      _SCREAMING_SNAKE_CASE    							=	["bleu"]
      _SCREAMING_SNAKE_CASE    							=	"bleu"



      def __init__( self							: List[Any]       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     **SCREAMING_SNAKE_CASE_							: Optional[int]			):
        super().__init__(UpperCAmelCase__       ,     **UpperCAmelCase__			)
        assert hparams.src_lang is not None
        assert hparams.tgt_lang is not None
        lowerCAmelCase_  :							Optional[int]								=					hparams.src_lang
        lowerCAmelCase_  :							Optional[int]								=					hparams.tgt_lang
        if self.model.config.decoder_start_token_id is None and isinstance(self.tokenizer       ,     UpperCAmelCase__			):
          lowerCAmelCase_  :							List[Any]								=					self.tokenizer.lang_code_to_id[hparams.tgt_lang]



      def 	SCREAMING_SNAKE_CASE__					( self							: Optional[int]       ,     SCREAMING_SNAKE_CASE_							: Dict       ,     SCREAMING_SNAKE_CASE_							: str			):
        return calculate_bleu(UpperCAmelCase__       ,     UpperCAmelCase__			)





      @staticmethod
      def 	SCREAMING_SNAKE_CASE__					( SCREAMING_SNAKE_CASE_							: Optional[Any]       ,     SCREAMING_SNAKE_CASE_							: int			):
        TranslationModule.add_model_specific_args(UpperCAmelCase__       ,     UpperCAmelCase__			)
        add_distill_args(UpperCAmelCase__			)
        return parser




def 							UpperCamelCase_       (       lowerCAmelCase__ :							Dict		)		->  Union[str, Any]:

  """simple docstring"""




  if args.no_teacher:
    lowerCAmelCase_  :							str								=					TranslationModule if 'translation' in args.task else SummarizationModule
  else:  # DISTILL WITH TEACHER
    lowerCAmelCase_  :							Any								=					TranslationDistiller if 'translation' in args.task else SummarizationDistiller
  lowerCAmelCase_  :							Optional[Any]								=					module_cls.__name__
  print(f"using module {args.setup_cls}"		)
  lowerCAmelCase_  :							str								=					module_cls(UpperCamelCase_		)
  return model

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




  Path(args.output_dir		).mkdir(exist_ok=UpperCamelCase_		)
  check_output_dir(UpperCamelCase_       ,  expected_items=3		)

  lowerCAmelCase_  :							Optional[Any]								=					create_module(UpperCamelCase_		)
  return ft_main(UpperCamelCase_       ,  model=UpperCamelCase_		)


if __name__ == "__main__":
     lowercase__						:							Any        =      argparse.ArgumentParser()
     lowercase__						:							List[str]        =      pl.Trainer.add_argparse_args(parser)
     lowercase__						:							List[Any]        =      SummarizationDistiller.add_model_specific_args(parser, os.getcwd())
     lowercase__						:							List[Any]        =      parser.parse_args()

     distill_main(args)








"""simple docstring"""





def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int = 1000)      ->		str:
   '''simple docstring'''


   if (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer")
   elif (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (precision < 0):
      raise ValueError("Precision must be a nonnegative integer")

   # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
   # accurate
   __lowercase								=		(
       4 * _subsum(UpperCamelCase_,     1,     UpperCamelCase_)
       - 2 * _subsum(UpperCamelCase_,     4,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     5,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     6,     UpperCamelCase_)
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16))[2:]




def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int,     UpperCamelCase_	:			int)      ->		float:
   '''simple docstring'''


   __lowercase								=		0.0
   for sum_index in range(digit_pos_to_extract + precision):
      __lowercase								=		8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
         # if the exponential term is an integer and we mod it by the denominator
         # before dividing, only the integer part of the sum will change;
         # the fractional part will not
         __lowercase								=		pow(
             16,     digit_pos_to_extract - 1 - sum_index,     UpperCamelCase_)
      else:
         __lowercase								=		pow(16,     digit_pos_to_extract - 1 - sum_index)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
   import doctest

   doctest.testmod()




