
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,
)


UpperCamelCase_   	=	{
    "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:
					UpperCamelCase_   	=	["BertTokenizerFast"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase_   	=	[
					    "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:
					UpperCamelCase_   	=	[
					    "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:
					UpperCamelCase_   	=	["TFBertTokenizer"]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase_   	=	[
					    "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

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








from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
					    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
					    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
					    LayoutLMvaConfig,
					    TFLayoutLMvaForQuestionAnswering,
					    TFLayoutLMvaForSequenceClassification,
					    TFLayoutLMvaForTokenClassification,
					    TFLayoutLMvaModel,
					)

if is_vision_available():
					from PIL import Image

					from transformers import LayoutLMvaImageProcessor

class       a		:







							def __init__(						self  :  Optional[int]      ,				snake_case__  :  Optional[Any]      ,				snake_case__  :  Optional[Any]=2      ,				snake_case__  :  Any=3      ,				snake_case__  :  str=4      ,				snake_case__  :  Tuple=2      ,				snake_case__  :  Optional[Any]=7      ,				snake_case__  :  int=True      ,				snake_case__  :  Dict=True      ,				snake_case__  :  int=True      ,				snake_case__  :  List[Any]=True      ,				snake_case__  :  Union[str, Any]=99      ,				snake_case__  :  str=36      ,				snake_case__  :  Tuple=2      ,				snake_case__  :  Optional[int]=4      ,				snake_case__  :  Optional[Any]=37      ,				snake_case__  :  int="gelu"      ,				snake_case__  :  List[Any]=0.1      ,				snake_case__  :  int=0.1      ,				snake_case__  :  Optional[Any]=512      ,				snake_case__  :  Union[str, Any]=16      ,				snake_case__  :  Optional[int]=2      ,				snake_case__  :  Any=0.0_2      ,				snake_case__  :  List[str]=6      ,				snake_case__  :  Optional[int]=6      ,				snake_case__  :  Any=3      ,				snake_case__  :  str=4      ,				snake_case__  :  int=None      ,				snake_case__  :  Any=1_000      ,				):
								"""simple docstring"""







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

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







							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							ids_tensor([self.batch_size, self.text_seq_length]      ,				self.vocab_size )

								__lowerCAmelCase         =							ids_tensor([self.batch_size, self.text_seq_length, 4]      ,				self.range_bbox )
								__lowerCAmelCase         =							bbox.numpy()
								# 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]:
											__lowerCAmelCase         =							bbox[i, j, 3]
											__lowerCAmelCase         =							bbox[i, j, 1]
											__lowerCAmelCase         =							tmp_coordinate
										if bbox[i, j, 2] < bbox[i, j, 0]:
											__lowerCAmelCase         =							bbox[i, j, 2]
											__lowerCAmelCase         =							bbox[i, j, 0]
											__lowerCAmelCase         =							tmp_coordinate
								__lowerCAmelCase         =							tf.constant(snake_case__ )

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

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

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

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

								__lowerCAmelCase         =							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       UpperCAmelCase__					(						self  :  List[Any]      ,				snake_case__  :  Union[str, Any]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModel(config=snake_case__ )

								# text + image
								__lowerCAmelCase         =							model(snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				training=snake_case__      ,				)
								__lowerCAmelCase         =							model(snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )

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

								# text only
								__lowerCAmelCase         =							model(snake_case__      ,				training=snake_case__ )
								self.parent.assertEqual(
								    result.last_hidden_state.shape      ,				(self.batch_size, self.text_seq_length, self.hidden_size) )

								# image only
								__lowerCAmelCase         =							model({"pixel_values": pixel_values}      ,				training=snake_case__ )
								self.parent.assertEqual(
								    result.last_hidden_state.shape      ,				(self.batch_size, self.image_seq_length, self.hidden_size) )







							def       UpperCAmelCase__					(						self  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  str      ,				snake_case__  :  List[Any]      ,				snake_case__  :  str      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int] ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.num_labels
								__lowerCAmelCase         =							TFLayoutLMvaForSequenceClassification(config=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				labels=snake_case__      ,				training=snake_case__      ,				)
								self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels) )







							def       UpperCAmelCase__					(						self  :  Optional[int]      ,				snake_case__  :  Dict      ,				snake_case__  :  Any      ,				snake_case__  :  Optional[Any]      ,				snake_case__  :  int      ,				snake_case__  :  str      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.num_labels
								__lowerCAmelCase         =							TFLayoutLMvaForTokenClassification(config=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				labels=snake_case__      ,				training=snake_case__      ,				)
								self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.text_seq_length, self.num_labels) )







							def       UpperCAmelCase__					(						self  :  Tuple      ,				snake_case__  :  str      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  Any      ,				snake_case__  :  Dict      ,				snake_case__  :  Dict      ,				snake_case__  :  Optional[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							2
								__lowerCAmelCase         =							TFLayoutLMvaForQuestionAnswering(config=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				start_positions=snake_case__      ,				end_positions=snake_case__      ,				training=snake_case__      ,				)
								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       UpperCAmelCase__					(						self  :  Optional[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.prepare_config_and_inputs()
								((__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase))         =							config_and_inputs
								__lowerCAmelCase         =							{
								    "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_tf
class       a		(   __UpperCAmelCase      ,	__UpperCAmelCase      ,	unittest.TestCase					):
							lowercase_		:						List[Any]   							=  (
							    (
							        TFLayoutLMvaModel,
							        TFLayoutLMvaForQuestionAnswering,
							        TFLayoutLMvaForSequenceClassification,
							        TFLayoutLMvaForTokenClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase_		:						Optional[int]   							=  (
							    {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
							    if is_tf_available()
							    else {}
							)

							lowercase_		:						Dict   							=  False
							lowercase_		:						str   							=  False
							lowercase_		:						Any   							=  False







							def       UpperCAmelCase__					(						self  :  Optional[Any]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  int ):
								"""simple docstring"""







								return True







							def       UpperCAmelCase__					(						self  :  Optional[int]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Union[str, Any]      ,				snake_case__  :  Tuple=False ):
								"""simple docstring"""







								__lowerCAmelCase         =							copy.deepcopy(snake_case__ )

								if model_class in get_values(snake_case__ ):
									__lowerCAmelCase         =							{
									    k: tf.tile(tf.expand_dims(snake_case__      ,				1 )      ,				(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1) )
									    if isinstance(snake_case__      ,				tf.Tensor ) and v.ndim > 0
									    else v
									    for k, v in inputs_dict.items()
									}

								if return_labels:
									if model_class in get_values(snake_case__ ):
										__lowerCAmelCase         =							tf.ones(self.model_tester.batch_size      ,				dtype=tf.intaa )
									elif model_class in get_values(snake_case__ ):
										__lowerCAmelCase         =							tf.zeros(self.model_tester.batch_size      ,				dtype=tf.intaa )
										__lowerCAmelCase         =							tf.zeros(self.model_tester.batch_size      ,				dtype=tf.intaa )
									elif model_class in get_values(snake_case__ ):
										__lowerCAmelCase         =							tf.zeros(self.model_tester.batch_size      ,				dtype=tf.intaa )
									elif model_class in get_values(snake_case__ ):
										__lowerCAmelCase         =							tf.zeros(
										    (self.model_tester.batch_size, self.model_tester.text_seq_length)      ,				dtype=tf.intaa )

								return inputs_dict







							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModelTester(self )
								__lowerCAmelCase         =							ConfigTester(self      ,				config_class=snake_case__      ,				hidden_size=37 )







							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								self.config_tester.run_common_tests()







							def       UpperCAmelCase__					(						self  :  List[str] ):
								"""simple docstring"""







								__lowerCAmelCase   ,						__lowerCAmelCase         =							self.model_tester.prepare_config_and_inputs_for_common()
								for model_class in self.all_model_classes:
									__lowerCAmelCase         =							model_class(snake_case__ )
									if getattr(snake_case__      ,				"hf_compute_loss"      ,				snake_case__ ):
										# The number of elements in the loss should be the same as the number of elements in the label
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							prepared_for_class[
										    sorted(prepared_for_class.keys() - inputs_dict.keys()      ,				reverse=snake_case__ )[0]
										]
										__lowerCAmelCase         =							added_label.shape.as_list()[:1]

										# Test that model correctly compute the loss with kwargs
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							prepared_for_class.pop("input_ids" )

										__lowerCAmelCase         =							model(snake_case__      ,				**snake_case__ )[0]
										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

										# Test that model correctly compute the loss when we mask some positions
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							prepared_for_class.pop("input_ids" )
										if "labels" in prepared_for_class:
											__lowerCAmelCase         =							prepared_for_class["labels"].numpy()
											if len(labels.shape ) > 1 and labels.shape[1] != 1:
												__lowerCAmelCase         =							-100
												__lowerCAmelCase         =							tf.convert_to_tensor(snake_case__ )
												__lowerCAmelCase         =							model(snake_case__      ,				**snake_case__ )[0]
												self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )
												self.assertTrue(not np.any(np.isnan(loss.numpy() ) ) )

                # Test that model correctly compute the loss with a dict
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							model(snake_case__ )[0]
										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )

										# Test that model correctly compute the loss with a tuple
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )

										# Get keys that were added with the _prepare_for_class function
										__lowerCAmelCase         =							prepared_for_class.keys() - inputs_dict.keys()
										__lowerCAmelCase         =							inspect.signature(model.call ).parameters
										__lowerCAmelCase         =							list(signature.keys() )

										# Create a dictionary holding the location of the tensors in the tuple
										__lowerCAmelCase         =							{0: "input_ids"}
										for label_key in label_keys:
											__lowerCAmelCase         =							signature_names.index(snake_case__ )
											__lowerCAmelCase         =							label_key
										__lowerCAmelCase         =							sorted(tuple_index_mapping.items() )
										# Initialize a list with their default values, update the values and convert to a tuple
										__lowerCAmelCase         =							[]

										for name in signature_names:
											if name != "kwargs":
												list_input.append(signature[name].default )

										for index, value in sorted_tuple_index_mapping:
											__lowerCAmelCase         =							prepared_for_class[value]

										__lowerCAmelCase         =							tuple(snake_case__ )

										# Send to model
										__lowerCAmelCase         =							model(tuple_input[:-1] )[0]

										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1] )







							def       UpperCAmelCase__					(						self  :  Dict ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Any ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
									__lowerCAmelCase         =							type
									self.model_tester.create_and_check_model(snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  str ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Optional[Any] ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							@slow
							def       UpperCAmelCase__					(						self  :  int ):
								"""simple docstring"""







								for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCAmelCase         =							TFLayoutLMvaModel.from_pretrained(snake_case__ )
									self.assertIsNotNone(snake_case__ )






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
	return image







@require_tf
class       a		(   unittest.TestCase					):







							@cached_property
							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								return LayoutLMvaImageProcessor(apply_ocr=snake_case__ ) if is_vision_available() else None







							@slow
							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base" )

								__lowerCAmelCase         =							self.default_image_processor
								__lowerCAmelCase         =							prepare_img()
								__lowerCAmelCase         =							image_processor(images=snake_case__      ,				return_tensors="tf" ).pixel_values

								__lowerCAmelCase         =							tf.constant([[1, 2]] )
								__lowerCAmelCase         =							tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]] )      ,				axis=0 )

								# forward pass
								__lowerCAmelCase         =							model(input_ids=snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )

								# verify the logits
								__lowerCAmelCase         =							(1, 199, 768)
								self.assertEqual(outputs.last_hidden_state.shape      ,				snake_case__ )

								__lowerCAmelCase         =							tf.constant(
								    [[-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]] )

								self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]      ,				snake_case__      ,				atol=1E-4 ) )






