



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


UpperCAmelCase_		 =					{
    """configuration_xlm""": ["""XLM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """XLMConfig""", """XLMOnnxConfig"""],
    """tokenization_xlm""": ["""XLMTokenizer"""],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_		 =					[
       """XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """XLMForMultipleChoice""",
       """XLMForQuestionAnswering""",
       """XLMForQuestionAnsweringSimple""",
       """XLMForSequenceClassification""",
       """XLMForTokenClassification""",
       """XLMModel""",
       """XLMPreTrainedModel""",
       """XLMWithLMHeadModel""",
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   UpperCAmelCase_		 =					[
       """TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TFXLMForMultipleChoice""",
       """TFXLMForQuestionAnsweringSimple""",
       """TFXLMForSequenceClassification""",
       """TFXLMForTokenClassification""",
       """TFXLMMainLayer""",
       """TFXLMModel""",
       """TFXLMPreTrainedModel""",
       """TFXLMWithLMHeadModel""",
   ]


if TYPE_CHECKING:
   from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
   from .tokenization_xlm import XLMTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_xlm import (
          XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          XLMForMultipleChoice,
          XLMForQuestionAnswering,
          XLMForQuestionAnsweringSimple,
          XLMForSequenceClassification,
          XLMForTokenClassification,
          XLMModel,
          XLMPreTrainedModel,
          XLMWithLMHeadModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_xlm import (
          TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFXLMForMultipleChoice,
          TFXLMForQuestionAnsweringSimple,
          TFXLMForSequenceClassification,
          TFXLMForTokenClassification,
          TFXLMMainLayer,
          TFXLMModel,
          TFXLMPreTrainedModel,
          TFXLMWithLMHeadModel,
      )

else:
   import sys

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








'''simple docstring'''





from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


if TYPE_CHECKING:
       from ...processing_utils import ProcessorMixin
       from ...utils import TensorType


__a  			=						logging.get_logger(__name__)

__a  			=						{
    "microsoft/layoutlmv3-base": "https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json",
}







class        UpperCAmelCase_			(			_a      ):
    """simple docstring"""







    lowercase   =						"layoutlmv3"




    def __init__(       self   :	Any					,	snake_case_   :	Dict=50_265					,	snake_case_   :	Union[str, Any]=768					,	snake_case_   :	Union[str, Any]=12					,	snake_case_   :	Optional[int]=12					,	snake_case_   :	Union[str, Any]=3_072					,	snake_case_   :	List[str]="gelu"					,	snake_case_   :	List[Any]=0.1					,	snake_case_   :	Union[str, Any]=0.1					,	snake_case_   :	Optional[int]=512					,	snake_case_   :	List[str]=2					,	snake_case_   :	List[str]=0.02					,	snake_case_   :	List[Any]=1E-5					,	snake_case_   :	Any=1					,	snake_case_   :	Any=0					,	snake_case_   :	int=2					,	snake_case_   :	Optional[Any]=1_024					,	snake_case_   :	int=128					,	snake_case_   :	Union[str, Any]=128					,	snake_case_   :	int=True					,	snake_case_   :	Tuple=32					,	snake_case_   :	str=128					,	snake_case_   :	Optional[int]=64					,	snake_case_   :	Optional[Any]=256					,	snake_case_   :	List[str]=True					,	snake_case_   :	str=True					,	snake_case_   :	Dict=True					,	snake_case_   :	int=224					,	snake_case_   :	Any=3					,	snake_case_   :	int=16					,	snake_case_   :	Tuple=None					,	**snake_case_   :	Optional[Any]					,	):
          super().__init__(
              vocab_size=snake_case_					,	hidden_size=snake_case_					,	num_hidden_layers=snake_case_					,	num_attention_heads=snake_case_					,	intermediate_size=snake_case_					,	hidden_act=snake_case_					,	hidden_dropout_prob=snake_case_					,	attention_probs_dropout_prob=snake_case_					,	max_position_embeddings=snake_case_					,	type_vocab_size=snake_case_					,	initializer_range=snake_case_					,	layer_norm_eps=snake_case_					,	pad_token_id=snake_case_					,	bos_token_id=snake_case_					,	eos_token_id=snake_case_					,	**snake_case_					,	)
          snake_case__    :       List[Any]       		= max_ad_position_embeddings
          snake_case__    :       Optional[int]       		= coordinate_size
          snake_case__    :       int       		= shape_size
          snake_case__    :       Optional[int]       		= has_relative_attention_bias
          snake_case__    :       Dict       		= rel_pos_bins
          snake_case__    :       List[Any]       		= max_rel_pos
          snake_case__    :       str       		= has_spatial_attention_bias
          snake_case__    :       Optional[Any]       		= rel_ad_pos_bins
          snake_case__    :       Optional[int]       		= max_rel_ad_pos
          snake_case__    :       Union[str, Any]       		= text_embed
          snake_case__    :       List[Any]       		= visual_embed
          snake_case__    :       Union[str, Any]       		= input_size
          snake_case__    :       int       		= num_channels
          snake_case__    :       Optional[Any]       		= patch_size
          snake_case__    :       Dict       		= classifier_dropout







class        UpperCAmelCase_			(			_a      ):
    """simple docstring"""







    lowercase   =						version.parse("1.12"      )




    @property
    def lowerCamelCase			(       self   :	Tuple		):
          # The order of inputs is different for question answering and sequence classification
          if self.task in ["question-answering", "sequence-classification"]:
                return OrderedDict(
                    [
                        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
                        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
                        ("""bbox""", {0: """batch""", 1: """sequence"""}),
                        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
                    ]		)
          else:
                return OrderedDict(
                    [
                        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
                        ("""bbox""", {0: """batch""", 1: """sequence"""}),
                        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
                        ("""pixel_values""", {0: """batch""", 1: """num_channels"""}),
                    ]		)




    @property
    def lowerCamelCase			(       self   :	str		):
          return 1E-5




    @property
    def lowerCamelCase			(       self   :	List[Any]		):
          return 12




    def lowerCamelCase			(       self   :	str					,	snake_case_   :	"ProcessorMixin"					,	snake_case_   :	int = -1					,	snake_case_   :	int = -1					,	snake_case_   :	bool = False					,	snake_case_   :	Optional["TensorType"] = None					,	snake_case_   :	int = 3					,	snake_case_   :	int = 40					,	snake_case_   :	int = 40					,	):
          setattr(processor.image_processor					,	"""apply_ocr"""					,	snake_case_		)

          # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
          snake_case__    :       Optional[Any]       		= compute_effective_axis_dimension(
              snake_case_					,	fixed_dimension=OnnxConfig.default_fixed_batch					,	num_token_to_add=0		)
          # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
          snake_case__    :       List[Any]       		= processor.tokenizer.num_special_tokens_to_add(snake_case_		)
          snake_case__    :       Tuple       		= compute_effective_axis_dimension(
              snake_case_					,	fixed_dimension=OnnxConfig.default_fixed_sequence					,	num_token_to_add=snake_case_		)
          # Generate dummy inputs according to compute batch and sequence
          snake_case__    :       int       		= [[""" """.join([processor.tokenizer.unk_token]		) * seq_length]] * batch_size

          # Generate dummy bounding boxes
          snake_case__    :       int       		= [[[48, 84, 73, 128]]] * batch_size

          # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
          # batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch)
          snake_case__    :       Optional[int]       		= self._generate_dummy_images(snake_case_					,	snake_case_					,	snake_case_					,	snake_case_		)

          snake_case__    :       Optional[int]       		= dict(
              processor(
                  snake_case_					,	text=snake_case_					,	boxes=snake_case_					,	return_tensors=snake_case_					,	)		)

          return inputs
