

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

   '''simple docstring'''




   def __init__(				self,    lowercase_,    lowercase_=13,    lowercase_=7,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=True,    lowercase_=99,    lowercase_=24,    lowercase_=2,    lowercase_=6,    lowercase_=37,    lowercase_="gelu",    lowercase_=0.1,    lowercase_=0.1,    lowercase_=512,    lowercase_=16,    lowercase_=2,    lowercase_=0.02,    lowercase_=3,    lowercase_=None,    lowercase_=1000,    )							->    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  _UpperCAmelCase (				self       )							->    List[Any]:






     """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  _UpperCAmelCase (				self       )							->    List[Any]:






     """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,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Tuple:






     """simple docstring"""






     a__  =LiltModel(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(lowercase_,    bbox=lowercase_,    attention_mask=lowercase_,    token_type_ids=lowercase_       )
     a__  =model(lowercase_,    bbox=lowercase_,    token_type_ids=lowercase_       )
     a__  =model(lowercase_,    bbox=lowercase_       )

     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,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Dict:






     """simple docstring"""






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



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    )							->    Dict:






     """simple docstring"""






     a__  =LiltForQuestionAnswering(config=lowercase_       )
     model.to(lowercase_       )
     model.eval()
     a__  =model(
         lowercase_,    bbox=lowercase_,    attention_mask=lowercase_,    token_type_ids=lowercase_,    start_positions=lowercase_,    end_positions=lowercase_,    )
     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       )							->    str:






     """simple docstring"""






     a__  =self.prepare_config_and_inputs()
     (
         (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         a__
     ),      (
         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 						__magic_name__			(							lowerCamelCase__		,       lowerCamelCase__		,       lowerCamelCase__		,       unittest.TestCase							):

   '''simple docstring'''




   lowerCamelCase__ :	Any    =   (
       (
           LiltModel,
           LiltForSequenceClassification,
           LiltForTokenClassification,
           LiltForQuestionAnswering,
       )
       if is_torch_available()
       else ()
   )
   lowerCamelCase__ :	Optional[int]    =   (
       {
           'feature-extraction': LiltModel,
           'question-answering': LiltForQuestionAnswering,
           'text-classification': LiltForSequenceClassification,
           'token-classification': LiltForTokenClassification,
           'zero-shot': LiltForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   lowerCamelCase__ :	Tuple    =   False
   lowerCamelCase__ :	str    =   False



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_,    lowercase_,    lowercase_       )							->    Optional[Any]:






     """simple docstring"""






     return True



   def  _UpperCAmelCase (				self       )							->    Optional[int]:






     """simple docstring"""






     a__  =LiltModelTester(self       )
     a__  =ConfigTester(self,    config_class=lowercase_,    hidden_size=37       )



   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     self.config_tester.run_common_tests()



   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Dict:






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



   def  _UpperCAmelCase (				self       )							->    List[str]:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*lowercase_       )



   def  _UpperCAmelCase (				self       )							->    List[str]:






     """simple docstring"""






     a__  =self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*lowercase_       )



   @slow
   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






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







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

   '''simple docstring'''




   def  _UpperCAmelCase (				self       )							->    Tuple:






     """simple docstring"""






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

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

     # forward pass
     with torch.no_grad():
       a__  =model(input_ids=lowercase_,    bbox=lowercase_       )

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

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



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase           =					{
    '''configuration_deberta''': ['''DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DebertaConfig''', '''DebertaOnnxConfig'''],
    '''tokenization_deberta''': ['''DebertaTokenizer'''],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					['''DebertaTokenizerFast''']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''DebertaForMaskedLM''',
           '''DebertaForQuestionAnswering''',
           '''DebertaForSequenceClassification''',
           '''DebertaForTokenClassification''',
           '''DebertaModel''',
           '''DebertaPreTrainedModel''',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase           =					[
           '''TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''TFDebertaForMaskedLM''',
           '''TFDebertaForQuestionAnswering''',
           '''TFDebertaForSequenceClassification''',
           '''TFDebertaForTokenClassification''',
           '''TFDebertaModel''',
           '''TFDebertaPreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_deberta import DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, DebertaConfig, DebertaOnnxConfig
       from .tokenization_deberta import DebertaTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_deberta_fast import DebertaTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_deberta import (
                  DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DebertaForMaskedLM,
                  DebertaForQuestionAnswering,
                  DebertaForSequenceClassification,
                  DebertaForTokenClassification,
                  DebertaModel,
                  DebertaPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_deberta import (
                  TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFDebertaForMaskedLM,
                  TFDebertaForQuestionAnswering,
                  TFDebertaForSequenceClassification,
                  TFDebertaForTokenClassification,
                  TFDebertaModel,
                  TFDebertaPreTrainedModel,
              )


else:
       import sys

       lowerCamelCase           =					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
