


'''simple docstring'''

import argparse
import os

import numpy as np
import tensorflow as tf
import torch

from transformers import BertModel





def __snake_case      (   UpperCAmelCase_		:		List[Any]      ,       UpperCAmelCase_		:		List[Any]      ,       UpperCAmelCase_		:		Any	):
 lowerCamelCase_  				=						("dense.weight", "attention.self.query", "attention.self.key", "attention.self.value")

 lowerCamelCase_  				=						(
     ("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(UpperCAmelCase_	):
  os.makedirs(UpperCAmelCase_	)

 lowerCamelCase_  				=						model.state_dict()

 def to_tf_var_name(UpperCAmelCase_		:		Optional[Any]	):
  for patt, repl in iter(UpperCAmelCase_	):
   lowerCamelCase_  				=						name.replace(UpperCAmelCase_      ,       UpperCAmelCase_	)
  return F'''bert/{name}'''

 def create_tf_var(UpperCAmelCase_		:		Optional[Any]      ,       UpperCAmelCase_		:		Dict      ,       UpperCAmelCase_		:		List[Any]	):
  lowerCamelCase_  				=						tf.dtypes.as_dtype(tensor.dtype	)
  lowerCamelCase_  				=						tf.get_variable(dtype=UpperCAmelCase_      ,       shape=tensor.shape      ,       name=UpperCAmelCase_      ,       initializer=tf.zeros_initializer()	)
  session.run(tf.variables_initializer([tf_var]	)	)
  session.run(UpperCAmelCase_	)
  return tf_var

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

  lowerCamelCase_  				=						tf.train.Saver(tf.trainable_variables()	)
  saver.save(UpperCAmelCase_      ,       os.path.join(UpperCAmelCase_      ,       model_name.replace("-"      ,       "_"	) + ".ckpt"	)	)





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

 lowerCamelCase_  				=						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=UpperCAmelCase_      ,       ckpt_dir=args.tf_cache_dir      ,       model_name=args.model_name	)


if __name__ == "__main__":
     main()







'''simple docstring'''

import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
     import tensorflow as tf

     from transformers import TensorFlowBenchmark, TensorFlowBenchmarkArguments





@require_tf
class   snake_case					(					unittest.TestCase    ):





  """simple docstring"""




  def 						snake_case	(					self    ,						UpperCamelCase  ):







   """simple docstring"""
   for model_result in results.values():
    for batch_size, sequence_length in zip(model_result["bs"]    ,						model_result["ss"]  ):
     lowerCamelCase_  				=						model_result["result"][batch_size][sequence_length]
     self.assertIsNotNone(UpperCamelCase  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sgugger/tiny-distilbert-classification"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						only_pretrain_model=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_train_result  )
   self.check_results_dict_not_empty(results.memory_train_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_train_result  )
   self.check_results_dict_not_empty(results.memory_train_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"patrickvonplaten/t5-tiny-random"
   lowerCamelCase_  				=						AutoConfig.from_pretrained(UpperCamelCase  )
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase    ,						configs=[config]  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  @unittest.skipIf(is_tf_available() and len(tf.config.list_physical_devices("GPU"  )  ) == 0    ,						"Cannot do xla on CPU."  )
  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
       models=[MODEL_ID]    ,						training=UpperCamelCase    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						use_xla=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
   lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
   lowerCamelCase_  				=						benchmark.run()
   self.check_results_dict_not_empty(results.time_inference_result  )
   self.check_results_dict_not_empty(results.memory_inference_result  )






  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"
   with tempfile.TemporaryDirectory() as tmp_dir:
    lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
        models=[MODEL_ID]    ,						inference=UpperCamelCase    ,						save_to_csv=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						inference_time_csv_file=os.path.join(UpperCamelCase    ,						"inf_time.csv"  )    ,						inference_memory_csv_file=os.path.join(UpperCamelCase    ,						"inf_mem.csv"  )    ,						env_info_csv_file=os.path.join(UpperCamelCase    ,						"env.csv"  )    ,						multi_process=UpperCamelCase    ,						)
    lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
    benchmark.run()
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"inf_time.csv"  )  ).exists()  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"inf_mem.csv"  )  ).exists()  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"env.csv"  )  ).exists()  )







  def 						snake_case	(					self  ):







   """simple docstring"""
   lowerCamelCase_  				=						"sshleifer/tiny-gpt2"

   def _check_summary_is_not_empty(UpperCamelCase  ):
    self.assertTrue(hasattr(UpperCamelCase    ,						"sequential"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"cumulative"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"current"  )  )
    self.assertTrue(hasattr(UpperCamelCase    ,						"total"  )  )

   with tempfile.TemporaryDirectory() as tmp_dir:
    lowerCamelCase_  				=						TensorFlowBenchmarkArguments(
        models=[MODEL_ID]    ,						inference=UpperCamelCase    ,						sequence_lengths=[8]    ,						batch_sizes=[1]    ,						log_filename=os.path.join(UpperCamelCase    ,						"log.txt"  )    ,						log_print=UpperCamelCase    ,						trace_memory_line_by_line=UpperCamelCase    ,						eager_mode=UpperCamelCase    ,						multi_process=UpperCamelCase    ,						)
    lowerCamelCase_  				=						TensorFlowBenchmark(UpperCamelCase  )
    lowerCamelCase_  				=						benchmark.run()
    _check_summary_is_not_empty(result.inference_summary  )
    self.assertTrue(Path(os.path.join(UpperCamelCase    ,						"log.txt"  )  ).exists()  )



