





def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			Union[str, Any]    )->Dict:
       # "extended trapezoidal rule"
       # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
       A__		   =		(boundary[1] - boundary[0]) / steps
       A__		   =		boundary[0]
       A__		   =		boundary[1]
       A__		   =		make_points(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__    )
       A__		   =		0.0
       y += (h / 2.0) * f(UpperCamelCase__    )
       for i in x_i:
              # print(i)
              y += h * f(UpperCamelCase__    )
       y += (h / 2.0) * f(UpperCamelCase__    )
       return y


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			Union[str, Any]					,	UpperCamelCase__     :			Optional[Any]    )->Union[str, Any]:
       A__		   =		a + h
       while x < (b - h):
              yield x
              A__		   =		x + h


def       UpperCamelCase__(			UpperCamelCase__     :			str    )->Tuple:  # enter your function here
       A__		   =		(x - 0) * (x - 0)
       return y


def       UpperCamelCase__(			)->Dict:
       A__		   =		0.0  # Lower bound of integration
       A__		   =		1.0  # Upper bound of integration
       A__		   =		10.0  # define number of steps or resolution
       A__		   =		[a, b]  # define boundary of integration
       A__		   =		method_a(UpperCamelCase__					,	UpperCamelCase__    )
       print(f"y = {y}"    )


if __name__ == "__main__":
       main()












import argparse

import torch

from transformers import RemBertConfig, RemBertModel, load_tf_weights_in_rembert
from transformers.utils import logging


logging.set_verbosity_info()


def       UpperCamelCase__(			UpperCamelCase__     :			Any					,	UpperCamelCase__     :			int					,	UpperCamelCase__     :			List[Any]    )->Optional[int]:
       # Initialise PyTorch model
       A__		   =		RemBertConfig.from_json_file(UpperCamelCase__    )
       print('''Building PyTorch model from configuration: {}'''.format(str(UpperCamelCase__    )    )    )
       A__		   =		RemBertModel(UpperCamelCase__    )

       # Load weights from tf checkpoint
       load_tf_weights_in_rembert(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__    )

       # Save pytorch-model
       print('''Save PyTorch model to {}'''.format(UpperCamelCase__    )    )
       torch.save(model.state_dict()					,	UpperCamelCase__    )


if __name__ == "__main__":
       a__: List[Any]							   =						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(
           '--rembert_config_file',
           default=None,
           type=str,
           required=True,
           help=(
               'The config json file corresponding to the pre-trained RemBERT 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.'
       )
       a__: Union[str, Any]							   =						parser.parse_args()
       convert_rembert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.rembert_config_file, args.pytorch_dump_path)





