

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


UpperCamelCase__     :					Dict								=			logging.get_logger(__name__)

UpperCamelCase__     :					str								=			{
    "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 					__snake_case     (			lowerCAmelCase__				):
  __lowerCAmelCase   :		Tuple         =     'layoutlmv2'

  def __init__(    self  ,						_A=30522  ,						_A=768  ,						_A=12  ,						_A=12  ,						_A=3072  ,						_A="gelu"  ,						_A=0.1  ,						_A=0.1  ,						_A=512  ,						_A=2  ,						_A=0.0_2  ,						_A=1E-12  ,						_A=0  ,						_A=1024  ,						_A=128  ,						_A=32  ,						_A=True  ,						_A=256  ,						_A=64  ,						_A=True  ,						_A=[7, 7, 256]  ,						_A=128  ,						_A=128  ,						_A=True  ,						_A=True  ,						_A=False  ,						_A=None  ,						**_A  ,						):
      super().__init__(
          vocab_size=_A  ,						hidden_size=_A  ,						num_hidden_layers=_A  ,						num_attention_heads=_A  ,						intermediate_size=_A  ,						hidden_act=_A  ,						hidden_dropout_prob=_A  ,						attention_probs_dropout_prob=_A  ,						max_position_embeddings=_A  ,						type_vocab_size=_A  ,						initializer_range=_A  ,						layer_norm_eps=_A  ,						pad_token_id=_A  ,						**_A  ,						)
      SCREAMING_SNAKE_CASE_													=  max_ad_position_embeddings
      SCREAMING_SNAKE_CASE_													=  max_rel_pos
      SCREAMING_SNAKE_CASE_													=  rel_pos_bins
      SCREAMING_SNAKE_CASE_													=  fast_qkv
      SCREAMING_SNAKE_CASE_													=  max_rel_ad_pos
      SCREAMING_SNAKE_CASE_													=  rel_ad_pos_bins
      SCREAMING_SNAKE_CASE_													=  convert_sync_batchnorm
      SCREAMING_SNAKE_CASE_													=  image_feature_pool_shape
      SCREAMING_SNAKE_CASE_													=  coordinate_size
      SCREAMING_SNAKE_CASE_													=  shape_size
      SCREAMING_SNAKE_CASE_													=  has_relative_attention_bias
      SCREAMING_SNAKE_CASE_													=  has_spatial_attention_bias
      SCREAMING_SNAKE_CASE_													=  has_visual_segment_embedding
      SCREAMING_SNAKE_CASE_													=  (
          detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
      )

  @classmethod
  def   lowerCAmelCase__   (    self):
      return {
          "MODEL.MASK_ON": True,
          "MODEL.PIXEL_STD": [5_7.3_7_5, 5_7.1_2_0, 5_8.3_9_5],
          "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   lowerCAmelCase__   (    self):
      SCREAMING_SNAKE_CASE_													=  detectrona.config.get_cfg()
      for k, v in self.detectrona_config_args.items():
          SCREAMING_SNAKE_CASE_													=  k.split('.')
          SCREAMING_SNAKE_CASE_													=  detectrona_config
          for attribute in attributes[:-1]:
              SCREAMING_SNAKE_CASE_													=  getattr(_A  ,						_A)
          setattr(_A  ,						attributes[-1]  ,						_A)

      return detectrona_config





from __future__ import annotations

from math import pi, pow


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						int | float				):





    """simple docstring"""


    if side_length < 0:
        raise ValueError('vol_cube() only accepts non-negative values'				)
    return pow(_SCREAMING_SNAKE_CASE       ,      3				)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('vol_spherical_cap() only accepts non-negative values'				)
    # Volume is 1/3 pi * height squared * (3 * radius - height)
    return 1 / 3 * pi * pow(_SCREAMING_SNAKE_CASE       ,      2				) * (3 * radius - height)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if radius_a < 0 or radius_a < 0 or centers_distance < 0:
        raise ValueError('vol_spheres_intersect() only accepts non-negative values'				)
    if centers_distance == 0:
        return vol_sphere(min(_SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE				)				)

    SCREAMING_SNAKE_CASE_													=  (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )
    SCREAMING_SNAKE_CASE_													=  (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )

    return vol_spherical_cap(_SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE				) + vol_spherical_cap(_SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE				)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
        raise ValueError(
            'vol_spheres_union() only accepts non-negative values, non-zero radius'				)

    if centers_distance == 0:
        return vol_sphere(max(_SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE				)				)

    return (
        vol_sphere(_SCREAMING_SNAKE_CASE				)
        + vol_sphere(_SCREAMING_SNAKE_CASE				)
        - vol_spheres_intersect(_SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE       ,      _SCREAMING_SNAKE_CASE				)
    )


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if width < 0 or height < 0 or length < 0:
        raise ValueError('vol_cuboid() only accepts non-negative values'				)
    return float(width * height * length				)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('vol_cone() only accepts non-negative values'				)
    return area_of_base * height / 3.0


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('vol_right_circ_cone() only accepts non-negative values'				)
    return pi * pow(_SCREAMING_SNAKE_CASE       ,      2				) * height / 3.0


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('vol_prism() only accepts non-negative values'				)
    return float(area_of_base * height				)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('vol_pyramid() only accepts non-negative values'				)
    return area_of_base * height / 3.0


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if radius < 0:
        raise ValueError('vol_sphere() only accepts non-negative values'				)
    # Volume is 4/3 * pi * radius cubed
    return 4 / 3 * pi * pow(_SCREAMING_SNAKE_CASE       ,      3				)


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if radius < 0:
        raise ValueError('vol_hemisphere() only accepts non-negative values'				)
    # Volume is radius cubed * pi * 2/3
    return pow(_SCREAMING_SNAKE_CASE       ,      3				) * pi * 2 / 3


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('vol_circular_cylinder() only accepts non-negative values'				)
    # Volume is radius squared * height * pi
    return pow(_SCREAMING_SNAKE_CASE       ,      2				) * height * pi


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if inner_radius < 0 or outer_radius < 0 or height < 0:
        raise ValueError(
            'vol_hollow_circular_cylinder() only accepts non-negative values'				)
    if outer_radius <= inner_radius:
        raise ValueError('outer_radius must be greater than inner_radius'				)
    return pi * (pow(_SCREAMING_SNAKE_CASE       ,      2				) - pow(_SCREAMING_SNAKE_CASE       ,      2				)) * height


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if radius_a < 0 or radius_a < 0 or height < 0:
        raise ValueError('vol_conical_frustum() only accepts non-negative values'				)
    return (
        1
        / 3
        * pi
        * height
        * (pow(_SCREAMING_SNAKE_CASE       ,      2				) + pow(_SCREAMING_SNAKE_CASE       ,      2				) + radius_a * radius_a)
    )


def     _UpperCAmelCase				(     _SCREAMING_SNAKE_CASE    :						float       ,      _SCREAMING_SNAKE_CASE    :						float				):





    """simple docstring"""


    if torus_radius < 0 or tube_radius < 0:
        raise ValueError('vol_torus() only accepts non-negative values'				)
    return 2 * pow(_SCREAMING_SNAKE_CASE       ,      2				) * torus_radius * pow(_SCREAMING_SNAKE_CASE       ,      2				)


def     _UpperCAmelCase				(     ):





    """simple docstring"""


    print('Volumes:'				)
    print(f"""Cube: {vol_cube(2				) = }"""				)  # = 8
    print(f"""Cuboid: {vol_cuboid(2       ,      2       ,      2				) = }"""				)  # = 8
    print(f"""Cone: {vol_cone(2       ,      2				) = }"""				)  # ~= 1.33
    print(f"""Right Circular Cone: {vol_right_circ_cone(2       ,      2				) = }"""				)  # ~= 8.38
    print(f"""Prism: {vol_prism(2       ,      2				) = }"""				)  # = 4
    print(f"""Pyramid: {vol_pyramid(2       ,      2				) = }"""				)  # ~= 1.33
    print(f"""Sphere: {vol_sphere(2				) = }"""				)  # ~= 33.5
    print(f"""Hemisphere: {vol_hemisphere(2				) = }"""				)  # ~= 16.75
    print(f"""Circular Cylinder: {vol_circular_cylinder(2       ,      2				) = }"""				)  # ~= 25.1
    print(f"""Torus: {vol_torus(2       ,      2				) = }"""				)  # ~= 157.9
    print(f"""Conical Frustum: {vol_conical_frustum(2       ,      2       ,      4				) = }"""				)  # ~= 58.6
    print(f"""Spherical cap: {vol_spherical_cap(1       ,      2				) = }"""				)  # ~= 5.24
    print(f"""Spheres intersetion: {vol_spheres_intersect(2       ,      2       ,      1				) = }"""				)  # ~= 21.21
    print(f"""Spheres union: {vol_spheres_union(2       ,      2       ,      1				) = }"""				)  # ~= 45.81
    print(
        f"""Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1       ,      2       ,      3				) = }"""				)  # ~= 28.3


if __name__ == "__main__":
       main()


