

'''simple docstring'''




# 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 						UpperCamelCase       ( a		,						a		,						a=0 )      ->	Optional[Any]:






     '''simple docstring'''
     # 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(_UpperCAmelCase )

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




def 						UpperCamelCase       ( a		,						a		,						a		,						a		,						a )      ->	Tuple:






     '''simple docstring'''
     # 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(*_UpperCAmelCase )
          __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(*_UpperCAmelCase )
          __magic_name__						   =				param.transpose(0		,						1 ).contiguous()
     __magic_name__						   =				param.view(*_UpperCAmelCase )
     return param




def 						UpperCamelCase       ( a		,						a		,						a )      ->	List[Any]:






     '''simple docstring'''
     # The converted output model.
     __magic_name__						   =				{}

     # old versions did not store training args
     __magic_name__						   =				input_state_dict.get('''args'''		,						_UpperCAmelCase )
     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(_UpperCAmelCase )

          # 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(_UpperCAmelCase		,						_UpperCAmelCase		,						3		,						_UpperCAmelCase		,						_UpperCAmelCase )
               # 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(_UpperCAmelCase		,						_UpperCAmelCase		,						3		,						_UpperCAmelCase		,						_UpperCAmelCase )
               # 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 						UpperCamelCase       ( )      ->	str:






     '''simple docstring'''
     # Create the argument parser.
     __magic_name__						   =				argparse.ArgumentParser()
     parser.add_argument('''--print-checkpoint-structure'''		,						action='''store_true''' )
     parser.add_argument('''path_to_checkpoint'''		,						type=_UpperCAmelCase		,						help='''Path to the ZIP file containing the checkpoint''' )
     parser.add_argument(
         '''--config_file'''		,						default=''''''		,						type=_UpperCAmelCase		,						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(_UpperCAmelCase		,						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(_UpperCAmelCase		,						_UpperCAmelCase		,						_UpperCAmelCase )

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

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

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


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

if __name__ == "__main__":
      main()

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













def    _lowercase    (  _UpperCAmelCase = 99_80_01 )  ->     int:

				# fetches the next number
				for number in range(n - 1	,					99_99	,					-1 ):
								lowerCamelCase		       =str(_UpperCAmelCase )

								# checks whether 'str_number' is a palindrome.
								if str_number == str_number[::-1]:
												lowerCamelCase		       =9_99

												# if 'number' is a product of two 3-digit numbers
												# then number is the answer otherwise fetch next number.
												while divisor != 99:
																if (number % divisor == 0) and (len(str(number // divisor ) ) == 3.0):
																				return number
																divisor -= 1
				raise ValueError("""That number is larger than our acceptable range.""" )


if __name__ == "__main__":
							print(F"{solution() = }")





