


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

 """simple docstring"""





 def __init__(				self    :       Optional[int]    ,    UpperCAmelCase__    :       Optional[int]    ,    UpperCAmelCase__    :       List[Any]=1_3    ,    UpperCAmelCase__    :       Optional[int]=7    ,    UpperCAmelCase__    :       List[str]=True    ,    UpperCAmelCase__    :       int=True    ,    UpperCAmelCase__    :       List[Any]=True    ,    UpperCAmelCase__    :       Optional[int]=True    ,    UpperCAmelCase__    :       List[str]=9_9    ,    UpperCAmelCase__    :       Dict=2_4    ,    UpperCAmelCase__    :       List[str]=2    ,    UpperCAmelCase__    :       Optional[Any]=6    ,    UpperCAmelCase__    :       int=3_7    ,    UpperCAmelCase__    :       Optional[Any]="gelu"    ,    UpperCAmelCase__    :       Optional[Any]=0.1    ,    UpperCAmelCase__    :       List[Any]=0.1    ,    UpperCAmelCase__    :       Any=5_1_2    ,    UpperCAmelCase__    :       str=1_6    ,    UpperCAmelCase__    :       List[str]=2    ,    UpperCAmelCase__    :       Optional[int]=0.02    ,    UpperCAmelCase__    :       Tuple=3    ,    UpperCAmelCase__    :       Union[str, Any]=None    ,    UpperCAmelCase__    :       Any=1_0_0_0    ,    ) ->			Tuple:
      __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 						UpperCAmelCase_   (				self    :       Tuple     ) ->			int:
      __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 						UpperCAmelCase_   (				self    :       int     ) ->			Optional[int]:
      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    :       Any    ,    UpperCAmelCase__    :       Union[str, Any]    ,    UpperCAmelCase__    :       Any    ,    UpperCAmelCase__    :       Dict    ,    UpperCAmelCase__    :       int    ,    UpperCAmelCase__    :       Union[str, Any]    ,    UpperCAmelCase__    :       Optional[Any]    ,    UpperCAmelCase__    :       Optional[int]    ,    ) ->			str:
      __SCREAMING_SNAKE_CASE		     =       LiltModel(config=UpperCAmelCase_     )
      model.to(UpperCAmelCase_     )
      model.eval()
      __SCREAMING_SNAKE_CASE		     =       model(UpperCAmelCase_    ,    bbox=UpperCAmelCase_    ,    attention_mask=UpperCAmelCase_    ,    token_type_ids=UpperCAmelCase_     )
      __SCREAMING_SNAKE_CASE		     =       model(UpperCAmelCase_    ,    bbox=UpperCAmelCase_    ,    token_type_ids=UpperCAmelCase_     )
      __SCREAMING_SNAKE_CASE		     =       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 						UpperCAmelCase_   (				self    :       int    ,    UpperCAmelCase__    :       str    ,    UpperCAmelCase__    :       Any    ,    UpperCAmelCase__    :       Tuple    ,    UpperCAmelCase__    :       Union[str, Any]    ,    UpperCAmelCase__    :       Optional[int]    ,    UpperCAmelCase__    :       str    ,    UpperCAmelCase__    :       List[Any]    ,    ) ->			Dict:
      __SCREAMING_SNAKE_CASE		     =       self.num_labels
      __SCREAMING_SNAKE_CASE		     =       LiltForTokenClassification(config=UpperCAmelCase_     )
      model.to(UpperCAmelCase_     )
      model.eval()
      __SCREAMING_SNAKE_CASE		     =       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 						UpperCAmelCase_   (				self    :       Any    ,    UpperCAmelCase__    :       List[str]    ,    UpperCAmelCase__    :       Dict    ,    UpperCAmelCase__    :       str    ,    UpperCAmelCase__    :       List[str]    ,    UpperCAmelCase__    :       int    ,    UpperCAmelCase__    :       List[Any]    ,    UpperCAmelCase__    :       List[str]    ,    ) ->			Dict:
      __SCREAMING_SNAKE_CASE		     =       LiltForQuestionAnswering(config=UpperCAmelCase_     )
      model.to(UpperCAmelCase_     )
      model.eval()
      __SCREAMING_SNAKE_CASE		     =       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 						UpperCAmelCase_   (				self    :       int     ) ->			Optional[int]:
      __SCREAMING_SNAKE_CASE		     =       self.prepare_config_and_inputs()
      (
          (
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __SCREAMING_SNAKE_CASE						
      )     ,						(
          __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_			(				snake_case__    ,						snake_case__    ,						snake_case__    ,						unittest.TestCase):

 """simple docstring"""





 snake_case__       :						Optional[int]					      =    (
     (
         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__       :						Union[str, Any]					      =    False
 snake_case__       :						List[str]					      =    False




 def 						UpperCAmelCase_   (				self    :       str    ,    UpperCAmelCase__    :       int    ,    UpperCAmelCase__    :       List[str]    ,    UpperCAmelCase__    :       Dict    ,    UpperCAmelCase__    :       int    ,    UpperCAmelCase__    :       Optional[int]     ) ->			Optional[int]:
      return True




 def 						UpperCAmelCase_   (				self    :       Dict     ) ->			Union[str, Any]:
      __SCREAMING_SNAKE_CASE		     =       LiltModelTester(self     )
      __SCREAMING_SNAKE_CASE		     =       ConfigTester(self    ,    config_class=UpperCAmelCase_    ,    hidden_size=3_7     )




 def 						UpperCAmelCase_   (				self    :       str     ) ->			List[Any]:
      self.config_tester.run_common_tests()




 def 						UpperCAmelCase_   (				self    :       List[str]     ) ->			int:
      __SCREAMING_SNAKE_CASE		     =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*UpperCAmelCase_     )




 def 						UpperCAmelCase_   (				self    :       Union[str, Any]     ) ->			List[str]:
      __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(*UpperCAmelCase_     )




 def 						UpperCAmelCase_   (				self    :       List[Any]     ) ->			Dict:
      __SCREAMING_SNAKE_CASE		     =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase_     )




 def 						UpperCAmelCase_   (				self    :       Optional[Any]     ) ->			Dict:
      __SCREAMING_SNAKE_CASE		     =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_     )




 @slow
 def 						UpperCAmelCase_   (				self    :       Union[str, Any]     ) ->			Optional[int]:



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




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

 """simple docstring"""





 def 						UpperCAmelCase_   (				self    :       Optional[int]     ) ->			Dict:
      __SCREAMING_SNAKE_CASE		     =       LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"     ).to(UpperCAmelCase_     )

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

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

      __SCREAMING_SNAKE_CASE		     =       torch.Size([1, 2, 7_6_8]     )
      __SCREAMING_SNAKE_CASE		     =       torch.tensor(
          [[-0.0_653, 0.0_950, -0.0_061], [-0.0_545, 0.0_926, -0.0_324]]    ,    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"""







from abc import ABC, abstractmethod
from argparse import ArgumentParser




class 				UpperCamelCase_			(				UpperCamelCase):

	"""simple docstring"""





	@staticmethod
	@abstractmethod
	def 						UpperCAmelCase_   (				UpperCAmelCase__    :       ArgumentParser     ) ->			Optional[Any]:
						raise NotImplementedError()




	@abstractmethod
	def 						UpperCAmelCase_   (				self    :       Optional[Any]     ) ->			List[str]:
						raise NotImplementedError()
