



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

						'''simple docstring'''




						def __init__(    self      ,							_A      ,							_A=13      ,							_A=7      ,							_A=True      ,							_A=True      ,							_A=True      ,							_A=True      ,							_A=99      ,							_A=24      ,							_A=2      ,							_A=6      ,							_A=37      ,							_A="gelu"      ,							_A=0.1      ,							_A=0.1      ,							_A=512      ,							_A=16      ,							_A=2      ,							_A=0.0_2      ,							_A=3      ,							_A=None      ,							_A=1_000      ,							):







													'''simple docstring'''

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






						def        _A	(    self		):







													'''simple docstring'''

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

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

													__SCREAMING_SNAKE_CASE									=					None
													if self.use_input_mask:
																				__SCREAMING_SNAKE_CASE									=					ids_tensor([self.batch_size, self.seq_length]      ,							vocab_size=2		)

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

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

													__SCREAMING_SNAKE_CASE									=					self.get_config()

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






						def        _A	(    self		):







													'''simple docstring'''

													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        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					LiltModel(config=snake_case__		)
													model.to(snake_case__		)
													model.eval()
													__SCREAMING_SNAKE_CASE									=					model(snake_case__      ,							bbox=snake_case__      ,							attention_mask=snake_case__      ,							token_type_ids=snake_case__		)
													__SCREAMING_SNAKE_CASE									=					model(snake_case__      ,							bbox=snake_case__      ,							token_type_ids=snake_case__		)
													__SCREAMING_SNAKE_CASE									=					model(snake_case__      ,							bbox=snake_case__		)

													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        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.num_labels
													__SCREAMING_SNAKE_CASE									=					LiltForTokenClassification(config=snake_case__		)
													model.to(snake_case__		)
													model.eval()
													__SCREAMING_SNAKE_CASE									=					model(
													    snake_case__      ,							bbox=snake_case__      ,							attention_mask=snake_case__      ,							token_type_ids=snake_case__      ,							labels=snake_case__		)
													self.parent.assertEqual(result.logits.shape      ,							(self.batch_size, self.seq_length, self.num_labels)		)






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A      ,							):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					LiltForQuestionAnswering(config=snake_case__		)
													model.to(snake_case__		)
													model.eval()
													__SCREAMING_SNAKE_CASE									=					model(
													    snake_case__      ,							bbox=snake_case__      ,							attention_mask=snake_case__      ,							token_type_ids=snake_case__      ,							start_positions=snake_case__      ,							end_positions=snake_case__      ,							)
													self.parent.assertEqual(result.start_logits.shape      ,							(self.batch_size, self.seq_length)		)
													self.parent.assertEqual(result.end_logits.shape      ,							(self.batch_size, self.seq_length)		)






						def        _A	(    self		):







													'''simple docstring'''

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







@require_torch
class    UpperCAmelCase_  (   UpperCamelCase_    ,    UpperCamelCase_    ,    UpperCamelCase_    ,    unittest.TestCase       ):

						'''simple docstring'''




						UpperCamelCase__			: int				  =  (
						    (
						        LiltModel,
						        LiltForSequenceClassification,
						        LiltForTokenClassification,
						        LiltForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase__			: Union[str, Any]				  =  (
						    {
						        "feature-extraction": LiltModel,
						        "question-answering": LiltForQuestionAnswering,
						        "text-classification": LiltForSequenceClassification,
						        "token-classification": LiltForTokenClassification,
						        "zero-shot": LiltForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						UpperCamelCase__			: Any				  =  False
						UpperCamelCase__			: Any				  =  False






						def        _A	(    self      ,							_A      ,							_A      ,							_A      ,							_A      ,							_A		):







													'''simple docstring'''

													return True






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					LiltModelTester(self		)
													__SCREAMING_SNAKE_CASE									=					ConfigTester(self      ,							config_class=snake_case__      ,							hidden_size=37		)






						def        _A	(    self		):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*snake_case__		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													for type in ["absolute", "relative_key", "relative_key_query"]:
																				__SCREAMING_SNAKE_CASE									=					type
																				self.model_tester.create_and_check_model(*snake_case__		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*snake_case__		)






						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*snake_case__		)






						@slow
						def        _A	(    self		):







													'''simple docstring'''

													for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE									=					LiltModel.from_pretrained(snake_case__		)
																				self.assertIsNotNone(snake_case__		)







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

						'''simple docstring'''




						def        _A	(    self		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									=					LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base'		).to(snake_case__		)

													__SCREAMING_SNAKE_CASE									=					torch.tensor([[1, 2]]      ,							device=snake_case__		)
													__SCREAMING_SNAKE_CASE									=					torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]      ,							device=snake_case__		)

													# forward pass
													with torch.no_grad():
																				__SCREAMING_SNAKE_CASE									=					model(input_ids=snake_case__      ,							bbox=snake_case__		)

													__SCREAMING_SNAKE_CASE									=					torch.Size([1, 2, 768]		)
													__SCREAMING_SNAKE_CASE									=					torch.tensor(
													    [[-0.0_6_5_3, 0.0_9_5_0, -0.0_0_6_1], [-0.0_5_4_5, 0.0_9_2_6, -0.0_3_2_4]]      ,							device=snake_case__      ,							)

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










"""simple docstring"""







import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation


class       SCREAMING_SNAKE_CASE__				(		unittest.TestCase				):
       """simple docstring"""


       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     int								=							get_activation("swish"						)

         self.assertIsInstance(snake_case__		,     nn.SiLU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							get_activation("silu"						)

         self.assertIsInstance(snake_case__		,     nn.SiLU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)

       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Dict								=							get_activation("mish"						)

         self.assertIsInstance(snake_case__		,     nn.Mish						)

         self.assertEqual(act(torch.tensor(-200		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)







       def        lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase     :     Union[str, Any]								=							get_activation("gelu"						)

         self.assertIsInstance(snake_case__		,     nn.GELU						)

         self.assertEqual(act(torch.tensor(-100		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertNotEqual(act(torch.tensor(-1		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(0		,     dtype=torch.floataa						)						).item()		,     0						)
         self.assertEqual(act(torch.tensor(20		,     dtype=torch.floataa						)						).item()		,     20						)





