


__UpperCamelCase							:							str    							=					(1, 153, 370, 371, 1634, 2467_8051, 115_1322_1901_8763_9925_6509_5597_9739_7152_2401)
__UpperCamelCase							:							List[str]    							=					(-153, -1, 0, 1.2, 200, "A", [], {}, None)

def       _a	(					SCREAMING_SNAKE_CASE						:					Optional[Any]  ):







 """simple docstring"""



 if not isinstance(lowercase_     ,			lowercase_  ) or n < 1:
  return False

 # Initialization of sum and number of digits.
 UpperCamelCase__       :     str 							= 0
 UpperCamelCase__       :     Optional[Any] 							= 0
 UpperCamelCase__       :     List[Any] 							= n
 # Calculation of digits of the number
 while temp > 0:
  number_of_digits += 1
  temp //= 10
 # Dividing number into separate digits and find Armstrong number
 UpperCamelCase__       :     Tuple 							= n
 while temp > 0:
  UpperCamelCase__       :     Dict 							= temp % 10
  total += rem**number_of_digits
  temp //= 10
 return n == total

def       _a	(					SCREAMING_SNAKE_CASE						:					Any  ):







 """simple docstring"""



 if not isinstance(lowercase_     ,			lowercase_  ) or n < 1:
  return False

 # Init a "histogram" of the digits
 UpperCamelCase__       :     Union[str, Any] 							= [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 UpperCamelCase__       :     Dict 							= 0
 UpperCamelCase__       :     Optional[int] 							= 0
 UpperCamelCase__       :     List[Any] 							= n
 while temp > 0:
  UpperCamelCase__							,					UpperCamelCase__       :     Dict 							= divmod(lowercase_     ,			10  )
  digit_histogram[rem] += 1
  digit_total += 1

 for cnt, i in zip(lowercase_     ,			range(len(lowercase_  )  )  ):
  total += cnt * i**digit_total

 return n == total

def       _a	(					SCREAMING_SNAKE_CASE						:					List[Any]  ):







 """simple docstring"""



 if not isinstance(lowercase_     ,			lowercase_  ) or n < 1:
  return False
 UpperCamelCase__       :     Optional[Any] 							= len(str(lowercase_  )  )  # the power that all digits will be raised to
 # check if sum of each digit multiplied expo times is equal to number
 return n == sum(int(lowercase_  ) ** expo for i in str(lowercase_  )  )

def       _a	(					):







 """simple docstring"""



 UpperCamelCase__       :     Any 							= int(input('''Enter an integer to see if it is an Armstrong number: '''  ).strip()  )
 print(F"{num} is {'' if armstrong_number(lowercase_  ) else 'not '}an Armstrong number."  )
 print(F"{num} is {'' if narcissistic_number(lowercase_  ) else 'not '}an Armstrong number."  )
 print(F"{num} is {'' if pluperfect_number(lowercase_  ) else 'not '}an Armstrong number."  )


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()








import argparse

import torch

from transformers import MraConfig, MraForMaskedLM




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						Any:

    """simple docstring"""


    if "model" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''model.'''       ,  ''''''   )
    if "norm1" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''norm1'''       ,  '''attention.output.LayerNorm'''   )
    if "norm2" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''norm2'''       ,  '''output.LayerNorm'''   )
    if "norm" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''norm'''       ,  '''LayerNorm'''   )
    if "transformer" in orig_key:
        __UpperCamelCase			=    orig_key.split('''.'''   )[0].split('''_'''   )[-1]
        __UpperCamelCase			=    orig_key.replace(F"transformer_{layer_num}"       ,  F"encoder.layer.{layer_num}"   )
    if "mha.attn" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''mha.attn'''       ,  '''attention.self'''   )
    if "mha" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''mha'''       ,  '''attention'''   )
    if "W_q" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''W_q'''       ,  '''self.query'''   )
    if "W_k" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''W_k'''       ,  '''self.key'''   )
    if "W_v" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''W_v'''       ,  '''self.value'''   )
    if "ff.0" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''ff.0'''       ,  '''intermediate.dense'''   )
    if "ff.2" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''ff.2'''       ,  '''output.dense'''   )
    if "ff" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''ff'''       ,  '''output.dense'''   )
    if "mlm_class" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''mlm.mlm_class'''       ,  '''cls.predictions.decoder'''   )
    if "mlm" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''mlm'''       ,  '''cls.predictions.transform'''   )
    if "backbone.backbone.encoders" in orig_key:
        __UpperCamelCase			=    orig_key.replace('''backbone.backbone.encoders'''       ,  '''encoder.layer'''   )
    if "cls" not in orig_key:
        __UpperCamelCase			=    '''mra.''' + orig_key

    return orig_key




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						Optional[int]:

    """simple docstring"""


    for key in orig_state_dict.copy().keys():
        __UpperCamelCase			=    orig_state_dict.pop(lowercase_   )

        if ("pooler" in key) or ("sen_class" in key):
            continue
        else:
            __UpperCamelCase			=    val

    __UpperCamelCase			=    orig_state_dict['''cls.predictions.decoder.bias''']
    __UpperCamelCase			=    torch.arange(lowercase_   ).expand((1, -1)   ) + 2

    return orig_state_dict




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						List[str]:

    """simple docstring"""


    __UpperCamelCase			=    torch.load(lowercase_       ,  map_location='''cpu'''   )['''model_state_dict''']
    __UpperCamelCase			=    MraConfig.from_json_file(lowercase_   )
    __UpperCamelCase			=    MraForMaskedLM(lowercase_   )

    __UpperCamelCase			=    convert_checkpoint_helper(config.max_position_embeddings       ,  lowercase_   )

    print(model.load_state_dict(lowercase_   )   )
    model.eval()
    model.save_pretrained(lowercase_   )

    print(F"Checkpoint successfuly converted. Model saved at {pytorch_dump_path}"   )


if __name__ == "__main__":
 a_ 		=  argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--pytorch_model_path", default=None, type=str, required=True, help="Path to Mra pytorch checkpoint."
 )
 parser.add_argument(
     "--config_file",
     default=None,
     type=str,
     required=True,
     help="The json file for Mra model config.",
 )
 parser.add_argument(
     "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
 )
 a_ 		=  parser.parse_args()
 convert_mra_checkpoint(args.pytorch_model_path, args.config_file, args.pytorch_dump_path)






