





"""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 						__snake_case   :





 """simple docstring"""


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



     '''simple docstring'''




     __A       :		Union[str, Any]							=	parent
     __A       :		List[Any]							=	batch_size
     __A       :		int							=	seq_length
     __A       :		Optional[int]							=	is_training
     __A       :		Dict							=	use_input_mask
     __A       :		Dict							=	use_token_type_ids
     __A       :		str							=	use_labels
     __A       :		str							=	vocab_size
     __A       :		Dict							=	hidden_size
     __A       :		str							=	num_hidden_layers
     __A       :		Optional[int]							=	num_attention_heads
     __A       :		Any							=	intermediate_size
     __A       :		str							=	hidden_act
     __A       :		Union[str, Any]							=	hidden_dropout_prob
     __A       :		Any							=	attention_probs_dropout_prob
     __A       :		Optional[int]							=	max_position_embeddings
     __A       :		Tuple							=	type_vocab_size
     __A       :		List[Any]							=	type_sequence_label_size
     __A       :		List[Any]							=	initializer_range
     __A       :		Optional[int]							=	num_labels
     __A       :		List[str]							=	scope
     __A       :		Union[str, Any]							=	range_bbox

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Union[str, Any]							=	ids_tensor([self.batch_size, self.seq_length]   ,		self.vocab_size    )

     __A       :		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]:
                 __A       :		Dict							=	bbox[i, j, 3]
                 __A       :		Any							=	bbox[i, j, 1]
                 __A       :		int							=	t
             if bbox[i, j, 2] < bbox[i, j, 0]:
                 __A       :		Optional[int]							=	bbox[i, j, 2]
                 __A       :		Tuple							=	bbox[i, j, 0]
                 __A       :		Optional[int]							=	t

     __A       :		int							=	None
     if self.use_input_mask:
         __A       :		List[str]							=	ids_tensor([self.batch_size, self.seq_length]   ,		vocab_size=2    )

     __A       :		Tuple							=	None
     if self.use_token_type_ids:
         __A       :		List[Any]							=	ids_tensor([self.batch_size, self.seq_length]   ,		self.type_vocab_size    )

     __A       :		List[str]							=	None
     __A       :		Union[str, Any]							=	None
     if self.use_labels:
         __A       :		Tuple							=	ids_tensor([self.batch_size]   ,		self.type_sequence_label_size    )
         __A       :		Any							=	ids_tensor([self.batch_size, self.seq_length]   ,		self.num_labels    )

     __A       :		Optional[Any]							=	self.get_config()

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

 def    UpperCamelCase__(       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    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		):



     '''simple docstring'''




     __A       :		Optional[int]							=	LiltModel(config=__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		int							=	model(__lowerCamelCase   ,		bbox=__lowerCamelCase   ,		attention_mask=__lowerCamelCase   ,		token_type_ids=__lowerCamelCase    )
     __A       :		Optional[int]							=	model(__lowerCamelCase   ,		bbox=__lowerCamelCase   ,		token_type_ids=__lowerCamelCase    )
     __A       :		Dict							=	model(__lowerCamelCase   ,		bbox=__lowerCamelCase    )

     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   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		):



     '''simple docstring'''




     __A       :		str							=	self.num_labels
     __A       :		Optional[int]							=	LiltForTokenClassification(config=__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		Tuple							=	model(
         __lowerCamelCase   ,		bbox=__lowerCamelCase   ,		attention_mask=__lowerCamelCase   ,		token_type_ids=__lowerCamelCase   ,		labels=__lowerCamelCase    )
     self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.seq_length, self.num_labels)    )

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		):



     '''simple docstring'''




     __A       :		Tuple							=	LiltForQuestionAnswering(config=__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		Dict							=	model(
         __lowerCamelCase   ,		bbox=__lowerCamelCase   ,		attention_mask=__lowerCamelCase   ,		token_type_ids=__lowerCamelCase   ,		start_positions=__lowerCamelCase   ,		end_positions=__lowerCamelCase   ,		)
     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    ):



     '''simple docstring'''




     __A       :		int							=	self.prepare_config_and_inputs()
     (
         (
         __A
     )					,			(
         __A
     )					,			(
         __A
     )					,			(
         __A
     )					,			(
         __A
     )					,			(
         __A
     )					,			(
         __A
     )					,			
     )       :		Any							=	config_and_inputs
     __A       :		Tuple							=	{
         '''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   (						SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				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   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     return True

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Dict							=	LiltModelTester(self    )
     __A       :		Tuple							=	ConfigTester(self   ,		config_class=__lowerCamelCase   ,		hidden_size=37    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     self.config_tester.run_common_tests()

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		int							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Dict							=	self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
         __A       :		Union[str, Any]							=	type
         self.model_tester.create_and_check_model(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		str							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase    )







 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __A       :		Any							=	LiltModel.from_pretrained(__lowerCamelCase    )
         self.assertIsNotNone(__lowerCamelCase    )






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





 """simple docstring"""


 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		List[str]							=	LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base'''    ).to(__lowerCamelCase    )

     __A       :		int							=	torch.tensor([[1, 2]]   ,		device=__lowerCamelCase    )
     __A       :		str							=	torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]   ,		device=__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		Any							=	model(input_ids=__lowerCamelCase   ,		bbox=__lowerCamelCase    )

     __A       :		Any							=	torch.Size([1, 2, 768]    )
     __A       :		Tuple							=	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=__lowerCamelCase   ,		)

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











"""simple docstring"""



from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a_					=     logging.get_logger(__name__)

a_					=     {
    """sail/poolformer_s12""": """https://huggingface.co/sail/poolformer_s12/resolve/main/config.json""",
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
}






class 						__snake_case   (						SCREAMING_SNAKE_CASE__	):





 """simple docstring"""


 _lowerCamelCase								=	"""poolformer"""

 def __init__(       self   ,		__lowerCamelCase=3   ,		__lowerCamelCase=16   ,		__lowerCamelCase=16   ,		__lowerCamelCase=3   ,		__lowerCamelCase=4.0   ,		__lowerCamelCase=[2, 2, 6, 2]   ,		__lowerCamelCase=[64, 128, 320, 512]   ,		__lowerCamelCase=[7, 3, 3, 3]   ,		__lowerCamelCase=[4, 2, 2, 2]   ,		__lowerCamelCase=[2, 1, 1, 1]   ,		__lowerCamelCase=4   ,		__lowerCamelCase=0.0   ,		__lowerCamelCase="gelu"   ,		__lowerCamelCase=True   ,		__lowerCamelCase=1e-5   ,		__lowerCamelCase=0.0_2   ,		**__lowerCamelCase   ,		):



     '''simple docstring'''




     __A       :		str							=	num_channels
     __A       :		List[str]							=	patch_size
     __A       :		str							=	stride
     __A       :		Any							=	padding
     __A       :		Any							=	pool_size
     __A       :		Dict							=	hidden_sizes
     __A       :		Optional[Any]							=	mlp_ratio
     __A       :		Any							=	depths
     __A       :		List[str]							=	patch_sizes
     __A       :		Union[str, Any]							=	strides
     __A       :		List[str]							=	num_encoder_blocks
     __A       :		Optional[int]							=	drop_path_rate
     __A       :		Union[str, Any]							=	hidden_act
     __A       :		Optional[Any]							=	use_layer_scale
     __A       :		List[Any]							=	layer_scale_init_value
     __A       :		List[Any]							=	initializer_range
     super().__init__(**__lowerCamelCase    )






class 						__snake_case   (						SCREAMING_SNAKE_CASE__	):





 """simple docstring"""


 _lowerCamelCase								=	version.parse("""1.11"""	)

 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return OrderedDict(
         [
             ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
         ]    )







 @property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return 2e-3




