




class 				__snake_case     :
				class 				__snake_case     :
								lowerCAmelCase__			=   "_prev", "_data", "_next"



								def __init__(					self					:						Optional[int]						,		_UpperCAmelCase					:						Optional[int]						,		_UpperCAmelCase					:						Dict						,		_UpperCAmelCase					:						Dict					)     ->			str:





												'''simple docstring'''




												_lowerCAmelCase			:			int        =					link_p
												_lowerCAmelCase			:			Tuple        =					element
												_lowerCAmelCase			:			Dict        =					link_n



								def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[Any]					)     ->			List[str]:





												'''simple docstring'''




												return (
												    f" Prev -> {self._prev is not None}, Next -> {self._next is not None}"
												)






				def __init__(					self					:						Any					)     ->			Optional[int]:





								'''simple docstring'''




								_lowerCAmelCase			:			int        =					self._Node(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase					)
								_lowerCAmelCase			:			str        =					self._Node(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase					)
								_lowerCAmelCase			:			str        =					self._trailer
								_lowerCAmelCase			:			List[str]        =					self._header
								_lowerCAmelCase			:			int        =					0



				def __len__(					self					:						Optional[int]					)     ->			List[Any]:





								'''simple docstring'''




								return self._size



				def 					SCREAMING_SNAKE_CASE				(					self					:						Any					)     ->			str:





								'''simple docstring'''




								return self.__len__() == 0



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[Any]						,		_UpperCAmelCase					:						Optional[Any]						,		_UpperCAmelCase					:						List[Any]						,		_UpperCAmelCase					:						Optional[int]					)     ->			List[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			int        =					self._Node(_UpperCAmelCase						,		_UpperCAmelCase						,		_UpperCAmelCase					)
								_lowerCAmelCase			:			Optional[Any]        =					new_node
								_lowerCAmelCase			:			int        =					new_node
								self._size += 1
								return self



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[int]						,		_UpperCAmelCase					:						Dict					)     ->			int:





								'''simple docstring'''




								_lowerCAmelCase			:			str        =					node._prev
								_lowerCAmelCase			:			Optional[int]        =					node._next

								_lowerCAmelCase			:			str        =					successor
								_lowerCAmelCase			:			Dict        =					predecessor
								self._size -= 1
								_lowerCAmelCase			:			List[str]        =					node._data
								_lowerCAmelCase			:			str        =					None
								del node
								return temp






class 				__snake_case     (_DoublyLinkedBase						):



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[Any]					)     ->			int:





								'''simple docstring'''




								if self.is_empty():
												raise Exception("""List is empty"""					)
								return self._header._next._data



				def 					SCREAMING_SNAKE_CASE				(					self					:						int					)     ->			List[Any]:





								'''simple docstring'''




								if self.is_empty():
												raise Exception("""List is empty"""					)
								return self._trailer._prev._data



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[int]						,		_UpperCAmelCase					:						Optional[Any]					)     ->			Tuple:





								'''simple docstring'''




								return self._insert(self._header						,		_UpperCAmelCase						,		self._header._next					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						int						,		_UpperCAmelCase					:						Dict					)     ->			Union[str, Any]:





								'''simple docstring'''




								return self._insert(self._trailer._prev						,		_UpperCAmelCase						,		self._trailer					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Tuple					)     ->			Union[str, Any]:





								'''simple docstring'''




								if self.is_empty():
												raise IndexError("""remove_first from empty list"""					)
								return self._delete(self._header._next					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[str]					)     ->			Optional[Any]:





								'''simple docstring'''




								if self.is_empty():
												raise IndexError("""remove_first from empty list"""					)
								return self._delete(self._trailer._prev					)


import argparse

import torch
from flax.training.checkpoints import restore_checkpoint

from transformers import FNetConfig, FNetForPreTraining
from transformers.utils import logging


logging.set_verbosity_info()






def       __lowerCamelCase		(						lowerCAmelCase__	,  lowerCAmelCase__	,  lowerCAmelCase__	):
       # Initialise PyTorch model
       lowerCAmelCase__     	=					FNetConfig.from_json_file(lowerCAmelCase__	)
       print(F"""Building PyTorch model from configuration: {config}"""	)
       lowerCAmelCase__     	=					FNetForPreTraining(lowerCAmelCase__	)

       lowerCAmelCase__     	=					restore_checkpoint(lowerCAmelCase__	,  lowerCAmelCase__	)
       lowerCAmelCase__     	=					checkpoint_dict['target']

       # Embeddings
       # Position IDs
       lowerCAmelCase__     	=					fnet_pretraining_model.state_dict()

       lowerCAmelCase__     	=					state_dict['fnet.embeddings.position_ids']
       lowerCAmelCase__     	=					{'fnet.embeddings.position_ids': position_ids}
       # Embedding Layers
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['word']['embedding']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['position']['embedding'][0]	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['type']['embedding']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['hidden_mapping_in']['kernel']	).T
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['hidden_mapping_in']['bias']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['layer_norm']['scale']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['layer_norm']['bias']	)

       # Encoder Layers
       for layer in range(config.num_hidden_layers	):
              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""encoder_{layer}"""]['mixing_layer_norm']['scale']	)
              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""encoder_{layer}"""]['mixing_layer_norm']['bias']	)

              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['intermediate']['kernel']	).T
              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['intermediate']['bias']	)

              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['output']['kernel']	).T
              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""feed_forward_{layer}"""]['output']['bias']	)

              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""encoder_{layer}"""]['output_layer_norm']['scale']	)
              lowerCAmelCase__     	=					torch.tensor(
                  pretrained_model_params['encoder'][F"""encoder_{layer}"""]['output_layer_norm']['bias']	)

       # Pooler Layers
       lowerCAmelCase__     	=					torch.tensor(pretrained_model_params['encoder']['pooler']['kernel']	).T
       lowerCAmelCase__     	=					torch.tensor(pretrained_model_params['encoder']['pooler']['bias']	)

       # Masked LM Layers
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['predictions_dense']['kernel']	).T
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['predictions_dense']['bias']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['predictions_layer_norm']['scale']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['predictions_layer_norm']['bias']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['encoder']['embedder']['word']['embedding']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['predictions_output']['output_bias']	)
       lowerCAmelCase__     	=					torch.tensor(pretrained_model_params['predictions_output']['output_bias']	)

       # Seq Relationship Layers
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['classification']['output_kernel']	)
       lowerCAmelCase__     	=					torch.tensor(
           pretrained_model_params['classification']['output_bias']	)

       # Load State Dict
       fnet_pretraining_model.load_state_dict(lowerCAmelCase__	)

       # Save PreTrained
       print(F"""Saving pretrained model to {save_path}"""	)
       fnet_pretraining_model.save_pretrained(lowerCAmelCase__	)


if __name__ == "__main__":
    lowerCAmelCase__							= argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '--flax_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
    )
    parser.add_argument(
        '--fnet_config_file',
        default=None,
        type=str,
        required=True,
        help=(
            'The config json file corresponding to the pre-trained FNet model. \n'
            'This specifies the model architecture.'
        ),
    )
    parser.add_argument('--save_path', default=None, type=str, required=True, help='Path to the output model.')
    lowerCAmelCase__							= parser.parse_args()
    convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)
