


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






			"""simple docstring"""






			def __init__(							self      ,						snake_case      ,						snake_case=13      ,						snake_case=7      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=True      ,						snake_case=99      ,						snake_case=24      ,						snake_case=2      ,						snake_case=6      ,						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=3      ,						snake_case=None      ,						snake_case=1000      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       parent
						UpperCamelCase__					=       batch_size
						UpperCamelCase__					=       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__					=       num_labels
						UpperCamelCase__					=       scope
						UpperCamelCase__					=       range_bbox




			def 				snake_case__				(							self				):

						'''simple docstring'''


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

						UpperCamelCase__					=       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]:
															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__					=       None
						if self.use_input_mask:
									UpperCamelCase__					=       ids_tensor([self.batch_size, self.seq_length]      ,						vocab_size=2				)

						UpperCamelCase__					=       None
						if self.use_token_type_ids:
									UpperCamelCase__					=       ids_tensor([self.batch_size, self.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.seq_length]      ,						self.num_labels				)

						UpperCamelCase__					=       self.get_config()

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




			def 				snake_case__				(							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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModel(config=snake_case				)
						model.to(snake_case				)
						model.eval()
						UpperCamelCase__					=       model(snake_case      ,						bbox=snake_case      ,						attention_mask=snake_case      ,						token_type_ids=snake_case				)
						UpperCamelCase__					=       model(snake_case      ,						bbox=snake_case      ,						token_type_ids=snake_case				)
						UpperCamelCase__					=       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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       self.num_labels
						UpperCamelCase__					=       LiltForTokenClassification(config=snake_case				)
						model.to(snake_case				)
						model.eval()
						UpperCamelCase__					=       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 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						):

						'''simple docstring'''


						UpperCamelCase__					=       LiltForQuestionAnswering(config=snake_case				)
						model.to(snake_case				)
						model.eval()
						UpperCamelCase__					=       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 				snake_case__				(							self				):

						'''simple docstring'''


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







@require_torch
class        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Dict    =		(
			    (
			        LiltModel,
			        LiltForSequenceClassification,
			        LiltForTokenClassification,
			        LiltForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			_UpperCamelCase		:					str    =		(
			    {
			        'feature-extraction': LiltModel,
			        'question-answering': LiltForQuestionAnswering,
			        'text-classification': LiltForSequenceClassification,
			        'token-classification': LiltForTokenClassification,
			        'zero-shot': LiltForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			_UpperCamelCase		:					List[Any]    =		False
			_UpperCamelCase		:					List[str]    =		False




			def 				snake_case__				(							self      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case      ,						snake_case				):

						'''simple docstring'''


						return True




			def 				snake_case__				(							self				):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModelTester(self				)
						UpperCamelCase__					=       ConfigTester(self      ,						config_class=snake_case      ,						hidden_size=37				)




			def 				snake_case__				(							self				):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			def 				snake_case__				(							self				):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case				)




			def 				snake_case__				(							self				):

						'''simple docstring'''


						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(*snake_case				)




			def 				snake_case__				(							self				):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*snake_case				)




			def 				snake_case__				(							self				):

						'''simple docstring'''


						UpperCamelCase__					=       self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*snake_case				)







			@slow
			def 				snake_case__				(							self				):

						'''simple docstring'''


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







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






			"""simple docstring"""






			def 				snake_case__				(							self				):

						'''simple docstring'''


						UpperCamelCase__					=       LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"				).to(snake_case				)

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

						# forward pass
						with torch.no_grad():
									UpperCamelCase__					=       model(input_ids=snake_case      ,						bbox=snake_case				)

						UpperCamelCase__					=       torch.Size([1, 2, 768]				)
						UpperCamelCase__					=       torch.tensor(
						    [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]      ,						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				)				)






def        UpperCamelCase_(				_A   :str  )->		int:
			UpperCamelCase__					=       hex_num.strip()
			if not hex_num:
						raise ValueError("No value was passed to the function"  )

			UpperCamelCase__					=       hex_num[0] == "-"
			if is_negative:
						UpperCamelCase__					=       hex_num[1:]

			try:
						UpperCamelCase__					=       int(_A				,     16  )
			except ValueError:
						raise ValueError("Invalid value was passed to the function"  )

			UpperCamelCase__					=       ""
			while int_num > 0:
						UpperCamelCase__					=       str(int_num % 2  ) + bin_str
						int_num >>= 1

			return int(("-" + bin_str) if is_negative else bin_str  )


if __name__ == "__main__":
						import doctest

						doctest.testmod()


