





import os
import pathlib
import tempfile
import uuid

import numpy as np

from ..utils import is_soundfile_availble, is_torch_available, is_vision_available, logging


a_    :				List[str]					=			logging.get_logger(__name__)

if is_vision_available():
    import PIL.Image
    from PIL import Image
    from PIL.Image import Image as ImageType
else:
    a_    :				Dict					=			object

if is_torch_available():
    import torch

if is_soundfile_availble():
    import soundfile as sf



class  SCREAMING_SNAKE_CASE_  :


  """simple docstring"""





  def __init__(  self	,  A						)		->   Any:





       '''simple docstring'''







       __magic_name__				=       value





  def __str__(  self						)		->   Tuple:





       '''simple docstring'''







       return self.to_string()





  def 			__A      (  self						)		->   List[Any]:





       '''simple docstring'''







       logger.error(
           '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''						)
       return self._value







  def 			__A      (  self						)		->   str:





       '''simple docstring'''







       logger.error(
           '''This is a raw AgentType of unknown type. Display in notebooks and string conversion will be unreliable'''						)
       return str(self._value						)



class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__   ,							SCREAMING_SNAKE_CASE__			):


  """simple docstring"""





  def 			__A      (  self						)		->   Dict:





       '''simple docstring'''







       return self._value







  def 			__A      (  self						)		->   Dict:





       '''simple docstring'''







       return self._value



class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__   ,							SCREAMING_SNAKE_CASE__			):


  """simple docstring"""





  def __init__(  self	,  A						)		->   Tuple:





       '''simple docstring'''







       super().__init__(A						)

       if not is_vision_available():
            raise ImportError('''PIL must be installed in order to handle images.'''						)

       __magic_name__				=       None
       __magic_name__				=       None
       __magic_name__				=       None

       if isinstance(A	,  A						):
            __magic_name__				=       value
       elif isinstance(A	,  (str, pathlib.Path)						):
            __magic_name__				=       value
       elif isinstance(A	,  torch.Tensor						):
            __magic_name__				=       value
       else:
            raise ValueError(F'Unsupported type for {self.__class__.__name__}: {type(A						)}'						)





  def 			__A      (  self	,  A=None	,  A=None						)		->   Tuple:





       '''simple docstring'''







       from IPython.display import Image, display

       display(Image(self.to_string()						)						)





  def 			__A      (  self						)		->   Any:





       '''simple docstring'''







       if self._raw is not None:
            return self._raw

       if self._path is not None:
            __magic_name__				=       Image.open(self._path						)
            return self._raw







  def 			__A      (  self						)		->   Union[str, Any]:





       '''simple docstring'''







       if self._path is not None:
            return self._path

       if self._raw is not None:
            __magic_name__				=       tempfile.mkdtemp()
            __magic_name__				=       os.path.join(A	,  str(uuid.uuida()						) + '''.png'''						)
            self._raw.save(self._path						)

            return self._path

       if self._tensor is not None:
            __magic_name__				=       self._tensor.cpu().detach().numpy()

            # There is likely simpler than load into image into save
            __magic_name__				=       Image.fromarray((array * 2_55).astype(np.uinta						)						)

            __magic_name__				=       tempfile.mkdtemp()
            __magic_name__				=       os.path.join(A	,  str(uuid.uuida()						) + '''.png'''						)

            img.save(self._path						)

            return self._path



class  SCREAMING_SNAKE_CASE_  ( SCREAMING_SNAKE_CASE__			):


  """simple docstring"""





  def __init__(  self	,  A	,  A=1_60_00						)		->   Optional[Any]:





       '''simple docstring'''







       super().__init__(A						)

       if not is_soundfile_availble():
            raise ImportError('''soundfile must be installed in order to handle audio.'''						)

       __magic_name__				=       None
       __magic_name__				=       None

       __magic_name__				=       samplerate

       if isinstance(A	,  (str, pathlib.Path)						):
            __magic_name__				=       value
       elif isinstance(A	,  torch.Tensor						):
            __magic_name__				=       value
       else:
            raise ValueError(F'Unsupported audio type: {type(A						)}'						)





  def 			__A      (  self	,  A=None	,  A=None						)		->   List[str]:





       '''simple docstring'''







       from IPython.display import Audio, display

       display(Audio(self.to_string()	,  rate=self.samplerate						)						)





  def 			__A      (  self						)		->   Union[str, Any]:





       '''simple docstring'''







       if self._tensor is not None:
            return self._tensor

       if self._path is not None:
            __magic_name__		,  __magic_name__				=       sf.read(self._path						)
            __magic_name__				=       torch.tensor(A						)
            return self._tensor







  def 			__A      (  self						)		->   Optional[int]:





       '''simple docstring'''







       if self._path is not None:
            return self._path

       if self._tensor is not None:
            __magic_name__				=       tempfile.mkdtemp()
            __magic_name__				=       os.path.join(A	,  str(uuid.uuida()						) + '''.wav'''						)
            sf.write(self._path	,  self._tensor	,  samplerate=self.samplerate						)
            return self._path


a_    :				Optional[int]					=			{'text': AgentText, 'image': AgentImage, 'audio': AgentAudio}
a_    :				int					=			{str: AgentText}

if is_vision_available():
    a_    :				Optional[Any]					=			AgentImage




def   _SCREAMING_SNAKE_CASE      (	*snake_case_		:						Dict ,     **snake_case_		:						List[str]						):
     __magic_name__				=       [(arg.to_raw() if isinstance(snake_case_ ,     snake_case_						) else arg) for arg in args]
     __magic_name__				=       {k: (v.to_raw() if isinstance(snake_case_ ,     snake_case_						) else v) for k, v in kwargs.items()}
     return args, kwargs




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						Tuple ,     snake_case_		:						Optional[int]=None						):
     if isinstance(snake_case_ ,     snake_case_						):
          __magic_name__				=       {}
          for i, (k, v) in enumerate(outputs.items()						):
               if output_types is not None:
                    # If the class has defined outputs, we can map directly according to the class definition
                    if output_types[i] in AGENT_TYPE_MAPPING:
                         __magic_name__				=       AGENT_TYPE_MAPPING[output_types[i]](snake_case_						)
                    else:
                         __magic_name__				=       AgentType(snake_case_						)

               else:
                    # If the class does not have defined output, then we map according to the type
                    for _k, _v in INSTANCE_TYPE_MAPPING.items():
                         if isinstance(snake_case_ ,     _k						):
                              __magic_name__				=       _v(snake_case_						)
                    if k not in decoded_outputs:
                         __magic_name__				=       AgentType[v]

     elif isinstance(snake_case_ ,     (list, tuple)						):
          __magic_name__				=       type(snake_case_						)()
          for i, v in enumerate(snake_case_						):
               if output_types is not None:
                    # If the class has defined outputs, we can map directly according to the class definition
                    if output_types[i] in AGENT_TYPE_MAPPING:
                         decoded_outputs.append(AGENT_TYPE_MAPPING[output_types[i]](snake_case_						)						)
                    else:
                         decoded_outputs.append(AgentType(snake_case_						)						)
               else:
                    # If the class does not have defined output, then we map according to the type
                    __magic_name__				=       False
                    for _k, _v in INSTANCE_TYPE_MAPPING.items():
                         if isinstance(snake_case_ ,     _k						):
                              decoded_outputs.append(_v(snake_case_						)						)
                              __magic_name__				=       True

                    if not found:
                         decoded_outputs.append(AgentType(snake_case_						)						)

     else:
          if output_types[0] in AGENT_TYPE_MAPPING:
               # If the class has defined outputs, we can map directly according to the class definition
               __magic_name__				=       AGENT_TYPE_MAPPING[output_types[0]](snake_case_						)

          else:
               # If the class does not have defined output, then we map according to the type
               for _k, _v in INSTANCE_TYPE_MAPPING.items():
                    if isinstance(snake_case_ ,     _k						):
                         return _v(snake_case_						)
               return AgentType(snake_case_						)

     return decoded_outputs






# Copyright (c) 2021-, NVIDIA CORPORATION.  All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

####################################################################################################

#
# Note: If when running this conversion script you're getting an exception:
#     ModuleNotFoundError: No module named 'megatron.model.enums'
# you need to tell python where to find the clone of Megatron-LM, e.g.:
#
# cd /tmp
# git clone https://github.com/NVIDIA/Megatron-LM
# PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py ...
#
# if you already have it cloned elsewhere, simply adjust the path to the existing path
#
# If the training was done using a Megatron-LM fork, e.g.,
# https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
# in your path, i.e., /path/to/Megatron-DeepSpeed/
#

import argparse
import os
import re
import zipfile

import torch

from transformers import MegatronBertConfig




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						Optional[int] ,     snake_case_		:						int ,     snake_case_		:						int=0						):
     # Format the message.
     if name is None:
          __magic_name__				=       None
     else:
          __magic_name__				=       '''.''' * max(0 ,     spaces - 2						) + '''# {:''' + str(50 - spaces						) + '''s}'''
          __magic_name__				=       fmt.format(snake_case_						)

     # Print and recurse (if needed).
     if isinstance(snake_case_ ,     snake_case_						):
          if msg is not None:
               print(snake_case_						)
          for k in val.keys():
               recursive_print(snake_case_ ,     val[k] ,     spaces + 2						)
     elif isinstance(snake_case_ ,     torch.Tensor						):
          print(snake_case_ ,     ''':''' ,     val.size()						)
     else:
          print(snake_case_ ,     ''':''' ,     snake_case_						)




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						int ,     snake_case_		:						Optional[int] ,     snake_case_		:						Any ,     snake_case_		:						Tuple ,     snake_case_		:						Tuple						):
     # Permutes layout of param tensor to [num_splits * num_heads * hidden_size, :]
     # for compatibility with later versions of NVIDIA Megatron-LM.
     # The inverse operation is performed inside Megatron-LM to read checkpoints:
     # https://github.com/NVIDIA/Megatron-LM/blob/v2.4/megatron/checkpointing.py#L209
     # If param is the weight tensor of the self-attention block, the returned tensor
     # will have to be transposed one more time to be read by HuggingFace BERT.
     __magic_name__				=       param.size()
     if checkpoint_version == 1.0:
          # version 1.0 stores [num_heads * hidden_size * num_splits, :]
          __magic_name__				=       (num_heads, hidden_size, num_splits) + input_shape[1:]
          __magic_name__				=       param.view(*snake_case_						)
          __magic_name__				=       param.transpose(0 ,     2						)
          __magic_name__				=       param.transpose(1 ,     2						).contiguous()
     elif checkpoint_version >= 2.0:
          # other versions store [num_heads * num_splits * hidden_size, :]
          __magic_name__				=       (num_heads, num_splits, hidden_size) + input_shape[1:]
          __magic_name__				=       param.view(*snake_case_						)
          __magic_name__				=       param.transpose(0 ,     1						).contiguous()
     __magic_name__				=       param.view(*snake_case_						)
     return param




def   _SCREAMING_SNAKE_CASE      (	snake_case_		:						int ,     snake_case_		:						Optional[int] ,     snake_case_		:						Union[str, Any]						):
     # The converted output model.
     __magic_name__				=       {}

     # old versions did not store training args
     __magic_name__				=       input_state_dict.get('''args''' ,     snake_case_						)
     if ds_args is not None:
          # do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
          # from pprint import pprint
          # pprint(vars(ds_args))

          __magic_name__				=       ds_args.tokenizer_type
          __magic_name__				=       ds_args.padded_vocab_size
          __magic_name__				=       ds_args.max_position_embeddings
          __magic_name__				=       ds_args.hidden_size
          __magic_name__				=       ds_args.num_layers
          __magic_name__				=       ds_args.num_attention_heads
          __magic_name__				=       ds_args.ffn_hidden_size if '''ffn_hidden_size''' in ds_args else 4 * ds_args.hidden_size
          # pprint(config)

     # The number of heads.
     __magic_name__				=       config.num_attention_heads
     # The hidden_size per head.
     __magic_name__				=       config.hidden_size // heads
     # Megatron-LM checkpoint version
     if "checkpoint_version" in input_state_dict.keys():
          __magic_name__				=       input_state_dict['''checkpoint_version''']
     else:
          __magic_name__				=       0.0

     # The model.
     __magic_name__				=       input_state_dict['''model''']
     # The language model.
     __magic_name__				=       model['''language_model''']
     # The embeddings.
     __magic_name__				=       lm['''embedding''']

     # The word embeddings.
     __magic_name__				=       embeddings['''word_embeddings''']['''weight''']
     # Truncate the embedding table to vocab_size rows.
     __magic_name__				=       word_embeddings[: config.vocab_size, :]
     # Store the word embeddings.
     __magic_name__				=       word_embeddings

     # The position embeddings.
     __magic_name__				=       embeddings['''position_embeddings''']['''weight''']
     assert pos_embeddings.size(0						) == config.max_position_embeddings and pos_embeddings.size(1						) == config.hidden_size
     # Store the position embeddings.
     __magic_name__				=       pos_embeddings

     # The token-type embeddings.
     __magic_name__				=       embeddings['''tokentype_embeddings''']['''weight''']
     # Store the position embeddings.
     __magic_name__				=       tokentype_embeddings

     # The transformer.
     __magic_name__				=       lm['''transformer'''] if '''transformer''' in lm.keys() else lm['''encoder''']

     # The regex to extract layer names.
     __magic_name__				=       re.compile(r'''layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)'''						)

     # The simple map of names for "automated" rules.
     __magic_name__				=       {
         '''attention.dense''': '''.attention.output.dense.''',
         '''self_attention.dense''': '''.attention.output.dense.''',
         '''mlp.dense_h_to_4h''': '''.intermediate.dense.''',
         '''mlp.dense_4h_to_h''': '''.output.dense.''',
     }

     # Keep track of the attention/query/value tensor.
     __magic_name__				=       None

     # Extract the layers.
     for key, val in transformer.items():
          # Match the name.
          __magic_name__				=       layer_re.match(snake_case_						)

          # Stop if that's not a layer
          if m is None:
               break

          # The index of the layer.
          __magic_name__				=       int(m.group(1						)						)
          # The name of the operation.
          __magic_name__				=       m.group(2						)
          # Is it a weight or a bias?
          __magic_name__				=       m.group(3						)

          # The name of the layer.
          __magic_name__				=       f'bert.encoder.layer.{layer_idx}'

          # For layernorm(s), simply store the layer norm.
          if op_name.endswith('''layernorm'''						):
               __magic_name__				=       '''attention.ln''' if op_name.startswith('''input'''						) else '''ln'''
               __magic_name__				=       val

          # Transpose the QKV matrix.
          elif (
              op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
          ) and weight_or_bias == "weight":
               # Make sure the QKV pointer is nil.
               assert attention_qkv_weight is None, ""

               __magic_name__				=       fix_query_key_value_ordering(snake_case_ ,     snake_case_ ,     3 ,     snake_case_ ,     snake_case_						)
               # Store the tensor as we need the bias as well to interleave QKV and biases.
               __magic_name__				=       out_val

          # Transpose the bias.
          elif (
              op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
          ) and weight_or_bias == "bias":
               # Make sure we read the weight tensor.
               assert attention_qkv_weight is not None, ""

               # Split the QKV matrix into Q, K and V. Megatron stores Q,K,V interleaved.
               __magic_name__				=       attention_qkv_weight[0 * config.hidden_size : 1 * config.hidden_size, :]
               __magic_name__				=       attention_qkv_weight[1 * config.hidden_size : 2 * config.hidden_size, :]
               __magic_name__				=       attention_qkv_weight[2 * config.hidden_size : 3 * config.hidden_size, :]

               __magic_name__				=       fix_query_key_value_ordering(snake_case_ ,     snake_case_ ,     3 ,     snake_case_ ,     snake_case_						)
               # Split the bias.
               __magic_name__				=       out_val[0 * config.hidden_size : 1 * config.hidden_size]
               __magic_name__				=       out_val[1 * config.hidden_size : 2 * config.hidden_size]
               __magic_name__				=       out_val[2 * config.hidden_size : 3 * config.hidden_size]

               # Store.
               __magic_name__				=       q
               __magic_name__				=       q_bias
               __magic_name__				=       k
               __magic_name__				=       k_bias
               __magic_name__				=       v
               __magic_name__				=       v_bias

               # Clear the stored tensor.
               __magic_name__				=       None

          # Copy weights and biases as is.
          elif weight_or_bias in ["weight", "bias"]:
               __magic_name__				=       megatron_to_transformers[op_name]
               __magic_name__				=       val

    # The final layernorm.
     __magic_name__				=       transformer['''final_layernorm.weight''']
     __magic_name__				=       transformer['''final_layernorm.bias''']

     # The pooler.
     __magic_name__				=       lm['''pooler''']

     # Store the matrix and the bias.
     __magic_name__				=       pooler['''dense.weight''']
     __magic_name__				=       pooler['''dense.bias''']

     # The LM head from Megatron (for RACE).
     __magic_name__				=       model['''lm_head''']

     # The transform matrix.
     __magic_name__				=       lm_head['''dense.weight''']
     __magic_name__				=       lm_head['''dense.bias''']

     # The transform LN.
     __magic_name__				=       lm_head['''layernorm.weight''']
     __magic_name__				=       lm_head['''layernorm.bias''']

     # For the decoder, we replicate the weights.
     __magic_name__				=       word_embeddings
     __magic_name__				=       lm_head['''bias''']

     # The classifier from Megatron (for MLNI).
     __magic_name__				=       model['''binary_head''']

     # Store the classifier.
     __magic_name__				=       binary_head['''weight''']
     __magic_name__				=       binary_head['''bias''']

     # It should be done!
     return output_state_dict




def   _SCREAMING_SNAKE_CASE      (	):
     # Create the argument parser.
     __magic_name__				=       argparse.ArgumentParser()
     parser.add_argument('''--print-checkpoint-structure''' ,     action='''store_true'''						)
     parser.add_argument('''path_to_checkpoint''' ,     type=snake_case_ ,     help='''Path to the ZIP file containing the checkpoint'''						)
     parser.add_argument(
         '''--config_file''' ,     default='''''' ,     type=snake_case_ ,     help='''An optional config json file describing the pre-trained model.''' ,     )
     __magic_name__				=       parser.parse_args()

     # Extract the basename.
     __magic_name__				=       os.path.dirname(args.path_to_checkpoint						)

     # Load the model.
     # the .zip is very optional, let's keep it for backward compatibility
     print(f'Extracting PyTorch state dictionary from "{args.path_to_checkpoint}"'						)
     if args.path_to_checkpoint.endswith('''.zip'''						):
          with zipfile.ZipFile(args.path_to_checkpoint ,     '''r'''						) as checkpoint:
               with checkpoint.open('''release/mp_rank_00/model_optim_rng.pt'''						) as pytorch_dict:
                    __magic_name__				=       torch.load(snake_case_ ,     map_location='''cpu'''						)
     else:
          __magic_name__				=       torch.load(args.path_to_checkpoint ,     map_location='''cpu'''						)

     if args.config_file == "":
          # Default config of megatron-bert 345m
          __magic_name__				=       MegatronBertConfig()

          # different megatron-bert-*-345m models have different vocab sizes, so override the default
          # config (which is for megatron-bert-cased-345m) with the actual vocab dimension
          __magic_name__				=       input_state_dict['''model''']['''lm_head''']['''bias'''].numel()
     else:
          __magic_name__				=       MegatronBertConfig.from_json_file(args.config_file						)

     # Convert.
     print('''Converting'''						)
     __magic_name__				=       convert_megatron_checkpoint(snake_case_ ,     snake_case_ ,     snake_case_						)

     # Print the structure of converted state dict.
     if args.print_checkpoint_structure:
          recursive_print(snake_case_ ,     snake_case_						)

     # Store the config to file.
     print('''Saving config'''						)
     config.save_pretrained(snake_case_						)

     # Store the state_dict to file.
     __magic_name__				=       os.path.join(snake_case_ ,     '''pytorch_model.bin'''						)
     print(f'Saving checkpoint to "{output_checkpoint_file}"'						)
     torch.save(snake_case_ ,     snake_case_						)


####################################################################################################

if __name__ == "__main__":
    main()

####################################################################################################