





import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    LiltForQuestionAnswering,
						    LiltForSequenceClassification,
						    LiltForTokenClassification,
						    LiltModel,
						)
						from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST







class    __snake_case	:





							'''simple docstring'''







							def __init__(  self			:   str							,    A			:   List[Any]							,    A			:   str=13							,    A			:   List[str]=7							,    A			:   Dict=True							,    A			:   Dict=True							,    A			:   Dict=True							,    A			:   List[str]=True							,    A			:   Union[str, Any]=99							,    A			:   int=24							,    A			:   Any=2							,    A			:   int=6							,    A			:   List[str]=37							,    A			:   Any="gelu"							,    A			:   str=0.1							,    A			:   Dict=0.1							,    A			:   Dict=512							,    A			:   Dict=16							,    A			:   Optional[int]=2							,    A			:   List[Any]=0.02							,    A			:   Optional[int]=3							,    A			:   Tuple=None							,    A			:   List[str]=1_000							,    ):
									__snake_case:						Optional[Any]			  =						parent
									__snake_case:						int			  =						batch_size
									__snake_case:						Optional[int]			  =						seq_length
									__snake_case:						Tuple			  =						is_training
									__snake_case:						str			  =						use_input_mask
									__snake_case:						List[Any]			  =						use_token_type_ids
									__snake_case:						Dict			  =						use_labels
									__snake_case:						Optional[int]			  =						vocab_size
									__snake_case:						Union[str, Any]			  =						hidden_size
									__snake_case:						int			  =						num_hidden_layers
									__snake_case:						Any			  =						num_attention_heads
									__snake_case:						Dict			  =						intermediate_size
									__snake_case:						Union[str, Any]			  =						hidden_act
									__snake_case:						Any			  =						hidden_dropout_prob
									__snake_case:						Dict			  =						attention_probs_dropout_prob
									__snake_case:						List[Any]			  =						max_position_embeddings
									__snake_case:						Optional[Any]			  =						type_vocab_size
									__snake_case:						Any			  =						type_sequence_label_size
									__snake_case:						List[Any]			  =						initializer_range
									__snake_case:						str			  =						num_labels
									__snake_case:						Any			  =						scope
									__snake_case:						str			  =						range_bbox




							def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
									__snake_case:						int			  =						ids_tensor([self.batch_size, self.seq_length]							,    self.vocab_size		)

									__snake_case:						int			  =						ids_tensor([self.batch_size, self.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]:
															__snake_case:						Any			  =						bbox[i, j, 3]
															__snake_case:						Dict			  =						bbox[i, j, 1]
															__snake_case:						Union[str, Any]			  =						t
													if bbox[i, j, 2] < bbox[i, j, 0]:
															__snake_case:						Optional[Any]			  =						bbox[i, j, 2]
															__snake_case:						Dict			  =						bbox[i, j, 0]
															__snake_case:						str			  =						t

									__snake_case:						Optional[int]			  =						None
									if self.use_input_mask:
											__snake_case:						Tuple			  =						ids_tensor([self.batch_size, self.seq_length]							,    vocab_size=2		)

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

									__snake_case:						Dict			  =						None
									__snake_case:						Optional[int]			  =						None
									if self.use_labels:
											__snake_case:						Any			  =						ids_tensor([self.batch_size]							,    self.type_sequence_label_size		)
											__snake_case:						List[str]			  =						ids_tensor([self.batch_size, self.seq_length]							,    self.num_labels		)

									__snake_case:						int			  =						self.get_config()

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




							def 							UpperCAmelCase__			(  self			:   Tuple		):
									return LiltConfig(
									    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							,    )




							def 							UpperCAmelCase__			(  self			:   int							,    A			:   Dict							,    A			:   Dict							,    A			:   List[Any]							,    A			:   Optional[Any]							,    A			:   Optional[Any]							,    A			:   List[Any]							,    A			:   List[Any]							,    ):
									__snake_case:						Optional[int]			  =						LiltModel(config=A		)
									model.to(A		)
									model.eval()
									__snake_case:						int			  =						model(A							,    bbox=A							,    attention_mask=A							,    token_type_ids=A		)
									__snake_case:						List[str]			  =						model(A							,    bbox=A							,    token_type_ids=A		)
									__snake_case:						Dict			  =						model(A							,    bbox=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 							UpperCAmelCase__			(  self			:   int							,    A			:   Optional[Any]							,    A			:   str							,    A			:   List[Any]							,    A			:   Optional[int]							,    A			:   int							,    A			:   str							,    A			:   Any							,    ):
									__snake_case:						Union[str, Any]			  =						self.num_labels
									__snake_case:						int			  =						LiltForTokenClassification(config=A		)
									model.to(A		)
									model.eval()
									__snake_case:						Optional[Any]			  =						model(
									    A							,    bbox=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 							UpperCAmelCase__			(  self			:   Union[str, Any]							,    A			:   Dict							,    A			:   Tuple							,    A			:   int							,    A			:   int							,    A			:   Optional[int]							,    A			:   str							,    A			:   str							,    ):
									__snake_case:						Optional[int]			  =						LiltForQuestionAnswering(config=A		)
									model.to(A		)
									model.eval()
									__snake_case:						Dict			  =						model(
									    A							,    bbox=A							,    attention_mask=A							,    token_type_ids=A							,    start_positions=A							,    end_positions=A							,    )
									self.parent.assertEqual(result.start_logits.shape							,    (self.batch_size, self.seq_length)		)
									self.parent.assertEqual(result.end_logits.shape							,    (self.batch_size, self.seq_length)		)






							def 							UpperCAmelCase__			(  self			:   List[Any]		):
									__snake_case:						Union[str, Any]			  =						self.prepare_config_and_inputs()
									(
									    __snake_case       
									):						str			  =						config_and_inputs
									__snake_case:						Optional[int]			  =						{
									    """input_ids""": input_ids,
									    """bbox""": bbox,
									    """token_type_ids""": token_type_ids,
									    """attention_mask""": input_mask,
									}
									return config, inputs_dict







@require_torch
class    __snake_case	(							__lowerCamelCase       ,      __lowerCamelCase       ,      __lowerCamelCase       ,      unittest.TestCase      ):





							'''simple docstring'''







							lowerCAmelCase__						=					(
							    (
							        LiltModel,
							        LiltForSequenceClassification,
							        LiltForTokenClassification,
							        LiltForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCAmelCase__						=					(
							    {
							        """feature-extraction""": LiltModel,
							        """question-answering""": LiltForQuestionAnswering,
							        """text-classification""": LiltForSequenceClassification,
							        """token-classification""": LiltForTokenClassification,
							        """zero-shot""": LiltForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							lowerCAmelCase__						=					False
							lowerCAmelCase__						=					False




							def 							UpperCAmelCase__			(  self			:   Dict							,    A			:   Any							,    A			:   str							,    A			:   Any							,    A			:   Optional[int]							,    A			:   Optional[Any]		):
									return True




							def 							UpperCAmelCase__			(  self			:   Dict		):
									__snake_case:						List[str]			  =						LiltModelTester(self		)
									__snake_case:						str			  =						ConfigTester(self							,    config_class=A							,    hidden_size=37		)




							def 							UpperCAmelCase__			(  self			:   str		):
									self.config_tester.run_common_tests()




							def 							UpperCAmelCase__			(  self			:   List[str]		):
									__snake_case:						Optional[Any]			  =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*A		)




							def 							UpperCAmelCase__			(  self			:   Tuple		):
									__snake_case:						str			  =						self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
											__snake_case:						Tuple			  =						type
											self.model_tester.create_and_check_model(*A		)




							def 							UpperCAmelCase__			(  self			:   List[str]		):
									__snake_case:						List[Any]			  =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*A		)




							def 							UpperCAmelCase__			(  self			:   Optional[int]		):
									__snake_case:						Any			  =						self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*A		)






							@slow
							def 							UpperCAmelCase__			(  self			:   List[Any]		):
									for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__snake_case:						Optional[int]			  =						LiltModel.from_pretrained(A		)
											self.assertIsNotNone(A		)







@require_torch
@slow
class    __snake_case	(							unittest.TestCase      ):





							'''simple docstring'''







							def 							UpperCAmelCase__			(  self			:   Optional[int]		):
									__snake_case:						Tuple			  =						LiltModel.from_pretrained("""SCUT-DLVCLab/lilt-roberta-en-base"""		).to(A		)

									__snake_case:						int			  =						torch.tensor([[1, 2]]							,    device=A		)
									__snake_case:						Optional[int]			  =						torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]							,    device=A		)

									# forward pass
									with torch.no_grad():
											__snake_case:						Union[str, Any]			  =						model(input_ids=A							,    bbox=A		)

									__snake_case:						Optional[int]			  =						torch.Size([1, 2, 768]		)
									__snake_case:						Optional[int]			  =						torch.tensor(
									    [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]							,    device=A							,    )

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













import warnings

from diffusers import StableDiffusionImgaImgPipeline  # noqa F401


warnings.warn(
    "The `image_to_image.py` script is outdated. Please use directly `from diffusers import"
    " StableDiffusionImg2ImgPipeline` instead."
)






