


import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def 							__lowercase   ( __lowerCAmelCase							:				str					,    __lowerCAmelCase							:				Any					,    __lowerCAmelCase							:				int   ):
							# Construct model
							if gpta_config_file == "":
														a__             =     GPTaConfig()
							else:
														a__             =     GPTaConfig.from_json_file(__lowerCAmelCase   )
							a__             =     GPTaModel(__lowerCAmelCase   )

							# Load weights from numpy
							load_tf_weights_in_gpta(__lowerCAmelCase					,    __lowerCAmelCase					,    __lowerCAmelCase   )

							# Save pytorch-model
							a__             =     pytorch_dump_folder_path + '/' + WEIGHTS_NAME
							a__             =     pytorch_dump_folder_path + '/' + CONFIG_NAME
							print(F'Save PyTorch model to {pytorch_weights_dump_path}'   )
							torch.save(model.state_dict()					,    __lowerCAmelCase   )
							print(F'Save configuration file to {pytorch_config_dump_path}'   )
							with open(__lowerCAmelCase					,    'w'					,    encoding='utf-8'   ) as f:
														f.write(config.to_json_string()   )


if __name__ == "__main__":
						snake_case							:       List[Any]     			=      argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--gpt2_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
						)
						parser.add_argument(
						    '''--gpt2_config_file''',
						    default='''''',
						    type=str,
						    help=(
						        '''An optional config json file corresponding to the pre-trained OpenAI model. \n'''
						        '''This specifies the model architecture.'''
						    ),
						)
						snake_case							:       Any     			=      parser.parse_args()
						convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)








def 							__lowercase   ( __lowerCAmelCase							:				str					,    __lowerCAmelCase							:				str   ):

							def get_matched_characters(__lowerCAmelCase							:				str					,    __lowerCAmelCase							:				str   ) -> str:
														a__             =     []
														a__             =     min(len(_stra   )					,    len(_stra   )   ) // 2
														for i, l in enumerate(_stra   ):
																					a__             =     int(max(0					,    i - limit   )   )
																					a__             =     int(min(i + limit + 1					,    len(_stra   )   )   )
																					if l in _stra[left:right]:
																												matched.append(__lowerCAmelCase   )
																												a__             =     F'{_stra[0:_stra.index(__lowerCAmelCase   )]} {_stra[_stra.index(__lowerCAmelCase   ) + 1:]}'

														return "".join(__lowerCAmelCase   )

							# matching characters
							a__             =     get_matched_characters(__lowerCAmelCase					,    __lowerCAmelCase   )
							a__             =     get_matched_characters(__lowerCAmelCase					,    __lowerCAmelCase   )
							a__             =     len(__lowerCAmelCase   )

							# transposition
							a__             =     (
							    len([(ca, ca) for ca, ca in zip(__lowerCAmelCase					,    __lowerCAmelCase   ) if ca != ca]   ) // 2
							)

							if not match_count:
														a__             =     0.0
							else:
														a__             =     (
														    1
														    / 3
														    * (
														        match_count / len(__lowerCAmelCase   )
														        + match_count / len(__lowerCAmelCase   )
														        + (match_count - transpositions) / match_count
														    )
														)

							# common prefix up to 4 characters
							a__             =     0
							for ca, ca in zip(stra[:4]					,    stra[:4]   ):
														if ca == ca:
																					prefix_len += 1
														else:
																					break

							return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						print(jaro_winkler('''hello''', '''world'''))




