



"""simple docstring"""







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



		def __init__( self  :    List[str]      ,							snake_case  :    Optional[int]      ,							snake_case  :    Union[str, Any]=13      ,							snake_case  :    List[Any]=7      ,							snake_case  :    int=True      ,							snake_case  :    Optional[int]=True      ,							snake_case  :    int=True      ,							snake_case  :    List[Any]=True      ,							snake_case  :    List[Any]=99      ,							snake_case  :    Union[str, Any]=24      ,							snake_case  :    Any=2      ,							snake_case  :    str=6      ,							snake_case  :    Optional[Any]=37      ,							snake_case  :    str="gelu"      ,							snake_case  :    Dict=0.1      ,							snake_case  :    int=0.1      ,							snake_case  :    int=512      ,							snake_case  :    Dict=16      ,							snake_case  :    List[Any]=2      ,							snake_case  :    Dict=0.02      ,							snake_case  :    Union[str, Any]=3      ,							snake_case  :    str=None      ,							snake_case  :    str=1_000      ,							)			->						List[str]:






									'''simple docstring'''

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



		def 					A_		( self  :    List[Any]				)			->						Tuple:






									'''simple docstring'''

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

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

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

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

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

									A         =					self.get_config()

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



		def 					A_		( self  :    Union[str, Any]				)			->						Optional[int]:






									'''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  :    List[Any]      ,							snake_case  :    Dict      ,							snake_case  :    List[Any]      ,							snake_case  :    int      ,							snake_case  :    Tuple      ,							snake_case  :    str      ,							snake_case  :    str      ,							snake_case  :    Dict      ,							)			->						int:






									'''simple docstring'''

									A         =					LiltModel(config=UpperCamelCase__				)
									model.to(UpperCamelCase__				)
									model.eval()
									A         =					model(UpperCamelCase__      ,							bbox=UpperCamelCase__      ,							attention_mask=UpperCamelCase__      ,							token_type_ids=UpperCamelCase__				)
									A         =					model(UpperCamelCase__      ,							bbox=UpperCamelCase__      ,							token_type_ids=UpperCamelCase__				)
									A         =					model(UpperCamelCase__      ,							bbox=UpperCamelCase__				)

									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  :    Any      ,							snake_case  :    List[Any]      ,							snake_case  :    int      ,							snake_case  :    List[str]      ,							snake_case  :    List[Any]      ,							snake_case  :    str      ,							snake_case  :    Optional[Any]      ,							snake_case  :    Any      ,							)			->						str:






									'''simple docstring'''

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



		def 					A_		( self  :    Optional[Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    Tuple      ,							snake_case  :    List[str]      ,							snake_case  :    Optional[int]      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    str      ,							snake_case  :    Dict      ,							)			->						int:






									'''simple docstring'''

									A         =					LiltForQuestionAnswering(config=UpperCamelCase__				)
									model.to(UpperCamelCase__				)
									model.eval()
									A         =					model(
									    UpperCamelCase__      ,							bbox=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 					A_		( self  :    str				)			->						List[Any]:






									'''simple docstring'''

									A         =					self.prepare_config_and_inputs()
									(
									    A						
									)         =					config_and_inputs
									A         =					{
									    '''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     ):
		lowerCAmelCase_       :	List[str] 							=     (
		    (
		        LiltModel,
		        LiltForSequenceClassification,
		        LiltForTokenClassification,
		        LiltForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		lowerCAmelCase_       :	Union[str, Any] 							=     (
		    {
		        """feature-extraction""": LiltModel,
		        """question-answering""": LiltForQuestionAnswering,
		        """text-classification""": LiltForSequenceClassification,
		        """token-classification""": LiltForTokenClassification,
		        """zero-shot""": LiltForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		lowerCAmelCase_       :	Union[str, Any] 							=     False
		lowerCAmelCase_       :	Tuple 							=     False



		def 					A_		( self  :    List[Any]      ,							snake_case  :    List[Any]      ,							snake_case  :    Optional[int]      ,							snake_case  :    str      ,							snake_case  :    List[str]      ,							snake_case  :    List[str]				)			->						int:






									'''simple docstring'''

									return True



		def 					A_		( self  :    List[str]				)			->						Optional[int]:






									'''simple docstring'''

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



		def 					A_		( self  :    Any				)			->						Tuple:






									'''simple docstring'''

									self.config_tester.run_common_tests()



		def 					A_		( self  :    Dict				)			->						Optional[Any]:






									'''simple docstring'''

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



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






									'''simple docstring'''

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



		def 					A_		( self  :    Dict				)			->						int:






									'''simple docstring'''

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



		def 					A_		( self  :    Dict				)			->						str:






									'''simple docstring'''

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



		@slow
		def 					A_		( self  :    str				)			->						Tuple:






									'''simple docstring'''

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






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



		def 					A_		( self  :    str				)			->						str:






									'''simple docstring'''

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

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

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

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

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








"""simple docstring"""







def   lowerCAmelCase__			(     lowerCamelCase__			) ->							int:

							if not isinstance(lowerCamelCase__				,      lowerCamelCase__			):
														raise ValueError('multiplicative_persistence() only accepts integral values'			)
							if num < 0:
														raise ValueError('multiplicative_persistence() does not accept negative values'			)

							A         =					0
							A         =					str(lowerCamelCase__			)

							while len(lowerCamelCase__			) != 1:
														A         =					[int(lowerCamelCase__			) for i in num_string]

														A         =					1
														for i in range(0				,      len(lowerCamelCase__			)			):
																					total *= numbers[i]

														A         =					str(lowerCamelCase__			)

														steps += 1
							return steps

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							int:

							if not isinstance(lowerCamelCase__				,      lowerCamelCase__			):
														raise ValueError('additive_persistence() only accepts integral values'			)
							if num < 0:
														raise ValueError('additive_persistence() does not accept negative values'			)

							A         =					0
							A         =					str(lowerCamelCase__			)

							while len(lowerCamelCase__			) != 1:
														A         =					[int(lowerCamelCase__			) for i in num_string]

														A         =					0
														for i in range(0				,      len(lowerCamelCase__			)			):
																					total += numbers[i]

														A         =					str(lowerCamelCase__			)

														steps += 1
							return steps


if __name__ == "__main__":
							import doctest

							doctest.testmod()



