


"""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 copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
    import torch

    from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      str				,			a__       :      Dict				,			a__       :      Tuple=None				,			a__       :      List[Any]=None				,			a__       :      Dict=None				,			a__       :      Union[str, Any]="resnet50"				,			a__       :      Dict=3				,			a__       :      str=32				,			a__       :      int=3				,			a__       :      Dict=True				,			a__       :      Any=True				,			):





         """simple docstring"""



         __snake_case							       =   parent
         __snake_case							       =   out_indices if out_indices is not None else [4]
         __snake_case							       =   stage_names
         __snake_case							       =   out_features
         __snake_case							       =   backbone
         __snake_case							       =   batch_size
         __snake_case							       =   image_size
         __snake_case							       =   num_channels
         __snake_case							       =   use_pretrained_backbone
         __snake_case							       =   is_training


      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         __snake_case							       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
         __snake_case							       =   self.get_config()

         return config, pixel_values


      def    a (self       :      Any      ):





         """simple docstring"""



         return TimmBackboneConfig(
             image_size=self.image_size				,			num_channels=self.num_channels				,			out_features=self.out_features				,			out_indices=self.out_indices				,			stage_names=self.stage_names				,			use_pretrained_backbone=self.use_pretrained_backbone				,			backbone=self.backbone				,			)


      def    a (self       :      List[Any]				,			a__       :      int				,			a__       :      int      ):





         """simple docstring"""



         __snake_case							       =   TimmBackbone(config=a__      )
         model.to(a__      )
         model.eval()
         with torch.no_grad():
            __snake_case							       =   model(a__      )
         self.parent.assertEqual(
             result.feature_map[-1].shape				,			(self.batch_size, model.channels[-1], 14, 14)				,			)


      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   self.prepare_config_and_inputs()
         __snake_case       ,	__snake_case							       =   config_and_inputs
         __snake_case							       =   {'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
@require_timm
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Union[str, Any]							=    (TimmBackbone,) if is_torch_available() else ()
      A_						:				Optional[Any]							=    {'feature-extraction': TimmBackbone} if is_torch_available() else {}
      A_						:				List[Any]							=    False
      A_						:				Dict							=    False
      A_						:				Any							=    False
      A_						:				List[Any]							=    False


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   TimmBackboneModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			has_text_modality=a__      )


      def    a (self       :      Any      ):





         """simple docstring"""



         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()


      def    a (self       :      int      ):





         """simple docstring"""



         __snake_case							       =   '''resnet18'''
         __snake_case							       =   '''microsoft/resnet-18'''

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__      )

         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(len(timm_model.stage_names      )				,			len(transformers_model.stage_names      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )
         # Out indices are set to the last layer by default. For timm models, we don't know
         # the number of layers in advance, so we set it to (-1,), whereas for transformers
         # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
         self.assertEqual(timm_model.out_indices				,			(-1,)      )
         self.assertEqual(transformers_model.out_indices				,			[len(timm_model.stage_names      ) - 1]      )

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__				,			out_indices=[1, 2, 3]      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			out_indices=[1, 2, 3]      )

         self.assertEqual(timm_model.out_indices				,			transformers_model.out_indices      )
         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )


      @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''      )
      def    a (self       :      str      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone initialization is managed on the timm side'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      Dict      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''Safetensors is not supported by timm.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __snake_case							       =   model_class(a__      )
            __snake_case							       =   inspect.signature(model.forward      )
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            __snake_case							       =   [*signature.parameters.keys()]

            __snake_case							       =   ['''pixel_values''']
            self.assertListEqual(arg_names[:1]				,			a__      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   True
         __snake_case							       =   self.has_attentions

         # no need to test all models as different heads yield the same functionality
         __snake_case							       =   self.all_model_classes[0]
         __snake_case							       =   model_class(a__      )
         model.to(a__      )

         __snake_case							       =   self._prepare_for_class(a__				,			a__      )
         __snake_case							       =   model(**a__      )
         __snake_case							       =   outputs[0][-1]

         # Encoder-/Decoder-only models
         __snake_case							       =   outputs.hidden_states[0]
         hidden_states.retain_grad()

         if self.has_attentions:
            __snake_case							       =   outputs.attentions[0]
            attentions.retain_grad()

         output.flatten()[0].backward(retain_graph=a__      )

         self.assertIsNotNone(hidden_states.grad      )

         if self.has_attentions:
            self.assertIsNotNone(attentions.grad      )


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			len(config.out_indices      )      )
            self.assertEqual(len(model.channels      )				,			len(config.out_indices      )      )

            # Check output of last stage is taken if out_features=None, out_indices=None
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   None
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			1      )
            self.assertEqual(len(model.channels      )				,			1      )

            # Check backbone can be initialized with fresh weights
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   False
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

