





'''simple docstring'''




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


lowercase__       : Union[str, Any]         =       logging.get_logger(__name__)

lowercase__       : Dict         =       {
    '''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 					SCREAMING_SNAKE_CASE       (a__   ,						a__				):
     lowerCAmelCase						     =			'''swin'''

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


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

          '''simple docstring'''






          super().__init__(**_UpperCAmelCase)

          __A		:					str						=			image_size
          __A		:					Dict						=			patch_size
          __A		:					Union[str, Any]						=			num_channels
          __A		:					str						=			embed_dim
          __A		:					List[str]						=			depths
          __A		:					List[Any]						=			len(_UpperCAmelCase)
          __A		:					Optional[int]						=			num_heads
          __A		:					Tuple						=			window_size
          __A		:					Union[str, Any]						=			mlp_ratio
          __A		:					List[str]						=			qkv_bias
          __A		:					Dict						=			hidden_dropout_prob
          __A		:					Dict						=			attention_probs_dropout_prob
          __A		:					Any						=			drop_path_rate
          __A		:					List[str]						=			hidden_act
          __A		:					str						=			use_absolute_embeddings
          __A		:					Union[str, Any]						=			layer_norm_eps
          __A		:					str						=			initializer_range
          __A		:					int						=			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
          __A		:					Dict						=			int(embed_dim * 2 ** (len(_UpperCAmelCase) - 1))
          __A		:					Any						=			['stem'] + [F'stage{idx}' for idx in range(1		,      len(_UpperCAmelCase) + 1)]
          __A					,__A		:					str						=			get_aligned_output_features_output_indices(
              out_features=_UpperCAmelCase		,      out_indices=_UpperCAmelCase		,      stage_names=self.stage_names)




class 					SCREAMING_SNAKE_CASE       (a__				):
     lowerCAmelCase						     =			version.parse('''1.11'''				)


     @property
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






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


     @property
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          return 1e-4

__lowerCamelCase				=			{
    0: """0""",
    1: """1""",
    2: """2""",
    3: """3""",
    4: """4""",
    5: """5""",
    6: """6""",
    7: """7""",
    8: """8""",
    9: """9""",
    10: """a""",
    11: """b""",
    12: """c""",
    13: """d""",
    14: """e""",
    15: """f""",
}


def      UpperCamelCase   (       __lowerCamelCase	:					float       ):
       assert type(__lowerCamelCase       ) in (int, float) and decimal == int(__lowerCamelCase       )
       snake_case			:  str     							= int(__lowerCamelCase       )
       snake_case			:  str     							= ""
       snake_case			:  str     							= False
       if decimal < 0:
              snake_case			:  Optional[Any]     							= True
              decimal *= -1
       while decimal > 0:
              snake_case							,   snake_case			:  Union[str, Any]     							= divmod(__lowerCamelCase							,   16       )
              snake_case			:  Tuple     							= values[remainder] + hexadecimal
       snake_case			:  Tuple     							= "0x" + hexadecimal
       if negative:
              snake_case			:  Any     							= "-" + hexadecimal
       return hexadecimal


if __name__ == "__main__":
   import doctest

   doctest.testmod()





