
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  UpperCamelCase__		:







	'''simple docstring'''





	def __init__(			self				,       UpperCamelCase__				,       UpperCamelCase__=2				,       UpperCamelCase__=3				,       UpperCamelCase__=4				,       UpperCamelCase__=2				,       UpperCamelCase__=7				,       UpperCamelCase__=True				,       UpperCamelCase__=True				,       UpperCamelCase__=True				,       UpperCamelCase__=True				,       UpperCamelCase__=99				,       UpperCamelCase__=36				,       UpperCamelCase__=3				,       UpperCamelCase__=4				,       UpperCamelCase__=37				,       UpperCamelCase__="gelu"				,       UpperCamelCase__=0.1				,       UpperCamelCase__=0.1				,       UpperCamelCase__=512				,       UpperCamelCase__=16				,       UpperCamelCase__=2				,       UpperCamelCase__=0.0_2				,       UpperCamelCase__=6				,       UpperCamelCase__=6				,       UpperCamelCase__=3				,       UpperCamelCase__=4				,       UpperCamelCase__=None				,       UpperCamelCase__=1000				,       ):
					A__  :	List[Any]         =							parent
					A__  :	Dict         =							batch_size
					A__  :	Optional[Any]         =							num_channels
					A__  :	Optional[Any]         =							image_size
					A__  :	Optional[Any]         =							patch_size
					A__  :	List[Any]         =							text_seq_length
					A__  :	List[Any]         =							is_training
					A__  :	Optional[int]         =							use_input_mask
					A__  :	Dict         =							use_token_type_ids
					A__  :	List[Any]         =							use_labels
					A__  :	int         =							vocab_size
					A__  :	Any         =							hidden_size
					A__  :	List[Any]         =							num_hidden_layers
					A__  :	Dict         =							num_attention_heads
					A__  :	int         =							intermediate_size
					A__  :	Optional[int]         =							hidden_act
					A__  :	Any         =							hidden_dropout_prob
					A__  :	Any         =							attention_probs_dropout_prob
					A__  :	int         =							max_position_embeddings
					A__  :	Optional[Any]         =							type_vocab_size
					A__  :	Tuple         =							type_sequence_label_size
					A__  :	Tuple         =							initializer_range
					A__  :	Dict         =							coordinate_size
					A__  :	Optional[Any]         =							shape_size
					A__  :	int         =							num_labels
					A__  :	Dict         =							num_choices
					A__  :	Any         =							scope
					A__  :	Optional[Any]         =							range_bbox

					# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
					A__  :	Any         =							text_seq_length
					A__  :	Optional[Any]         =							(image_size // patch_size) ** 2 + 1
					A__  :	List[Any]         =							self.text_seq_length + self.image_seq_length





	def   __snake_case				(			self		):
					A__  :	List[Any]         =							ids_tensor([self.batch_size, self.text_seq_length]				,       self.vocab_size		)

					A__  :	Union[str, Any]         =							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]:
																	A__  :	Tuple         =							bbox[i, j, 3]
																	A__  :	Optional[int]         =							bbox[i, j, 1]
																	A__  :	Optional[Any]         =							t
													if bbox[i, j, 2] < bbox[i, j, 0]:
																	A__  :	str         =							bbox[i, j, 2]
																	A__  :	List[Any]         =							bbox[i, j, 0]
																	A__  :	List[Any]         =							t

					A__  :	Any         =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

					A__  :	Any         =							None
					if self.use_input_mask:
									A__  :	int         =							random_attention_mask([self.batch_size, self.text_seq_length]		)

					A__  :	str         =							None
					if self.use_token_type_ids:
									A__  :	Union[str, Any]         =							ids_tensor([self.batch_size, self.text_seq_length]				,       self.type_vocab_size		)

					A__  :	Dict         =							None
					A__  :	List[str]         =							None
					if self.use_labels:
									A__  :	int         =							ids_tensor([self.batch_size]				,       self.type_sequence_label_size		)
									A__  :	Optional[int]         =							ids_tensor([self.batch_size, self.text_seq_length]				,       self.num_labels		)

					A__  :	Dict         =							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   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__		):
					A__  :	Any         =							LayoutLMvaModel(config=UpperCamelCase__		)
					model.to(UpperCamelCase__		)
					model.eval()

					# text + image
					A__  :	List[str]         =							model(UpperCamelCase__				,       pixel_values=UpperCamelCase__		)
					A__  :	Optional[int]         =							model(
					    UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__				,       attention_mask=UpperCamelCase__				,       token_type_ids=UpperCamelCase__		)
					A__  :	Union[str, Any]         =							model(UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__				,       token_type_ids=UpperCamelCase__		)
					A__  :	Optional[int]         =							model(UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__		)

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

					# text only
					A__  :	Tuple         =							model(UpperCamelCase__		)
					self.parent.assertEqual(
					    result.last_hidden_state.shape				,       (self.batch_size, self.text_seq_length, self.hidden_size)		)

					# image only
					A__  :	Tuple         =							model(pixel_values=UpperCamelCase__		)
					self.parent.assertEqual(
					    result.last_hidden_state.shape				,       (self.batch_size, self.image_seq_length, self.hidden_size)		)





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__		):
					A__  :	List[Any]         =							self.num_labels
					A__  :	List[Any]         =							LayoutLMvaForSequenceClassification(UpperCamelCase__		)
					model.to(UpperCamelCase__		)
					model.eval()
					A__  :	Any         =							model(
					    UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__				,       attention_mask=UpperCamelCase__				,       token_type_ids=UpperCamelCase__				,       labels=UpperCamelCase__				,       )
					self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)		)





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__		):
					A__  :	Dict         =							self.num_labels
					A__  :	str         =							LayoutLMvaForTokenClassification(config=UpperCamelCase__		)
					model.to(UpperCamelCase__		)
					model.eval()
					A__  :	List[str]         =							model(
					    UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__				,       attention_mask=UpperCamelCase__				,       token_type_ids=UpperCamelCase__				,       labels=UpperCamelCase__				,       )
					self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.text_seq_length, self.num_labels)		)





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__		):
					A__  :	Optional[Any]         =							LayoutLMvaForQuestionAnswering(config=UpperCamelCase__		)
					model.to(UpperCamelCase__		)
					model.eval()
					A__  :	Dict         =							model(
					    UpperCamelCase__				,       bbox=UpperCamelCase__				,       pixel_values=UpperCamelCase__				,       attention_mask=UpperCamelCase__				,       token_type_ids=UpperCamelCase__				,       start_positions=UpperCamelCase__				,       end_positions=UpperCamelCase__				,       )
					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   __snake_case				(			self		):
					A__  :	Any         =							self.prepare_config_and_inputs()
					(
					    (
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							(
					    A__
					)       ,							
					)  :	List[Any]         =							config_and_inputs
					A__  :	List[Any]         =							{
					    '''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  UpperCamelCase__		(    SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			unittest.TestCase   ):







	'''simple docstring'''
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				False
	_lowerCAmelCase							       =				False

	_lowerCAmelCase							       =				(
	    (
	        LayoutLMvaModel,
	        LayoutLMvaForSequenceClassification,
	        LayoutLMvaForTokenClassification,
	        LayoutLMvaForQuestionAnswering,
	    )
	    if is_torch_available()
	    else ()
	)
	_lowerCAmelCase							       =				(
	    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
	    if is_torch_available()
	    else {}
	)





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__		):
					# `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   __snake_case				(			self		):
					A__  :	str         =							LayoutLMvaModelTester(self		)
					A__  :	Union[str, Any]         =							ConfigTester(self				,       config_class=UpperCamelCase__				,       hidden_size=37		)





	def   __snake_case				(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__=False		):
					A__  :	str         =							copy.deepcopy(UpperCamelCase__		)
					if model_class in get_values(UpperCamelCase__		):
									A__  :	Optional[Any]         =							{
									    k: v.unsqueeze(1		).expand(-1				,       self.model_tester.num_choices				,       -1		).contiguous()
									    if isinstance(UpperCamelCase__				,       torch.Tensor		) and v.ndim > 1
									    else v
									    for k, v in inputs_dict.items()
									}
					if return_labels:
									if model_class in get_values(UpperCamelCase__		):
													A__  :	List[Any]         =							torch.ones(self.model_tester.batch_size				,       dtype=torch.long				,       device=UpperCamelCase__		)
									elif model_class in get_values(UpperCamelCase__		):
													A__  :	List[Any]         =							torch.zeros(
													    self.model_tester.batch_size				,       dtype=torch.long				,       device=UpperCamelCase__		)
													A__  :	List[str]         =							torch.zeros(
													    self.model_tester.batch_size				,       dtype=torch.long				,       device=UpperCamelCase__		)
									elif model_class in [
									    *get_values(UpperCamelCase__		),
									]:
													A__  :	int         =							torch.zeros(
													    self.model_tester.batch_size				,       dtype=torch.long				,       device=UpperCamelCase__		)
									elif model_class in [
									    *get_values(UpperCamelCase__		),
									]:
													A__  :	Optional[Any]         =							torch.zeros(
													    (self.model_tester.batch_size, self.model_tester.text_seq_length)				,       dtype=torch.long				,       device=UpperCamelCase__				,       )

					return inputs_dict





	def   __snake_case				(			self		):
					self.config_tester.run_common_tests()





	def   __snake_case				(			self		):
					A__  :	str         =							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*UpperCamelCase__		)





	def   __snake_case				(			self		):
					A__  :	Optional[Any]         =							self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
									A__  :	Optional[Any]         =							type
									self.model_tester.create_and_check_model(*UpperCamelCase__		)





	def   __snake_case				(			self		):
					A__  :	Tuple         =							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__		)





	def   __snake_case				(			self		):
					A__  :	List[Any]         =							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__		)





	def   __snake_case				(			self		):
					A__  :	Dict         =							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__		)





	@slow
	def   __snake_case				(			self		):
					for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									A__  :	Any         =							LayoutLMvaModel.from_pretrained(UpperCamelCase__		)
									self.assertIsNotNone(UpperCamelCase__		)




def 				SCREAMING_SNAKE_CASE     (      ) ->       Optional[int]:

				"""simple docstring"""







				A__  :	int         =							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
				return image







@require_torch
class  UpperCamelCase__		(    unittest.TestCase   ):







	'''simple docstring'''





	@cached_property
	def   __snake_case				(			self		):
					return LayoutLMvaImageProcessor(apply_ocr=UpperCamelCase__		) if is_vision_available() else None





	@slow
	def   __snake_case				(			self		):
					A__  :	Tuple         =							LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''		).to(UpperCamelCase__		)

					A__  :	Any         =							self.default_image_processor
					A__  :	Dict         =							prepare_img()
					A__  :	List[str]         =							image_processor(images=UpperCamelCase__				,       return_tensors='''pt'''		).pixel_values.to(UpperCamelCase__		)

					A__  :	Optional[int]         =							torch.tensor([[1, 2]]		)
					A__  :	Optional[Any]         =							torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]		).unsqueeze(0		)

					# forward pass
					A__  :	Dict         =							model(
					    input_ids=input_ids.to(UpperCamelCase__		)				,       bbox=bbox.to(UpperCamelCase__		)				,       pixel_values=pixel_values.to(UpperCamelCase__		)				,       )

					# verify the logits
					A__  :	Union[str, Any]         =							torch.Size((1, 199, 768)		)
					self.assertEqual(outputs.last_hidden_state.shape				,       UpperCamelCase__		)

					A__  :	Tuple         =							torch.tensor(
					    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]		).to(UpperCamelCase__		)

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

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE    :      int          =			{
    'configuration_bert': ['BERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BertConfig', 'BertOnnxConfig'],
    'tokenization_bert': ['BasicTokenizer', 'BertTokenizer', 'WordpieceTokenizer'],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[Any]          =			['BertTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			[
					    'BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'BertForMaskedLM',
					    'BertForMultipleChoice',
					    'BertForNextSentencePrediction',
					    'BertForPreTraining',
					    'BertForQuestionAnswering',
					    'BertForSequenceClassification',
					    'BertForTokenClassification',
					    'BertLayer',
					    'BertLMHeadModel',
					    'BertModel',
					    'BertPreTrainedModel',
					    'load_tf_weights_in_bert',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Tuple          =			[
					    'TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFBertEmbeddings',
					    'TFBertForMaskedLM',
					    'TFBertForMultipleChoice',
					    'TFBertForNextSentencePrediction',
					    'TFBertForPreTraining',
					    'TFBertForQuestionAnswering',
					    'TFBertForSequenceClassification',
					    'TFBertForTokenClassification',
					    'TFBertLMHeadModel',
					    'TFBertMainLayer',
					    'TFBertModel',
					    'TFBertPreTrainedModel',
					]
try:
					if not is_tensorflow_text_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Dict          =			['TFBertTokenizer']

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[int]          =			[
					    'FlaxBertForCausalLM',
					    'FlaxBertForMaskedLM',
					    'FlaxBertForMultipleChoice',
					    'FlaxBertForNextSentencePrediction',
					    'FlaxBertForPreTraining',
					    'FlaxBertForQuestionAnswering',
					    'FlaxBertForSequenceClassification',
					    'FlaxBertForTokenClassification',
					    'FlaxBertModel',
					    'FlaxBertPreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
					from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_bert_fast import BertTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_bert import (
										    BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    BertForMaskedLM,
										    BertForMultipleChoice,
										    BertForNextSentencePrediction,
										    BertForPreTraining,
										    BertForQuestionAnswering,
										    BertForSequenceClassification,
										    BertForTokenClassification,
										    BertLayer,
										    BertLMHeadModel,
										    BertModel,
										    BertPreTrainedModel,
										    load_tf_weights_in_bert,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_bert import (
										    TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFBertEmbeddings,
										    TFBertForMaskedLM,
										    TFBertForMultipleChoice,
										    TFBertForNextSentencePrediction,
										    TFBertForPreTraining,
										    TFBertForQuestionAnswering,
										    TFBertForSequenceClassification,
										    TFBertForTokenClassification,
										    TFBertLMHeadModel,
										    TFBertMainLayer,
										    TFBertModel,
										    TFBertPreTrainedModel,
										)

					try:
										if not is_tensorflow_text_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_bert_tf import TFBertTokenizer

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_bert import (
										    FlaxBertForCausalLM,
										    FlaxBertForMaskedLM,
										    FlaxBertForMultipleChoice,
										    FlaxBertForNextSentencePrediction,
										    FlaxBertForPreTraining,
										    FlaxBertForQuestionAnswering,
										    FlaxBertForSequenceClassification,
										    FlaxBertForTokenClassification,
										    FlaxBertModel,
										    FlaxBertPreTrainedModel,
										)

else:
					import sys

					_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)