





'''simple docstring'''

from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
   import tensorflow as tf


lowercase__						:      Dict	=    logging.get_logger(__name__)
@dataclass
class     __lowerCAmelCase					(   __magic_name__			):






       """simple docstring"""
       _snake_case     :					Tuple						    =   [
           'no_inference',
           'no_cuda',
           'no_tpu',
           'no_speed',
           'no_memory',
           'no_env_print',
           'no_multi_process',
       ]





       def __init__(							self       :		int	,			**lowerCAmelCase__       :		Any					)   ->					Tuple:

            '''simple docstring'''




            for deprecated_arg in self.deprecated_args:
                 if deprecated_arg in kwargs:
                      _UpperCamelCase       =	deprecated_arg[3:]
                      _UpperCamelCase       =	not kwargs.pop(lowerCAmelCase__					)
                      logger.warning(
                          f"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                          f""" {positive_arg}={kwargs[positive_arg]}"""					)
            _UpperCamelCase       =	kwargs.pop('''tpu_name'''	,			self.tpu_name					)
            _UpperCamelCase       =	kwargs.pop('''device_idx'''	,			self.device_idx					)
            _UpperCamelCase       =	kwargs.pop('''eager_mode'''	,			self.eager_mode					)
            _UpperCamelCase       =	kwargs.pop('''use_xla'''	,			self.use_xla					)
            super().__init__(**lowerCAmelCase__					)

       _snake_case     :					str						    =   field(
           default=__magic_name__						,						metadata={'help': 'Name of TPU'}						,						)
       _snake_case     :					int						    =   field(
           default=0						,						metadata={'help': 'CPU / GPU device index. Defaults to 0.'}						,						)
       _snake_case     :					bool						    =   field(default=__magic_name__						,						metadata={'help': 'Benchmark models in eager model.'}			)
       _snake_case     :					bool						    =   field(
           default=__magic_name__						,						metadata={
               'help': 'Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'
           }						,						)





       @cached_property
       def snake_case__						(							self       :		Optional[int]					)   ->					Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            _UpperCamelCase       =	None
            if self.tpu:
                 try:
                      if self.tpu_name:
                           _UpperCamelCase       =	tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name					)
                      else:
                           _UpperCamelCase       =	tf.distribute.cluster_resolver.TPUClusterResolver()
                 except ValueError:
                      _UpperCamelCase       =	None
            return tpu





       @cached_property
       def snake_case__						(							self       :		Tuple					)   ->					Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            if self.is_tpu:
                 tf.config.experimental_connect_to_cluster(self._setup_tpu					)
                 tf.tpu.experimental.initialize_tpu_system(self._setup_tpu					)

                 _UpperCamelCase       =	tf.distribute.TPUStrategy(self._setup_tpu					)
            else:
                 # currently no multi gpu is allowed
                 if self.is_gpu:
                      # TODO: Currently only single GPU is supported
                      tf.config.set_visible_devices(self.gpu_list[self.device_idx]	,			'''GPU'''					)
                      _UpperCamelCase       =	tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""					)
                 else:
                      tf.config.set_visible_devices([]	,			'''GPU'''					)  # disable GPU
                      _UpperCamelCase       =	tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""					)

            return strategy





       @property
       def snake_case__						(							self       :		Optional[int]					)   ->					bool:

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            return self._setup_tpu is not None





       @property
       def snake_case__						(							self       :		Union[str, Any]					)   ->					"tf.distribute.Strategy":

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            return self._setup_strategy





       @property
       def snake_case__						(							self       :		Any					)   ->					int:

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            return tf.config.list_physical_devices('''GPU'''					)





       @property
       def snake_case__						(							self       :		List[Any]					)   ->					int:

            '''simple docstring'''




            requires_backends(self	,			['''tf''']					)
            if self.cuda:
                 return len(self.gpu_list					)
            return 0







       @property
       def snake_case__						(							self       :		List[Any]					)   ->					bool:

            '''simple docstring'''




            return self.n_gpu > 0










'''simple docstring'''

import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





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

            '''simple docstring'''




            _UpperCamelCase       =	['''a''', '''b''', '''c''']

            # Defaults to last layer if both are None
            _UpperCamelCase   ,    _UpperCamelCase       =	get_aligned_output_features_output_indices(lowerCAmelCase__	,			lowerCAmelCase__	,			lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			['''c''']					)
            self.assertEqual(lowerCAmelCase__	,			[2]					)

            # Out indices set to match out features
            _UpperCamelCase   ,    _UpperCamelCase       =	get_aligned_output_features_output_indices(['''a''', '''c''']	,			lowerCAmelCase__	,			lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			['''a''', '''c''']					)
            self.assertEqual(lowerCAmelCase__	,			[0, 2]					)

            # Out features set to match out indices
            _UpperCamelCase   ,    _UpperCamelCase       =	get_aligned_output_features_output_indices(lowerCAmelCase__	,			[0, 2]	,			lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			['''a''', '''c''']					)
            self.assertEqual(lowerCAmelCase__	,			[0, 2]					)

            # Out features selected from negative indices
            _UpperCamelCase   ,    _UpperCamelCase       =	get_aligned_output_features_output_indices(lowerCAmelCase__	,			[-3, -1]	,			lowerCAmelCase__					)
            self.assertEqual(lowerCAmelCase__	,			['''a''', '''c''']					)
            self.assertEqual(lowerCAmelCase__	,			[-3, -1]					)





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

            '''simple docstring'''




            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(['''a''', '''b''']	,			(0, 1)	,			lowerCAmelCase__					)

            # Out features must be a list
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(('''a''', '''b''')	,			(0, 1)	,			['''a''', '''b''']					)

            # Out features must be a subset of stage names
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(['''a''', '''b''']	,			(0, 1)	,			['''a''']					)

            # Out indices must be a list or tuple
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(lowerCAmelCase__	,			0	,			['''a''', '''b''']					)

            # Out indices must be a subset of stage names
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(lowerCAmelCase__	,			(0, 1)	,			['''a''']					)

            # Out features and out indices must be the same length
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(['''a''', '''b''']	,			(0,)	,			['''a''', '''b''', '''c''']					)

            # Out features should match out indices
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(['''a''', '''b''']	,			(0, 2)	,			['''a''', '''b''', '''c''']					)

            # Out features and out indices should be in order
            with self.assertRaises(lowerCAmelCase__					):
                 verify_out_features_out_indices(['''b''', '''a''']	,			(0, 1)	,			['''a''', '''b''']					)

            # Check passes with valid inputs
            verify_out_features_out_indices(['''a''', '''b''', '''d''']	,			(0, 1, -1)	,			['''a''', '''b''', '''c''', '''d''']					)







       def snake_case__						(							self       :		Any					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	BackboneMixin()

            _UpperCamelCase       =	['''a''', '''b''', '''c''']
            _UpperCamelCase       =	['''a''', '''c''']
            _UpperCamelCase       =	[0, 2]

            # Check that the output features and indices are set correctly
            self.assertEqual(backbone.out_features	,			['''a''', '''c''']					)
            self.assertEqual(backbone.out_indices	,			[0, 2]					)

            # Check out features and indices are updated correctly
            _UpperCamelCase       =	['''a''', '''b''']
            self.assertEqual(backbone.out_features	,			['''a''', '''b''']					)
            self.assertEqual(backbone.out_indices	,			[0, 1]					)

            _UpperCamelCase       =	[-3, -1]
            self.assertEqual(backbone.out_features	,			['''a''', '''c''']					)
            self.assertEqual(backbone.out_indices	,			[-3, -1]					)



