





'''simple docstring'''


def       __snake_case		( SCREAMING_SNAKE_CASE_ :			List[str]			,	SCREAMING_SNAKE_CASE_ :			Tuple )							->     Optional[Any]:

       """simple docstring"""


       UpperCAmelCase  =						(boundary[1] - boundary[0]) / steps
       UpperCAmelCase  =						boundary[0]
       UpperCAmelCase  =						boundary[1]
       UpperCAmelCase  =						make_points(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )
       UpperCAmelCase  =						0.0
       y += (h / 2.0) * f(SCREAMING_SNAKE_CASE_ )
       for i in x_i:
              # print(i)
              y += h * f(SCREAMING_SNAKE_CASE_ )
       y += (h / 2.0) * f(SCREAMING_SNAKE_CASE_ )
       return y
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Dict			,	SCREAMING_SNAKE_CASE_ :			List[Any]			,	SCREAMING_SNAKE_CASE_ :			List[Any] )							->     Any:

       """simple docstring"""


       UpperCAmelCase  =						a + h
       while x < (b - h):
              yield x
              UpperCAmelCase  =						x + h
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			Union[str, Any] )							->     Tuple:  # enter your function here

       """simple docstring"""


       UpperCAmelCase  =						(x - 0) * (x - 0)
       return y
def       __snake_case		( )							->     Union[str, Any]:

       """simple docstring"""


       UpperCAmelCase  =						0.0  # Lower bound of integration
       UpperCAmelCase  =						1.0  # Upper bound of integration
       UpperCAmelCase  =						10.0  # define number of steps or resolution
       UpperCAmelCase  =						[a, b]  # define boundary of integration
       UpperCAmelCase  =						method_a(SCREAMING_SNAKE_CASE_			,	SCREAMING_SNAKE_CASE_ )
       print(f"y = {y}" )


if __name__ == "__main__":
    main()



import argparse

import torch

from transformers import MobileBertConfig, MobileBertForPreTraining, load_tf_weights_in_mobilebert
from transformers.utils import logging


logging.set_verbosity_info()





def 			lowercase(	UpperCamelCase_							,					UpperCamelCase_							,					UpperCamelCase_       )		->	Any:







 '''simple docstring'''
 # Initialise PyTorch model
 UpperCamelCase			  =      MobileBertConfig.from_json_file(UpperCamelCase_       )
 print(f"""Building PyTorch model from configuration: {config}"""       )
 UpperCamelCase			  =      MobileBertForPreTraining(UpperCamelCase_       )
 # Load weights from tf checkpoint
 UpperCamelCase			  =      load_tf_weights_in_mobilebert(UpperCamelCase_							,					UpperCamelCase_							,					UpperCamelCase_       )
 # Save pytorch-model
 print(f"""Save PyTorch model to {pytorch_dump_path}"""       )
 torch.save(model.state_dict()							,					UpperCamelCase_       )


if __name__ == "__main__":
     _SCREAMING_SNAKE_CASE 		=      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(
         """--mobilebert_config_file""",
         default=None,
         type=str,
         required=True,
         help=(
             """The config json file corresponding to the pre-trained MobileBERT 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."""
     )
     _SCREAMING_SNAKE_CASE 		=      parser.parse_args()
     convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.mobilebert_config_file, args.pytorch_dump_path)
