






'''simple docstring'''







import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
			from transformers import (
			    FlaxBertModel,
			    FlaxCLIPVisionModel,
			    FlaxVisionTextDualEncoderModel,
			    FlaxViTModel,
			    VisionTextDualEncoderConfig,
			    VisionTextDualEncoderProcessor,
			)
			from transformers.modeling_flax_pytorch_utils import (
			    convert_pytorch_state_dict_to_flax,
			    load_flax_weights_in_pytorch_model,
			)


if is_torch_available():
			import torch

			from transformers import VisionTextDualEncoderModel

if is_vision_available():
			from PIL import Image





def  SCREAMING_SNAKE_CASE_       (UpperCamelCase      )      ->       Union[str, Any]:
							if isinstance(UpperCamelCase				,			collections.abc.Iterable      ):
														return x
							return (x, x)

@require_flax
class _lowercase	:




							def 		lowerCamelCase_				(							self:				Dict			,							UpperCamelCase__:				str			,							UpperCamelCase__:				Optional[Any]     ):
														pass




							def 		lowerCamelCase_				(							self:				Dict     ):
														pass




							def 		lowerCamelCase_				(							self:				Tuple     ):
														pass




							def 		lowerCamelCase_				(							self:				Tuple			,							UpperCamelCase__:				np.ndarray			,							UpperCamelCase__:				np.ndarray			,							UpperCamelCase__:				float     ):
														lowerCamelCase__					:	List[str]         =       np.abs((a - b)     ).max()
														self.assertLessEqual(UpperCamelCase__			,							UpperCamelCase__			,							F'''Difference between torch and flax is {diff} (>= {tol}).'''     )




							def 		lowerCamelCase_				(							self:				Dict			,							UpperCamelCase__:				Tuple			,							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				List[str]			,							UpperCamelCase__:				Tuple			,							UpperCamelCase__:				int=None			,							**UpperCamelCase__:				Any     ):
														lowerCamelCase__					:	Dict         =       VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Tuple         =       FlaxVisionTextDualEncoderModel(UpperCamelCase__     )

														lowerCamelCase__					:	Union[str, Any]         =       model(input_ids=UpperCamelCase__			,							pixel_values=UpperCamelCase__			,							attention_mask=UpperCamelCase__     )

														self.assertEqual(output["""text_embeds"""].shape			,							(input_ids.shape[0], config.projection_dim)     )
														self.assertEqual(output["""image_embeds"""].shape			,							(pixel_values.shape[0], config.projection_dim)     )




							def 		lowerCamelCase_				(							self:				Any			,							UpperCamelCase__:				Dict			,							UpperCamelCase__:				Dict			,							UpperCamelCase__:				Union[str, Any]			,							UpperCamelCase__:				Dict			,							UpperCamelCase__:				List[str]=None			,							**UpperCamelCase__:				Optional[int]     ):
														lowerCamelCase__  ,		lowerCamelCase__					:	Union[str, Any]         =       self.get_vision_text_model(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       {"""vision_model""": vision_model, """text_model""": text_model}
														lowerCamelCase__					:	int         =       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__     )

														lowerCamelCase__					:	Optional[Any]         =       model(input_ids=UpperCamelCase__			,							pixel_values=UpperCamelCase__			,							attention_mask=UpperCamelCase__     )

														self.assertEqual(output["""text_embeds"""].shape			,							(input_ids.shape[0], model.config.projection_dim)     )
														self.assertEqual(output["""image_embeds"""].shape			,							(pixel_values.shape[0], model.config.projection_dim)     )




							def 		lowerCamelCase_				(							self:				Any			,							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				Any			,							UpperCamelCase__:				List[Any]			,							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				Optional[Any]=None			,							**UpperCamelCase__:				List[Any]     ):
														lowerCamelCase__  ,		lowerCamelCase__					:	Tuple         =       self.get_vision_text_model(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Optional[Any]         =       {"""vision_model""": vision_model, """text_model""": text_model}
														lowerCamelCase__					:	Any         =       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__     )

														lowerCamelCase__					:	Dict         =       model(input_ids=UpperCamelCase__			,							pixel_values=UpperCamelCase__			,							attention_mask=UpperCamelCase__     )
														lowerCamelCase__					:	Tuple         =       output[0]

														with tempfile.TemporaryDirectory() as tmpdirname:
																					model.save_pretrained(UpperCamelCase__     )
																					lowerCamelCase__					:	List[Any]         =       FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__     )

																					lowerCamelCase__					:	List[Any]         =       model(input_ids=UpperCamelCase__			,							pixel_values=UpperCamelCase__			,							attention_mask=UpperCamelCase__     )
																					lowerCamelCase__					:	List[Any]         =       after_output[0]
																					lowerCamelCase__					:	int         =       np.amax(np.abs(out_a - out_a     )     )
																					self.assertLessEqual(UpperCamelCase__			,							1e-3     )




							def 		lowerCamelCase_				(							self:				List[str]			,							UpperCamelCase__:				Union[str, Any]			,							UpperCamelCase__:				List[Any]			,							UpperCamelCase__:				Optional[Any]			,							UpperCamelCase__:				Any			,							UpperCamelCase__:				Optional[Any]=None			,							**UpperCamelCase__:				Any     ):
														lowerCamelCase__  ,		lowerCamelCase__					:	str         =       self.get_vision_text_model(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Optional[Any]         =       {"""vision_model""": vision_model, """text_model""": text_model}
														lowerCamelCase__					:	Dict         =       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**UpperCamelCase__     )

														lowerCamelCase__					:	str         =       model(
														    input_ids=UpperCamelCase__			,							pixel_values=UpperCamelCase__			,							attention_mask=UpperCamelCase__			,							output_attentions=UpperCamelCase__     )

														lowerCamelCase__					:	int         =       output.vision_model_output.attentions
														self.assertEqual(len(UpperCamelCase__     )			,							vision_config.num_hidden_layers     )

														# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
														lowerCamelCase__					:	Dict         =       to_atuple(vision_model.config.image_size     )
														lowerCamelCase__					:	Union[str, Any]         =       to_atuple(vision_model.config.patch_size     )
														lowerCamelCase__					:	List[str]         =       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
														lowerCamelCase__					:	Union[str, Any]         =       num_patches + 1
														self.assertEqual(vision_attentions[0].shape[-3:]			,							(vision_config.num_attention_heads, seq_len, seq_len)     )

														lowerCamelCase__					:	List[str]         =       output.text_model_output.attentions
														self.assertEqual(len(UpperCamelCase__     )			,							text_config.num_hidden_layers     )

														self.assertEqual(
														    text_attentions[0].shape[-3:]			,							(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])			,							)




							def 		lowerCamelCase_				(							self:				Optional[Any]			,							UpperCamelCase__:				Union[str, Any]			,							UpperCamelCase__:				Dict			,							UpperCamelCase__:				List[Any]     ):
														pt_model.to(UpperCamelCase__     )
														pt_model.eval()

														# prepare inputs
														lowerCamelCase__					:	List[str]         =       inputs_dict
														lowerCamelCase__					:	Optional[Any]         =       {k: torch.tensor(v.tolist()     ) for k, v in flax_inputs.items()}

														with torch.no_grad():
																					lowerCamelCase__					:	List[str]         =       pt_model(**UpperCamelCase__     ).to_tuple()

														lowerCamelCase__					:	List[Any]         =       fx_model(**UpperCamelCase__     ).to_tuple()
														self.assertEqual(len(UpperCamelCase__     )			,							len(UpperCamelCase__     )			,							"""Output lengths differ between Flax and PyTorch"""     )
														for fx_output, pt_output in zip(fx_outputs[:4]			,							pt_outputs[:4]     ):
																					self.assert_almost_equals(UpperCamelCase__			,							pt_output.numpy()			,							4e-2     )

														# PT -> Flax
														with tempfile.TemporaryDirectory() as tmpdirname:
																					pt_model.save_pretrained(UpperCamelCase__     )
																					lowerCamelCase__					:	Dict         =       FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__			,							from_pt=UpperCamelCase__     )

														lowerCamelCase__					:	Union[str, Any]         =       fx_model_loaded(**UpperCamelCase__     ).to_tuple()
														self.assertEqual(len(UpperCamelCase__     )			,							len(UpperCamelCase__     )			,							"""Output lengths differ between Flax and PyTorch"""     )
														for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]			,							pt_outputs[:4]     ):
																					self.assert_almost_equals(UpperCamelCase__			,							pt_output.numpy()			,							4e-2     )

														# Flax -> PT
														with tempfile.TemporaryDirectory() as tmpdirname:
																					fx_model.save_pretrained(UpperCamelCase__     )
																					lowerCamelCase__					:	Union[str, Any]         =       VisionTextDualEncoderModel.from_pretrained(UpperCamelCase__			,							from_flax=UpperCamelCase__     )

														pt_model_loaded.to(UpperCamelCase__     )
														pt_model_loaded.eval()

														with torch.no_grad():
																					lowerCamelCase__					:	Optional[Any]         =       pt_model_loaded(**UpperCamelCase__     ).to_tuple()

														self.assertEqual(len(UpperCamelCase__     )			,							len(UpperCamelCase__     )			,							"""Output lengths differ between Flax and PyTorch"""     )
														for fx_output, pt_output_loaded in zip(fx_outputs[:4]			,							pt_outputs_loaded[:4]     ):
																					self.assert_almost_equals(UpperCamelCase__			,							pt_output_loaded.numpy()			,							4e-2     )




							def 		lowerCamelCase_				(							self:				List[Any]			,							UpperCamelCase__:				Any			,							UpperCamelCase__:				int			,							UpperCamelCase__:				Any     ):
														lowerCamelCase__					:	int         =       VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Union[str, Any]         =       VisionTextDualEncoderModel(UpperCamelCase__     )
														lowerCamelCase__					:	Union[str, Any]         =       FlaxVisionTextDualEncoderModel(UpperCamelCase__     )

														lowerCamelCase__					:	str         =       convert_pytorch_state_dict_to_flax(pt_model.state_dict()			,							UpperCamelCase__     )
														lowerCamelCase__					:	Tuple         =       fx_state

														self.check_pt_flax_equivalence(UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Any			,							UpperCamelCase__:				Dict			,							UpperCamelCase__:				int			,							UpperCamelCase__:				str     ):
														lowerCamelCase__					:	Union[str, Any]         =       VisionTextDualEncoderConfig.from_vision_text_configs(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	int         =       VisionTextDualEncoderModel(UpperCamelCase__     )
														lowerCamelCase__					:	Tuple         =       FlaxVisionTextDualEncoderModel(UpperCamelCase__     )

														lowerCamelCase__					:	List[Any]         =       load_flax_weights_in_pytorch_model(UpperCamelCase__			,							fx_model.params     )

														self.check_pt_flax_equivalence(UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Dict     ):
														lowerCamelCase__					:	Tuple         =       self.prepare_config_and_inputs()
														self.check_model_from_pretrained_configs(**UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Tuple     ):
														lowerCamelCase__					:	Dict         =       self.prepare_config_and_inputs()
														self.check_vision_text_dual_encoder_from_pretrained(**UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	Union[str, Any]         =       self.prepare_config_and_inputs()
														self.check_save_load(**UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Optional[int]     ):
														lowerCamelCase__					:	List[str]         =       self.prepare_config_and_inputs()
														self.check_vision_text_output_attention(**UpperCamelCase__     )




							@is_pt_flax_cross_test
							def 		lowerCamelCase_				(							self:				Dict     ):
														lowerCamelCase__					:	Any         =       self.prepare_config_and_inputs()
														lowerCamelCase__					:	int         =       config_inputs_dict.pop("""vision_config"""     )
														lowerCamelCase__					:	str         =       config_inputs_dict.pop("""text_config"""     )

														lowerCamelCase__					:	Dict         =       config_inputs_dict

														self.check_equivalence_pt_to_flax(UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__     )
														self.check_equivalence_flax_to_pt(UpperCamelCase__			,							UpperCamelCase__			,							UpperCamelCase__     )




							@slow
							def 		lowerCamelCase_				(							self:				Dict     ):
														lowerCamelCase__  ,		lowerCamelCase__					:	Any         =       self.get_pretrained_model_and_inputs()

														lowerCamelCase__					:	Dict         =       model_a(**UpperCamelCase__     )
														lowerCamelCase__					:	str         =       outputs[0]

														with tempfile.TemporaryDirectory() as tmp_dirname:
																					model_a.save_pretrained(UpperCamelCase__     )
																					lowerCamelCase__					:	Union[str, Any]         =       FlaxVisionTextDualEncoderModel.from_pretrained(UpperCamelCase__     )

																					lowerCamelCase__					:	Any         =       model_a(**UpperCamelCase__     )
																					lowerCamelCase__					:	Any         =       after_outputs[0]
																					lowerCamelCase__					:	List[Any]         =       np.amax(np.abs(out_a - out_a     )     )
																					self.assertLessEqual(UpperCamelCase__			,							1e-5     )



@require_flax
class _lowercase	(				_lowercase				,      unittest.TestCase		):




							def 		lowerCamelCase_				(							self:				List[Any]     ):
														lowerCamelCase__					:	List[Any]         =       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
														    """hf-internal-testing/tiny-random-vit"""			,							"""hf-internal-testing/tiny-bert"""			,							vision_from_pt=UpperCamelCase__			,							text_from_pt=UpperCamelCase__			,							)
														lowerCamelCase__					:	Optional[int]         =       13
														lowerCamelCase__					:	Optional[Any]         =       floats_tensor(
														    [
														        batch_size,
														        model.config.vision_config.num_channels,
														        model.config.vision_config.image_size,
														        model.config.vision_config.image_size,
														    ]     )
														lowerCamelCase__					:	List[Any]         =       ids_tensor([batch_size, 4]			,							model.config.text_config.vocab_size     )
														lowerCamelCase__					:	Any         =       random_attention_mask([batch_size, 4]     )
														lowerCamelCase__					:	Optional[int]         =       {"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

														return model, inputs




							def 		lowerCamelCase_				(							self:				Union[str, Any]			,							UpperCamelCase__:				Tuple			,							UpperCamelCase__:				Tuple     ):
														lowerCamelCase__					:	Dict         =       FlaxViTModel(UpperCamelCase__     )
														lowerCamelCase__					:	Optional[Any]         =       FlaxBertModel(UpperCamelCase__     )
														return vision_model, text_model




							def 		lowerCamelCase_				(							self:				Tuple     ):
														lowerCamelCase__					:	List[Any]         =       FlaxViTModelTester(self     )
														lowerCamelCase__					:	List[Any]         =       FlaxBertModelTester(self     )
														lowerCamelCase__					:	List[Any]         =       vit_model_tester.prepare_config_and_inputs()
														lowerCamelCase__					:	str         =       bert_model_tester.prepare_config_and_inputs()

														lowerCamelCase__  ,		lowerCamelCase__					:	Union[str, Any]         =       vision_config_and_inputs

														lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__					:	Tuple         =       text_config_and_inputs

														# make sure that cross attention layers are added
														return {
														    "text_config": text_config,
														    "vision_config": vision_config,
														    "pixel_values": pixel_values,
														    "attention_mask": attention_mask,
														    "input_ids": input_ids,
														    "token_type_ids": token_type_ids,
														}



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




							def 		lowerCamelCase_				(							self:				Tuple     ):
														lowerCamelCase__					:	Any         =       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
														    """hf-internal-testing/tiny-random-clip"""			,							"""hf-internal-testing/tiny-bert"""			,							vision_from_pt=UpperCamelCase__			,							text_from_pt=UpperCamelCase__			,							)
														lowerCamelCase__					:	str         =       13
														lowerCamelCase__					:	Tuple         =       floats_tensor(
														    [
														        batch_size,
														        model.config.vision_config.num_channels,
														        model.config.vision_config.image_size,
														        model.config.vision_config.image_size,
														    ]     )
														lowerCamelCase__					:	Optional[Any]         =       ids_tensor([batch_size, 4]			,							model.config.text_config.vocab_size     )
														lowerCamelCase__					:	str         =       random_attention_mask([batch_size, 4]     )
														lowerCamelCase__					:	int         =       {"""pixel_values""": pixel_values, """input_ids""": input_ids, """attention_mask""": attention_mask}

														return model, inputs




							def 		lowerCamelCase_				(							self:				Tuple			,							UpperCamelCase__:				int			,							UpperCamelCase__:				List[Any]     ):
														lowerCamelCase__					:	List[Any]         =       FlaxCLIPVisionModel(UpperCamelCase__     )
														lowerCamelCase__					:	Optional[int]         =       FlaxBertModel(UpperCamelCase__     )
														return vision_model, text_model




							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	List[str]         =       FlaxCLIPVisionModelTester(self     )
														lowerCamelCase__					:	Tuple         =       FlaxBertModelTester(self     )
														lowerCamelCase__					:	Any         =       clip_model_tester.prepare_config_and_inputs()
														lowerCamelCase__					:	List[str]         =       bert_model_tester.prepare_config_and_inputs()

														lowerCamelCase__  ,		lowerCamelCase__					:	str         =       vision_config_and_inputs

														lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__  ,		lowerCamelCase__					:	str         =       text_config_and_inputs

														# make sure that cross attention layers are added
														return {
														    "text_config": text_config,
														    "vision_config": vision_config,
														    "pixel_values": pixel_values,
														    "attention_mask": attention_mask,
														    "input_ids": input_ids,
														    "token_type_ids": token_type_ids,
														}



@require_flax
@require_vision
class _lowercase	(				unittest.TestCase		):




							@slow
							def 		lowerCamelCase_				(							self:				str     ):
														lowerCamelCase__					:	Optional[Any]         =       FlaxVisionTextDualEncoderModel.from_pretrained("""clip-italian/clip-italian"""			,							logit_scale_init_value=1.0     )
														lowerCamelCase__					:	str         =       VisionTextDualEncoderProcessor.from_pretrained("""clip-italian/clip-italian"""     )

														lowerCamelCase__					:	List[str]         =       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
														lowerCamelCase__					:	Dict         =       processor(
														    text=["""una foto di un gatto""", """una foto di un cane"""]			,							images=UpperCamelCase__			,							padding=UpperCamelCase__			,							return_tensors="""np"""     )

														lowerCamelCase__					:	Union[str, Any]         =       model(**UpperCamelCase__     )

														# verify the logits
														self.assertEqual(outputs.logits_per_image.shape			,							(inputs.pixel_values.shape[0], inputs.input_ids.shape[0])     )
														self.assertEqual(
														    outputs.logits_per_text.shape			,							(inputs.input_ids.shape[0], inputs.pixel_values.shape[0])			,							)

														lowerCamelCase__					:	str         =       np.array([[1.2_284_727, 0.3_104_122]]     )

														self.assertTrue(np.allclose(outputs.logits_per_image			,							UpperCamelCase__			,							atol=1e-3     )     )



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




							def __init__(				self   ,A__   ,A__=2   ,A__=3   ,A__=4   ,A__=2   ,A__=7   ,A__=True   ,A__=True   ,A__=True   ,A__=True   ,A__=9_9   ,A__=3_6   ,A__=3   ,A__=4   ,A__=3_7   ,A__="gelu"   ,A__=0.1   ,A__=0.1   ,A__=5_1_2   ,A__=1_6   ,A__=2   ,A__=0.02   ,A__=6   ,A__=6   ,A__=3   ,A__=4   ,A__=None   ,A__=1_0_0_0   ,):
												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  A__      (				self):
												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  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						LayoutLMvaModel(config=A__)
												model.to(A__)
												model.eval()

												# text + image
												lowercase							=						model(A__   ,pixel_values=A__)
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__)
												lowercase							=						model(A__   ,bbox=A__   ,pixel_values=A__   ,token_type_ids=A__)
												lowercase							=						model(A__   ,bbox=A__   ,pixel_values=A__)

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

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

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




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						self.num_labels
												lowercase							=						LayoutLMvaForSequenceClassification(A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,labels=A__   ,)
												self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.num_labels))




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						self.num_labels
												lowercase							=						LayoutLMvaForTokenClassification(config=A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,labels=A__   ,)
												self.parent.assertEqual(result.logits.shape   ,(self.batch_size, self.text_seq_length, self.num_labels))




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__   ,A__):
												lowercase							=						LayoutLMvaForQuestionAnswering(config=A__)
												model.to(A__)
												model.eval()
												lowercase							=						model(
												    A__   ,bbox=A__   ,pixel_values=A__   ,attention_mask=A__   ,token_type_ids=A__   ,start_positions=A__   ,end_positions=A__   ,)
												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):
												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 				lowercase		(					SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase		):
							lowercase_       :       Dict       					=False
							lowercase_       :       Any       					=False
							lowercase_       :       Tuple       					=False

							lowercase_       :       Any       					=(
							    (
							        LayoutLMvaModel,
							        LayoutLMvaForSequenceClassification,
							        LayoutLMvaForTokenClassification,
							        LayoutLMvaForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase_       :       int       					=(
							    {'''document-question-answering''': LayoutLMvaForQuestionAnswering, '''feature-extraction''': LayoutLMvaModel}
							    if is_torch_available()
							    else {}
							)




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__   ,A__):
												# `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  A__      (				self):
												lowercase							=						LayoutLMvaModelTester(self)
												lowercase							=						ConfigTester(self   ,config_class=A__   ,hidden_size=3_7)




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

												return inputs_dict




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




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def  A__      (				self):
												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(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*A__)




							def  A__      (				self):
												lowercase							=						self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*A__)





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



def        UpperCamelCase    (							):
					'''simple docstring'''
					lowercase							=						Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
					return image







@require_torch
class 				lowercase		(					unittest.TestCase		):




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





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

												lowercase							=						self.default_image_processor
												lowercase							=						prepare_img()
												lowercase							=						image_processor(images=A__   ,return_tensors='''pt''').pixel_values.to(A__)

												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(A__)   ,bbox=bbox.to(A__)   ,pixel_values=pixel_values.to(A__)   ,)

												# verify the logits
												lowercase							=						torch.Size((1, 1_9_9, 7_6_8))
												self.assertEqual(outputs.last_hidden_state.shape   ,A__)

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

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




