



'''simple docstring'''



import os
from pickle import UnpicklingError
from typing import Dict, Tuple

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict, unflatten_dict

import transformers

from .utils import logging


lowerCAmelCase_     :       List[str]								=						logging.get_logger(__name__)
def 					UpperCAmelCase   (						A  :				Optional[Any]					,		A  :				List[Any]					,		A  :				Any					,		A  :				Dict=False				):
       try:
              import torch  # noqa: F401
       except ImportError:
              logger.error(
                  '''Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see'''
                  ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
                  ''' instructions.'''				)
              raise

       if not is_sharded:
              SCREAMING_SNAKE_CASE					:      List[str]     					=			os.path.abspath(A				)
              logger.info(F"""Loading PyTorch weights from {pt_path}"""				)

              SCREAMING_SNAKE_CASE					:      List[str]     					=			torch.load(A					,		map_location='''cpu'''				)
              logger.info(F"""PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()				):,} parameters."""				)

              SCREAMING_SNAKE_CASE					:      Any     					=			convert_pytorch_state_dict_to_flax(A					,		A				)
       else:
              # model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
              SCREAMING_SNAKE_CASE					:      List[str]     					=			convert_pytorch_sharded_state_dict_to_flax(A					,		A				)
       return flax_state_dict
def 					UpperCAmelCase   (						A  :				Tuple[str]					,		A  :				np.ndarray					,		A  :				Dict[str, jnp.ndarray]					,		A  :				str					,		):

       def is_key_or_prefix_key_in_dict(A  :				Tuple[str]				) -> bool:
              return len(set(A				) & {key, (model_prefix,) + key}				) > 0

       # layer norm
       SCREAMING_SNAKE_CASE					:      List[str]     					=			pt_tuple_key[:-1] + ('''scale''',)
       if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(A				):
              return renamed_pt_tuple_key, pt_tensor

       # batch norm layer mean
       SCREAMING_SNAKE_CASE					:      List[Any]     					=			pt_tuple_key[:-1] + ('''mean''',)
       if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(A				):
              return renamed_pt_tuple_key, pt_tensor

       # batch norm layer var
       SCREAMING_SNAKE_CASE					:      Dict     					=			pt_tuple_key[:-1] + ('''var''',)
       if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(A				):
              return renamed_pt_tuple_key, pt_tensor

       # embedding
       SCREAMING_SNAKE_CASE					:      Any     					=			pt_tuple_key[:-1] + ('''embedding''',)
       if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(A				):
              return renamed_pt_tuple_key, pt_tensor

       # conv layer
       SCREAMING_SNAKE_CASE					:      Any     					=			pt_tuple_key[:-1] + ('''kernel''',)
       if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(A				):
              SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			pt_tensor.transpose(2					,		3					,		1					,		0				)
              return renamed_pt_tuple_key, pt_tensor

       # linear layer
       SCREAMING_SNAKE_CASE					:      Any     					=			pt_tuple_key[:-1] + ('''kernel''',)
       if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(A				):
              SCREAMING_SNAKE_CASE					:      Any     					=			pt_tensor.T
              return renamed_pt_tuple_key, pt_tensor

       # old PyTorch layer norm weight
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			pt_tuple_key[:-1] + ('''weight''',)
       if pt_tuple_key[-1] == "gamma":
              return renamed_pt_tuple_key, pt_tensor

       # old PyTorch layer norm bias
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			pt_tuple_key[:-1] + ('''bias''',)
       if pt_tuple_key[-1] == "beta":
              return renamed_pt_tuple_key, pt_tensor

       # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			None
       if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
              SCREAMING_SNAKE_CASE					:      Optional[int]     					=			pt_tuple_key[-2] + '''_g'''
       elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
              SCREAMING_SNAKE_CASE					:      Dict     					=			pt_tuple_key[-2] + '''_v'''
       if name is not None:
              SCREAMING_SNAKE_CASE					:      str     					=			pt_tuple_key[:-3] + (name,)
              return renamed_pt_tuple_key, pt_tensor

       return pt_tuple_key, pt_tensor
def 					UpperCAmelCase   (						A  :				Union[str, Any]					,		A  :				List[str]				):
       # convert pytorch tensor to numpy
       SCREAMING_SNAKE_CASE					:      str     					=			{k: v.numpy() for k, v in pt_state_dict.items()}

       SCREAMING_SNAKE_CASE					:      str     					=			flax_model.base_model_prefix

       # use params dict if the model contains batch norm layers
       if "params" in flax_model.params:
              SCREAMING_SNAKE_CASE					:      Tuple     					=			flax_model.params['''params''']
       else:
              SCREAMING_SNAKE_CASE					:      Optional[int]     					=			flax_model.params
       SCREAMING_SNAKE_CASE					:      int     					=			flatten_dict(A				)

       # add batch_stats keys,values to dict
       if "batch_stats" in flax_model.params:
              SCREAMING_SNAKE_CASE					:      int     					=			flatten_dict(flax_model.params['''batch_stats''']				)
              random_flax_state_dict.update(A				)

       SCREAMING_SNAKE_CASE					:      Any     					=			{}

       SCREAMING_SNAKE_CASE					:      int     					=			(model_prefix not in flax_model_params) and (
           model_prefix in {k.split('''.'''				)[0] for k in pt_state_dict.keys()}
       )
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			(model_prefix in flax_model_params) and (
           model_prefix not in {k.split('''.'''				)[0] for k in pt_state_dict.keys()}
       )

       # Need to change some parameters name to match Flax names
       for pt_key, pt_tensor in pt_state_dict.items():
              SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			tuple(pt_key.split('''.'''				)				)

              # remove base model prefix if necessary
              SCREAMING_SNAKE_CASE					:      str     					=			pt_tuple_key[0] == model_prefix
              if load_model_with_head_into_base_model and has_base_model_prefix:
                     SCREAMING_SNAKE_CASE					:      List[str]     					=			pt_tuple_key[1:]

              # Correctly rename weight parameters
              SCREAMING_SNAKE_CASE					:      Dict     					=			rename_key_and_reshape_tensor(
                  A					,		A					,		A					,		A				)

              # add model prefix if necessary
              SCREAMING_SNAKE_CASE					:      str     					=			(model_prefix,) + flax_key in random_flax_state_dict
              if load_base_model_into_model_with_head and require_base_model_prefix:
                     SCREAMING_SNAKE_CASE					:      List[str]     					=			(model_prefix,) + flax_key

              if flax_key in random_flax_state_dict:
                     if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                            raise ValueError(
                                F"""PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape """
                                F"""{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}."""				)

        # add batch stats if the model contains batchnorm layers
              if "batch_stats" in flax_model.params:
                     if "mean" in flax_key[-1] or "var" in flax_key[-1]:
                            SCREAMING_SNAKE_CASE					:      str     					=			jnp.asarray(A				)
                            continue
                     # remove num_batches_tracked key
                     if "num_batches_tracked" in flax_key[-1]:
                            flax_state_dict.pop(A					,		A				)
                            continue

                     # also add unexpected weight so that warning is thrown
                     SCREAMING_SNAKE_CASE					:      str     					=			jnp.asarray(A				)

              else:
                     # also add unexpected weight so that warning is thrown
                     SCREAMING_SNAKE_CASE					:      Tuple     					=			jnp.asarray(A				)

       return unflatten_dict(A				)
def 					UpperCAmelCase   (						A  :				Any					,		A  :				Union[str, Any]				):
       import torch

       # Load the index
       SCREAMING_SNAKE_CASE					:      str     					=			{}
       for shard_file in shard_filenames:
              # load using msgpack utils
              SCREAMING_SNAKE_CASE					:      Optional[int]     					=			torch.load(A				)
              SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			{k: v.numpy() for k, v in pt_state_dict.items()}

              SCREAMING_SNAKE_CASE					:      List[str]     					=			flax_model.base_model_prefix

              # use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
              if "batch_stats" in flax_model.params:
                     SCREAMING_SNAKE_CASE					:      Tuple     					=			flax_model.params['''params''']

                     SCREAMING_SNAKE_CASE					:      Optional[int]     					=			flatten_dict(A				)
                     random_flax_state_dict.update(flatten_dict(flax_model.params['''batch_stats''']				)				)
              else:
                     SCREAMING_SNAKE_CASE					:      Optional[int]     					=			flax_model.params
                     SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			flatten_dict(A				)

              SCREAMING_SNAKE_CASE					:      List[str]     					=			(model_prefix not in flax_model_params) and (
                  model_prefix in {k.split('''.'''				)[0] for k in pt_state_dict.keys()}
              )
              SCREAMING_SNAKE_CASE					:      List[str]     					=			(model_prefix in flax_model_params) and (
                  model_prefix not in {k.split('''.'''				)[0] for k in pt_state_dict.keys()}
              )
              # Need to change some parameters name to match Flax names
              for pt_key, pt_tensor in pt_state_dict.items():
                     SCREAMING_SNAKE_CASE					:      Tuple     					=			tuple(pt_key.split('''.'''				)				)

                     # remove base model prefix if necessary
                     SCREAMING_SNAKE_CASE					:      str     					=			pt_tuple_key[0] == model_prefix
                     if load_model_with_head_into_base_model and has_base_model_prefix:
                            SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			pt_tuple_key[1:]

                     # Correctly rename weight parameters
                     SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			rename_key_and_reshape_tensor(
                         A					,		A					,		A					,		A				)
                     # add model prefix if necessary
                     SCREAMING_SNAKE_CASE					:      Dict     					=			(model_prefix,) + flax_key in random_flax_state_dict
                     if load_base_model_into_model_with_head and require_base_model_prefix:
                            SCREAMING_SNAKE_CASE					:      Tuple     					=			(model_prefix,) + flax_key

                     if flax_key in random_flax_state_dict:
                            if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                                   raise ValueError(
                                       F"""PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape """
                                       F"""{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}."""				)

            # add batch stats if the model contains batchnorm layers
                     if "batch_stats" in flax_model.params:
                            if "mean" in flax_key[-1]:
                                   SCREAMING_SNAKE_CASE					:      List[str]     					=			jnp.asarray(A				)
                                   continue
                            if "var" in flax_key[-1]:
                                   SCREAMING_SNAKE_CASE					:      Any     					=			jnp.asarray(A				)
                                   continue
                            # remove num_batches_tracked key
                            if "num_batches_tracked" in flax_key[-1]:
                                   flax_state_dict.pop(A					,		A				)
                                   continue

                            # also add unexpected weight so that warning is thrown
                            SCREAMING_SNAKE_CASE					:      Any     					=			jnp.asarray(A				)

                     else:
                            # also add unexpected weight so that warning is thrown
                            SCREAMING_SNAKE_CASE					:      Optional[int]     					=			jnp.asarray(A				)
       return unflatten_dict(A				)
def 					UpperCAmelCase   (						A  :				List[str]					,		A  :				str				):
       SCREAMING_SNAKE_CASE					:      str     					=			os.path.abspath(A				)
       logger.info(F"""Loading Flax weights from {flax_checkpoint_path}"""				)

       # import correct flax class
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			getattr(A					,		'''Flax''' + model.__class__.__name__				)

       # load flax weight dict
       with open(A					,		'''rb'''				) as state_f:
              try:
                     SCREAMING_SNAKE_CASE					:      Optional[int]     					=			from_bytes(A					,		state_f.read()				)
              except UnpicklingError:
                     raise EnvironmentError(F"""Unable to convert {flax_checkpoint_path} to Flax deserializable object. """				)

       return load_flax_weights_in_pytorch_model(A					,		A				)






def 					UpperCAmelCase   (						A  :				int					,		A  :				int				):

       try:
              import torch  # noqa: F401
       except ImportError:
              logger.error(
                  '''Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see'''
                  ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
                  ''' instructions.'''				)
              raise

       # check if we have bf16 weights
       SCREAMING_SNAKE_CASE					:      Any     					=			flatten_dict(jax.tree_util.tree_map(lambda A				: x.dtype == jnp.bfloataa					,		A				)				).values()
       if any(A				):
              # convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16
              # and bf16 is not fully supported in PT yet.
              logger.warning(
                  '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '''
                  '''before loading those in PyTorch model.'''				)
              SCREAMING_SNAKE_CASE					:      int     					=			jax.tree_util.tree_map(
                  lambda A				: params.astype(np.floataa				) if params.dtype == jnp.bfloataa else params					,		A				)

       SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			flatten_dict(A				)
       SCREAMING_SNAKE_CASE					:      str     					=			pt_model.state_dict()

       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			(pt_model.base_model_prefix in flax_state) and (
           pt_model.base_model_prefix not in {k.split('''.'''				)[0] for k in pt_model_dict.keys()}
       )
       SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			(pt_model.base_model_prefix not in flax_state) and (
           pt_model.base_model_prefix in {k.split('''.'''				)[0] for k in pt_model_dict.keys()}
       )

       # keep track of unexpected & missing keys
       SCREAMING_SNAKE_CASE					:      int     					=			[]
       SCREAMING_SNAKE_CASE					:      Any     					=			set(pt_model_dict.keys()				)

       for flax_key_tuple, flax_tensor in flax_state_dict.items():
              SCREAMING_SNAKE_CASE					:      List[str]     					=			flax_key_tuple[0] == pt_model.base_model_prefix
              SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			'''.'''.join((pt_model.base_model_prefix,) + flax_key_tuple				) in pt_model_dict

              # adapt flax_key to prepare for loading from/to base model only
              if load_model_with_head_into_base_model and has_base_model_prefix:
                     SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			flax_key_tuple[1:]
              elif load_base_model_into_model_with_head and require_base_model_prefix:
                     SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			(pt_model.base_model_prefix,) + flax_key_tuple

              # rename flax weights to PyTorch format
              if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(A				) not in pt_model_dict:
                     # conv layer
                     SCREAMING_SNAKE_CASE					:      Tuple     					=			flax_key_tuple[:-1] + ('''weight''',)
                     SCREAMING_SNAKE_CASE					:      List[Any]     					=			jnp.transpose(A					,		(3, 2, 0, 1)				)
              elif flax_key_tuple[-1] == "kernel" and ".".join(A				) not in pt_model_dict:
                     # linear layer
                     SCREAMING_SNAKE_CASE					:      List[str]     					=			flax_key_tuple[:-1] + ('''weight''',)
                     SCREAMING_SNAKE_CASE					:      List[Any]     					=			flax_tensor.T
              elif flax_key_tuple[-1] in ["scale", "embedding"]:
                     SCREAMING_SNAKE_CASE					:      List[Any]     					=			flax_key_tuple[:-1] + ('''weight''',)

              # adding batch stats from flax batch norm to pt
              elif "mean" in flax_key_tuple[-1]:
                     SCREAMING_SNAKE_CASE					:      Dict     					=			flax_key_tuple[:-1] + ('''running_mean''',)
              elif "var" in flax_key_tuple[-1]:
                     SCREAMING_SNAKE_CASE					:      Optional[int]     					=			flax_key_tuple[:-1] + ('''running_var''',)

              if "batch_stats" in flax_state:
                     SCREAMING_SNAKE_CASE					:      Any     					=			'''.'''.join(flax_key_tuple[1:]				)  # Remove the params/batch_stats header
              else:
                     SCREAMING_SNAKE_CASE					:      List[str]     					=			'''.'''.join(A				)

              # We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
              SCREAMING_SNAKE_CASE					:      Any     					=			{}
              # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
              for key in pt_model_dict:
                     SCREAMING_SNAKE_CASE					:      Tuple     					=			key.split('''.'''				)
                     SCREAMING_SNAKE_CASE					:      str     					=			None
                     if key_components[-3::2] == ["parametrizations", "original0"]:
                            SCREAMING_SNAKE_CASE					:      List[Any]     					=			key_components[-2] + '''_g'''
                     elif key_components[-3::2] == ["parametrizations", "original1"]:
                            SCREAMING_SNAKE_CASE					:      Any     					=			key_components[-2] + '''_v'''
                     if name is not None:
                            SCREAMING_SNAKE_CASE					:      List[Any]     					=			key_components[:-3] + [name]
                            SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			'''.'''.join(A				)
                            SCREAMING_SNAKE_CASE					:      Optional[int]     					=			key

              if flax_key in special_pt_names:
                     SCREAMING_SNAKE_CASE					:      Dict     					=			special_pt_names[flax_key]

              if flax_key in pt_model_dict:
                     if flax_tensor.shape != pt_model_dict[flax_key].shape:
                            raise ValueError(
                                F"""Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected """
                                F"""to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."""				)
                     else:
                            # add weight to pytorch dict
                            SCREAMING_SNAKE_CASE					:      Optional[int]     					=			np.asarray(A				) if not isinstance(A					,		np.ndarray				) else flax_tensor
                            SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			torch.from_numpy(A				)
                            # remove from missing keys
                            missing_keys.remove(A				)
              else:
                     # weight is not expected by PyTorch model
                     unexpected_keys.append(A				)

       pt_model.load_state_dict(A				)

       # re-transform missing_keys to list
       SCREAMING_SNAKE_CASE					:      Tuple     					=			list(A				)

       if len(A				) > 0:
              logger.warning(
                  '''Some weights of the Flax model were not used when initializing the PyTorch model'''
                  F""" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"""
                  F""" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"""
                  ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'''
                  F""" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"""
                  ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'''
                  ''' FlaxBertForSequenceClassification model).'''				)
       else:
              logger.warning(F"""All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n"""				)
       if len(A				) > 0:
              logger.warning(
                  F"""Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"""
                  F""" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"""
                  ''' use it for predictions and inference.'''				)
       else:
              logger.warning(
                  F"""All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n"""
                  '''If your task is similar to the task the model of the checkpoint was trained on, '''
                  F"""you can already use {pt_model.__class__.__name__} for predictions without further training."""				)

       return pt_model









'''simple docstring'''



from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_     :       Optional[int]								=						logging.get_logger(__name__)

lowerCAmelCase_     :       Optional[Any]								=						{
    'microsoft/swinv2-tiny-patch4-window8-256': (
        'https://huggingface.co/microsoft/swinv2-tiny-patch4-window8-256/resolve/main/config.json'
    ),
}
class 	lowerCamelCase_							(					snake_case_			):
						_lowerCAmelCase     :   str	     =				'swinv2'

						_lowerCAmelCase     :   Optional[int]	     =				{
						    'num_attention_heads': 'num_heads',
						    'num_hidden_layers': 'num_layers',
						}







						def __init__(  self   :      Optional[int]				,    lowerCAmelCase__   :      Any=2_24				,    lowerCAmelCase__   :      Optional[Any]=4				,    lowerCAmelCase__   :      Tuple=3				,    lowerCAmelCase__   :      Tuple=96				,    lowerCAmelCase__   :      Optional[int]=[2, 2, 6, 2]				,    lowerCAmelCase__   :      Tuple=[3, 6, 12, 24]				,    lowerCAmelCase__   :      List[str]=7				,    lowerCAmelCase__   :      Tuple=4.0				,    lowerCAmelCase__   :      Dict=True				,    lowerCAmelCase__   :      Any=0.0				,    lowerCAmelCase__   :      Optional[int]=0.0				,    lowerCAmelCase__   :      Optional[Any]=0.1				,    lowerCAmelCase__   :      int="gelu"				,    lowerCAmelCase__   :      Tuple=False				,    lowerCAmelCase__   :      Tuple=0.02				,    lowerCAmelCase__   :      Dict=1e-5				,    lowerCAmelCase__   :      List[str]=32				,    **lowerCAmelCase__   :      Union[str, Any]				,    ):

													"""simple docstring"""
													super().__init__(**lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			image_size
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			patch_size
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			num_channels
													SCREAMING_SNAKE_CASE					:      int     					=			embed_dim
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			depths
													SCREAMING_SNAKE_CASE					:      str     					=			len(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			num_heads
													SCREAMING_SNAKE_CASE					:      Tuple     					=			window_size
													SCREAMING_SNAKE_CASE					:      Any     					=			mlp_ratio
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			qkv_bias
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			hidden_dropout_prob
													SCREAMING_SNAKE_CASE					:      int     					=			attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE					:      List[str]     					=			drop_path_rate
													SCREAMING_SNAKE_CASE					:      Any     					=			hidden_act
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			use_absolute_embeddings
													SCREAMING_SNAKE_CASE					:      List[str]     					=			layer_norm_eps
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			initializer_range
													SCREAMING_SNAKE_CASE					:      Dict     					=			encoder_stride
													# we set the hidden_size attribute in order to make Swinv2 work with VisionEncoderDecoderModel
													# this indicates the channel dimension after the last stage of the model
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			int(embed_dim * 2 ** (len(lowerCAmelCase__				) - 1)				)
													SCREAMING_SNAKE_CASE					:      int     					=			(0, 0, 0, 0)




