




'''simple docstring'''

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       :   List[Any]			,							lowercase_       :   Tuple			,							lowercase_       :   Optional[int]=2			,							lowercase_       :   Optional[Any]=3			,							lowercase_       :   Any=4			,							lowercase_       :   Dict=2			,							lowercase_       :   str=7			,							lowercase_       :   List[Any]=True			,							lowercase_       :   List[str]=True			,							lowercase_       :   str=True			,							lowercase_       :   str=True			,							lowercase_       :   Tuple=99			,							lowercase_       :   Union[str, Any]=36			,							lowercase_       :   str=2			,							lowercase_       :   Optional[Any]=4			,							lowercase_       :   List[str]=37			,							lowercase_       :   Optional[Any]="gelu"			,							lowercase_       :   Dict=0.1			,							lowercase_       :   int=0.1			,							lowercase_       :   Dict=512			,							lowercase_       :   List[Any]=16			,							lowercase_       :   Union[str, Any]=2			,							lowercase_       :   Any=0.02			,							lowercase_       :   Any=6			,							lowercase_       :   Any=6			,							lowercase_       :   List[str]=3			,							lowercase_       :   Optional[Any]=4			,							lowercase_       :   Dict=None			,							lowercase_       :   Dict=1000			,							):
									snake_case_		     =							parent
									snake_case_		     =							batch_size
									snake_case_		     =							num_channels
									snake_case_		     =							image_size
									snake_case_		     =							patch_size
									snake_case_		     =							is_training
									snake_case_		     =							use_input_mask
									snake_case_		     =							use_token_type_ids
									snake_case_		     =							use_labels
									snake_case_		     =							vocab_size
									snake_case_		     =							hidden_size
									snake_case_		     =							num_hidden_layers
									snake_case_		     =							num_attention_heads
									snake_case_		     =							intermediate_size
									snake_case_		     =							hidden_act
									snake_case_		     =							hidden_dropout_prob
									snake_case_		     =							attention_probs_dropout_prob
									snake_case_		     =							max_position_embeddings
									snake_case_		     =							type_vocab_size
									snake_case_		     =							type_sequence_label_size
									snake_case_		     =							initializer_range
									snake_case_		     =							coordinate_size
									snake_case_		     =							shape_size
									snake_case_		     =							num_labels
									snake_case_		     =							num_choices
									snake_case_		     =							scope
									snake_case_		     =							range_bbox

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


				def     A_					(						self       :   Union[str, Any]   ):
									snake_case_		     =							ids_tensor([self.batch_size, self.text_seq_length]			,							self.vocab_size   )

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

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

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

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

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

									snake_case_		     =							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     A_					(						self       :   Any			,							lowercase_       :   Tuple			,							lowercase_       :   Optional[int]			,							lowercase_       :   str			,							lowercase_       :   Optional[int]			,							lowercase_       :   str			,							lowercase_       :   str   ):
									snake_case_		     =							TFLayoutLMvaModel(config=lowerCAmelCase__   )

									# text + image
									snake_case_		     =							model(lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							training=lowerCAmelCase__   )
									snake_case_		     =							model(
									    lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							attention_mask=lowerCAmelCase__			,							token_type_ids=lowerCAmelCase__			,							training=lowerCAmelCase__			,							)
									snake_case_		     =							model(lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							training=lowerCAmelCase__   )

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

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

									# image only
									snake_case_		     =							model({'''pixel_values''': pixel_values}			,							training=lowerCAmelCase__   )
									self.parent.assertEqual(
									    result.last_hidden_state.shape			,							(self.batch_size, self.image_seq_length, self.hidden_size)   )


				def     A_					(						self       :   Any			,							lowercase_       :   int			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Tuple			,							lowercase_       :   List[Any]			,							lowercase_       :   Dict			,							lowercase_       :   Any   ):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFLayoutLMvaForSequenceClassification(config=lowerCAmelCase__   )
									snake_case_		     =							model(
									    lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							attention_mask=lowerCAmelCase__			,							token_type_ids=lowerCAmelCase__			,							labels=lowerCAmelCase__			,							training=lowerCAmelCase__			,							)
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.num_labels)   )


				def     A_					(						self       :   List[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   List[str]			,							lowercase_       :   str			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str			,							lowercase_       :   int			,							lowercase_       :   Any   ):
									snake_case_		     =							self.num_labels
									snake_case_		     =							TFLayoutLMvaForTokenClassification(config=lowerCAmelCase__   )
									snake_case_		     =							model(
									    lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							attention_mask=lowerCAmelCase__			,							token_type_ids=lowerCAmelCase__			,							labels=lowerCAmelCase__			,							training=lowerCAmelCase__			,							)
									self.parent.assertEqual(result.logits.shape			,							(self.batch_size, self.text_seq_length, self.num_labels)   )


				def     A_					(						self       :   Optional[Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   List[str]			,							lowercase_       :   Dict			,							lowercase_       :   Any			,							lowercase_       :   str			,							lowercase_       :   str			,							lowercase_       :   List[Any]   ):
									snake_case_		     =							2
									snake_case_		     =							TFLayoutLMvaForQuestionAnswering(config=lowerCAmelCase__   )
									snake_case_		     =							model(
									    lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							attention_mask=lowerCAmelCase__			,							token_type_ids=lowerCAmelCase__			,							start_positions=lowerCAmelCase__			,							end_positions=lowerCAmelCase__			,							training=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     A_					(						self       :   int   ):
									snake_case_		     =							self.prepare_config_and_inputs()
									((snake_case_)     ,(snake_case_)     ,(snake_case_)     ,(snake_case_)     ,(snake_case_)     ,(snake_case_)     ,(snake_case_)     ,(snake_case_))		     =							config_and_inputs
									snake_case_		     =							{
									    '''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	):
				snake_case_           =						(
				    (
				        TFLayoutLMvaModel,
				        TFLayoutLMvaForQuestionAnswering,
				        TFLayoutLMvaForSequenceClassification,
				        TFLayoutLMvaForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				snake_case_           =						(
				    {'''document-question-answering''': TFLayoutLMvaForQuestionAnswering, '''feature-extraction''': TFLayoutLMvaModel}
				    if is_tf_available()
				    else {}
				)

				snake_case_           =						False
				snake_case_           =						False
				snake_case_           =						False


				def     A_					(						self       :   Dict			,							lowercase_       :   int			,							lowercase_       :   Union[str, Any]			,							lowercase_       :   Optional[Any]			,							lowercase_       :   Dict			,							lowercase_       :   str   ):
									return True


				def     A_					(						self       :   Optional[Any]			,							lowercase_       :   int			,							lowercase_       :   Optional[Any]			,							lowercase_       :   str=False   ):
									snake_case_		     =							copy.deepcopy(lowerCAmelCase__   )

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

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

									return inputs_dict


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							TFLayoutLMvaModelTester(self   )
									snake_case_		     =							ConfigTester(self			,							config_class=lowerCAmelCase__			,							hidden_size=37   )


				def     A_					(						self       :   Tuple   ):
									self.config_tester.run_common_tests()


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

																			# Test that model correctly compute the loss with kwargs
																			snake_case_		     =							self._prepare_for_class(inputs_dict.copy()			,							lowerCAmelCase__			,							return_labels=lowerCAmelCase__   )
																			snake_case_		     =							prepared_for_class.pop('''input_ids'''   )

																			snake_case_		     =							model(lowerCAmelCase__			,							**lowerCAmelCase__   )[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
																			snake_case_		     =							self._prepare_for_class(inputs_dict.copy()			,							lowerCAmelCase__			,							return_labels=lowerCAmelCase__   )
																			snake_case_		     =							prepared_for_class.pop('''input_ids'''   )
																			if "labels" in prepared_for_class:
																								snake_case_		     =							prepared_for_class['''labels'''].numpy()
																								if len(labels.shape   ) > 1 and labels.shape[1] != 1:
																													snake_case_		     =							-100
																													snake_case_		     =							tf.convert_to_tensor(lowerCAmelCase__   )
																													snake_case_		     =							model(lowerCAmelCase__			,							**lowerCAmelCase__   )[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
																			snake_case_		     =							self._prepare_for_class(inputs_dict.copy()			,							lowerCAmelCase__			,							return_labels=lowerCAmelCase__   )
																			snake_case_		     =							model(lowerCAmelCase__   )[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
																			snake_case_		     =							self._prepare_for_class(inputs_dict.copy()			,							lowerCAmelCase__			,							return_labels=lowerCAmelCase__   )

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

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

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

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

																			snake_case_		     =							tuple(lowerCAmelCase__   )

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

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


				def     A_					(						self       :   List[Any]   ):
									(
									    (
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,	
									)		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__   )


				def     A_					(						self       :   Optional[int]   ):
									(
									    (
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,	
									)		     =							self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
														snake_case_		     =							type
														self.model_tester.create_and_check_model(lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__   )


				def     A_					(						self       :   Any   ):
									(
									    (
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,	
									)		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(
									    lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__   )


				def     A_					(						self       :   Dict   ):
									(
									    (
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,	
									)		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(
									    lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__   )


				def     A_					(						self       :   int   ):
									(
									    (
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,(
									    snake_case_	
									)     ,	
									)		     =							self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(
									    lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__			,							lowerCAmelCase__   )


				@slow
				def     A_					(						self       :   List[Any]   ):


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







def 						__magic_name__       (      )						->   Optional[Any]:

					'''simple docstring'''

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






@require_tf
class 		a							(  unittest.TestCase	):


				@cached_property
				def     A_					(						self       :   Tuple   ):
									return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase__   ) if is_vision_available() else None


				@slow
				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							TFLayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''   )

									snake_case_		     =							self.default_image_processor
									snake_case_		     =							prepare_img()
									snake_case_		     =							image_processor(images=lowerCAmelCase__			,							return_tensors='''tf'''   ).pixel_values

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

									# forward pass
									snake_case_		     =							model(input_ids=lowerCAmelCase__			,							bbox=lowerCAmelCase__			,							pixel_values=lowerCAmelCase__			,							training=lowerCAmelCase__   )

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

									snake_case_		     =							tf.constant(
									    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]   )

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


import unittest

from accelerate import debug_launcher
from accelerate.test_utils import require_cpu, test_ops, test_script




@require_cpu
class   _UpperCamelCase (		unittest.TestCase					):


			"""simple docstring"""






			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							debug_launcher(test_script.main		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							debug_launcher(test_ops.main		)