code: 
  
  '''simple docstring'''
  
  import argparse
  
  import torch
  
  from transformers import RoFormerConfig, RoFormerForMaskedLM, load_tf_weights_in_roformer
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					Optional[Any]      , __lowerCamelCase				:					int      , __lowerCamelCase				:					str					)		->int:
      _SCREAMING_SNAKE_CASE             =    RoFormerConfig.from_json_file(_A					)
      print(F'Building PyTorch model from configuration: {config}'					)
      _SCREAMING_SNAKE_CASE             =    RoFormerForMaskedLM(_A					)
  
      # Load weights from tf checkpoint
      load_tf_weights_in_roformer(_A      , _A      , _A					)
  
      # Save pytorch-model
      print(F'Save PyTorch model to {pytorch_dump_path}'					)
      torch.save(model.state_dict()      , _A      , _use_new_zipfile_serialization=_A					)
  
  
  if __name__ == "__main__":
        lowercase_			       =				argparse.ArgumentParser()
        # Required parameters
        parser.add_argument(
            """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
        )
        parser.add_argument(
            """--bert_config_file""",
            default=None,
            type=str,
            required=True,
            help=(
                """The config json file corresponding to the pre-trained BERT model. \n"""
                """This specifies the model architecture."""
            ),
        )
        parser.add_argument(
            """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
        )
        lowercase_			       =				parser.parse_args()
        convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  import math
  from timeit import timeit
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      _SCREAMING_SNAKE_CASE             =    0
      _SCREAMING_SNAKE_CASE             =    abs(__lowerCamelCase					)
      while True:
          _SCREAMING_SNAKE_CASE             =    n // 10
          digits += 1
          if n == 0:
              break
      return digits
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      return 1 if n == 0 else math.floor(math.log(abs(__lowerCamelCase					)      , 10					) + 1					)
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->int:
      return len(str(abs(__lowerCamelCase					)					)					)
  
  
  
  
  
  def lowerCamelCase		(  )		->None:
      from collections.abc import Callable
  
      def benchmark_a_function(__lowerCamelCase				:					Callable      , __lowerCamelCase				:					int					) -> None:
          _SCREAMING_SNAKE_CASE             =    F'{func.__name__}({value})'
          _SCREAMING_SNAKE_CASE             =    timeit(F'__main__.{call}'      , setup="""import __main__"""					)
          print(F'{call}: {func(__lowerCamelCase					)} -- {timing} seconds'					)
  
      for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
          for func in (num_digits, num_digits_fast, num_digits_faster):
              benchmark_a_function(__lowerCamelCase      , __lowerCamelCase					)
          print()
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
        benchmark()
  
  
  
  