





import argparse
import os

import numpy as np
import tensorflow as tf
import torch

from transformers import BertModel



def 		A_				(     _lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase     )						-> List[Any]:
 UpperCamelCase	:					Dict       	=   ("dense.weight", "attention.self.query", "attention.self.key", "attention.self.value")

 UpperCamelCase	:					Any       	=   (
     ("layer.", "layer_"),
     ("word_embeddings.weight", "word_embeddings"),
     ("position_embeddings.weight", "position_embeddings"),
     ("token_type_embeddings.weight", "token_type_embeddings"),
     (".", "/"),
     ("LayerNorm/weight", "LayerNorm/gamma"),
     ("LayerNorm/bias", "LayerNorm/beta"),
     ("weight", "kernel"),
 )

 if not os.path.isdir(_lowerCAmelCase     ):
  os.makedirs(_lowerCAmelCase     )

 UpperCamelCase	:					str       	=   model.state_dict()

 def to_tf_var_name(_lowerCAmelCase     ):
  for patt, repl in iter(_lowerCAmelCase     ):
   UpperCamelCase	:					str       	=   name.replace(_lowerCAmelCase							,   _lowerCAmelCase     )
  return F"""bert/{name}"""

 def create_tf_var(_lowerCAmelCase							,   _lowerCAmelCase							,   _lowerCAmelCase     ):
  UpperCamelCase	:					str       	=   tf.dtypes.as_dtype(tensor.dtype     )
  UpperCamelCase	:					str       	=   tf.get_variable(dtype=_lowerCAmelCase							,   shape=tensor.shape							,   name=_lowerCAmelCase							,   initializer=tf.zeros_initializer()     )
  session.run(tf.variables_initializer([tf_var]     )     )
  session.run(_lowerCAmelCase     )
  return tf_var

 tf.reset_default_graph()
 with tf.Session() as session:
  for var_name in state_dict:
   UpperCamelCase	:					str       	=   to_tf_var_name(_lowerCAmelCase     )
   UpperCamelCase	:					Union[str, Any]       	=   state_dict[var_name].numpy()
   if any(x in var_name for x in tensors_to_transpose     ):
    UpperCamelCase	:					Any       	=   torch_tensor.T
   UpperCamelCase	:					Any       	=   create_tf_var(tensor=_lowerCAmelCase							,   name=_lowerCAmelCase							,   session=_lowerCAmelCase     )
   tf.keras.backend.set_value(_lowerCAmelCase							,   _lowerCAmelCase     )
   UpperCamelCase	:					List[str]       	=   session.run(_lowerCAmelCase     )
   print(F"""Successfully created {tf_name}: {np.allclose(_lowerCAmelCase							,   _lowerCAmelCase     )}"""     )

  UpperCamelCase	:					Optional[Any]       	=   tf.train.Saver(tf.trainable_variables()     )
  saver.save(_lowerCAmelCase							,   os.path.join(_lowerCAmelCase							,   model_name.replace("-"							,   "_"     ) + ".ckpt"     )     )



def 		A_				(     _lowerCAmelCase=None     )						-> Dict:
 UpperCamelCase	:					str       	=   argparse.ArgumentParser()
 parser.add_argument("--model_name"							,   type=_lowerCAmelCase							,   required=_lowerCAmelCase							,   help="model name e.g. bert-base-uncased"     )
 parser.add_argument(
     "--cache_dir"							,   type=_lowerCAmelCase							,   default=_lowerCAmelCase							,   required=_lowerCAmelCase							,   help="Directory containing pytorch model"     )
 parser.add_argument("--pytorch_model_path"							,   type=_lowerCAmelCase							,   required=_lowerCAmelCase							,   help="/path/to/<pytorch-model-name>.bin"     )
 parser.add_argument("--tf_cache_dir"							,   type=_lowerCAmelCase							,   required=_lowerCAmelCase							,   help="Directory in which to save tensorflow model"     )
 UpperCamelCase	:					List[Any]       	=   parser.parse_args(_lowerCAmelCase     )

 UpperCamelCase	:					Dict       	=   BertModel.from_pretrained(
     pretrained_model_name_or_path=args.model_name							,   state_dict=torch.load(args.pytorch_model_path     )							,   cache_dir=args.cache_dir							,   )

 convert_pytorch_checkpoint_to_tf(model=_lowerCAmelCase							,   ckpt_dir=args.tf_cache_dir							,   model_name=args.model_name     )


if __name__ == "__main__":
    main()





'''simple docstring'''






import tempfile
import unittest

import numpy as np
from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_flax


if is_flax_available():
						import os

						from flax.core.frozen_dict import unfreeze
						from flax.traverse_util import flatten_dict

						from transformers import FlaxBertModel

						UpperCamelCase__:   Tuple								=			"0.12"  # assumed parallelism: 8

@require_flax
@is_staging_test
class 				SCREAMING_SNAKE_CASE(							unittest.TestCase			):







	"""simple docstring"""






	@classmethod
	def      A	(						cls			:     Union[str, Any]		)			->		int:
								UpperCAmelCase :       Optional[Any] 							=		TOKEN
								HfFolder.save_token(__snake_case		)







	@classmethod
	def      A	(						cls			:     List[str]		)			->		Tuple:
								try:
															delete_repo(token=cls._token		,			repo_id='''test-model-flax'''		)
								except HTTPError:
															pass

								try:
															delete_repo(token=cls._token		,			repo_id='''valid_org/test-model-flax-org'''		)
								except HTTPError:
															pass







	def      A	(						self			:     int		)			->		Tuple:
								UpperCAmelCase :       List[Any] 							=		BertConfig(
								    vocab_size=99		,			hidden_size=32		,			num_hidden_layers=5		,			num_attention_heads=4		,			intermediate_size=37		)
								UpperCAmelCase :       Dict 							=		FlaxBertModel(__snake_case		)
								model.push_to_hub('''test-model-flax'''		,			use_auth_token=self._token		)

								UpperCAmelCase :       Tuple 							=		FlaxBertModel.from_pretrained(F"""{USER}/test-model-flax"""		)

								UpperCAmelCase :       List[Any] 							=		flatten_dict(unfreeze(model.params		)		)
								UpperCAmelCase :       Tuple 							=		flatten_dict(unfreeze(new_model.params		)		)

								for key in base_params.keys():
															UpperCAmelCase :       Union[str, Any] 							=		(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(__snake_case		,			1E-3		,			msg=F"""{key} not identical"""		)

								# Reset repo
								delete_repo(token=self._token		,			repo_id='''test-model-flax'''		)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(__snake_case		,			repo_id='''test-model-flax'''		,			push_to_hub=__snake_case		,			use_auth_token=self._token		)

								UpperCAmelCase :       str 							=		FlaxBertModel.from_pretrained(F"""{USER}/test-model-flax"""		)

								UpperCAmelCase :       Any 							=		flatten_dict(unfreeze(model.params		)		)
								UpperCAmelCase :       str 							=		flatten_dict(unfreeze(new_model.params		)		)

								for key in base_params.keys():
															UpperCAmelCase :       Optional[Any] 							=		(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(__snake_case		,			1E-3		,			msg=F"""{key} not identical"""		)







	def      A	(						self			:     Optional[Any]		)			->		Union[str, Any]:
								UpperCAmelCase :       Dict 							=		BertConfig(
								    vocab_size=99		,			hidden_size=32		,			num_hidden_layers=5		,			num_attention_heads=4		,			intermediate_size=37		)
								UpperCAmelCase :       Optional[Any] 							=		FlaxBertModel(__snake_case		)
								model.push_to_hub('''valid_org/test-model-flax-org'''		,			use_auth_token=self._token		)

								UpperCAmelCase :       Union[str, Any] 							=		FlaxBertModel.from_pretrained('''valid_org/test-model-flax-org'''		)

								UpperCAmelCase :       List[Any] 							=		flatten_dict(unfreeze(model.params		)		)
								UpperCAmelCase :       int 							=		flatten_dict(unfreeze(new_model.params		)		)

								for key in base_params.keys():
															UpperCAmelCase :       Any 							=		(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(__snake_case		,			1E-3		,			msg=F"""{key} not identical"""		)

								# Reset repo
								delete_repo(token=self._token		,			repo_id='''valid_org/test-model-flax-org'''		)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(
															    __snake_case		,			repo_id='''valid_org/test-model-flax-org'''		,			push_to_hub=__snake_case		,			use_auth_token=self._token		)

								UpperCAmelCase :       str 							=		FlaxBertModel.from_pretrained('''valid_org/test-model-flax-org'''		)

								UpperCAmelCase :       Any 							=		flatten_dict(unfreeze(model.params		)		)
								UpperCAmelCase :       Optional[Any] 							=		flatten_dict(unfreeze(new_model.params		)		)

								for key in base_params.keys():
															UpperCAmelCase :       int 							=		(base_params[key] - new_params[key]).sum().item()
															self.assertLessEqual(__snake_case		,			1E-3		,			msg=F"""{key} not identical"""		)


def  snake_case_     (					_lowerCAmelCase  :						Optional[Any]   ,      _lowerCAmelCase  :						Any  )      ->   Union[str, Any]:
							UpperCAmelCase :       str 							=		True
							UpperCAmelCase :       int 							=		flatten_dict(modela.params  )
							UpperCAmelCase :       Dict 							=		flatten_dict(modela.params  )
							for key in flat_params_a.keys():
														if np.sum(np.abs(flat_params_a[key] - flat_params_a[key]  )  ) > 1e-4:
																					UpperCAmelCase :       Dict 							=		False

							return models_are_equal




@require_flax
class 				SCREAMING_SNAKE_CASE(							unittest.TestCase			):







	"""simple docstring"""






	def      A	(						self			:     Tuple		)			->		Union[str, Any]:
								UpperCAmelCase :       List[Any] 							=		BertConfig.from_pretrained('''hf-internal-testing/tiny-bert-flax-only'''		)
								UpperCAmelCase :       Dict 							=		FlaxBertModel(__snake_case		)

								UpperCAmelCase :       int 							=		'''bert'''
								with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(os.path.join(__snake_case		,			__snake_case		)		)

															with self.assertRaises(__snake_case		):
																						UpperCAmelCase :       Tuple 							=		FlaxBertModel.from_pretrained(__snake_case		)

															UpperCAmelCase :       str 							=		FlaxBertModel.from_pretrained(__snake_case		,			subfolder=__snake_case		)

								self.assertTrue(check_models_equal(__snake_case		,			__snake_case		)		)







	def      A	(						self			:     List[str]		)			->		Dict:
								UpperCAmelCase :       Dict 							=		BertConfig.from_pretrained('''hf-internal-testing/tiny-bert-flax-only'''		)
								UpperCAmelCase :       Dict 							=		FlaxBertModel(__snake_case		)

								UpperCAmelCase :       Optional[int] 							=		'''bert'''
								with tempfile.TemporaryDirectory() as tmp_dir:
															model.save_pretrained(os.path.join(__snake_case		,			__snake_case		)		,			max_shard_size='''10KB'''		)

															with self.assertRaises(__snake_case		):
																						UpperCAmelCase :       Any 							=		FlaxBertModel.from_pretrained(__snake_case		)

															UpperCAmelCase :       Union[str, Any] 							=		FlaxBertModel.from_pretrained(__snake_case		,			subfolder=__snake_case		)

								self.assertTrue(check_models_equal(__snake_case		,			__snake_case		)		)







	def      A	(						self			:     Optional[int]		)			->		str:
								UpperCAmelCase :       Dict 							=		'''bert'''
								UpperCAmelCase :       int 							=		'''hf-internal-testing/tiny-random-bert-subfolder'''

								with self.assertRaises(__snake_case		):
															UpperCAmelCase :       Optional[Any] 							=		FlaxBertModel.from_pretrained(__snake_case		)

								UpperCAmelCase :       Tuple 							=		FlaxBertModel.from_pretrained(__snake_case		,			subfolder=__snake_case		)

								self.assertIsNotNone(__snake_case		)







	def      A	(						self			:     Dict		)			->		List[Any]:
								UpperCAmelCase :       Optional[int] 							=		'''bert'''
								UpperCAmelCase :       int 							=		'''hf-internal-testing/tiny-random-bert-sharded-subfolder'''
								with self.assertRaises(__snake_case		):
															UpperCAmelCase :       Dict 							=		FlaxBertModel.from_pretrained(__snake_case		)

								UpperCAmelCase :       Union[str, Any] 							=		FlaxBertModel.from_pretrained(__snake_case		,			subfolder=__snake_case		)

								self.assertIsNotNone(__snake_case		)





