
import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()



def      __UpperCAmelCase    (  snake_case_							:		Optional[Any]				,					snake_case_							:		int				,					snake_case_							:		str				,					snake_case_							:		List[Any]				):



	'''simple docstring'''



	UpperCAmelCase:					Optional[Any] 						=     ElectraConfig.from_json_file(snake_case_				)
	print(F'Building PyTorch model from configuration: {config}'				)

	if discriminator_or_generator == "discriminator":
		UpperCAmelCase:					Union[str, Any] 						=     ElectraForPreTraining(snake_case_				)
	elif discriminator_or_generator == "generator":
		UpperCAmelCase:					Any 						=     ElectraForMaskedLM(snake_case_				)
	else:
		raise ValueError("The discriminator_or_generator argument should be either 'discriminator' or 'generator'"				)

	# Load weights from tf checkpoint
	load_tf_weights_in_electra(
	    snake_case_				,					snake_case_				,					snake_case_				,					discriminator_or_generator=snake_case_				)

	# Save pytorch-model
	print(F'Save PyTorch model to {pytorch_dump_path}'				)
	torch.save(model.state_dict()				,					snake_case_				)


if __name__ == "__main__":
	snake_case_      :					Tuple				      =     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(
	    '--config_file',
	    default=None,
	    type=str,
	    required=True,
	    help='The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.',
	)
	parser.add_argument(
	    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
	)
	parser.add_argument(
	    '--discriminator_or_generator',
	    default=None,
	    type=str,
	    required=True,
	    help=(
	        'Whether to export the generator or the discriminator. Should be a string, either \'discriminator\' or '
	        '\'generator\'.'
	    ),
	)
	snake_case_      :					Optional[int]				      =     parser.parse_args()
	convert_tf_checkpoint_to_pytorch(
	    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
	)


def      __UpperCAmelCase    (  snake_case_							:		str				):



	'''simple docstring'''



	UpperCAmelCase:					Tuple 						=     str(snake_case_				).strip()
	if not bin_string:
		raise ValueError("Empty string was passed to the function"				)
	UpperCAmelCase:					List[Any] 						=     bin_string[0] == "-"
	if is_negative:
		UpperCAmelCase:					Optional[int] 						=     bin_string[1:]
	if not all(char in "01" for char in bin_string				):
		raise ValueError("Non-binary value was passed to the function"				)
	UpperCAmelCase:					List[str] 						=     0
	for char in bin_string:
		UpperCAmelCase:					Union[str, Any] 						=     2 * decimal_number + int(snake_case_				)
	return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
	from doctest import testmod

	testmod()
