

"""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    ,_A    ,_A=13    ,_A=7    ,_A=True    ,_A=True    ,_A=True    ,_A=True    ,_A=99    ,_A=24    ,_A=2    ,_A=6    ,_A=37    ,_A="gelu"    ,_A=0.1    ,_A=0.1    ,_A=512    ,_A=16    ,_A=2    ,_A=0.0_2    ,_A=3    ,_A=None    ,_A=1000    ,):
      '''simple docstring'''

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

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Optional[int]  =    ids_tensor([self.batch_size, self.seq_length]    ,self.vocab_size      )

      _lowerCAmelCase       :   List[Any]  =    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]:
                  _lowerCAmelCase       :   Union[str, Any]  =    bbox[i, j, 3]
                  _lowerCAmelCase       :   str  =    bbox[i, j, 1]
                  _lowerCAmelCase       :   Union[str, Any]  =    t
              if bbox[i, j, 2] < bbox[i, j, 0]:
                  _lowerCAmelCase       :   str  =    bbox[i, j, 2]
                  _lowerCAmelCase       :   Optional[Any]  =    bbox[i, j, 0]
                  _lowerCAmelCase       :   List[str]  =    t

      _lowerCAmelCase       :   Optional[int]  =    None
      if self.use_input_mask:
          _lowerCAmelCase       :   Dict  =    ids_tensor([self.batch_size, self.seq_length]    ,vocab_size=2      )

      _lowerCAmelCase       :   Dict  =    None
      if self.use_token_type_ids:
          _lowerCAmelCase       :   Optional[int]  =    ids_tensor([self.batch_size, self.seq_length]    ,self.type_vocab_size      )

      _lowerCAmelCase       :   int  =    None
      _lowerCAmelCase       :   Any  =    None
      if self.use_labels:
          _lowerCAmelCase       :   Any  =    ids_tensor([self.batch_size]    ,self.type_sequence_label_size      )
          _lowerCAmelCase       :   Optional[int]  =    ids_tensor([self.batch_size, self.seq_length]    ,self.num_labels      )

      _lowerCAmelCase       :   str  =    self.get_config()

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

  def __lowerCamelCase		(		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 __lowerCamelCase		(		self    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Any  =    LiltModel(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   List[str]  =    model(_A    ,bbox=_A    ,attention_mask=_A    ,token_type_ids=_A      )
      _lowerCAmelCase       :   Tuple  =    model(_A    ,bbox=_A    ,token_type_ids=_A      )
      _lowerCAmelCase       :   Optional[int]  =    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 __lowerCamelCase		(		self    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.num_labels
      _lowerCAmelCase       :   List[str]  =    LiltForTokenClassification(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   int  =    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 __lowerCamelCase		(		self    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,_A    ,):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    LiltForQuestionAnswering(config=_A      )
      model.to(_A      )
      model.eval()
      _lowerCAmelCase       :   Union[str, Any]  =    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 __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   List[Any]  =    self.prepare_config_and_inputs()
      (
          _lowerCAmelCase					
      )       :   List[Any]  =    config_and_inputs
      _lowerCAmelCase       :   Tuple  =    {
          'input_ids': input_ids,
          'bbox': bbox,
          'token_type_ids': token_type_ids,
          'attention_mask': input_mask,
      }
      return config, inputs_dict







@require_torch
class 	__UpperCamelCase    (    a__							,							a__							,							a__							,							unittest.TestCase						):
  _UpperCAmelCase          =		(
      (
          LiltModel,
          LiltForSequenceClassification,
          LiltForTokenClassification,
          LiltForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  _UpperCAmelCase          =		(
      {
          "feature-extraction": LiltModel,
          "question-answering": LiltForQuestionAnswering,
          "text-classification": LiltForSequenceClassification,
          "token-classification": LiltForTokenClassification,
          "zero-shot": LiltForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  _UpperCAmelCase          =		False
  _UpperCAmelCase          =		False

  def __lowerCamelCase		(		self    ,_A    ,_A    ,_A    ,_A    ,_A      ):
      '''simple docstring'''

      return True

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Dict  =    LiltModelTester(self      )
      _lowerCAmelCase       :   str  =    ConfigTester(self    ,config_class=_A    ,hidden_size=37      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      self.config_tester.run_common_tests()

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Union[str, Any]  =    self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
          _lowerCAmelCase       :   List[Any]  =    type
          self.model_tester.create_and_check_model(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   int  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*_A      )

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   str  =    self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*_A      )







  @slow
  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowerCAmelCase       :   int  =    LiltModel.from_pretrained(_A      )
          self.assertIsNotNone(_A      )







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

  def __lowerCamelCase		(		self      ):
      '''simple docstring'''

      _lowerCAmelCase       :   Tuple  =    LiltModel.from_pretrained('SCUT-DLVCLab/lilt-roberta-en-base'      ).to(_A      )

      _lowerCAmelCase       :   Dict  =    torch.tensor([[1, 2]]    ,device=_A      )
      _lowerCAmelCase       :   Optional[int]  =    torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]    ,device=_A      )

      # forward pass
      with torch.no_grad():
          _lowerCAmelCase       :   int  =    model(input_ids=_A    ,bbox=_A      )

      _lowerCAmelCase       :   Tuple  =    torch.Size([1, 2, 768]      )
      _lowerCAmelCase       :   List[str]  =    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=_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"""






import baseaa

def 		lowerCamelCase__		(					_lowerCamelCase   ):

    '''simple docstring'''



    return baseaa.aaaencode(string.encode('utf-8'   )   )

def 		lowerCamelCase__		(					_lowerCamelCase   ):

    '''simple docstring'''



    return baseaa.aaadecode(_lowerCamelCase   ).decode('utf-8'   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()





