
"""simple docstring"""






import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
					    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
					    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
					    LayoutLMvaConfig,
					    LayoutLMvaForQuestionAnswering,
					    LayoutLMvaForSequenceClassification,
					    LayoutLMvaForTokenClassification,
					    LayoutLMvaModel,
					)
					from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
					from PIL import Image

					from transformers import LayoutLMvaImageProcessor

class 					__a     :



							'''simple docstring'''







							def __init__(     self  ,    _lowerCamelCase  ,    _lowerCamelCase=2  ,    _lowerCamelCase=3  ,    _lowerCamelCase=4  ,    _lowerCamelCase=2  ,    _lowerCamelCase=7  ,    _lowerCamelCase=True  ,    _lowerCamelCase=True  ,    _lowerCamelCase=True  ,    _lowerCamelCase=True  ,    _lowerCamelCase=99  ,    _lowerCamelCase=36  ,    _lowerCamelCase=3  ,    _lowerCamelCase=4  ,    _lowerCamelCase=37  ,    _lowerCamelCase="gelu"  ,    _lowerCamelCase=0.1  ,    _lowerCamelCase=0.1  ,    _lowerCamelCase=512  ,    _lowerCamelCase=16  ,    _lowerCamelCase=2  ,    _lowerCamelCase=0.02  ,    _lowerCamelCase=6  ,    _lowerCamelCase=6  ,    _lowerCamelCase=3  ,    _lowerCamelCase=4  ,    _lowerCamelCase=None  ,    _lowerCamelCase=1_000  ,    )			->							Optional[Any]:




										'''simple docstring'''
										__lowercase       =       parent
										__lowercase       =       batch_size
										__lowercase       =       num_channels
										__lowercase       =       image_size
										__lowercase       =       patch_size
										__lowercase       =       text_seq_length
										__lowercase       =       is_training
										__lowercase       =       use_input_mask
										__lowercase       =       use_token_type_ids
										__lowercase       =       use_labels
										__lowercase       =       vocab_size
										__lowercase       =       hidden_size
										__lowercase       =       num_hidden_layers
										__lowercase       =       num_attention_heads
										__lowercase       =       intermediate_size
										__lowercase       =       hidden_act
										__lowercase       =       hidden_dropout_prob
										__lowercase       =       attention_probs_dropout_prob
										__lowercase       =       max_position_embeddings
										__lowercase       =       type_vocab_size
										__lowercase       =       type_sequence_label_size
										__lowercase       =       initializer_range
										__lowercase       =       coordinate_size
										__lowercase       =       shape_size
										__lowercase       =       num_labels
										__lowercase       =       num_choices
										__lowercase       =       scope
										__lowercase       =       range_bbox

										# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
										__lowercase       =       text_seq_length
										__lowercase       =       (image_size // patch_size) ** 2 + 1
										__lowercase       =       self.text_seq_length + self.image_seq_length
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										__lowercase       =       ids_tensor([self.batch_size, self.text_seq_length]  ,    self.vocab_size       )

										__lowercase       =       ids_tensor([self.batch_size, self.text_seq_length, 4]  ,    self.range_bbox       )
										# Ensure that bbox is legal
										for i in range(bbox.shape[0]       ):
													for j in range(bbox.shape[1]       ):
																if bbox[i, j, 3] < bbox[i, j, 1]:
																			__lowercase       =       bbox[i, j, 3]
																			__lowercase       =       bbox[i, j, 1]
																			__lowercase       =       t
																if bbox[i, j, 2] < bbox[i, j, 0]:
																			__lowercase       =       bbox[i, j, 2]
																			__lowercase       =       bbox[i, j, 0]
																			__lowercase       =       t

										__lowercase       =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

										__lowercase       =       None
										if self.use_input_mask:
													__lowercase       =       random_attention_mask([self.batch_size, self.text_seq_length]       )

										__lowercase       =       None
										if self.use_token_type_ids:
													__lowercase       =       ids_tensor([self.batch_size, self.text_seq_length]  ,    self.type_vocab_size       )

										__lowercase       =       None
										__lowercase       =       None
										if self.use_labels:
													__lowercase       =       ids_tensor([self.batch_size]  ,    self.type_sequence_label_size       )
													__lowercase       =       ids_tensor([self.batch_size, self.text_seq_length]  ,    self.num_labels       )

										__lowercase       =       LayoutLMvaConfig(
										    vocab_size=self.vocab_size  ,    hidden_size=self.hidden_size  ,    num_hidden_layers=self.num_hidden_layers  ,    num_attention_heads=self.num_attention_heads  ,    intermediate_size=self.intermediate_size  ,    hidden_act=self.hidden_act  ,    hidden_dropout_prob=self.hidden_dropout_prob  ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,    max_position_embeddings=self.max_position_embeddings  ,    type_vocab_size=self.type_vocab_size  ,    initializer_range=self.initializer_range  ,    coordinate_size=self.coordinate_size  ,    shape_size=self.shape_size  ,    input_size=self.image_size  ,    patch_size=self.patch_size  ,    )

										return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       LayoutLMvaModel(config=_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()

										# text + image
										__lowercase       =       model(_lowerCamelCase  ,    pixel_values=_lowerCamelCase       )
										__lowercase       =       model(
										    _lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase  ,    attention_mask=_lowerCamelCase  ,    token_type_ids=_lowerCamelCase       )
										__lowercase       =       model(_lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase  ,    token_type_ids=_lowerCamelCase       )
										__lowercase       =       model(_lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase       )

										self.parent.assertEqual(result.last_hidden_state.shape  ,    (self.batch_size, self.seq_length, self.hidden_size)       )

										# text only
										__lowercase       =       model(_lowerCamelCase       )
										self.parent.assertEqual(
										    result.last_hidden_state.shape  ,    (self.batch_size, self.text_seq_length, self.hidden_size)       )

										# image only
										__lowercase       =       model(pixel_values=_lowerCamelCase       )
										self.parent.assertEqual(
										    result.last_hidden_state.shape  ,    (self.batch_size, self.image_seq_length, self.hidden_size)       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							List[Any]:




										'''simple docstring'''
										__lowercase       =       self.num_labels
										__lowercase       =       LayoutLMvaForSequenceClassification(_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       model(
										    _lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase  ,    attention_mask=_lowerCamelCase  ,    token_type_ids=_lowerCamelCase  ,    labels=_lowerCamelCase  ,    )
										self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							List[Any]:




										'''simple docstring'''
										__lowercase       =       self.num_labels
										__lowercase       =       LayoutLMvaForTokenClassification(config=_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       model(
										    _lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase  ,    attention_mask=_lowerCamelCase  ,    token_type_ids=_lowerCamelCase  ,    labels=_lowerCamelCase  ,    )
										self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.text_seq_length, self.num_labels)       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							Optional[Any]:




										'''simple docstring'''
										__lowercase       =       LayoutLMvaForQuestionAnswering(config=_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       model(
										    _lowerCamelCase  ,    bbox=_lowerCamelCase  ,    pixel_values=_lowerCamelCase  ,    attention_mask=_lowerCamelCase  ,    token_type_ids=_lowerCamelCase  ,    start_positions=_lowerCamelCase  ,    end_positions=_lowerCamelCase  ,    )
										self.parent.assertEqual(result.start_logits.shape  ,    (self.batch_size, self.seq_length)       )
										self.parent.assertEqual(result.end_logits.shape  ,    (self.batch_size, self.seq_length)       )





							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       self.prepare_config_and_inputs()
										(
										    (
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					(
										    __lowercase
										)   ,					
										)       =       config_and_inputs
										__lowercase       =       {
										    "input_ids": input_ids,
										    "bbox": bbox,
										    "pixel_values": pixel_values,
										    "token_type_ids": token_type_ids,
										    "attention_mask": input_mask,
										}
										return config, inputs_dict





@require_torch
class 					__a     ( __a					,   __a					,   unittest.TestCase       ):



							'''simple docstring'''







							_lowerCamelCase					:			Dict          =   False
							_lowerCamelCase					:			Tuple          =   False
							_lowerCamelCase					:			str          =   False

							_lowerCamelCase					:			List[Any]          =   (
							    (
							        LayoutLMvaModel,
							        LayoutLMvaForSequenceClassification,
							        LayoutLMvaForTokenClassification,
							        LayoutLMvaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							_lowerCamelCase					:			int          =   (
							    {"""document-question-answering""": LayoutLMvaForQuestionAnswering, """feature-extraction""": LayoutLMvaModel}
							    if is_torch_available()
							    else {}
							)
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							Optional[int]:




										'''simple docstring'''
										# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
										# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
										# the sequence dimension of the text embedding only.
										# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
										return True
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										__lowercase       =       LayoutLMvaModelTester(self       )
										__lowercase       =       ConfigTester(self  ,    config_class=_lowerCamelCase  ,    hidden_size=37       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase=False       )			->							str:




										'''simple docstring'''
										__lowercase       =       copy.deepcopy(_lowerCamelCase       )
										if model_class in get_values(_lowerCamelCase       ):
													__lowercase       =       {
													    k: v.unsqueeze(1       ).expand(-1  ,    self.model_tester.num_choices  ,    -1       ).contiguous()
													    if isinstance(_lowerCamelCase  ,    torch.Tensor       ) and v.ndim > 1
													    else v
													    for k, v in inputs_dict.items()
													}
										if return_labels:
													if model_class in get_values(_lowerCamelCase       ):
																__lowercase       =       torch.ones(self.model_tester.batch_size  ,    dtype=torch.long  ,    device=_lowerCamelCase       )
													elif model_class in get_values(_lowerCamelCase       ):
																__lowercase       =       torch.zeros(
																    self.model_tester.batch_size  ,    dtype=torch.long  ,    device=_lowerCamelCase       )
																__lowercase       =       torch.zeros(
																    self.model_tester.batch_size  ,    dtype=torch.long  ,    device=_lowerCamelCase       )
													elif model_class in [
													    *get_values(_lowerCamelCase       ),
													]:
																__lowercase       =       torch.zeros(
																    self.model_tester.batch_size  ,    dtype=torch.long  ,    device=_lowerCamelCase       )
													elif model_class in [
													    *get_values(_lowerCamelCase       ),
													]:
																__lowercase       =       torch.zeros(
																    (self.model_tester.batch_size, self.model_tester.text_seq_length)  ,    dtype=torch.long  ,    device=_lowerCamelCase  ,    )

										return inputs_dict
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[Any]:




										'''simple docstring'''
										self.config_tester.run_common_tests()
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
													__lowercase       =       type
													self.model_tester.create_and_check_model(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Union[str, Any]:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase       )





							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''simple docstring'''
										for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowercase       =       LayoutLMvaModel.from_pretrained(_lowerCamelCase       )
													self.assertIsNotNone(_lowerCamelCase       )





def      lowerCAmelCase__			(		)						->List[str]:
			__lowercase       =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
			return image







@require_torch
class 					__a     ( unittest.TestCase       ):



							'''simple docstring'''







							@cached_property
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Any:




										'''simple docstring'''
										return LayoutLMvaImageProcessor(apply_ocr=_lowerCamelCase       ) if is_vision_available() else None





							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Optional[Any]:




										'''simple docstring'''
										__lowercase       =       LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"       ).to(_lowerCamelCase       )

										__lowercase       =       self.default_image_processor
										__lowercase       =       prepare_img()
										__lowercase       =       image_processor(images=_lowerCamelCase  ,    return_tensors="pt"       ).pixel_values.to(_lowerCamelCase       )

										__lowercase       =       torch.tensor([[1, 2]]       )
										__lowercase       =       torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]       ).unsqueeze(0       )

										# forward pass
										__lowercase       =       model(
										    input_ids=input_ids.to(_lowerCamelCase       )  ,    bbox=bbox.to(_lowerCamelCase       )  ,    pixel_values=pixel_values.to(_lowerCamelCase       )  ,    )

										# verify the logits
										__lowercase       =       torch.Size((1, 199, 768)       )
										self.assertEqual(outputs.last_hidden_state.shape  ,    _lowerCamelCase       )

										__lowercase       =       torch.tensor(
										    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]       ).to(_lowerCamelCase       )

										self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]  ,    _lowerCamelCase  ,    atol=1e-4       )       )







"""simple docstring"""






from typing import TYPE_CHECKING

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


_lowercase							=				{
    '''configuration_mask2former''': [
        '''MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Mask2FormerConfig''',
    ],
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				['''Mask2FormerImageProcessor''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				[
					    '''MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''Mask2FormerForUniversalSegmentation''',
					    '''Mask2FormerModel''',
					    '''Mask2FormerPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_maskaformer import MaskaFormerImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_maskaformer import (
										    MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MaskaFormerForUniversalSegmentation,
										    MaskaFormerModel,
										    MaskaFormerPreTrainedModel,
										)


else:
					import sys

					_lowercase							=				_LazyModule(__name__, globals()['''__file__'''], _import_structure)





