

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_		(			__lowercase   ):
							"""simple docstring"""







							UpperCAmelCase__       :						str	    =    "layoutlmv3"


							def __init__(			self       ,							_a=5_0_2_6_5       ,							_a=7_6_8       ,							_a=1_2       ,							_a=1_2       ,							_a=3_0_7_2       ,							_a="gelu"       ,							_a=0.1       ,							_a=0.1       ,							_a=5_1_2       ,							_a=2       ,							_a=0.02       ,							_a=1e-5       ,							_a=1       ,							_a=0       ,							_a=2       ,							_a=1_0_2_4       ,							_a=1_2_8       ,							_a=1_2_8       ,							_a=True       ,							_a=3_2       ,							_a=1_2_8       ,							_a=6_4       ,							_a=2_5_6       ,							_a=True       ,							_a=True       ,							_a=True       ,							_a=2_2_4       ,							_a=3       ,							_a=1_6       ,							_a=None       ,							**_a       ,							)    ->    List[str]:
												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       ,							bos_token_id=_a       ,							eos_token_id=_a       ,							**_a       ,							)
												_a	:    List[Any]         =		max_ad_position_embeddings
												_a	:    Tuple         =		coordinate_size
												_a	:    Union[str, Any]         =		shape_size
												_a	:    List[str]         =		has_relative_attention_bias
												_a	:    Tuple         =		rel_pos_bins
												_a	:    str         =		max_rel_pos
												_a	:    List[Any]         =		has_spatial_attention_bias
												_a	:    List[Any]         =		rel_ad_pos_bins
												_a	:    Optional[Any]         =		max_rel_ad_pos
												_a	:    str         =		text_embed
												_a	:    str         =		visual_embed
												_a	:    Optional[Any]         =		input_size
												_a	:    Dict         =		num_channels
												_a	:    List[str]         =		patch_size
												_a	:    List[str]         =		classifier_dropout



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







							UpperCAmelCase__       :						Dict	    =    version.parse("1.12"   )


							@property
							def 				__lowercase				(			self       )    ->    Mapping[str, Mapping[int, str]]:
												# 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 				__lowercase				(			self       )    ->    float:
												return 1e-5


							@property
							def 				__lowercase				(			self       )    ->    int:
												return 1_2




							def 				__lowercase				(			self       ,							_a       ,							_a = -1       ,							_a = -1       ,							_a = False       ,							_a = None       ,							_a = 3       ,							_a = 4_0       ,							_a = 4_0       ,							)    ->    Mapping[str, Any]:
												setattr(processor.image_processor       ,							'''apply_ocr'''       ,							_a       )

												# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
												_a	:    Union[str, Any]         =		compute_effective_axis_dimension(
												    _a       ,							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
												_a	:    Tuple         =		processor.tokenizer.num_special_tokens_to_add(_a       )
												_a	:    Optional[Any]         =		compute_effective_axis_dimension(
												    _a       ,							fixed_dimension=OnnxConfig.default_fixed_sequence       ,							num_token_to_add=_a       )
												# Generate dummy inputs according to compute batch and sequence
												_a	:    Any         =		[[''' '''.join([processor.tokenizer.unk_token]       ) * seq_length]] * batch_size

												# Generate dummy bounding boxes
												_a	:    Optional[int]         =		[[[4_8, 8_4, 7_3, 1_2_8]]] * 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)
												_a	:    Tuple         =		self._generate_dummy_images(_a       ,							_a       ,							_a       ,							_a       )

												_a	:    Union[str, Any]         =		dict(
												    processor(
												        _a       ,							text=_a       ,							boxes=_a       ,							return_tensors=_a       ,							)       )

												return inputs






a__				=		'''0.18.2'''

from .configuration_utils import ConfigMixin
from .utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_inflect_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_scipy_available,
    is_torch_available,
    is_torchsde_available,
    is_transformers_available,
    is_transformers_version,
    is_unidecode_available,
    logging,
)


try:
			if not is_onnx_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_onnx_objects import *  # noqa F403
else:
			from .pipelines import OnnxRuntimeModel

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_pt_objects import *  # noqa F403
else:
			from .models import (
			    AutoencoderKL,
			    ControlNetModel,
			    ModelMixin,
			    PriorTransformer,
			    TaFilmDecoder,
			    TransformeraDModel,
			    UNetaDModel,
			    UNetaDConditionModel,
			    UNetaDModel,
			    UNetaDConditionModel,
			    VQModel,
			)
			from .optimization import (
			    get_constant_schedule,
			    get_constant_schedule_with_warmup,
			    get_cosine_schedule_with_warmup,
			    get_cosine_with_hard_restarts_schedule_with_warmup,
			    get_linear_schedule_with_warmup,
			    get_polynomial_decay_schedule_with_warmup,
			    get_scheduler,
			)
			from .pipelines import (
			    AudioPipelineOutput,
			    ConsistencyModelPipeline,
			    DanceDiffusionPipeline,
			    DDIMPipeline,
			    DDPMPipeline,
			    DiffusionPipeline,
			    DiTPipeline,
			    ImagePipelineOutput,
			    KarrasVePipeline,
			    LDMPipeline,
			    LDMSuperResolutionPipeline,
			    PNDMPipeline,
			    RePaintPipeline,
			    ScoreSdeVePipeline,
			)
			from .schedulers import (
			    CMStochasticIterativeScheduler,
			    DDIMInverseScheduler,
			    DDIMParallelScheduler,
			    DDIMScheduler,
			    DDPMParallelScheduler,
			    DDPMScheduler,
			    DEISMultistepScheduler,
			    DPMSolverMultistepInverseScheduler,
			    DPMSolverMultistepScheduler,
			    DPMSolverSinglestepScheduler,
			    EulerAncestralDiscreteScheduler,
			    EulerDiscreteScheduler,
			    HeunDiscreteScheduler,
			    IPNDMScheduler,
			    KarrasVeScheduler,
			    KDPMaAncestralDiscreteScheduler,
			    KDPMaDiscreteScheduler,
			    PNDMScheduler,
			    RePaintScheduler,
			    SchedulerMixin,
			    ScoreSdeVeScheduler,
			    UnCLIPScheduler,
			    UniPCMultistepScheduler,
			    VQDiffusionScheduler,
			)
			from .training_utils import EMAModel

try:
			if not (is_torch_available() and is_scipy_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_scipy_objects import *  # noqa F403
else:
			from .schedulers import LMSDiscreteScheduler

try:
			if not (is_torch_available() and is_torchsde_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_torchsde_objects import *  # noqa F403
else:
			from .schedulers import DPMSolverSDEScheduler

try:
			if not (is_torch_available() and is_transformers_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
			from .pipelines import (
			    AltDiffusionImgaImgPipeline,
			    AltDiffusionPipeline,
			    AudioLDMPipeline,
			    CycleDiffusionPipeline,
			    IFImgaImgPipeline,
			    IFImgaImgSuperResolutionPipeline,
			    IFInpaintingPipeline,
			    IFInpaintingSuperResolutionPipeline,
			    IFPipeline,
			    IFSuperResolutionPipeline,
			    ImageTextPipelineOutput,
			    KandinskyImgaImgPipeline,
			    KandinskyInpaintPipeline,
			    KandinskyPipeline,
			    KandinskyPriorPipeline,
			    KandinskyVaaControlnetImgaImgPipeline,
			    KandinskyVaaControlnetPipeline,
			    KandinskyVaaImgaImgPipeline,
			    KandinskyVaaInpaintPipeline,
			    KandinskyVaaPipeline,
			    KandinskyVaaPriorEmbaEmbPipeline,
			    KandinskyVaaPriorPipeline,
			    LDMTextToImagePipeline,
			    PaintByExamplePipeline,
			    SemanticStableDiffusionPipeline,
			    ShapEImgaImgPipeline,
			    ShapEPipeline,
			    StableDiffusionAttendAndExcitePipeline,
			    StableDiffusionControlNetImgaImgPipeline,
			    StableDiffusionControlNetInpaintPipeline,
			    StableDiffusionControlNetPipeline,
			    StableDiffusionDepthaImgPipeline,
			    StableDiffusionDiffEditPipeline,
			    StableDiffusionImageVariationPipeline,
			    StableDiffusionImgaImgPipeline,
			    StableDiffusionInpaintPipeline,
			    StableDiffusionInpaintPipelineLegacy,
			    StableDiffusionInstructPixaPixPipeline,
			    StableDiffusionLatentUpscalePipeline,
			    StableDiffusionLDMaDPipeline,
			    StableDiffusionModelEditingPipeline,
			    StableDiffusionPanoramaPipeline,
			    StableDiffusionParadigmsPipeline,
			    StableDiffusionPipeline,
			    StableDiffusionPipelineSafe,
			    StableDiffusionPixaPixZeroPipeline,
			    StableDiffusionSAGPipeline,
			    StableDiffusionUpscalePipeline,
			    StableUnCLIPImgaImgPipeline,
			    StableUnCLIPPipeline,
			    TextToVideoSDPipeline,
			    TextToVideoZeroPipeline,
			    UnCLIPImageVariationPipeline,
			    UnCLIPPipeline,
			    UniDiffuserModel,
			    UniDiffuserPipeline,
			    UniDiffuserTextDecoder,
			    VersatileDiffusionDualGuidedPipeline,
			    VersatileDiffusionImageVariationPipeline,
			    VersatileDiffusionPipeline,
			    VersatileDiffusionTextToImagePipeline,
			    VideoToVideoSDPipeline,
			    VQDiffusionPipeline,
			)

try:
			if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
			from .pipelines import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
			if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
			from .pipelines import StableDiffusionKDiffusionPipeline

try:
			if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
			from .pipelines import (
			    OnnxStableDiffusionImgaImgPipeline,
			    OnnxStableDiffusionInpaintPipeline,
			    OnnxStableDiffusionInpaintPipelineLegacy,
			    OnnxStableDiffusionPipeline,
			    OnnxStableDiffusionUpscalePipeline,
			    StableDiffusionOnnxPipeline,
			)

try:
			if not (is_torch_available() and is_librosa_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
			from .pipelines import AudioDiffusionPipeline, Mel

try:
			if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
			from .pipelines import SpectrogramDiffusionPipeline

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_flax_objects import *  # noqa F403
else:
			from .models.controlnet_flax import FlaxControlNetModel
			from .models.modeling_flax_utils import FlaxModelMixin
			from .models.unet_ad_condition_flax import FlaxUNetaDConditionModel
			from .models.vae_flax import FlaxAutoencoderKL
			from .pipelines import FlaxDiffusionPipeline
			from .schedulers import (
			    FlaxDDIMScheduler,
			    FlaxDDPMScheduler,
			    FlaxDPMSolverMultistepScheduler,
			    FlaxKarrasVeScheduler,
			    FlaxLMSDiscreteScheduler,
			    FlaxPNDMScheduler,
			    FlaxSchedulerMixin,
			    FlaxScoreSdeVeScheduler,
			)


try:
			if not (is_flax_available() and is_transformers_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
			from .pipelines import (
			    FlaxStableDiffusionControlNetPipeline,
			    FlaxStableDiffusionImgaImgPipeline,
			    FlaxStableDiffusionInpaintPipeline,
			    FlaxStableDiffusionPipeline,
			)

try:
			if not (is_note_seq_available()):
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			from .utils.dummy_note_seq_objects import *  # noqa F403
else:
			from .pipelines import MidiProcessor



