code: 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 			__lowercase     (				a__							,     a__							,     a__							,     a__     )       ->				Any:
  							# Initialise PyTorch model
  							__SCREAMING_SNAKE_CASE								=      ElectraConfig.from_json_file(lowercase__     )
  							print(f"""Building PyTorch model from configuration: {config}"""     )
  
  							if discriminator_or_generator == "discriminator":
  														__SCREAMING_SNAKE_CASE								=      ElectraForPreTraining(lowercase__     )
  							elif discriminator_or_generator == "generator":
  														__SCREAMING_SNAKE_CASE								=      ElectraForMaskedLM(lowercase__     )
  							else:
  														raise ValueError('The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''     )
  
  							# Load weights from tf checkpoint
  							load_tf_weights_in_electra(
  							    lowercase__							,     lowercase__							,     lowercase__							,     discriminator_or_generator=lowercase__     )
  
  							# Save pytorch-model
  							print(f"""Save PyTorch model to {pytorch_dump_path}"""     )
  							torch.save(model.state_dict()							,     lowercase__     )
  
  
  if __name__ == "__main__":
  			lowerCAmelCase__	:  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(
  			    '''--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\'.'''
  			    ),
  			)
  			lowerCAmelCase__	:  Union[str, Any] 		=parser.parse_args()
  			convert_tf_checkpoint_to_pytorch(
  			    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
  			)
  
  
  
  
  
  
  
style_context: 
  
  
  
  def 			__lowercase     (				a__     )       ->				list:
  							__SCREAMING_SNAKE_CASE								=      1.3
  							__SCREAMING_SNAKE_CASE								=      len(a__     )
  							__SCREAMING_SNAKE_CASE								=      False
  
  							while not completed:
  														# Update the gap value for a next comb
  														__SCREAMING_SNAKE_CASE								=      int(gap / shrink_factor     )
  														if gap <= 1:
  																					__SCREAMING_SNAKE_CASE								=      True
  
  														__SCREAMING_SNAKE_CASE								=      0
  														while index + gap < len(a__     ):
  																					if data[index] > data[index + gap]:
  																												# Swap values
  																												__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      data[index + gap], data[index]
  																												__SCREAMING_SNAKE_CASE								=      False
  																					index += 1
  
  							return data
  
  
  if __name__ == "__main__":
  			import doctest
  
  			doctest.testmod()
  
  			lowerCAmelCase__	:  int 		=input('''Enter numbers separated by a comma:\n''').strip()
  			lowerCAmelCase__	:  Dict 		=[int(item) for item in user_input.split(''',''')]
  			print(comb_sort(unsorted))
  
  
  
  
  
  
  