





'''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


lowerCAmelCase_					:    Optional[Any]      	=			logging.get_logger(__name__)
@dataclass
class 				__SCREAMING_SNAKE_CASE  (lowerCamelCase_      ):






				"""simple docstring"""







				__a            =[
				    'no_inference',
				    'no_cuda',
				    'no_tpu',
				    'no_speed',
				    'no_memory',
				    'no_env_print',
				    'no_multi_process',
				]




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

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




				@cached_property
				def   UpperCamelCase__   (  self     :					List[str]					):
								requires_backends(self					,				["tf"]					)
								_a								= None
								if self.tpu:
												try:
																if self.tpu_name:
																				_a								= tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name					)
																else:
																				_a								= tf.distribute.cluster_resolver.TPUClusterResolver()
												except ValueError:
																_a								= None
								return tpu




				@cached_property
				def   UpperCamelCase__   (  self     :					Optional[int]					):
								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					)

												_a								= 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"					)
																_a								= tf.distribute.OneDeviceStrategy(device=f'/gpu:{self.device_idx}'					)
												else:
																tf.config.set_visible_devices([]					,				"GPU"					)  # disable GPU
																_a								= tf.distribute.OneDeviceStrategy(device=f'/cpu:{self.device_idx}'					)

								return strategy




				@property
				def   UpperCamelCase__   (  self     :					List[Any]					):
								requires_backends(self					,				["tf"]					)
								return self._setup_tpu is not None




				@property
				def   UpperCamelCase__   (  self     :					str					):
								requires_backends(self					,				["tf"]					)
								return self._setup_strategy




				@property
				def   UpperCamelCase__   (  self     :					Tuple					):
								requires_backends(self					,				["tf"]					)
								return tf.config.list_physical_devices("GPU"					)




				@property
				def   UpperCamelCase__   (  self     :					Tuple					):
								requires_backends(self					,				["tf"]					)
								if self.cuda:
												return len(self.gpu_list					)
								return 0




				@property
				def   UpperCamelCase__   (  self     :					Tuple					):
								return self.n_gpu > 0





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_snake_case		=  logging.get_logger(__name__)

_snake_case		=  {
    "microsoft/swin-tiny-patch4-window7-224": (
        "https://huggingface.co/microsoft/swin-tiny-patch4-window7-224/resolve/main/config.json"
    ),
    # See all Swin models at https://huggingface.co/models?filter=swin
}



class   UpperCAmelCase_    (       a   ,					a):
							lowerCamelCase__   			=		'swin'

							lowerCamelCase__   			=		{
							    'num_attention_heads': 'num_heads',
							    'num_hidden_layers': 'num_layers',
							}







							def __init__(   self,			__a=224,			__a=4,			__a=3,			__a=96,			__a=[2, 2, 6, 2],			__a=[3, 6, 12, 24],			__a=7,			__a=4.0,			__a=True,			__a=0.0,			__a=0.0,			__a=0.1,			__a="gelu",			__a=False,			__a=0.02,			__a=1E-5,			__a=32,			__a=None,			__a=None,			**__a,			):

														'''simple docstring'''

														super().__init__(**__a)

														_lowerCAmelCase     :							Any    =    image_size
														_lowerCAmelCase     :							Union[str, Any]    =    patch_size
														_lowerCAmelCase     :							Tuple    =    num_channels
														_lowerCAmelCase     :							List[Any]    =    embed_dim
														_lowerCAmelCase     :							Tuple    =    depths
														_lowerCAmelCase     :							Optional[Any]    =    len(__a)
														_lowerCAmelCase     :							int    =    num_heads
														_lowerCAmelCase     :							int    =    window_size
														_lowerCAmelCase     :							int    =    mlp_ratio
														_lowerCAmelCase     :							List[Any]    =    qkv_bias
														_lowerCAmelCase     :							str    =    hidden_dropout_prob
														_lowerCAmelCase     :							Union[str, Any]    =    attention_probs_dropout_prob
														_lowerCAmelCase     :							Any    =    drop_path_rate
														_lowerCAmelCase     :							int    =    hidden_act
														_lowerCAmelCase     :							Tuple    =    use_absolute_embeddings
														_lowerCAmelCase     :							Optional[int]    =    layer_norm_eps
														_lowerCAmelCase     :							Tuple    =    initializer_range
														_lowerCAmelCase     :							Tuple    =    encoder_stride
														# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
														# this indicates the channel dimension after the last stage of the model
														_lowerCAmelCase     :							List[str]    =    int(embed_dim * 2 ** (len(__a) - 1))
														_lowerCAmelCase     :							List[Any]    =    ["stem"] + [f"stage{idx}" for idx in range(1,			len(__a) + 1)]
														_lowerCAmelCase   ,    _lowerCAmelCase     :							Optional[int]    =    get_aligned_output_features_output_indices(
														    out_features=__a,			out_indices=__a,			stage_names=self.stage_names)



class   UpperCAmelCase_    (       a):
							lowerCamelCase__   			=		version.parse('1.11')







							@property
							def    snake_case__      (   self):

														'''simple docstring'''

														return OrderedDict(
														    [
														        ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
														    ])







							@property
							def    snake_case__      (   self):

														'''simple docstring'''

														return 1E-4
