



from ...configuration_utils import PretrainedConfig
from ...utils import is_detectrona_available, logging


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

snake_case     :    Dict						=    {
    'layoutlmv2-base-uncased': 'https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json',
    'layoutlmv2-large-uncased': 'https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json',
    # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
}

# soft dependency
if is_detectrona_available():
		import detectrona




class 				lowerCAmelCase__	(						__lowerCamelCase    ):
					__A  :     Tuple     =    'layoutlmv2'







					def __init__(							self   :  Union[str, Any]      ,		_A   :  List[str]=3_0522      ,		_A   :  str=768      ,		_A   :  Tuple=12      ,		_A   :  Union[str, Any]=12      ,		_A   :  Any=3072      ,		_A   :  List[str]="gelu"      ,		_A   :  Dict=0.1      ,		_A   :  Optional[int]=0.1      ,		_A   :  Union[str, Any]=512      ,		_A   :  Optional[int]=2      ,		_A   :  Union[str, Any]=0.02      ,		_A   :  Optional[Any]=1e-12      ,		_A   :  List[Any]=0      ,		_A   :  str=1024      ,		_A   :  str=128      ,		_A   :  List[Any]=32      ,		_A   :  Tuple=True      ,		_A   :  Optional[int]=256      ,		_A   :  List[str]=64      ,		_A   :  Optional[Any]=True      ,		_A   :  Optional[Any]=[7, 7, 256]      ,		_A   :  Optional[int]=128      ,		_A   :  int=128      ,		_A   :  str=True      ,		_A   :  Dict=True      ,		_A   :  Union[str, Any]=False      ,		_A   :  Union[str, Any]=None      ,		**_A   :  Optional[int]      ,		):
											super().__init__(
											    vocab_size=UpperCamelCase_      ,		hidden_size=UpperCamelCase_      ,		num_hidden_layers=UpperCamelCase_      ,		num_attention_heads=UpperCamelCase_      ,		intermediate_size=UpperCamelCase_      ,		hidden_act=UpperCamelCase_      ,		hidden_dropout_prob=UpperCamelCase_      ,		attention_probs_dropout_prob=UpperCamelCase_      ,		max_position_embeddings=UpperCamelCase_      ,		type_vocab_size=UpperCamelCase_      ,		initializer_range=UpperCamelCase_      ,		layer_norm_eps=UpperCamelCase_      ,		pad_token_id=UpperCamelCase_      ,		**UpperCamelCase_      ,		)
											A__						:				int         =			max_ad_position_embeddings
											A__						:				Dict         =			max_rel_pos
											A__						:				Dict         =			rel_pos_bins
											A__						:				str         =			fast_qkv
											A__						:				Union[str, Any]         =			max_rel_ad_pos
											A__						:				Tuple         =			rel_ad_pos_bins
											A__						:				Tuple         =			convert_sync_batchnorm
											A__						:				List[str]         =			image_feature_pool_shape
											A__						:				Dict         =			coordinate_size
											A__						:				int         =			shape_size
											A__						:				Union[str, Any]         =			has_relative_attention_bias
											A__						:				str         =			has_spatial_attention_bias
											A__						:				Union[str, Any]         =			has_visual_segment_embedding
											A__						:				List[Any]         =			(
											    detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
											)







					@classmethod
					def 			_lowercase      (							self   :  Optional[int]):
											return {
											    "MODEL.MASK_ON": True,
											    "MODEL.PIXEL_STD": [57.3_75, 57.1_20, 58.3_95],
											    "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
											    "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
											    "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [128], [256], [512]],
											    "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
											    "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 2000,
											    "MODEL.RPN.PRE_NMS_TOPK_TEST": 1000,
											    "MODEL.RPN.POST_NMS_TOPK_TRAIN": 1000,
											    "MODEL.POST_NMS_TOPK_TEST": 1000,
											    "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
											    "MODEL.ROI_HEADS.NUM_CLASSES": 5,
											    "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
											    "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
											    "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
											    "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
											    "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
											    "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
											    "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
											    "MODEL.RESNETS.DEPTH": 101,
											    "MODEL.RESNETS.SIZES": [[32], [64], [128], [256], [512]],
											    "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
											    "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
											    "MODEL.RESNETS.NUM_GROUPS": 32,
											    "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
											    "MODEL.RESNETS.STRIDE_IN_1X1": False,
											}







					def 			_lowercase      (							self   :  Optional[int]):
											A__						:				Any         =			detectrona.config.get_cfg()
											for k, v in self.detectrona_config_args.items():
																	A__						:				List[str]         =			k.split(".")
																	A__						:				Tuple         =			detectrona_config
																	for attribute in attributes[:-1]:
																							A__						:				int         =			getattr(UpperCamelCase_      ,		UpperCamelCase_)
																	setattr(UpperCamelCase_      ,		attributes[-1]      ,		UpperCamelCase_)

											return detectrona_config





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_   							=      {'configuration_dinat': ['DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DinatConfig']}


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       UpperCAmelCase_   							=      [
           'DINAT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'DinatForImageClassification',
           'DinatModel',
           'DinatPreTrainedModel',
           'DinatBackbone',
       ]

if TYPE_CHECKING:
       from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_dinat import (
                  DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DinatBackbone,
                  DinatForImageClassification,
                  DinatModel,
                  DinatPreTrainedModel,
              )

else:
       import sys

       UpperCAmelCase_   							=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

