

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







   '''simple docstring'''




   def __init__(       self					:			List[str]     , __lowerCamelCase					:			Tuple     , __lowerCamelCase					:			List[Any]=13     , __lowerCamelCase					:			str=7     , __lowerCamelCase					:			Tuple=True     , __lowerCamelCase					:			List[Any]=True     , __lowerCamelCase					:			str=True     , __lowerCamelCase					:			List[str]=True     , __lowerCamelCase					:			Dict=99     , __lowerCamelCase					:			Any=24     , __lowerCamelCase					:			int=2     , __lowerCamelCase					:			Tuple=6     , __lowerCamelCase					:			Tuple=37     , __lowerCamelCase					:			Any="gelu"     , __lowerCamelCase					:			List[str]=0.1     , __lowerCamelCase					:			Any=0.1     , __lowerCamelCase					:			Dict=512     , __lowerCamelCase					:			Optional[Any]=16     , __lowerCamelCase					:			Tuple=2     , __lowerCamelCase					:			Dict=0.02     , __lowerCamelCase					:			Tuple=3     , __lowerCamelCase					:			Union[str, Any]=None     , __lowerCamelCase					:			List[Any]=1000     , ):
       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      _snake_case		(       self					:			Dict			):
       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      _snake_case		(       self					:			List[str]			):
       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      _snake_case		(       self					:			Any     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Any     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Any     , __lowerCamelCase					:			List[Any]     , __lowerCamelCase					:			List[Any]     , __lowerCamelCase					:			List[Any]     , ):
       SCREAMING_SNAKE_CASE										=   LiltModel(config=__lowerCamelCase			)
       model.to(__lowerCamelCase			)
       model.eval()
       SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , bbox=__lowerCamelCase     , attention_mask=__lowerCamelCase     , token_type_ids=__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , bbox=__lowerCamelCase     , token_type_ids=__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   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      _snake_case		(       self					:			str     , __lowerCamelCase					:			List[Any]     , __lowerCamelCase					:			List[Any]     , __lowerCamelCase					:			Dict     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Dict     , __lowerCamelCase					:			List[Any]     , __lowerCamelCase					:			Union[str, Any]     , ):
       SCREAMING_SNAKE_CASE										=   self.num_labels
       SCREAMING_SNAKE_CASE										=   LiltForTokenClassification(config=__lowerCamelCase			)
       model.to(__lowerCamelCase			)
       model.eval()
       SCREAMING_SNAKE_CASE										=   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      _snake_case		(       self					:			Optional[Any]     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			str     , __lowerCamelCase					:			List[str]     , __lowerCamelCase					:			Union[str, Any]     , __lowerCamelCase					:			str     , __lowerCamelCase					:			int     , ):
       SCREAMING_SNAKE_CASE										=   LiltForQuestionAnswering(config=__lowerCamelCase			)
       model.to(__lowerCamelCase			)
       model.eval()
       SCREAMING_SNAKE_CASE										=   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      _snake_case		(       self					:			Tuple			):
       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 			_SCREAMING_SNAKE_CASE (   __snake_case					,       __snake_case					,       __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      _snake_case		(       self					:			str     , __lowerCamelCase					:			Dict     , __lowerCamelCase					:			int     , __lowerCamelCase					:			List[str]     , __lowerCamelCase					:			int     , __lowerCamelCase					:			Union[str, Any]			):
       return True





   def      _snake_case		(       self					:			Any			):
       SCREAMING_SNAKE_CASE										=   LiltModelTester(self			)
       SCREAMING_SNAKE_CASE										=   ConfigTester(self     , config_class=__lowerCamelCase     , hidden_size=37			)





   def      _snake_case		(       self					:			Optional[Any]			):
       self.config_tester.run_common_tests()





   def      _snake_case		(       self					:			int			):
       SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__lowerCamelCase			)





   def      _snake_case		(       self					:			Dict			):
       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(*__lowerCamelCase			)





   def      _snake_case		(       self					:			Union[str, Any]			):
       SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase			)





   def      _snake_case		(       self					:			Tuple			):
       SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase			)





   @slow
   def      _snake_case		(       self					:			Union[str, Any]			):
       for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           SCREAMING_SNAKE_CASE										=   LiltModel.from_pretrained(__lowerCamelCase			)
           self.assertIsNotNone(__lowerCamelCase			)





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







   '''simple docstring'''




   def      _snake_case		(       self					:			Dict			):
       SCREAMING_SNAKE_CASE										=   LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"			).to(__lowerCamelCase			)

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

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

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

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


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A			:					List[Any]						=			{
    'configuration_git': ['GIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GitConfig', 'GitVisionConfig'],
    'processing_git': ['GitProcessor'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __A			:					int						=			[
        'GIT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'GitForCausalLM',
        'GitModel',
        'GitPreTrainedModel',
        'GitVisionModel',
    ]

if TYPE_CHECKING:
    from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
    from .processing_git import GitProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_git import (
            GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
            GitForCausalLM,
            GitModel,
            GitPreTrainedModel,
            GitVisionModel,
        )

else:
    import sys

    __A			:					List[Any]						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)