






"""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 ..auto import CONFIG_MAPPING


__A		:       str  				=		logging.get_logger(__name__)

__A		:       Union[str, Any]  				=		{
    '''microsoft/table-transformer-detection''': (
        '''https://huggingface.co/microsoft/table-transformer-detection/resolve/main/config.json'''
    ),
}





class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				int							    =   "table-transformer"
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   ["past_key_values"]
					SCREAMING_SNAKE_CASE_		:				Optional[int]							    =   {
					    "hidden_size": "d_model",
					    "num_attention_heads": "encoder_attention_heads",
					}




					def __init__(				self     :						Tuple    ,						A     :						Dict=True    ,						A     :						List[str]=None    ,						A     :						str=3    ,						A     :						int=1_00    ,						A     :						Optional[int]=6    ,						A     :						Union[str, Any]=20_48    ,						A     :						Union[str, Any]=8    ,						A     :						Optional[Any]=6    ,						A     :						Tuple=20_48    ,						A     :						List[Any]=8    ,						A     :						str=0.0    ,						A     :						Optional[int]=0.0    ,						A     :						str=True    ,						A     :						Optional[int]="relu"    ,						A     :						List[Any]=2_56    ,						A     :						Union[str, Any]=0.1    ,						A     :						Tuple=0.0    ,						A     :						int=0.0    ,						A     :						Any=0.02    ,						A     :						Optional[Any]=1.0    ,						A     :						List[Any]=False    ,						A     :						List[Any]="sine"    ,						A     :						Tuple="resnet50"    ,						A     :						Optional[Any]=True    ,						A     :						int=False    ,						A     :						List[Any]=1    ,						A     :						Optional[Any]=5    ,						A     :						Union[str, Any]=2    ,						A     :						Optional[int]=1    ,						A     :						Tuple=1    ,						A     :						List[str]=5    ,						A     :						Optional[Any]=2    ,						A     :						str=0.1    ,						**A     :						int    ,						)  ->  Dict:
							if backbone_config is not None and use_timm_backbone:
									raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.'''   )

							if not use_timm_backbone:
									if backbone_config is None:
											logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''   )
											lowercase_ : Dict							       =   CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']   )
									elif isinstance(A    ,						A   ):
											lowercase_ : Union[str, Any]							       =   backbone_config.get('''model_type'''   )
											lowercase_ : Any							       =   CONFIG_MAPPING[backbone_model_type]
											lowercase_ : List[str]							       =   config_class.from_dict(A   )
									# set timm attributes to None
									lowercase_       ,					lowercase_       ,					lowercase_ : Dict							       =   None, None, None

							lowercase_ : Union[str, Any]							       =   use_timm_backbone
							lowercase_ : Tuple							       =   backbone_config
							lowercase_ : Dict							       =   num_channels
							lowercase_ : List[str]							       =   num_queries
							lowercase_ : Any							       =   d_model
							lowercase_ : Optional[Any]							       =   encoder_ffn_dim
							lowercase_ : Any							       =   encoder_layers
							lowercase_ : Dict							       =   encoder_attention_heads
							lowercase_ : str							       =   decoder_ffn_dim
							lowercase_ : str							       =   decoder_layers
							lowercase_ : int							       =   decoder_attention_heads
							lowercase_ : Optional[int]							       =   dropout
							lowercase_ : Optional[Any]							       =   attention_dropout
							lowercase_ : str							       =   activation_dropout
							lowercase_ : Tuple							       =   activation_function
							lowercase_ : Any							       =   init_std
							lowercase_ : str							       =   init_xavier_std
							lowercase_ : Union[str, Any]							       =   encoder_layerdrop
							lowercase_ : Optional[Any]							       =   decoder_layerdrop
							lowercase_ : Optional[Any]							       =   encoder_layers
							lowercase_ : Tuple							       =   auxiliary_loss
							lowercase_ : Dict							       =   position_embedding_type
							lowercase_ : Optional[Any]							       =   backbone
							lowercase_ : List[str]							       =   use_pretrained_backbone
							lowercase_ : Any							       =   dilation
							# Hungarian matcher
							lowercase_ : Any							       =   class_cost
							lowercase_ : Optional[Any]							       =   bbox_cost
							lowercase_ : int							       =   giou_cost
							# Loss coefficients
							lowercase_ : Union[str, Any]							       =   mask_loss_coefficient
							lowercase_ : Optional[int]							       =   dice_loss_coefficient
							lowercase_ : Optional[Any]							       =   bbox_loss_coefficient
							lowercase_ : Optional[int]							       =   giou_loss_coefficient
							lowercase_ : Union[str, Any]							       =   eos_coefficient
							super().__init__(is_encoder_decoder=A    ,						**A   )




					@property
					def   A  (				self     :						Any   )  ->  int:
							return self.encoder_attention_heads






					@property
					def   A  (				self     :						List[Any]   )  ->  int:
							return self.d_model





class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				Optional[Any]							    =   version.parse("1.11"							)




					@property
					def   A  (				self     :						Dict   )  ->  Mapping[str, Mapping[int, str]]:
							return OrderedDict(
							    [
							        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
							        ('''pixel_mask''', {0: '''batch'''}),
							    ]   )




					@property
					def   A  (				self     :						List[str]   )  ->  float:
							return 1e-5






					@property
					def   A  (				self     :						int   )  ->  int:
							return 12











"""simple docstring"""



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


__A		:       Dict  				=		logging.get_logger(__name__)

__A		:       Union[str, Any]  				=		{
    '''facebook/vit-mae-base''': '''https://huggingface.co/facebook/vit-mae-base/resolve/main/config.json''',
    # See all ViT MAE models at https://huggingface.co/models?filter=vit-mae
}





class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				Union[str, Any]							    =   "vit_mae"




					def __init__(				self     :						Dict    ,						A     :						List[str]=7_68    ,						A     :						Any=12    ,						A     :						Union[str, Any]=12    ,						A     :						Tuple=30_72    ,						A     :						Any="gelu"    ,						A     :						Tuple=0.0    ,						A     :						List[str]=0.0    ,						A     :						Tuple=0.02    ,						A     :						Tuple=1e-12    ,						A     :						int=2_24    ,						A     :						Dict=16    ,						A     :						int=3    ,						A     :						Tuple=True    ,						A     :						Tuple=16    ,						A     :						Optional[Any]=5_12    ,						A     :						Union[str, Any]=8    ,						A     :						List[Any]=20_48    ,						A     :						Dict=0.75    ,						A     :						Any=False    ,						**A     :						Optional[int]    ,						)  ->  Union[str, Any]:
							super().__init__(**A   )

							lowercase_ : List[Any]							       =   hidden_size
							lowercase_ : str							       =   num_hidden_layers
							lowercase_ : List[Any]							       =   num_attention_heads
							lowercase_ : Any							       =   intermediate_size
							lowercase_ : Optional[int]							       =   hidden_act
							lowercase_ : List[Any]							       =   hidden_dropout_prob
							lowercase_ : int							       =   attention_probs_dropout_prob
							lowercase_ : int							       =   initializer_range
							lowercase_ : Dict							       =   layer_norm_eps
							lowercase_ : Optional[Any]							       =   image_size
							lowercase_ : str							       =   patch_size
							lowercase_ : Dict							       =   num_channels
							lowercase_ : Any							       =   qkv_bias
							lowercase_ : Union[str, Any]							       =   decoder_num_attention_heads
							lowercase_ : Optional[Any]							       =   decoder_hidden_size
							lowercase_ : List[str]							       =   decoder_num_hidden_layers
							lowercase_ : List[Any]							       =   decoder_intermediate_size
							lowercase_ : Optional[Any]							       =   mask_ratio
							lowercase_ : Optional[Any]							       =   norm_pix_loss



