


"""simple docstring"""







import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
 import tensorflow as tf
 from tensorflow.python.framework.errors_impl import ResourceExhaustedError

 from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
 import pyanvml.pyanvml as nvml

__lowercase    					=      logging.get_logger(__name__)


def      lowercase			(				A_  ,   A_       )->      Optional[Any]:
  '''simple docstring'''







  def run_func(A_       ):
    @wraps(A_       )
    def run_in_eager_mode(*A_  ,   **A_       ):
      return func(*A_  ,   **A_       )

    @wraps(A_       )
    @tf.function(experimental_compile=A_       )
    def run_in_graph_mode(*A_  ,   **A_       ):
      return func(*A_  ,   **A_       )

    if do_eager_mode is True:
      if use_xla is not False:
        raise ValueError(
            "Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`."       )
      return run_in_eager_mode
    else:
      return run_in_graph_mode

  return run_func


def      lowercase			(				A_  ,   A_  ,   A_       )->      ["tf.Tensor"]:
  '''simple docstring'''







  a						:		Dict      							=			random.Random()
  a						:		Optional[int]      							=			[rng.randint(0  ,   vocab_size - 1       ) for i in range(batch_size * sequence_length       )]
  return tf.constant(A_  ,   shape=(batch_size, sequence_length)  ,   dtype=tf.intaa       )







class 						_A  (  _a  ):







    """simple docstring"""




    UpperCAmelCase       :							TensorFlowBenchmarkArguments
    UpperCAmelCase       :							PretrainedConfig
    UpperCAmelCase       :							str	=       "TensorFlow"






    @property
    def 	__snake_case							(					self				:    Any):
      return tf.__version__






    def 	__snake_case							(					self				:    Optional[Any]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      # initialize GPU on separate process
      a						:		Union[str, Any]      							=			self.args.strategy
      if strategy is None:
        raise ValueError("A device strategy has to be initialized before using TensorFlow.")
      a						:		Tuple      							=			self._prepare_inference_func(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)
      return self._measure_speed(_inference)






    def 	__snake_case							(					self				:    str				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      a						:		int      							=			self.args.strategy
      if strategy is None:
        raise ValueError("A device strategy has to be initialized before using TensorFlow.")
      a						:		Any      							=			self._prepare_train_func(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)
      return self._measure_speed(_train)






    def 	__snake_case							(					self				:    int				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      # initialize GPU on separate process
      if self.args.is_gpu:
        tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]				, __UpperCAmelCase)
      a						:		List[Any]      							=			self.args.strategy
      if strategy is None:
        raise ValueError("A device strategy has to be initialized before using TensorFlow.")
      a						:		Any      							=			self._prepare_inference_func(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)
      return self._measure_memory(_inference)






    def 	__snake_case							(					self				:    List[Any]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      if self.args.is_gpu:
        tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]				, __UpperCAmelCase)
      a						:		List[str]      							=			self.args.strategy
      if strategy is None:
        raise ValueError("A device strategy has to be initialized before using TensorFlow.")

      a						:		Optional[int]      							=			self._prepare_train_func(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)
      return self._measure_memory(_train)






    def 	__snake_case							(					self				:    int				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      a						:		List[Any]      							=			self.config_dict[model_name]

      if self.args.fpaa:
        raise NotImplementedError("Mixed precision is currently not supported.")

      a						:		int      							=			(
          hasattr(__UpperCAmelCase				, "architectures")
          and isinstance(config.architectures				, __UpperCAmelCase)
          and len(config.architectures) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
        try:
          a						:		Union[str, Any]      							=			"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
          a						:		int      							=			__import__("transformers"				, fromlist=[model_class])
          a						:		int      							=			getattr(__UpperCAmelCase				, __UpperCAmelCase)
          a						:		List[Any]      							=			model_cls(__UpperCAmelCase)
        except ImportError:
          raise ImportError(
              f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
              " set `--only_pretrain_model` or `args.only_pretrain_model=True`.")
      else:
        a						:		str      							=			TF_MODEL_MAPPING[config.__class__](__UpperCAmelCase)

      # encoder-decoder has vocab size saved differently
      a						:		Dict      							=			config.vocab_size if hasattr(__UpperCAmelCase				, "vocab_size") else config.encoder.vocab_size
      a						:		List[str]      							=			random_input_ids(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)

      @run_with_tf_optimizations(self.args.eager_mode				, self.args.use_xla)
      def encoder_decoder_forward():
        return model(__UpperCAmelCase				, decoder_input_ids=__UpperCAmelCase				, training=__UpperCAmelCase)

      @run_with_tf_optimizations(self.args.eager_mode				, self.args.use_xla)
      def encoder_forward():
        return model(__UpperCAmelCase				, training=__UpperCAmelCase)

      a						:		str      							=			encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

      return _inference






    def 	__snake_case							(					self				:    Union[str, Any]				, __UpperCAmelCase				:    str				, __UpperCAmelCase				:    int				, __UpperCAmelCase				:    int):
      a						:		str      							=			self.config_dict[model_name]

      if self.args.eager_mode is not False:
        raise ValueError("Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.")

      if self.args.fpaa:
        raise NotImplementedError("Mixed precision is currently not supported.")

      a						:		Dict      							=			(
          hasattr(__UpperCAmelCase				, "architectures")
          and isinstance(config.architectures				, __UpperCAmelCase)
          and len(config.architectures) > 0
      )
      if not self.args.only_pretrain_model and has_model_class_in_config:
        try:
          a						:		Union[str, Any]      							=			"TF" + config.architectures[0]  # prepend 'TF' for tensorflow model
          a						:		Optional[Any]      							=			__import__("transformers"				, fromlist=[model_class])
          a						:		List[str]      							=			getattr(__UpperCAmelCase				, __UpperCAmelCase)
          a						:		List[Any]      							=			model_cls(__UpperCAmelCase)
        except ImportError:
          raise ImportError(
              f'''{model_class} does not exist. If you just want to test the pretrained model, you might want to'''
              " set `--only_pretrain_model` or `args.only_pretrain_model=True`.")
      else:
        a						:		Optional[int]      							=			TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__UpperCAmelCase)

      # encoder-decoder has vocab size saved differently
      a						:		int      							=			config.vocab_size if hasattr(__UpperCAmelCase				, "vocab_size") else config.encoder.vocab_size
      a						:		Union[str, Any]      							=			random_input_ids(__UpperCAmelCase				, __UpperCAmelCase				, __UpperCAmelCase)

      @run_with_tf_optimizations(self.args.eager_mode				, self.args.use_xla)
      def encoder_decoder_train():
        a						:		str      							=			model(__UpperCAmelCase				, decoder_input_ids=__UpperCAmelCase				, labels=__UpperCAmelCase				, training=__UpperCAmelCase)[0]
        a						:		Any      							=			tf.gradients(__UpperCAmelCase				, model.trainable_variables)
        return gradients

      @run_with_tf_optimizations(self.args.eager_mode				, self.args.use_xla)
      def encoder_train():
        a						:		List[str]      							=			model(__UpperCAmelCase				, labels=__UpperCAmelCase				, training=__UpperCAmelCase)[0]
        a						:		int      							=			tf.gradients(__UpperCAmelCase				, model.trainable_variables)
        return gradients

      a						:		List[Any]      							=			encoder_decoder_train if config.is_encoder_decoder else encoder_train

      return _train






    def 	__snake_case							(					self				:    Optional[int]				, __UpperCAmelCase				:    Any):
      with self.args.strategy.scope():
        try:
          if self.args.is_tpu or self.args.use_xla:
            # run additional 10 times to stabilize compilation for tpu
            logger.info("Do inference on TPU. Running model 5 times to stabilize compilation")
            timeit.repeat(__UpperCAmelCase				, repeat=1				, number=5)

          # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
          a						:		List[Any]      							=			timeit.repeat(
              __UpperCAmelCase				, repeat=self.args.repeat				, number=10				, )

          return min(__UpperCAmelCase) / 10.0
        except ResourceExhaustedError as e:
          self.print_fn(f'''Doesn\'t fit on GPU. {e}''')






    def 	__snake_case							(					self				:    Dict				, __UpperCAmelCase				:    Callable[[], None]):
      logger.info(
          "Note that TensorFlow allocates more memory than "
          "it might need to speed up computation. "
          "The memory reported here corresponds to the memory "
          "reported by `nvidia-smi`, which can vary depending "
          "on total available memory on the GPU that is used.")
      with self.args.strategy.scope():
        try:
          if self.args.trace_memory_line_by_line:
            if not self.args.eager_mode:
              raise ValueError(
                  "`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory"
                  " consumption line by line.")
            a						:		List[Any]      							=			start_memory_tracing("transformers")

          if self.args.is_tpu:
            # tpu
            raise NotImplementedError(
                "Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking"
                " with `args.memory=False`")
          elif self.args.is_gpu:
            # gpu
            if not is_pyanvml_available():
              logger.warning(
                  "py3nvml not installed, we won't log GPU memory usage. "
                  "Install py3nvml (pip install py3nvml) to log information about GPU.")
              a						:		Any      							=			"N/A"
            else:
              logger.info(
                  "Measuring total GPU usage on GPU device. Make sure to not have additional processes"
                  " running on the same GPU.")
              # init nvml
              nvml.nvmlInit()
              func()
              a						:		Any      							=			nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx)
              a						:		Tuple      							=			nvml.nvmlDeviceGetMemoryInfo(__UpperCAmelCase)
              a						:		Tuple      							=			meminfo.used
              a						:		List[Any]      							=			Memory(__UpperCAmelCase)
              # shutdown nvml
              nvml.nvmlShutdown()
          else:
            # cpu
            if self.args.trace_memory_line_by_line:
              logger.info(
                  "When enabling line by line tracing, the max peak memory for CPU is inaccurate in"
                  " TensorFlow.")
              a						:		Tuple      							=			None
            else:
              a						:		int      							=			measure_peak_memory_cpu(__UpperCAmelCase)
              a						:		List[Any]      							=			Memory(__UpperCAmelCase) if isinstance(__UpperCAmelCase				, __UpperCAmelCase) else memory_bytes
          if self.args.trace_memory_line_by_line:
            a						:		Dict      							=			stop_memory_tracing(__UpperCAmelCase)
            if memory is None:
              a						:		str      							=			summary.total
          else:
            a						:		int      							=			None

          return memory, summary
        except ResourceExhaustedError as e:
          self.print_fn(f'''Doesn\'t fit on GPU. {e}''')
          return "N/A", None








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

					A     :	int    = '0.12'  # assumed parallelism: 8







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




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      Union[str, Any]:


								'''simple docstring'''




								__a										=    TOKEN
								HfFolder.save_token(_snake_case				)




				@classmethod
				def 				SCREAMING_SNAKE_CASE_		(     cls				)    ->      Union[str, Any]:


								'''simple docstring'''




								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 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[Any]:


								'''simple docstring'''




								__a										=    BertConfig(
								    vocab_size=99		,     hidden_size=32		,     num_hidden_layers=5		,     num_attention_heads=4		,     intermediate_size=37				)
								__a										=    FlaxBertModel(_snake_case				)
								model.push_to_hub('''test-model-flax'''		,     use_auth_token=self._token				)

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

								__a										=    flatten_dict(unfreeze(model.params				)				)
								__a										=    flatten_dict(unfreeze(new_model.params				)				)

								for key in base_params.keys():
												__a										=    (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				)

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

								__a										=    flatten_dict(unfreeze(model.params				)				)
								__a										=    flatten_dict(unfreeze(new_model.params				)				)

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




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




								__a										=    BertConfig(
								    vocab_size=99		,     hidden_size=32		,     num_hidden_layers=5		,     num_attention_heads=4		,     intermediate_size=37				)
								__a										=    FlaxBertModel(_snake_case				)
								model.push_to_hub('''valid_org/test-model-flax-org'''		,     use_auth_token=self._token				)

								__a										=    FlaxBertModel.from_pretrained('''valid_org/test-model-flax-org'''				)

								__a										=    flatten_dict(unfreeze(model.params				)				)
								__a										=    flatten_dict(unfreeze(new_model.params				)				)

								for key in base_params.keys():
												__a										=    (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				)

								__a										=    FlaxBertModel.from_pretrained('''valid_org/test-model-flax-org'''				)

								__a										=    flatten_dict(unfreeze(model.params				)				)
								__a										=    flatten_dict(unfreeze(new_model.params				)				)

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



def     __lowerCAmelCase			(			a__						,    a__  )       ->  str:
				__a										=    True
				__a										=    flatten_dict(modela.params  )
				__a										=    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:
												__a										=    False

				return models_are_equal







@require_flax
class 			__A( unittest.TestCase			):




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


								'''simple docstring'''




								__a										=    BertConfig.from_pretrained('''hf-internal-testing/tiny-bert-flax-only'''				)
								__a										=    FlaxBertModel(_snake_case				)

								__a										=    '''bert'''
								with tempfile.TemporaryDirectory() as tmp_dir:
												model.save_pretrained(os.path.join(_snake_case		,     _snake_case				)				)

												with self.assertRaises(_snake_case				):
																__a										=    FlaxBertModel.from_pretrained(_snake_case				)

												__a										=    FlaxBertModel.from_pretrained(_snake_case		,     subfolder=_snake_case				)

								self.assertTrue(check_models_equal(_snake_case		,     _snake_case				)				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[Any]:


								'''simple docstring'''




								__a										=    BertConfig.from_pretrained('''hf-internal-testing/tiny-bert-flax-only'''				)
								__a										=    FlaxBertModel(_snake_case				)

								__a										=    '''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				):
																__a										=    FlaxBertModel.from_pretrained(_snake_case				)

												__a										=    FlaxBertModel.from_pretrained(_snake_case		,     subfolder=_snake_case				)

								self.assertTrue(check_models_equal(_snake_case		,     _snake_case				)				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      int:


								'''simple docstring'''




								__a										=    '''bert'''
								__a										=    '''hf-internal-testing/tiny-random-bert-subfolder'''

								with self.assertRaises(_snake_case				):
												__a										=    FlaxBertModel.from_pretrained(_snake_case				)

								__a										=    FlaxBertModel.from_pretrained(_snake_case		,     subfolder=_snake_case				)

								self.assertIsNotNone(_snake_case				)




				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Optional[int]:


								'''simple docstring'''




								__a										=    '''bert'''
								__a										=    '''hf-internal-testing/tiny-random-bert-sharded-subfolder'''
								with self.assertRaises(_snake_case				):
												__a										=    FlaxBertModel.from_pretrained(_snake_case				)

								__a										=    FlaxBertModel.from_pretrained(_snake_case		,     subfolder=_snake_case				)

								self.assertIsNotNone(_snake_case				)