


'''simple docstring'''






import argparse
import pickle

import numpy as np
import torch
from torch import nn

from transformers import ReformerConfig, ReformerModelWithLMHead
from transformers.utils import logging


logging.set_verbosity_info()


def       _snake_case     (  A				,					A				,					A=None )		->					Dict:
							# set parameter of one layer
							assert torch_layer.weight.shape == weight.shape, F"""{torch_layer} layer.weight does not match"""
							lowerCAmelCase__      =			nn.Parameter(A )
							if bias is not None:
														assert torch_layer.bias.shape == bias.shape, F"""{torch_layer} layer.bias does not match"""
														lowerCAmelCase__      =			nn.Parameter(A )


def       _snake_case     (  A				,					A				,					A )		->					List[str]:
							# set torch weights for 1-to-1 comparison
							lowerCAmelCase__      =			np.asarray(weights[0] )
							lowerCAmelCase__      =			np.asarray(weights[1] )
							lowerCAmelCase__      =			np.asarray(weights[2] )

							set_param(
							    torch_layer.self_attention.query_key				,					torch.tensor(A ).transpose(1				,					2 ).contiguous().view(-1				,					A )				,					)
							set_param(
							    torch_layer.self_attention.value				,					torch.tensor(A ).transpose(1				,					2 ).contiguous().view(-1				,					A )				,					)
							set_param(
							    torch_layer.output.dense				,					torch.tensor(A ).view(-1				,					A ).contiguous().transpose(0				,					1 )				,					)


def       _snake_case     (  A				,					A				,					A )		->					Optional[Any]:
							# set torch weights for 1-to-1 comparison
							lowerCAmelCase__      =			np.asarray(weights[0] )
							lowerCAmelCase__      =			np.asarray(weights[1] )
							lowerCAmelCase__      =			np.asarray(weights[2] )
							lowerCAmelCase__      =			np.asarray(weights[3] )

							set_param(
							    torch_layer.self_attention.query				,					torch.tensor(A ).transpose(1				,					2 ).contiguous().view(-1				,					A )				,					)
							set_param(
							    torch_layer.self_attention.key				,					torch.tensor(A ).transpose(1				,					2 ).contiguous().view(-1				,					A )				,					)
							set_param(
							    torch_layer.self_attention.value				,					torch.tensor(A ).transpose(1				,					2 ).contiguous().view(-1				,					A )				,					)
							set_param(
							    torch_layer.output.dense				,					torch.tensor(A ).view(-1				,					A ).contiguous().transpose(0				,					1 )				,					)


def       _snake_case     (  A				,					A				,					A )		->					int:
							# layernorm 1
							lowerCAmelCase__      =			weights[0][0][0]
							lowerCAmelCase__      =			np.asarray(layer_norm_a[0] )
							lowerCAmelCase__      =			np.asarray(layer_norm_a[1] )
							set_param(
							    torch_block.attention.layer_norm				,					torch.tensor(A )				,					torch.tensor(A )				,					)

							# lsh weights + output
							lowerCAmelCase__      =			weights[0][1]
							if len(A ) < 4:
														set_layer_weights_in_torch_lsh(A				,					torch_block.attention				,					A )
							else:
														set_layer_weights_in_torch_local(A				,					torch_block.attention				,					A )

							# intermediate weighs
							lowerCAmelCase__      =			weights[2][0][1][2]

							# Chunked Feed Forward
							if len(A ) == 4:
														lowerCAmelCase__      =			intermediate_weights[2]

							# layernorm 2
							lowerCAmelCase__      =			np.asarray(intermediate_weights[0][0] )
							lowerCAmelCase__      =			np.asarray(intermediate_weights[0][1] )
							set_param(
							    torch_block.feed_forward.layer_norm				,					torch.tensor(A )				,					torch.tensor(A )				,					)

							# intermediate dense
							lowerCAmelCase__      =			np.asarray(intermediate_weights[1][0] )
							lowerCAmelCase__      =			np.asarray(intermediate_weights[1][1] )
							set_param(
							    torch_block.feed_forward.dense.dense				,					torch.tensor(A ).transpose(0				,					1 ).contiguous()				,					torch.tensor(A )				,					)

							# intermediate out
							lowerCAmelCase__      =			np.asarray(intermediate_weights[4][0] )
							lowerCAmelCase__      =			np.asarray(intermediate_weights[4][1] )
							set_param(
							    torch_block.feed_forward.output.dense				,					torch.tensor(A ).transpose(0				,					1 ).contiguous()				,					torch.tensor(A )				,					)


def       _snake_case     (  A				,					A				,					A )		->					List[str]:
							# reformer model
							lowerCAmelCase__      =			torch_model.reformer

							# word embeds
							lowerCAmelCase__      =			np.asarray(weights[1] )
							set_param(
							    torch_model_reformer.embeddings.word_embeddings				,					torch.tensor(A )				,					)

							if isinstance(weights[3]				,					A ):
														lowerCAmelCase__      =			torch_model_reformer.embeddings.position_embeddings
														for emb_idx in range(len(position_embeddings.weights ) ):
																					lowerCAmelCase__      =			np.asarray(weights[3][emb_idx][0] )
																					assert (
																					    position_embeddings.weights[emb_idx].shape == emb_weights.shape
																					), F"""{position_embeddings[emb_idx]} emb does not match"""
																					lowerCAmelCase__      =			nn.Parameter(torch.tensor(A ) )

							lowerCAmelCase__      =			weights[5]
							assert len(torch_model_reformer.encoder.layers ) * 4 == len(
							    A ), "HF and trax model do not have the same number of layers"
							for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers ):
														lowerCAmelCase__      =			trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
														set_block_weights_in_torch(A				,					A				,					A )

							# output layer norm
							lowerCAmelCase__      =			np.asarray(weights[7][0] )
							lowerCAmelCase__      =			np.asarray(weights[7][1] )
							set_param(
							    torch_model_reformer.encoder.layer_norm				,					torch.tensor(A )				,					torch.tensor(A )				,					)

							# output embeddings
							lowerCAmelCase__      =			np.asarray(weights[9][0] )
							lowerCAmelCase__      =			np.asarray(weights[9][1] )
							set_param(
							    torch_model.lm_head.decoder				,					torch.tensor(A ).transpose(0				,					1 ).contiguous()				,					torch.tensor(A )				,					)


def       _snake_case     (  A				,					A				,					A )		->					Union[str, Any]:
							# Initialise PyTorch model
							lowerCAmelCase__      =			ReformerConfig.from_json_file(A )
							print(F"""Building PyTorch model from configuration: {config}""" )
							lowerCAmelCase__      =			ReformerModelWithLMHead(A )

							with open(A				,					'''rb''' ) as f:
														lowerCAmelCase__      =			pickle.load(A )['''weights''']

							set_model_weights_in_torch(A				,					A				,					config.hidden_size )

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


if __name__ == "__main__":
		__UpperCAmelCase					       =							argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '''--trax_model_pkl_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 Reformer 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.'''
		)
		__UpperCAmelCase					       =							parser.parse_args()
		convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)



'''simple docstring'''






from collections import Counter
from timeit import timeit


def       _snake_case     (  A = ""				,					)		->					bool:
							return sum(c % 2 for c in Counter(input_str.replace(''' '''				,					'''''' ).lower() ).values() ) < 2


def       _snake_case     (  A = "" )		->					bool:
							if len(A ) == 0:
														return True
							lowerCAmelCase__      =			input_str.replace(''' '''				,					'''''' ).lower()
							# character_freq_dict: Stores the frequency of every character in the input string
							lowerCAmelCase__      =			{}

							for character in lower_case_input_str:
														lowerCAmelCase__      =			character_freq_dict.get(A				,					0 ) + 1
							lowerCAmelCase__      =			0

							for character_count in character_freq_dict.values():
														if character_count % 2:
																					odd_char += 1
							if odd_char > 1:
														return False
							return True


def       _snake_case     (  A = "" )		->					None:
							print('''\nFor string = '''				,					A				,					''':''' )
							print(
							    '''> can_string_be_rearranged_as_palindrome_counter()'''				,					'''\tans ='''				,					can_string_be_rearranged_as_palindrome_counter(A )				,					'''\ttime ='''				,					timeit(
							        '''z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'''				,					setup='''import __main__ as z'''				,					)				,					'''seconds'''				,					)
							print(
							    '''> can_string_be_rearranged_as_palindrome()'''				,					'''\tans ='''				,					can_string_be_rearranged_as_palindrome(A )				,					'''\ttime ='''				,					timeit(
							        '''z.can_string_be_rearranged_as_palindrome(z.check_str)'''				,					setup='''import __main__ as z'''				,					)				,					'''seconds'''				,					)


if __name__ == "__main__":
		__UpperCAmelCase					       =							input(
		    '''Enter string to determine if it can be rearranged as a palindrome or not: '''
		).strip()
		benchmark(check_str)
		__UpperCAmelCase					       =							can_string_be_rearranged_as_palindrome_counter(check_str)
		print(f"""{check_str} can {'' if status else 'not '}be rearranged as a palindrome""")