



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()



class    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   def       UpperCAmelCase		(    self	:      List[Any])						->					Any:




         """simple docstring"""

         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()


   @property
   def       UpperCAmelCase		(    self	:      str)						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	1
         lowercase__  =	3
         lowercase__  =	(32, 32)

         lowercase__  =	floats_tensor((batch_size, num_channels) + sizes      ,					rng=random.Random(0)).to(lowerCAmelCase)
         return image


   @property
   def       UpperCAmelCase		(    self	:      int)						->					Any:




         """simple docstring"""

         torch.manual_seed(0)
         lowercase__  =	UNetaDConditionModel(
             block_out_channels=(32, 32, 64)      ,					layers_per_block=2      ,					sample_size=32      ,					in_channels=7      ,					out_channels=4      ,					down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D')      ,					up_block_types=('CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'UpBlock2D')      ,					cross_attention_dim=32      ,					attention_head_dim=8      ,					use_linear_projection=lowerCAmelCase      ,					only_cross_attention=(True, True, False)      ,					num_class_embeds=1_00      ,					)
         return model


   @property
   def       UpperCAmelCase		(    self	:      List[Any])						->					str:




         """simple docstring"""

         torch.manual_seed(0)
         lowercase__  =	AutoencoderKL(
             block_out_channels=[32, 32, 64]      ,					in_channels=3      ,					out_channels=3      ,					down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D']      ,					up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']      ,					latent_channels=4      ,					)
         return model


   @property
   def       UpperCAmelCase		(    self	:      List[str])						->					Dict:




         """simple docstring"""

         torch.manual_seed(0)
         lowercase__  =	CLIPTextConfig(
             bos_token_id=0      ,					eos_token_id=2      ,					hidden_size=32      ,					intermediate_size=37      ,					layer_norm_eps=1E-0_5      ,					num_attention_heads=4      ,					num_hidden_layers=5      ,					pad_token_id=1      ,					vocab_size=10_00      ,					hidden_act='gelu'      ,					projection_dim=5_12      ,					)
         return CLIPTextModel(lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      int)						->					str:




         """simple docstring"""

         lowercase__  =	'cpu'  # ensure determinism for the device-dependent torch.Generator
         lowercase__  =	self.dummy_cond_unet_upscale
         lowercase__  =	DDPMScheduler()
         lowercase__  =	DDIMScheduler(prediction_type='v_prediction')
         lowercase__  =	self.dummy_vae
         lowercase__  =	self.dummy_text_encoder
         lowercase__  =	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

         lowercase__  =	self.dummy_image.cpu().permute(0      ,					2      ,					3      ,					1)[0]
         lowercase__  =	Image.fromarray(np.uinta(lowerCAmelCase)).convert('RGB').resize((64, 64))

         # make sure here that pndm scheduler skips prk
         lowercase__  =	StableDiffusionUpscalePipeline(
             unet=lowerCAmelCase      ,					low_res_scheduler=lowerCAmelCase      ,					scheduler=lowerCAmelCase      ,					vae=lowerCAmelCase      ,					text_encoder=lowerCAmelCase      ,					tokenizer=lowerCAmelCase      ,					max_noise_level=3_50      ,					)
         lowercase__  =	sd_pipe.to(lowerCAmelCase)
         sd_pipe.set_progress_bar_config(disable=lowerCAmelCase)

         lowercase__  =	'A painting of a squirrel eating a burger'
         lowercase__  =	torch.Generator(device=lowerCAmelCase).manual_seed(0)
         lowercase__  =	sd_pipe(
             [prompt]      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					guidance_scale=6.0      ,					noise_level=20      ,					num_inference_steps=2      ,					output_type='np'      ,					)

         lowercase__  =	output.images

         lowercase__  =	torch.Generator(device=lowerCAmelCase).manual_seed(0)
         lowercase__  =	sd_pipe(
             [prompt]      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					guidance_scale=6.0      ,					noise_level=20      ,					num_inference_steps=2      ,					output_type='np'      ,					return_dict=lowerCAmelCase      ,					)[0]

         lowercase__  =	image[0, -3:, -3:, -1]
         lowercase__  =	image_from_tuple[0, -3:, -3:, -1]

         lowercase__  =	low_res_image.size[0] * 4
         assert image.shape == (1, expected_height_width, expected_height_width, 3)
         lowercase__  =	np.array([0.31_13, 0.39_10, 0.42_72, 0.48_59, 0.50_61, 0.46_52, 0.53_62, 0.57_15, 0.56_61])

         assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-2
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 1E-2


   def       UpperCAmelCase		(    self	:      List[Any])						->					str:




         """simple docstring"""

         lowercase__  =	'cpu'  # ensure determinism for the device-dependent torch.Generator
         lowercase__  =	self.dummy_cond_unet_upscale
         lowercase__  =	DDPMScheduler()
         lowercase__  =	DDIMScheduler(prediction_type='v_prediction')
         lowercase__  =	self.dummy_vae
         lowercase__  =	self.dummy_text_encoder
         lowercase__  =	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

         lowercase__  =	self.dummy_image.cpu().permute(0      ,					2      ,					3      ,					1)[0]
         lowercase__  =	Image.fromarray(np.uinta(lowerCAmelCase)).convert('RGB').resize((64, 64))

         # make sure here that pndm scheduler skips prk
         lowercase__  =	StableDiffusionUpscalePipeline(
             unet=lowerCAmelCase      ,					low_res_scheduler=lowerCAmelCase      ,					scheduler=lowerCAmelCase      ,					vae=lowerCAmelCase      ,					text_encoder=lowerCAmelCase      ,					tokenizer=lowerCAmelCase      ,					max_noise_level=3_50      ,					)
         lowercase__  =	sd_pipe.to(lowerCAmelCase)
         sd_pipe.set_progress_bar_config(disable=lowerCAmelCase)

         lowercase__  =	'A painting of a squirrel eating a burger'
         lowercase__  =	sd_pipe(
             2 * [prompt]      ,					image=2 * [low_res_image]      ,					guidance_scale=6.0      ,					noise_level=20      ,					num_inference_steps=2      ,					output_type='np'      ,					)
         lowercase__  =	output.images
         assert image.shape[0] == 2

         lowercase__  =	torch.Generator(device=lowerCAmelCase).manual_seed(0)
         lowercase__  =	sd_pipe(
             [prompt]      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					num_images_per_prompt=2      ,					guidance_scale=6.0      ,					noise_level=20      ,					num_inference_steps=2      ,					output_type='np'      ,					)
         lowercase__  =	output.images
         assert image.shape[0] == 2



   @unittest.skipIf(torch_device != 'cuda'      ,					'This test requires a GPU')
   def       UpperCAmelCase		(    self	:      List[str])						->					Dict:




         """simple docstring"""

         lowercase__  =	self.dummy_cond_unet_upscale
         lowercase__  =	DDPMScheduler()
         lowercase__  =	DDIMScheduler(prediction_type='v_prediction')
         lowercase__  =	self.dummy_vae
         lowercase__  =	self.dummy_text_encoder
         lowercase__  =	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

         lowercase__  =	self.dummy_image.cpu().permute(0      ,					2      ,					3      ,					1)[0]
         lowercase__  =	Image.fromarray(np.uinta(lowerCAmelCase)).convert('RGB').resize((64, 64))

         # put models in fp16, except vae as it overflows in fp16
         lowercase__  =	unet.half()
         lowercase__  =	text_encoder.half()

         # make sure here that pndm scheduler skips prk
         lowercase__  =	StableDiffusionUpscalePipeline(
             unet=lowerCAmelCase      ,					low_res_scheduler=lowerCAmelCase      ,					scheduler=lowerCAmelCase      ,					vae=lowerCAmelCase      ,					text_encoder=lowerCAmelCase      ,					tokenizer=lowerCAmelCase      ,					max_noise_level=3_50      ,					)
         lowercase__  =	sd_pipe.to(lowerCAmelCase)
         sd_pipe.set_progress_bar_config(disable=lowerCAmelCase)

         lowercase__  =	'A painting of a squirrel eating a burger'
         lowercase__  =	torch.manual_seed(0)
         lowercase__  =	sd_pipe(
             [prompt]      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					num_inference_steps=2      ,					output_type='np'      ,					).images

         lowercase__  =	low_res_image.size[0] * 4
         assert image.shape == (1, expected_height_width, expected_height_width, 3)



@slow
@require_torch_gpu
class    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   def       UpperCAmelCase		(    self	:      str)						->					int:




         """simple docstring"""

         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()


   def       UpperCAmelCase		(    self	:      str)						->					Optional[Any]:




         """simple docstring"""

         lowercase__  =	load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/sd2-upscale/low_res_cat.png')
         lowercase__  =	load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
             '/upsampled_cat.npy')

         lowercase__  =	'stabilityai/stable-diffusion-x4-upscaler'
         lowercase__  =	StableDiffusionUpscalePipeline.from_pretrained(lowerCAmelCase)
         pipe.to(lowerCAmelCase)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)
         pipe.enable_attention_slicing()

         lowercase__  =	'a cat sitting on a park bench'

         lowercase__  =	torch.manual_seed(0)
         lowercase__  =	pipe(
             prompt=lowerCAmelCase      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					output_type='np'      ,					)
         lowercase__  =	output.images[0]

         assert image.shape == (5_12, 5_12, 3)
         assert np.abs(expected_image - image).max() < 1E-3


   def       UpperCAmelCase		(    self	:      Tuple)						->					Optional[Any]:




         """simple docstring"""

         lowercase__  =	load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/sd2-upscale/low_res_cat.png')
         lowercase__  =	load_numpy(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'
             '/upsampled_cat_fp16.npy')

         lowercase__  =	'stabilityai/stable-diffusion-x4-upscaler'
         lowercase__  =	StableDiffusionUpscalePipeline.from_pretrained(
             lowerCAmelCase      ,					torch_dtype=torch.floataa      ,					)
         pipe.to(lowerCAmelCase)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)
         pipe.enable_attention_slicing()

         lowercase__  =	'a cat sitting on a park bench'

         lowercase__  =	torch.manual_seed(0)
         lowercase__  =	pipe(
             prompt=lowerCAmelCase      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					output_type='np'      ,					)
         lowercase__  =	output.images[0]

         assert image.shape == (5_12, 5_12, 3)
         assert np.abs(expected_image - image).max() < 5E-1



   def       UpperCAmelCase		(    self	:      Dict)						->					List[Any]:




         """simple docstring"""

         torch.cuda.empty_cache()
         torch.cuda.reset_max_memory_allocated()
         torch.cuda.reset_peak_memory_stats()

         lowercase__  =	load_image(
             'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
             '/sd2-upscale/low_res_cat.png')

         lowercase__  =	'stabilityai/stable-diffusion-x4-upscaler'
         lowercase__  =	StableDiffusionUpscalePipeline.from_pretrained(
             lowerCAmelCase      ,					torch_dtype=torch.floataa      ,					)
         pipe.to(lowerCAmelCase)
         pipe.set_progress_bar_config(disable=lowerCAmelCase)
         pipe.enable_attention_slicing(1)
         pipe.enable_sequential_cpu_offload()

         lowercase__  =	'a cat sitting on a park bench'

         lowercase__  =	torch.manual_seed(0)
         lowercase__  =	pipe(
             prompt=lowerCAmelCase      ,					image=lowerCAmelCase      ,					generator=lowerCAmelCase      ,					num_inference_steps=5      ,					output_type='np'      ,					)

         lowercase__  =	torch.cuda.max_memory_allocated()
         # make sure that less than 2.9 GB is allocated
         assert mem_bytes < 2.9 * 10**9





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

   '''simple docstring'''




   def __init__(    self	:      Dict      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Tuple=2      ,					lowerCAmelCase	:      Any=3      ,					lowerCAmelCase	:      Any=4      ,					lowerCAmelCase	:      Optional[Any]=2      ,					lowerCAmelCase	:      Optional[Any]=7      ,					lowerCAmelCase	:      Tuple=True      ,					lowerCAmelCase	:      Optional[int]=True      ,					lowerCAmelCase	:      int=True      ,					lowerCAmelCase	:      Dict=True      ,					lowerCAmelCase	:      Dict=99      ,					lowerCAmelCase	:      Optional[int]=36      ,					lowerCAmelCase	:      List[Any]=2      ,					lowerCAmelCase	:      Dict=4      ,					lowerCAmelCase	:      int=37      ,					lowerCAmelCase	:      Optional[int]="gelu"      ,					lowerCAmelCase	:      str=0.1      ,					lowerCAmelCase	:      str=0.1      ,					lowerCAmelCase	:      List[Any]=5_12      ,					lowerCAmelCase	:      List[str]=16      ,					lowerCAmelCase	:      Union[str, Any]=2      ,					lowerCAmelCase	:      Dict=0.02      ,					lowerCAmelCase	:      Tuple=6      ,					lowerCAmelCase	:      Tuple=6      ,					lowerCAmelCase	:      Dict=3      ,					lowerCAmelCase	:      List[str]=4      ,					lowerCAmelCase	:      List[str]=None      ,					lowerCAmelCase	:      Optional[Any]=10_00      ,					)						->					Dict:




         """simple docstring"""

         lowercase__  =	parent
         lowercase__  =	batch_size
         lowercase__  =	num_channels
         lowercase__  =	image_size
         lowercase__  =	patch_size
         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       UpperCAmelCase		(    self	:      str)						->					List[str]:




         """simple docstring"""

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

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

         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       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      List[Any])						->					List[str]:




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModel(config=lowerCAmelCase)

         # text + image
         lowercase__  =	model(lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					training=lowerCAmelCase)
         lowercase__  =	model(
             lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					attention_mask=lowerCAmelCase      ,					token_type_ids=lowerCAmelCase      ,					training=lowerCAmelCase      ,					)
         lowercase__  =	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
         lowercase__  =	model(lowerCAmelCase      ,					training=lowerCAmelCase)
         self.parent.assertEqual(
             result.last_hidden_state.shape      ,					(self.batch_size, self.text_seq_length, self.hidden_size))

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


   def       UpperCAmelCase		(    self	:      Any      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      List[str])						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMvaForSequenceClassification(config=lowerCAmelCase)
         lowercase__  =	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       UpperCAmelCase		(    self	:      Union[str, Any]      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      Optional[int]      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      str)						->					str:




         """simple docstring"""

         lowercase__  =	self.num_labels
         lowercase__  =	TFLayoutLMvaForTokenClassification(config=lowerCAmelCase)
         lowercase__  =	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       UpperCAmelCase		(    self	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      str      ,					lowerCAmelCase	:      List[str]      ,					lowerCAmelCase	:      List[Any])						->					int:




         """simple docstring"""

         lowercase__  =	2
         lowercase__  =	TFLayoutLMvaForQuestionAnswering(config=lowerCAmelCase)
         lowercase__  =	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       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

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



@require_tf
class    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	Optional[Any]												=     (
       (
           TFLayoutLMvaModel,
           TFLayoutLMvaForQuestionAnswering,
           TFLayoutLMvaForSequenceClassification,
           TFLayoutLMvaForTokenClassification,
       )
       if is_tf_available()
       else ()
   )
   A     :	List[Any]												=     (
       {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
       if is_tf_available()
       else {}
   )

   A     :	Any												=     False
   A     :	Any												=     False
   A     :	Dict												=     False


   def       UpperCAmelCase		(    self	:      int      ,					lowerCAmelCase	:      int      ,					lowerCAmelCase	:      Dict      ,					lowerCAmelCase	:      Any      ,					lowerCAmelCase	:      List[Any]      ,					lowerCAmelCase	:      Dict)						->					Tuple:




         """simple docstring"""

         return True


   def       UpperCAmelCase		(    self	:      Tuple      ,					lowerCAmelCase	:      Union[str, Any]      ,					lowerCAmelCase	:      Optional[Any]      ,					lowerCAmelCase	:      List[str]=False)						->					dict:




         """simple docstring"""

         lowercase__  =	copy.deepcopy(lowerCAmelCase)

         if model_class in get_values(lowerCAmelCase):
               lowercase__  =	{
                   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):
                     lowercase__  =	tf.ones(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(self.model_tester.batch_size      ,					dtype=tf.intaa)
               elif model_class in get_values(lowerCAmelCase):
                     lowercase__  =	tf.zeros(
                         (self.model_tester.batch_size, self.model_tester.text_seq_length)      ,					dtype=tf.intaa)

         return inputs_dict


   def       UpperCAmelCase		(    self	:      Optional[int])						->					int:




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModelTester(self)
         lowercase__  =	ConfigTester(self      ,					config_class=lowerCAmelCase      ,					hidden_size=37)


   def       UpperCAmelCase		(    self	:      Optional[Any])						->					str:




         """simple docstring"""

         self.config_tester.run_common_tests()


   def       UpperCAmelCase		(    self	:      List[Any])						->					List[str]:




         """simple docstring"""

         lowercase__,						lowercase__  =	self.model_tester.prepare_config_and_inputs_for_common()
         for model_class in self.all_model_classes:
               lowercase__  =	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
                     lowercase__  =	self._prepare_for_class(inputs_dict.copy()      ,					lowerCAmelCase      ,					return_labels=lowerCAmelCase)
                     lowercase__  =	prepared_for_class[
                         sorted(prepared_for_class.keys() - inputs_dict.keys()      ,					reverse=lowerCAmelCase)[0]
                     ]
                     lowercase__  =	added_label.shape.as_list()[:1]

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

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

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

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

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

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

                     lowercase__  =	tuple(lowerCAmelCase)

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

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


   def       UpperCAmelCase		(    self	:      str)						->					Any:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


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




         """simple docstring"""

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


   def       UpperCAmelCase		(    self	:      List[str])						->					Optional[Any]:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(
             lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      List[str])						->					int:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(
             lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase      ,					lowerCAmelCase)


   def       UpperCAmelCase		(    self	:      int)						->					Dict:




         """simple docstring"""

         (
             (
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						(
             lowercase__
         ),						
         )  =	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       UpperCAmelCase		(    self	:      List[Any])						->					Tuple:




         """simple docstring"""

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

def 	_lowerCAmelCase (    ):
      lowercase__  =	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
      return image



@require_tf
class    UpperCAmelCase__(				unittest.TestCase						):

   '''simple docstring'''




   @cached_property
   def       UpperCAmelCase		(    self	:      Union[str, Any])						->					Tuple:




         """simple docstring"""

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



   @slow
   def       UpperCAmelCase		(    self	:      str)						->					str:




         """simple docstring"""

         lowercase__  =	TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base')

         lowercase__  =	self.default_image_processor
         lowercase__  =	prepare_img()
         lowercase__  =	image_processor(images=lowerCAmelCase      ,					return_tensors='tf').pixel_values

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

         # forward pass
         lowercase__  =	model(input_ids=lowerCAmelCase      ,					bbox=lowerCAmelCase      ,					pixel_values=lowerCAmelCase      ,					training=lowerCAmelCase)

         # verify the logits
         lowercase__  =	(1, 1_99, 7_68)
         self.assertEqual(outputs.last_hidden_state.shape      ,					lowerCAmelCase)

         lowercase__  =	tf.constant(
             [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]])

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