




'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
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

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()




class 			_snake_case		(     lowercase_						,						unittest.TestCase							):
			lowerCAmelCase_					:				str							=   KandinskyImgaImgPipeline
			lowerCAmelCase_					:				Union[str, Any]							=   ["prompt", "image_embeds", "negative_image_embeds", "image"]
			lowerCAmelCase_					:				Optional[int]							=   [
			    "prompt",
			    "negative_prompt",
			    "image_embeds",
			    "negative_image_embeds",
			    "image",
			]
			lowerCAmelCase_					:				Optional[Any]							=   [
			    "generator",
			    "height",
			    "width",
			    "strength",
			    "guidance_scale",
			    "negative_prompt",
			    "num_inference_steps",
			    "return_dict",
			    "guidance_scale",
			    "num_images_per_prompt",
			    "output_type",
			    "return_dict",
			]
			lowerCAmelCase_					:				Optional[Any]							=   False




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

										'''simple docstring'''




										return 32




			@property
			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										return 32




			@property
			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										return self.time_input_dim




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

										'''simple docstring'''




										return self.time_input_dim * 4




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

										'''simple docstring'''




										return 100




			@property
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				XLMRobertaTokenizerFast.from_pretrained("YiYiXu/tiny-random-mclip-base"							)
										return tokenizer




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

										'''simple docstring'''




										torch.manual_seed(0							)
										snake_case_      =				MCLIPConfig(
										    numDims=self.cross_attention_dim    ,							transformerDimensions=self.text_embedder_hidden_size    ,							hidden_size=self.text_embedder_hidden_size    ,							intermediate_size=37    ,							num_attention_heads=4    ,							num_hidden_layers=5    ,							vocab_size=1_005    ,							)

										snake_case_      =				MultilingualCLIP(a__							)
										snake_case_      =				text_encoder.eval()

										return text_encoder




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

										'''simple docstring'''




										torch.manual_seed(0							)

										snake_case_      =				{
										    "in_channels": 4,
										    # Out channels is double in channels because predicts mean and variance
										    "out_channels": 8,
										    "addition_embed_type": "text_image",
										    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
										    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
										    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
										    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
										    "layers_per_block": 1,
										    "encoder_hid_dim": self.text_embedder_hidden_size,
										    "encoder_hid_dim_type": "text_image_proj",
										    "cross_attention_dim": self.cross_attention_dim,
										    "attention_head_dim": 4,
										    "resnet_time_scale_shift": "scale_shift",
										    "class_embed_type": None,
										}

										snake_case_      =				UNetaDConditionModel(**a__							)
										return model




			@property
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										return {
										    "block_out_channels": [32, 64],
										    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
										    "in_channels": 3,
										    "latent_channels": 4,
										    "layers_per_block": 1,
										    "norm_num_groups": 8,
										    "norm_type": "spatial",
										    "num_vq_embeddings": 12,
										    "out_channels": 3,
										    "up_block_types": [
										        "AttnUpDecoderBlock2D",
										        "UpDecoderBlock2D",
										    ],
										    "vq_embed_dim": 4,
										}




			@property
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										torch.manual_seed(0							)
										snake_case_      =				VQModel(**self.dummy_movq_kwargs							)
										return model




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.dummy_text_encoder
										snake_case_      =				self.dummy_tokenizer
										snake_case_      =				self.dummy_unet
										snake_case_      =				self.dummy_movq

										snake_case_      =				{
										    "num_train_timesteps": 1_000,
										    "beta_schedule": "linear",
										    "beta_start": 0.0_0_0_8_5,
										    "beta_end": 0.0_1_2,
										    "clip_sample": False,
										    "set_alpha_to_one": False,
										    "steps_offset": 0,
										    "prediction_type": "epsilon",
										    "thresholding": False,
										}

										snake_case_      =				DDIMScheduler(**a__							)

										snake_case_      =				{
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "unet": unet,
										    "scheduler": scheduler,
										    "movq": movq,
										}

										return components




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__=0							)    ->    Dict:

										'''simple docstring'''




										snake_case_      =				floats_tensor((1, self.cross_attention_dim)    ,							rng=random.Random(a__							)							).to(a__							)
										snake_case_      =				floats_tensor((1, self.cross_attention_dim)    ,							rng=random.Random(seed + 1							)							).to(a__							)
										# create init_image
										snake_case_      =				floats_tensor((1, 3, 64, 64)    ,							rng=random.Random(a__							)							).to(a__							)
										snake_case_      =				image.cpu().permute(0    ,							2    ,							3    ,							1							)[0]
										snake_case_      =				Image.fromarray(np.uinta(a__							)							).convert("RGB"							).resize((256, 256)							)

										if str(a__							).startswith("mps"							):
																	snake_case_      =				torch.manual_seed(a__							)
										else:
																	snake_case_      =				torch.Generator(device=a__							).manual_seed(a__							)
										snake_case_      =				{
										    "prompt": "horse",
										    "image": init_image,
										    "image_embeds": image_embeds,
										    "negative_image_embeds": negative_image_embeds,
										    "generator": generator,
										    "height": 64,
										    "width": 64,
										    "num_inference_steps": 10,
										    "guidance_scale": 7.0,
										    "strength": 0.2,
										    "output_type": "np",
										}
										return inputs




			def        lowerCAmelCase__    ( self							)    ->    str:

										'''simple docstring'''




										snake_case_      =				"cpu"

										snake_case_      =				self.get_dummy_components()

										snake_case_      =				self.pipeline_class(**a__							)
										snake_case_      =				pipe.to(a__							)

										pipe.set_progress_bar_config(disable=a__							)

										snake_case_      =				pipe(**self.get_dummy_inputs(a__							)							)
										snake_case_      =				output.images

										snake_case_      =				pipe(
										    **self.get_dummy_inputs(a__							)    ,							return_dict=a__    ,							)[0]

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

										assert image.shape == (1, 64, 64, 3)

										snake_case_      =				np.array(
										    [0.6_1_4_7_4_9_4_3, 0.6_0_7_3_5_3_9, 0.4_3_3_0_8_5_4_4, 0.5_9_2_8_2_6_9, 0.4_7_4_9_3_5_9_5, 0.4_6_7_5_5_9_7_3, 0.4_6_1_3_8_3_8, 0.4_5_3_6_8_7_9_7, 0.5_0_1_1_9_2_3_3]							)
										assert (
										    np.abs(image_slice.flatten() - expected_slice							).max() < 1e-2
										), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
										assert (
										    np.abs(image_from_tuple_slice.flatten() - expected_slice							).max() < 1e-2
										), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'




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




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




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




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/kandinsky/kandinsky_img2img_frog.npy"							)

										snake_case_      =				load_image(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"							)
										snake_case_      =				"A red cartoon frog, 4k"

										snake_case_      =				KandinskyPriorPipeline.from_pretrained(
										    "kandinsky-community/kandinsky-2-1-prior"    ,							torch_dtype=torch.floataa							)
										pipe_prior.to(a__							)

										snake_case_      =				KandinskyImgaImgPipeline.from_pretrained(
										    "kandinsky-community/kandinsky-2-1"    ,							torch_dtype=torch.floataa							)
										snake_case_      =				pipeline.to(a__							)

										pipeline.set_progress_bar_config(disable=a__							)

										snake_case_      =				torch.Generator(device="cpu"							).manual_seed(0							)
										snake_case_ ,				snake_case_      =				pipe_prior(
										    a__    ,							generator=a__    ,							num_inference_steps=5    ,							negative_prompt=""    ,							).to_tuple()

										snake_case_      =				pipeline(
										    a__    ,							image=a__    ,							image_embeds=a__    ,							negative_image_embeds=a__    ,							generator=a__    ,							num_inference_steps=100    ,							height=768    ,							width=768    ,							strength=0.2    ,							output_type="np"    ,							)

										snake_case_      =				output.images[0]

										assert image.shape == (768, 768, 3)

										assert_mean_pixel_difference(a__    ,							a__							)










'''simple docstring'''





from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
		import tensorflow as tf

		from transformers.models.layoutlm.modeling_tf_layoutlm import (
		    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMForMaskedLM,
		    TFLayoutLMForQuestionAnswering,
		    TFLayoutLMForSequenceClassification,
		    TFLayoutLMForTokenClassification,
		    TFLayoutLMModel,
		)




class 			_snake_case		:




			def __init__( self    ,							a__    ,							a__=13    ,							a__=7    ,							a__=True    ,							a__=True    ,							a__=True    ,							a__=True    ,							a__=99    ,							a__=32    ,							a__=2    ,							a__=4    ,							a__=37    ,							a__="gelu"    ,							a__=0.1    ,							a__=0.1    ,							a__=512    ,							a__=16    ,							a__=2    ,							a__=0.0_2    ,							a__=3    ,							a__=4    ,							a__=None    ,							a__=1_000    ,							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				parent
										snake_case_      =				batch_size
										snake_case_      =				seq_length
										snake_case_      =				is_training
										snake_case_      =				use_input_mask
										snake_case_      =				use_token_type_ids
										snake_case_      =				use_labels
										snake_case_      =				vocab_size
										snake_case_      =				hidden_size
										snake_case_      =				num_hidden_layers
										snake_case_      =				num_attention_heads
										snake_case_      =				intermediate_size
										snake_case_      =				hidden_act
										snake_case_      =				hidden_dropout_prob
										snake_case_      =				attention_probs_dropout_prob
										snake_case_      =				max_position_embeddings
										snake_case_      =				type_vocab_size
										snake_case_      =				type_sequence_label_size
										snake_case_      =				initializer_range
										snake_case_      =				num_labels
										snake_case_      =				num_choices
										snake_case_      =				scope
										snake_case_      =				range_bbox




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

										'''simple docstring'''




										snake_case_      =				ids_tensor([self.batch_size, self.seq_length]    ,							self.vocab_size							)

										# convert bbox to numpy since TF does not support item assignment
										snake_case_      =				ids_tensor([self.batch_size, self.seq_length, 4]    ,							self.range_bbox							).numpy()
										# Ensure that bbox is legal
										for i in range(bbox.shape[0]							):
																	for j in range(bbox.shape[1]							):
																								if bbox[i, j, 3] < bbox[i, j, 1]:
																															snake_case_      =				bbox[i, j, 3]
																															snake_case_      =				bbox[i, j, 1]
																															snake_case_      =				t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															snake_case_      =				bbox[i, j, 2]
																															snake_case_      =				bbox[i, j, 0]
																															snake_case_      =				t
										snake_case_      =				tf.convert_to_tensor(a__							)

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

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

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

										snake_case_      =				LayoutLMConfig(
										    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    ,							)

										return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__							)
										snake_case_      =				model(a__    ,							a__    ,							token_type_ids=a__							)
										snake_case_      =				model(a__    ,							a__							)
										self.parent.assertEqual(result.last_hidden_state.shape    ,							(self.batch_size, self.seq_length, self.hidden_size)							)
										self.parent.assertEqual(result.pooler_output.shape    ,							(self.batch_size, self.hidden_size)							)




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

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForMaskedLM(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.seq_length, self.vocab_size)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForSequenceClassification(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForTokenClassification(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.seq_length, self.num_labels)							)




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

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=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        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										(
										    (
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				
										)      =				config_and_inputs
										snake_case_      =				{
										    "input_ids": input_ids,
										    "bbox": bbox,
										    "token_type_ids": token_type_ids,
										    "attention_mask": input_mask,
										}
										return config, inputs_dict




@require_tf
class 			_snake_case		(     lowercase_						,						lowercase_						,						unittest.TestCase							):
			lowerCAmelCase_					:				Optional[int]							=   (
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCAmelCase_					:				List[Any]							=   (
			    {
			        "feature-extraction": TFLayoutLMModel,
			        "fill-mask": TFLayoutLMForMaskedLM,
			        "text-classification": TFLayoutLMForSequenceClassification,
			        "token-classification": TFLayoutLMForTokenClassification,
			        "zero-shot": TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCAmelCase_					:				Union[str, Any]							=   False
			lowerCAmelCase_					:				int							=   True
			lowerCAmelCase_					:				List[str]							=   10




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=a__    ,							hidden_size=37							)




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

										'''simple docstring'''




										self.config_tester.run_common_tests()




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*a__							)




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

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				TFLayoutLMModel.from_pretrained(a__							)
																	self.assertIsNotNone(a__							)




			@unittest.skip("Onnx compliancy broke with TF 2.10"							)
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										pass


def 					UpperCamelCase_(     ):

							'''simple docstring'''






							snake_case_      =				tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]					)  # noqa: E231
							# these are sequence labels (i.e. at the token level)
							snake_case_      =				tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]					)  # noqa: E231
							# fmt: on

							return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class 			_snake_case		(     unittest.TestCase							):




			@slow
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

										# test the sequence output on [0, :3, :3]
										snake_case_      =				tf.convert_to_tensor(
										    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]    ,							)

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

										# test the pooled output on [1, :3]
										snake_case_      =				tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]							)

										self.assertTrue(np.allclose(outputs.pooler_output[1, :3]    ,							a__    ,							atol=1e-3							)							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=2							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(
										    input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=tf.convert_to_tensor([1, 1]							)    ,							)

										# test whether we get a loss as a scalar
										snake_case_      =				outputs.loss
										snake_case_      =				(2,)
										self.assertEqual(loss.shape    ,							a__							)

										# test the shape of the logits
										snake_case_      =				outputs.logits
										snake_case_      =				(2, 2)
										self.assertEqual(logits.shape    ,							a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=13							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(
										    input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=a__							)

										# test the shape of the logits
										snake_case_      =				outputs.logits
										snake_case_      =				tf.convert_to_tensor((2, 25, 13)							)
										self.assertEqual(logits.shape    ,							a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

										# test the shape of the logits
										snake_case_      =				tf.convert_to_tensor((2, 25)							)
										self.assertEqual(outputs.start_logits.shape    ,							a__							)
										self.assertEqual(outputs.end_logits.shape    ,							a__							)




