



import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class    _lowercase (a_   ):
				'''simple docstring'''







				lowercase__     =    ["""image_processor""", """tokenizer"""]
				lowercase__     =    """LayoutLMv2ImageProcessor"""
				lowercase__     =    ("""LayoutLMv2Tokenizer""", """LayoutLMv2TokenizerFast""")

				def __init__(			self  ,			snake_case__=None  ,			snake_case__=None  ,			**snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= None
									if "feature_extractor" in kwargs:
														warnings.warn(
														    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
														    " instead."  ,			snake_case__  ,			)
														UpperCamelCase_			= kwargs.pop("feature_extractor"     )

									UpperCamelCase_			= image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
														raise ValueError("You need to specify an `image_processor`."     )
									if tokenizer is None:
														raise ValueError("You need to specify a `tokenizer`."     )

									super().__init__(snake_case__  ,			snake_case__     )

				def __call__(			self  ,			snake_case__  ,			snake_case__ = None  ,			snake_case__ = None  ,			snake_case__ = None  ,			snake_case__ = None  ,			snake_case__ = True  ,			snake_case__ = False  ,			snake_case__ = False  ,			snake_case__ = None  ,			snake_case__ = 0  ,			snake_case__ = None  ,			snake_case__ = None  ,			snake_case__ = None  ,			snake_case__ = False  ,			snake_case__ = False  ,			snake_case__ = False  ,			snake_case__ = False  ,			snake_case__ = True  ,			snake_case__ = None  ,			**snake_case__  ,			):

									'''simple docstring'''


									if self.image_processor.apply_ocr and (boxes is not None):
														raise ValueError(
														    "You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True."     )

									if self.image_processor.apply_ocr and (word_labels is not None):
														raise ValueError(
														    "You cannot provide word labels if you initialized the image processor with apply_ocr set to True."     )

									if return_overflowing_tokens is True and return_offsets_mapping is False:
														raise ValueError("You cannot return overflowing tokens without returning the offsets mapping."     )

									# first, apply the image processor
									UpperCamelCase_			= self.image_processor(images=snake_case__  ,			return_tensors=snake_case__     )

									# second, apply the tokenizer
									if text is not None and self.image_processor.apply_ocr and text_pair is None:
														if isinstance(snake_case__  ,			snake_case__     ):
																			UpperCamelCase_			= [text]  # add batch dimension (as the image processor always adds a batch dimension)
														UpperCamelCase_			= features["words"]

									UpperCamelCase_			= self.tokenizer(
									    text=text if text is not None else features["words"]  ,			text_pair=text_pair if text_pair is not None else None  ,			boxes=boxes if boxes is not None else features["boxes"]  ,			word_labels=snake_case__  ,			add_special_tokens=snake_case__  ,			padding=snake_case__  ,			truncation=snake_case__  ,			max_length=snake_case__  ,			stride=snake_case__  ,			pad_to_multiple_of=snake_case__  ,			return_token_type_ids=snake_case__  ,			return_attention_mask=snake_case__  ,			return_overflowing_tokens=snake_case__  ,			return_special_tokens_mask=snake_case__  ,			return_offsets_mapping=snake_case__  ,			return_length=snake_case__  ,			verbose=snake_case__  ,			return_tensors=snake_case__  ,			**snake_case__  ,			)

									# add pixel values
									UpperCamelCase_			= features.pop("pixel_values"     )
									if return_overflowing_tokens is True:
														UpperCamelCase_			= self.get_overflowing_images(snake_case__  ,			encoded_inputs["overflow_to_sample_mapping"]     )
									UpperCamelCase_			= images

									return encoded_inputs

				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= []
									for sample_idx in overflow_to_sample_mapping:
														images_with_overflow.append(images[sample_idx]     )

									if len(snake_case__     ) != len(snake_case__     ):
														raise ValueError(
														    "Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"
														    F""" {len(snake_case__     )} and {len(snake_case__     )}"""     )

									return images_with_overflow

				def    _lowerCamelCase       (			self  ,			*snake_case__  ,			**snake_case__     ):

									'''simple docstring'''


									return self.tokenizer.batch_decode(*snake_case__  ,			**snake_case__     )

				def    _lowerCamelCase       (			self  ,			*snake_case__  ,			**snake_case__     ):

									'''simple docstring'''


									return self.tokenizer.decode(*snake_case__  ,			**snake_case__     )

				@property
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									return ["input_ids", "bbox", "token_type_ids", "attention_mask", "image"]

				@property
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									warnings.warn(
									    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."  ,			snake_case__  ,			)
									return self.image_processor_class

				@property
				def    _lowerCamelCase       (			self     ):

									'''simple docstring'''


									warnings.warn(
									    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."  ,			snake_case__  ,			)
									return self.image_processor







# 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()

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