



"""simple docstring"""





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__			:
       '''simple docstring'''







       def __init__(  self	,       snake_case	,       snake_case=2	,       snake_case=3	,       snake_case=4	,       snake_case=2	,       snake_case=7	,       snake_case=True	,       snake_case=True	,       snake_case=True	,       snake_case=True	,       snake_case=99	,       snake_case=36	,       snake_case=3	,       snake_case=4	,       snake_case=37	,       snake_case="gelu"	,       snake_case=0.1	,       snake_case=0.1	,       snake_case=512	,       snake_case=16	,       snake_case=2	,       snake_case=0.02	,       snake_case=6	,       snake_case=6	,       snake_case=3	,       snake_case=4	,       snake_case=None	,       snake_case=1000	,       )			->							List[str]:
         _UpperCAmelCase							 =		parent
         _UpperCAmelCase							 =		batch_size
         _UpperCAmelCase							 =		num_channels
         _UpperCAmelCase							 =		image_size
         _UpperCAmelCase							 =		patch_size
         _UpperCAmelCase							 =		text_seq_length
         _UpperCAmelCase							 =		is_training
         _UpperCAmelCase							 =		use_input_mask
         _UpperCAmelCase							 =		use_token_type_ids
         _UpperCAmelCase							 =		use_labels
         _UpperCAmelCase							 =		vocab_size
         _UpperCAmelCase							 =		hidden_size
         _UpperCAmelCase							 =		num_hidden_layers
         _UpperCAmelCase							 =		num_attention_heads
         _UpperCAmelCase							 =		intermediate_size
         _UpperCAmelCase							 =		hidden_act
         _UpperCAmelCase							 =		hidden_dropout_prob
         _UpperCAmelCase							 =		attention_probs_dropout_prob
         _UpperCAmelCase							 =		max_position_embeddings
         _UpperCAmelCase							 =		type_vocab_size
         _UpperCAmelCase							 =		type_sequence_label_size
         _UpperCAmelCase							 =		initializer_range
         _UpperCAmelCase							 =		coordinate_size
         _UpperCAmelCase							 =		shape_size
         _UpperCAmelCase							 =		num_labels
         _UpperCAmelCase							 =		num_choices
         _UpperCAmelCase							 =		scope
         _UpperCAmelCase							 =		range_bbox

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






       def        lowerCamelCase_   (  self						)			->							Optional[int]:
         _UpperCAmelCase							 =		ids_tensor([self.batch_size, self.text_seq_length]	,       self.vocab_size						)

         _UpperCAmelCase							 =		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]:
               _UpperCAmelCase							 =		bbox[i, j, 3]
               _UpperCAmelCase							 =		bbox[i, j, 1]
               _UpperCAmelCase							 =		t
             if bbox[i, j, 2] < bbox[i, j, 0]:
               _UpperCAmelCase							 =		bbox[i, j, 2]
               _UpperCAmelCase							 =		bbox[i, j, 0]
               _UpperCAmelCase							 =		t

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

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

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

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

         _UpperCAmelCase							 =		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        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case						)			->							Optional[int]:
         _UpperCAmelCase							 =		LayoutLMvaModel(config=UpperCamelCase__						)
         model.to(UpperCamelCase__						)
         model.eval()

         # text + image
         _UpperCAmelCase							 =		model(UpperCamelCase__	,       pixel_values=UpperCamelCase__						)
         _UpperCAmelCase							 =		model(
             UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__	,       attention_mask=UpperCamelCase__	,       token_type_ids=UpperCamelCase__						)
         _UpperCAmelCase							 =		model(UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__	,       token_type_ids=UpperCamelCase__						)
         _UpperCAmelCase							 =		model(UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__						)

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

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

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






       def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case						)			->							Union[str, Any]:
         _UpperCAmelCase							 =		self.num_labels
         _UpperCAmelCase							 =		LayoutLMvaForSequenceClassification(UpperCamelCase__						)
         model.to(UpperCamelCase__						)
         model.eval()
         _UpperCAmelCase							 =		model(
             UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__	,       attention_mask=UpperCamelCase__	,       token_type_ids=UpperCamelCase__	,       labels=UpperCamelCase__	,       )
         self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.num_labels)						)






       def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case						)			->							List[str]:
         _UpperCAmelCase							 =		self.num_labels
         _UpperCAmelCase							 =		LayoutLMvaForTokenClassification(config=UpperCamelCase__						)
         model.to(UpperCamelCase__						)
         model.eval()
         _UpperCAmelCase							 =		model(
             UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__	,       attention_mask=UpperCamelCase__	,       token_type_ids=UpperCamelCase__	,       labels=UpperCamelCase__	,       )
         self.parent.assertEqual(result.logits.shape	,       (self.batch_size, self.text_seq_length, self.num_labels)						)






       def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case						)			->							Optional[Any]:
         _UpperCAmelCase							 =		LayoutLMvaForQuestionAnswering(config=UpperCamelCase__						)
         model.to(UpperCamelCase__						)
         model.eval()
         _UpperCAmelCase							 =		model(
             UpperCamelCase__	,       bbox=UpperCamelCase__	,       pixel_values=UpperCamelCase__	,       attention_mask=UpperCamelCase__	,       token_type_ids=UpperCamelCase__	,       start_positions=UpperCamelCase__	,       end_positions=UpperCamelCase__	,       )
         self.parent.assertEqual(result.start_logits.shape	,       (self.batch_size, self.seq_length)						)
         self.parent.assertEqual(result.end_logits.shape	,       (self.batch_size, self.seq_length)						)






       def        lowerCamelCase_   (  self						)			->							Any:
         _UpperCAmelCase							 =		self.prepare_config_and_inputs()
         (
             _UpperCAmelCase							
         )							 =		config_and_inputs
         _UpperCAmelCase							 =		{
             '''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    ):
       '''simple docstring'''







       _UpperCAmelCase      				=					False
       _UpperCAmelCase      				=					False
       _UpperCAmelCase      				=					False

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






       def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case						)			->							Dict:
         # `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        lowerCamelCase_   (  self						)			->							str:
         _UpperCAmelCase							 =		LayoutLMvaModelTester(self						)
         _UpperCAmelCase							 =		ConfigTester(self	,       config_class=UpperCamelCase__	,       hidden_size=37						)






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

         return inputs_dict






       def        lowerCamelCase_   (  self						)			->							str:
         self.config_tester.run_common_tests()






       def        lowerCamelCase_   (  self						)			->							Optional[Any]:
         _UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase__						)






       def        lowerCamelCase_   (  self						)			->							List[Any]:
         _UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
           _UpperCAmelCase							 =		type
           self.model_tester.create_and_check_model(*UpperCamelCase__						)






       def        lowerCamelCase_   (  self						)			->							List[str]:
         _UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase__						)






       def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
         _UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*UpperCamelCase__						)






       def        lowerCamelCase_   (  self						)			->							List[str]:
         _UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*UpperCamelCase__						)






       @slow
       def        lowerCamelCase_   (  self						)			->							Dict:
         for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _UpperCAmelCase							 =		LayoutLMvaModel.from_pretrained(UpperCamelCase__						)
           self.assertIsNotNone(UpperCamelCase__						)







def 	UpperCAmelCase     (		):

  '''simple docstring'''


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






@require_torch
class 			lowercase__			(      unittest.TestCase    ):
       '''simple docstring'''







       @cached_property
       def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
         return LayoutLMvaImageProcessor(apply_ocr=UpperCamelCase__						) if is_vision_available() else None






       @slow
       def        lowerCamelCase_   (  self						)			->							List[str]:
         _UpperCAmelCase							 =		LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'						).to(UpperCamelCase__						)

         _UpperCAmelCase							 =		self.default_image_processor
         _UpperCAmelCase							 =		prepare_img()
         _UpperCAmelCase							 =		image_processor(images=UpperCamelCase__	,       return_tensors='pt'						).pixel_values.to(UpperCamelCase__						)

         _UpperCAmelCase							 =		torch.tensor([[1, 2]]						)
         _UpperCAmelCase							 =		torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]						).unsqueeze(0						)

         # forward pass
         _UpperCAmelCase							 =		model(
             input_ids=input_ids.to(UpperCamelCase__						)	,       bbox=bbox.to(UpperCamelCase__						)	,       pixel_values=pixel_values.to(UpperCamelCase__						)	,       )

         # verify the logits
         _UpperCAmelCase							 =		torch.Size((1, 199, 768)						)
         self.assertEqual(outputs.last_hidden_state.shape	,       UpperCamelCase__						)

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

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







"""simple docstring"""





import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()




class 			lowercase__			(      A,					unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					DiTPipeline
							_UpperCAmelCase      				=					CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
							_UpperCAmelCase      				=					PipelineTesterMixin.required_optional_params - {
							    '''latents''',
							    '''num_images_per_prompt''',
							    '''callback''',
							    '''callback_steps''',
							}
							_UpperCAmelCase      				=					CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
							_UpperCAmelCase      				=					False






							def        lowerCamelCase_   (  self						)			->							str:
									torch.manual_seed(0						)
									_UpperCAmelCase							 =		TransformeraDModel(
									    sample_size=16	,       num_layers=2	,       patch_size=4	,       attention_head_dim=8	,       num_attention_heads=2	,       in_channels=4	,       out_channels=8	,       attention_bias=snake_case	,       activation_fn='gelu-approximate'	,       num_embeds_ada_norm=1000	,       norm_type='ada_norm_zero'	,       norm_elementwise_affine=snake_case	,       )
									_UpperCAmelCase							 =		AutoencoderKL()
									_UpperCAmelCase							 =		DDIMScheduler()
									_UpperCAmelCase							 =		{'transformer': transformer.eval(), 'vae': vae.eval(), 'scheduler': scheduler}
									return components






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case=0						)			->							Optional[Any]:
									if str(snake_case						).startswith('mps'						):
											_UpperCAmelCase							 =		torch.manual_seed(snake_case						)
									else:
											_UpperCAmelCase							 =		torch.Generator(device=snake_case						).manual_seed(snake_case						)
									_UpperCAmelCase							 =		{
									    'class_labels': [1],
									    'generator': generator,
									    'num_inference_steps': 2,
									    'output_type': 'numpy',
									}
									return inputs






							def        lowerCamelCase_   (  self						)			->							List[Any]:
									_UpperCAmelCase							 =		'cpu'

									_UpperCAmelCase							 =		self.get_dummy_components()
									_UpperCAmelCase							 =		self.pipeline_class(**snake_case						)
									pipe.to(snake_case						)
									pipe.set_progress_bar_config(disable=snake_case						)

									_UpperCAmelCase							 =		self.get_dummy_inputs(snake_case						)
									_UpperCAmelCase							 =		pipe(**snake_case						).images
									_UpperCAmelCase							 =		image[0, -3:, -3:, -1]

									self.assertEqual(image.shape	,       (1, 16, 16, 3)						)
									_UpperCAmelCase							 =		np.array([0.2946, 0.6601, 0.4329, 0.3296, 0.4144, 0.5319, 0.7273, 0.5013, 0.4457]						)
									_UpperCAmelCase							 =		np.abs(image_slice.flatten() - expected_slice						).max()
									self.assertLessEqual(snake_case	,       1E-3						)






							def        lowerCamelCase_   (  self						)			->							Any:
									self._test_inference_batch_single_identical(relax_max_difference=snake_case	,       expected_max_diff=1E-3						)






							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()	,       reason='XFormers attention is only available with CUDA and `xformers` installed'	,       )
							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3						)







@require_torch_gpu
@slow
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							int:
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()






							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		torch.manual_seed(0						)

									_UpperCAmelCase							 =		DiTPipeline.from_pretrained('facebook/DiT-XL-2-256'						)
									pipe.to('cuda'						)

									_UpperCAmelCase							 =		['vase', 'umbrella', 'white shark', 'white wolf']
									_UpperCAmelCase							 =		pipe.get_label_ids(snake_case						)

									_UpperCAmelCase							 =		pipe(snake_case	,       generator=snake_case	,       num_inference_steps=40	,       output_type='np'						).images

									for word, image in zip(snake_case	,       snake_case						):
											_UpperCAmelCase							 =		load_numpy(
											    f'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy'						)
											assert np.abs((expected_image - image).max()						) < 1E-2






							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		DiTPipeline.from_pretrained('facebook/DiT-XL-2-512'						)
									_UpperCAmelCase							 =		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config						)
									pipe.to('cuda'						)

									_UpperCAmelCase							 =		['vase', 'umbrella']
									_UpperCAmelCase							 =		pipe.get_label_ids(snake_case						)

									_UpperCAmelCase							 =		torch.manual_seed(0						)
									_UpperCAmelCase							 =		pipe(snake_case	,       generator=snake_case	,       num_inference_steps=25	,       output_type='np'						).images

									for word, image in zip(snake_case	,       snake_case						):
											_UpperCAmelCase							 =		load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
											    f'/dit/{word}_512.npy'						)

											assert np.abs((expected_image - image).max()						) < 1E-1


