
'''simple docstring'''



import math
import time

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
     import torch_xla.core.xla_model as xm
     import torch_xla.debug.metrics as met

class    _a				(_lowerCamelCase):





       """simple docstring"""




       def __init__(							self       ,							*A__       ,							A__=None       ,							A__=None       ,							**A__      )    ->			Union[str, Any]:
          super().__init__(*A__       ,							**A__      )
          _SCREAMING_SNAKE_CASE      =				eval_examples
          _SCREAMING_SNAKE_CASE      =				post_process_function






       def        UpperCamelCase				(							self       ,							A__=None       ,							A__=None       ,							A__=None       ,							A__ = "eval"      )    ->			Optional[Any]:
          _SCREAMING_SNAKE_CASE      =				self.eval_dataset if eval_dataset is None else eval_dataset
          _SCREAMING_SNAKE_CASE      =				self.get_eval_dataloader(A__      )
          _SCREAMING_SNAKE_CASE      =				self.eval_examples if eval_examples is None else eval_examples

          # Temporarily disable metric computation, we will do it in the loop here.
          _SCREAMING_SNAKE_CASE      =				self.compute_metrics
          _SCREAMING_SNAKE_CASE      =				None
          _SCREAMING_SNAKE_CASE      =				self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
          _SCREAMING_SNAKE_CASE      =				time.time()
          try:
             _SCREAMING_SNAKE_CASE      =				eval_loop(
                 A__       ,							description="""Evaluation"""       ,							prediction_loss_only=True if compute_metrics is None else None       ,							ignore_keys=A__       ,							metric_key_prefix=A__       ,							)
          finally:
             _SCREAMING_SNAKE_CASE      =				compute_metrics
          _SCREAMING_SNAKE_CASE      =				self.args.eval_batch_size * self.args.world_size
          if F"{metric_key_prefix}_jit_compilation_time" in output.metrics:
             start_time += output.metrics[F"{metric_key_prefix}_jit_compilation_time"]
          output.metrics.update(
              speed_metrics(
                  A__       ,							A__       ,							num_samples=output.num_samples       ,							num_steps=math.ceil(output.num_samples / total_batch_size      )       ,							)      )
          if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
             # Only the main node write the results by default
             _SCREAMING_SNAKE_CASE      =				self.post_process_function(A__       ,							A__       ,							output.predictions      )
             _SCREAMING_SNAKE_CASE      =				self.compute_metrics(A__      )

             # Prefix all keys with metric_key_prefix + '_'
             for key in list(metrics.keys()      ):
                if not key.startswith(F"{metric_key_prefix}_"      ):
                   _SCREAMING_SNAKE_CASE      =				metrics.pop(A__      )
             metrics.update(output.metrics      )
          else:
             _SCREAMING_SNAKE_CASE      =				output.metrics

          if self.args.should_log:
             # Only the main node log the results by default
             self.log(A__      )

          if self.args.tpu_metrics_debug or self.args.debug:
             # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
             xm.master_print(met.metrics_report()      )

          _SCREAMING_SNAKE_CASE      =				self.callback_handler.on_evaluate(self.args       ,							self.state       ,							self.control       ,							A__      )
          return metrics






       def        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__=None       ,							A__ = "test"      )    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				self.get_test_dataloader(A__      )

          # Temporarily disable metric computation, we will do it in the loop here.
          _SCREAMING_SNAKE_CASE      =				self.compute_metrics
          _SCREAMING_SNAKE_CASE      =				None
          _SCREAMING_SNAKE_CASE      =				self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
          _SCREAMING_SNAKE_CASE      =				time.time()
          try:
             _SCREAMING_SNAKE_CASE      =				eval_loop(
                 A__       ,							description="""Prediction"""       ,							prediction_loss_only=True if compute_metrics is None else None       ,							ignore_keys=A__       ,							metric_key_prefix=A__       ,							)
          finally:
             _SCREAMING_SNAKE_CASE      =				compute_metrics
          _SCREAMING_SNAKE_CASE      =				self.args.eval_batch_size * self.args.world_size
          if F"{metric_key_prefix}_jit_compilation_time" in output.metrics:
             start_time += output.metrics[F"{metric_key_prefix}_jit_compilation_time"]
          output.metrics.update(
              speed_metrics(
                  A__       ,							A__       ,							num_samples=output.num_samples       ,							num_steps=math.ceil(output.num_samples / total_batch_size      )       ,							)      )

          if self.post_process_function is None or self.compute_metrics is None:
             return output

          _SCREAMING_SNAKE_CASE      =				self.post_process_function(A__       ,							A__       ,							output.predictions       ,							"""predict"""      )
          _SCREAMING_SNAKE_CASE      =				self.compute_metrics(A__      )

          # Prefix all keys with metric_key_prefix + '_'
          for key in list(metrics.keys()      ):
             if not key.startswith(F"{metric_key_prefix}_"      ):
                _SCREAMING_SNAKE_CASE      =				metrics.pop(A__      )
          metrics.update(output.metrics      )
          return PredictionOutput(predictions=predictions.predictions       ,							label_ids=predictions.label_ids       ,							metrics=A__      )








'''simple docstring'''



import argparse

import torch
from torch import nn

from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     Any:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				[
       """encoder.version""",
       """decoder.version""",
       """model.encoder.version""",
       """model.decoder.version""",
       """decoder.output_projection.weight""",
       """_float_tensor""",
       """encoder.embed_positions._float_tensor""",
       """decoder.embed_positions._float_tensor""",
   ]
   for k in ignore_keys:
      state_dict.pop(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_						)
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     str:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE ,							_SCREAMING_SNAKE_CASE      =				emb.weight.shape
   _SCREAMING_SNAKE_CASE      =				nn.Linear(SCREAMING_SNAKE_CASE_    ,      SCREAMING_SNAKE_CASE_    ,      bias=SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				emb.weight.data
   return lin_layer
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     List[Any]:




   """simple docstring"""
   _SCREAMING_SNAKE_CASE      =				torch.load(SCREAMING_SNAKE_CASE_    ,      map_location="""cpu"""						)
   _SCREAMING_SNAKE_CASE      =				mam_aaa["""args"""] or mam_aaa["""cfg"""]["""model"""]
   _SCREAMING_SNAKE_CASE      =				mam_aaa["""model"""]
   remove_ignore_keys_(SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				state_dict["""encoder.embed_tokens.weight"""].shape[0]

   _SCREAMING_SNAKE_CASE      =				MaMaaaConfig(
       vocab_size=SCREAMING_SNAKE_CASE_    ,      max_position_embeddings=10_24    ,      encoder_layers=args.encoder_layers    ,      decoder_layers=args.decoder_layers    ,      encoder_attention_heads=args.encoder_attention_heads    ,      decoder_attention_heads=args.decoder_attention_heads    ,      encoder_ffn_dim=args.encoder_ffn_embed_dim    ,      decoder_ffn_dim=args.decoder_ffn_embed_dim    ,      d_model=args.encoder_embed_dim    ,      encoder_layerdrop=args.encoder_layerdrop    ,      decoder_layerdrop=args.decoder_layerdrop    ,      dropout=args.dropout    ,      attention_dropout=args.attention_dropout    ,      activation_dropout=args.activation_dropout    ,      activation_function="""relu"""    ,      )

   _SCREAMING_SNAKE_CASE      =				state_dict["""decoder.embed_tokens.weight"""]
   _SCREAMING_SNAKE_CASE      =				MaMaaaForConditionalGeneration(SCREAMING_SNAKE_CASE_						)
   model.model.load_state_dict(SCREAMING_SNAKE_CASE_    ,      strict=SCREAMING_SNAKE_CASE_						)
   _SCREAMING_SNAKE_CASE      =				make_linear_from_emb(model.model.shared						)

   return model


if __name__ == "__main__":
     UpperCamelCase__      :		Dict       							=  argparse.ArgumentParser()
     # Required parameters
     parser.add_argument("fairseq_path", type=str, help="path to a model.pt on local filesystem.")
     parser.add_argument("pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
     UpperCamelCase__      :		List[str]       							=  parser.parse_args()
     UpperCamelCase__      :		Any       							=  convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß)
     model.save_pretrained(args.pytorch_dump_folder_path)






