






"""simple docstring"""




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


__snake_case							 =  logging.get_logger(__name__)

__snake_case							 =  {
    """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       UpperCAmelCase_						( lowercase			):



      """simple docstring"""
      UpperCamelCase_    : int									='layoutlmv2'
      def __init__(    self   ,    SCREAMING_SNAKE_CASE_=3_0522   ,    SCREAMING_SNAKE_CASE_=768   ,    SCREAMING_SNAKE_CASE_=12   ,    SCREAMING_SNAKE_CASE_=12   ,    SCREAMING_SNAKE_CASE_=3072   ,    SCREAMING_SNAKE_CASE_="gelu"   ,    SCREAMING_SNAKE_CASE_=0.1   ,    SCREAMING_SNAKE_CASE_=0.1   ,    SCREAMING_SNAKE_CASE_=512   ,    SCREAMING_SNAKE_CASE_=2   ,    SCREAMING_SNAKE_CASE_=0.02   ,    SCREAMING_SNAKE_CASE_=1e-12   ,    SCREAMING_SNAKE_CASE_=0   ,    SCREAMING_SNAKE_CASE_=1024   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=32   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=256   ,    SCREAMING_SNAKE_CASE_=64   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=[7, 7, 256]   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=False   ,    SCREAMING_SNAKE_CASE_=None   ,    **SCREAMING_SNAKE_CASE_   ,    )    ->				Optional[Any]:
          super().__init__(
              vocab_size=SCREAMING_SNAKE_CASE_   ,    hidden_size=SCREAMING_SNAKE_CASE_   ,    num_hidden_layers=SCREAMING_SNAKE_CASE_   ,    num_attention_heads=SCREAMING_SNAKE_CASE_   ,    intermediate_size=SCREAMING_SNAKE_CASE_   ,    hidden_act=SCREAMING_SNAKE_CASE_   ,    hidden_dropout_prob=SCREAMING_SNAKE_CASE_   ,    attention_probs_dropout_prob=SCREAMING_SNAKE_CASE_   ,    max_position_embeddings=SCREAMING_SNAKE_CASE_   ,    type_vocab_size=SCREAMING_SNAKE_CASE_   ,    initializer_range=SCREAMING_SNAKE_CASE_   ,    layer_norm_eps=SCREAMING_SNAKE_CASE_   ,    pad_token_id=SCREAMING_SNAKE_CASE_   ,    **SCREAMING_SNAKE_CASE_   ,    )
          UpperCamelCase	:List[str]     							=       max_ad_position_embeddings
          UpperCamelCase	:str     							=       max_rel_pos
          UpperCamelCase	:Dict     							=       rel_pos_bins
          UpperCamelCase	:str     							=       fast_qkv
          UpperCamelCase	:int     							=       max_rel_ad_pos
          UpperCamelCase	:int     							=       rel_ad_pos_bins
          UpperCamelCase	:str     							=       convert_sync_batchnorm
          UpperCamelCase	:List[str]     							=       image_feature_pool_shape
          UpperCamelCase	:List[Any]     							=       coordinate_size
          UpperCamelCase	:Union[str, Any]     							=       shape_size
          UpperCamelCase	:List[Any]     							=       has_relative_attention_bias
          UpperCamelCase	:Optional[Any]     							=       has_spatial_attention_bias
          UpperCamelCase	:Optional[int]     							=       has_visual_segment_embedding
          UpperCamelCase	:Dict     							=       (
              detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
          )
      @classmethod
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          return {
              "MODEL.MASK_ON": True,
              "MODEL.PIXEL_STD": [57.375, 57.120, 58.395],
              "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    UpperCAmelCase						(    self			)    ->				str:
          UpperCamelCase	:List[str]     							=       detectrona.config.get_cfg()
          for k, v in self.detectrona_config_args.items():
              UpperCamelCase	:Union[str, Any]     							=       k.split('''.'''			)
              UpperCamelCase	:Optional[Any]     							=       detectrona_config
              for attribute in attributes[:-1]:
                  UpperCamelCase	:List[Any]     							=       getattr(SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)
              setattr(SCREAMING_SNAKE_CASE_   ,    attributes[-1]   ,    SCREAMING_SNAKE_CASE_			)

          return detectrona_config













def   _A       (    SCREAMING_SNAKE_CASE__  :     float					,  SCREAMING_SNAKE_CASE__  :     float					,  SCREAMING_SNAKE_CASE__  :     float	):
    if hue < 0 or hue > 360:
        raise Exception('''hue should be between 0 and 360'''	)

    if saturation < 0 or saturation > 1:
        raise Exception('''saturation should be between 0 and 1'''	)

    if value < 0 or value > 1:
        raise Exception('''value should be between 0 and 1'''	)

    UpperCamelCase	:Tuple     							=       value * saturation
    UpperCamelCase	:Any     							=       hue / 60
    UpperCamelCase	:Any     							=       chroma * (1 - abs(hue_section % 2 - 1	))
    UpperCamelCase	:Optional[int]     							=       value - chroma

    if hue_section >= 0 and hue_section <= 1:
        UpperCamelCase	:Any     							=       round(255 * (chroma + match_value)	)
        UpperCamelCase	:Union[str, Any]     							=       round(255 * (second_largest_component + match_value)	)
        UpperCamelCase	:List[str]     							=       round(255 * (match_value)	)
    elif hue_section > 1 and hue_section <= 2:
        UpperCamelCase	:Dict     							=       round(255 * (second_largest_component + match_value)	)
        UpperCamelCase	:Dict     							=       round(255 * (chroma + match_value)	)
        UpperCamelCase	:str     							=       round(255 * (match_value)	)
    elif hue_section > 2 and hue_section <= 3:
        UpperCamelCase	:Any     							=       round(255 * (match_value)	)
        UpperCamelCase	:Optional[Any]     							=       round(255 * (chroma + match_value)	)
        UpperCamelCase	:Union[str, Any]     							=       round(255 * (second_largest_component + match_value)	)
    elif hue_section > 3 and hue_section <= 4:
        UpperCamelCase	:Tuple     							=       round(255 * (match_value)	)
        UpperCamelCase	:Optional[Any]     							=       round(255 * (second_largest_component + match_value)	)
        UpperCamelCase	:str     							=       round(255 * (chroma + match_value)	)
    elif hue_section > 4 and hue_section <= 5:
        UpperCamelCase	:int     							=       round(255 * (second_largest_component + match_value)	)
        UpperCamelCase	:str     							=       round(255 * (match_value)	)
        UpperCamelCase	:List[str]     							=       round(255 * (chroma + match_value)	)
    else:
        UpperCamelCase	:Union[str, Any]     							=       round(255 * (chroma + match_value)	)
        UpperCamelCase	:List[str]     							=       round(255 * (match_value)	)
        UpperCamelCase	:Optional[int]     							=       round(255 * (second_largest_component + match_value)	)

    return [red, green, blue]


def   _A       (    SCREAMING_SNAKE_CASE__  :     int					,  SCREAMING_SNAKE_CASE__  :     int					,  SCREAMING_SNAKE_CASE__  :     int	):
    if red < 0 or red > 255:
        raise Exception('''red should be between 0 and 255'''	)

    if green < 0 or green > 255:
        raise Exception('''green should be between 0 and 255'''	)

    if blue < 0 or blue > 255:
        raise Exception('''blue should be between 0 and 255'''	)

    UpperCamelCase	:str     							=       red / 255
    UpperCamelCase	:List[str]     							=       green / 255
    UpperCamelCase	:int     							=       blue / 255
    UpperCamelCase	:Optional[int]     							=       max(SCREAMING_SNAKE_CASE__					,  SCREAMING_SNAKE_CASE__					,  SCREAMING_SNAKE_CASE__	)
    UpperCamelCase	:int     							=       value - min(SCREAMING_SNAKE_CASE__					,  SCREAMING_SNAKE_CASE__					,  SCREAMING_SNAKE_CASE__	)
    UpperCamelCase	:Dict     							=       0 if value == 0 else chroma / value

    if chroma == 0:
        UpperCamelCase	:Dict     							=       0.0
    elif value == float_red:
        UpperCamelCase	:Optional[Any]     							=       60 * (0 + (float_green - float_blue) / chroma)
    elif value == float_green:
        UpperCamelCase	:List[str]     							=       60 * (2 + (float_blue - float_red) / chroma)
    else:
        UpperCamelCase	:str     							=       60 * (4 + (float_red - float_green) / chroma)

    UpperCamelCase	:int     							=       (hue + 360) % 360

    return [hue, saturation, value]



def   _A       (    SCREAMING_SNAKE_CASE__  :     list[float]					,  SCREAMING_SNAKE_CASE__  :     list[float]	):
    UpperCamelCase	:str     							=       abs(hsv_a[0] - hsv_a[0]	) < 0.2
    UpperCamelCase	:List[str]     							=       abs(hsv_a[1] - hsv_a[1]	) < 0.0_02
    UpperCamelCase	:Any     							=       abs(hsv_a[2] - hsv_a[2]	) < 0.0_02

    return check_hue and check_saturation and check_value





