




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 :







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




									"""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 UpperCamelCase			(       self    :			int      ):




									"""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 UpperCamelCase			(       self    :			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 UpperCamelCase			(       self    :			int    ,    snake_case__    :			Any    ,    snake_case__    :			str    ,    snake_case__    :			Union[str, Any]    ,    snake_case__    :			Any    ,    snake_case__    :			Tuple    ,    snake_case__    :			List[Any]    ,    snake_case__    :			Dict    ,    ):




									"""simple docstring"""


									_UpperCAmelCase													=     LiltModel(config=_a      )
									model.to(_a      )
									model.eval()
									_UpperCAmelCase													=     model(_a    ,    bbox=_a    ,    attention_mask=_a    ,    token_type_ids=_a      )
									_UpperCAmelCase													=     model(_a    ,    bbox=_a    ,    token_type_ids=_a      )
									_UpperCAmelCase													=     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    :			Optional[int]    ,    snake_case__    :			Tuple    ,    snake_case__    :			List[str]    ,    snake_case__    :			Optional[Any]    ,    snake_case__    :			Any    ,    snake_case__    :			Tuple    ,    snake_case__    :			Any    ,    snake_case__    :			Optional[int]    ,    ):




									"""simple docstring"""


									_UpperCAmelCase													=     self.num_labels
									_UpperCAmelCase													=     LiltForTokenClassification(config=_a      )
									model.to(_a      )
									model.eval()
									_UpperCAmelCase													=     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    :			Tuple    ,    snake_case__    :			str    ,    snake_case__    :			List[str]    ,    snake_case__    :			Optional[Any]    ,    snake_case__    :			Union[str, Any]    ,    snake_case__    :			Dict    ,    snake_case__    :			List[Any]    ,    snake_case__    :			str    ,    ):




									"""simple docstring"""


									_UpperCAmelCase													=     LiltForQuestionAnswering(config=_a      )
									model.to(_a      )
									model.eval()
									_UpperCAmelCase													=     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    :			Dict      ):




									"""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 (       A__					,		A__					,		A__					,		unittest.TestCase ):
			snake_case_      : Dict      =     (
			    (
			        LiltModel,
			        LiltForSequenceClassification,
			        LiltForTokenClassification,
			        LiltForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			snake_case_      : Optional[Any]      =     (
			    {
			        "feature-extraction": LiltModel,
			        "question-answering": LiltForQuestionAnswering,
			        "text-classification": LiltForSequenceClassification,
			        "token-classification": LiltForTokenClassification,
			        "zero-shot": LiltForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			snake_case_      : Tuple      =     False
			snake_case_      : int      =     False







			def UpperCamelCase			(       self    :			Tuple    ,    snake_case__    :			Union[str, Any]    ,    snake_case__    :			int    ,    snake_case__    :			List[Any]    ,    snake_case__    :			Optional[int]    ,    snake_case__    :			int      ):




									"""simple docstring"""


									return True







			def UpperCamelCase			(       self    :			List[str]      ):




									"""simple docstring"""


									_UpperCAmelCase													=     LiltModelTester(self      )
									_UpperCAmelCase													=     ConfigTester(self    ,    config_class=_a    ,    hidden_size=37      )







			def UpperCamelCase			(       self    :			Dict      ):




									"""simple docstring"""


									self.config_tester.run_common_tests()







			def UpperCamelCase			(       self    :			Union[str, Any]      ):




									"""simple docstring"""


									_UpperCAmelCase													=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_a      )







			def UpperCamelCase			(       self    :			Optional[int]      ):




									"""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(*_a      )







			def UpperCamelCase			(       self    :			int      ):




									"""simple docstring"""


									_UpperCAmelCase													=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_a      )







			def UpperCamelCase			(       self    :			List[Any]      ):




									"""simple docstring"""


									_UpperCAmelCase													=     self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_a      )







			@slow
			def UpperCamelCase			(       self    :			Optional[int]      ):




									"""simple docstring"""


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






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







			def UpperCamelCase			(       self    :			Dict      ):




									"""simple docstring"""


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

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

									# forward pass
									with torch.no_grad():
															_UpperCAmelCase													=     model(input_ids=_a    ,    bbox=_a      )

									_UpperCAmelCase													=     torch.Size([1, 2, 768]      )
									_UpperCAmelCase													=     torch.tensor(
									    [[-0.0_653, 0.0_950, -0.0_061], [-0.0_545, 0.0_926, -0.0_324]]    ,    device=_a    ,    )

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







'''simple docstring'''
from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin







class 							A__    (       A__     ,   A__  ):





  @register_to_config
  def __init__(		self      :	Dict							,					_a      :	int = 768							,					)	->    Union[str, Any]:





       '''simple docstring'''






       super().__init__()

       _SCREAMING_SNAKE_CASE							    =nn.Parameter(torch.zeros(1							,					_a ) )
       _SCREAMING_SNAKE_CASE							    =nn.Parameter(torch.ones(1							,					_a ) )





  def 						A  (		self      :	Tuple							,					_a      :	Optional[Union[str, torch.device]] = None							,					_a      :	Optional[torch.dtype] = None							,					)	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =nn.Parameter(self.mean.to(_a ).to(_a ) )
       _SCREAMING_SNAKE_CASE							    =nn.Parameter(self.std.to(_a ).to(_a ) )
       return self





  def 						A  (		self      :	Tuple							,					_a      :	str )	->    str:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =(embeds - self.mean) * 1.0 / self.std
       return embeds





  def 						A  (		self      :	List[str]							,					_a      :	Optional[Any] )	->    Tuple:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =(embeds * self.std) + self.mean
       return embeds
