
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import is_speech_available, is_vision_available
from transformers.testing_utils import require_torch


if is_vision_available():
   from transformers import TvltImageProcessor

if is_speech_available():
   from transformers import TvltFeatureExtractor

from transformers import TvltProcessor







@require_torch
class 					lowerCamelCase		(  unittest.TestCase  ):





     def 		UpperCAmelCase(self				:   List[str]       )						->						Optional[int]:
         snake_case								= "ZinengTang/tvlt-base"
         snake_case								= tempfile.mkdtemp()





     def 		UpperCAmelCase(self				:   Union[str, Any]    ,   **_A				:   List[str]       )						->						List[Any]:
         return TvltImageProcessor.from_pretrained(self.checkpoint    ,   **_A       )





     def 		UpperCAmelCase(self				:   Dict    ,   **_A				:   Tuple       )						->						int:
         return TvltFeatureExtractor.from_pretrained(self.checkpoint    ,   **_A       )





     def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Union[str, Any]:
         shutil.rmtree(self.tmpdirname       )





     def 		UpperCAmelCase(self				:   Tuple       )						->						int:
         snake_case								= self.get_image_processor()
         snake_case								= self.get_feature_extractor()

         snake_case								= TvltProcessor(image_processor=_A    ,   feature_extractor=_A       )
         processor.save_pretrained(self.tmpdirname       )
         snake_case								= TvltProcessor.from_pretrained(self.tmpdirname       )

         self.assertIsInstance(processor.feature_extractor    ,   _A       )
         self.assertIsInstance(processor.image_processor    ,   _A       )





     def 		UpperCAmelCase(self				:   Any       )						->						int:
         snake_case								= self.get_image_processor()
         snake_case								= self.get_feature_extractor()

         snake_case								= TvltProcessor(image_processor=_A    ,   feature_extractor=_A       )

         snake_case								= np.ones([1_2_0_0_0]       )

         snake_case								= feature_extractor(_A    ,   return_tensors="np"       )
         snake_case								= processor(audio=_A    ,   return_tensors="np"       )

         for key in audio_dict.keys():
             self.assertAlmostEqual(audio_dict[key].sum()    ,   input_processor[key].sum()    ,   delta=1E-2       )





     def 		UpperCAmelCase(self				:   Dict       )						->						str:
         snake_case								= self.get_image_processor()
         snake_case								= self.get_feature_extractor()

         snake_case								= TvltProcessor(image_processor=_A    ,   feature_extractor=_A       )

         snake_case								= np.ones([3, 2_2_4, 2_2_4]       )

         snake_case								= image_processor(_A    ,   return_tensors="np"       )
         snake_case								= processor(images=_A    ,   return_tensors="np"       )

         for key in image_dict.keys():
             self.assertAlmostEqual(image_dict[key].sum()    ,   input_processor[key].sum()    ,   delta=1E-2       )





     def 		UpperCAmelCase(self				:   Dict       )						->						Any:
         snake_case								= self.get_image_processor()
         snake_case								= self.get_feature_extractor()

         snake_case								= TvltProcessor(image_processor=_A    ,   feature_extractor=_A       )

         snake_case								= np.ones([1_2_0_0_0]       )
         snake_case								= np.ones([3, 2_2_4, 2_2_4]       )

         snake_case								= processor(audio=_A    ,   images=_A       )

         self.assertListEqual(list(inputs.keys()       )    ,   ["audio_values", "audio_mask", "pixel_values", "pixel_mask"]       )

         # test if it raises when no input is passed
         with pytest.raises(_A       ):
             processor()





     def 		UpperCAmelCase(self				:   List[str]       )						->						Optional[Any]:
         snake_case								= self.get_image_processor()
         snake_case								= self.get_feature_extractor()

         snake_case								= TvltProcessor(image_processor=_A    ,   feature_extractor=_A       )

         self.assertListEqual(
             processor.model_input_names    ,   image_processor.model_input_names + feature_extractor.model_input_names    ,   msg="`processor` and `image_processor`+`feature_extractor` model input names do not match"    ,   )



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				:   Union[str, Any]    ,   _A				:   Any    ,   _A				:   Tuple=1_3    ,   _A				:   Optional[int]=7    ,   _A				:   Any=True    ,   _A				:   str=True    ,   _A				:   Union[str, Any]=True    ,   _A				:   Optional[int]=True    ,   _A				:   str=9_9    ,   _A				:   str=2_4    ,   _A				:   int=2    ,   _A				:   Optional[Any]=6    ,   _A				:   int=3_7    ,   _A				:   List[Any]="gelu"    ,   _A				:   str=0.1    ,   _A				:   Dict=0.1    ,   _A				:   Dict=5_1_2    ,   _A				:   Tuple=1_6    ,   _A				:   List[str]=2    ,   _A				:   Dict=0.02    ,   _A				:   List[str]=3    ,   _A				:   Optional[Any]=None    ,   _A				:   Dict=1_0_0_0    ,   )						->						Any:
         snake_case								= parent
         snake_case								= batch_size
         snake_case								= seq_length
         snake_case								= is_training
         snake_case								= use_input_mask
         snake_case								= use_token_type_ids
         snake_case								= use_labels
         snake_case								= vocab_size
         snake_case								= hidden_size
         snake_case								= num_hidden_layers
         snake_case								= num_attention_heads
         snake_case								= intermediate_size
         snake_case								= hidden_act
         snake_case								= hidden_dropout_prob
         snake_case								= attention_probs_dropout_prob
         snake_case								= max_position_embeddings
         snake_case								= type_vocab_size
         snake_case								= type_sequence_label_size
         snake_case								= initializer_range
         snake_case								= num_labels
         snake_case								= scope
         snake_case								= range_bbox





     def 		UpperCAmelCase(self				:   List[str]       )						->						List[str]:
         snake_case								= ids_tensor([self.batch_size, self.seq_length]    ,   self.vocab_size       )

         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]:
                     snake_case								= bbox[i, j, 3]
                     snake_case								= bbox[i, j, 1]
                     snake_case								= t
                 if bbox[i, j, 2] < bbox[i, j, 0]:
                     snake_case								= bbox[i, j, 2]
                     snake_case								= bbox[i, j, 0]
                     snake_case								= t

         snake_case								= None
         if self.use_input_mask:
             snake_case								= ids_tensor([self.batch_size, self.seq_length]    ,   vocab_size=2       )

         snake_case								= None
         if self.use_token_type_ids:
             snake_case								= ids_tensor([self.batch_size, self.seq_length]    ,   self.type_vocab_size       )

         snake_case								= None
         snake_case								= None
         if self.use_labels:
             snake_case								= ids_tensor([self.batch_size]    ,   self.type_sequence_label_size       )
             snake_case								= ids_tensor([self.batch_size, self.seq_length]    ,   self.num_labels       )

         snake_case								= self.get_config()

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





     def 		UpperCAmelCase(self				:   Tuple       )						->						Tuple:
         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				:   List[str]    ,   _A				:   Dict    ,   _A				:   List[Any]    ,   _A				:   Optional[Any]    ,   _A				:   Dict    ,   _A				:   str    ,   _A				:   Optional[Any]    ,   _A				:   Tuple    ,   )						->						Dict:
         snake_case								= LiltModel(config=_A       )
         model.to(_A       )
         model.eval()
         snake_case								= model(_A    ,   bbox=_A    ,   attention_mask=_A    ,   token_type_ids=_A       )
         snake_case								= model(_A    ,   bbox=_A    ,   token_type_ids=_A       )
         snake_case								= 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[Any]    ,   _A				:   Optional[int]    ,   _A				:   Dict    ,   _A				:   List[Any]    ,   _A				:   Tuple    ,   _A				:   Optional[int]    ,   _A				:   Tuple    ,   _A				:   Union[str, Any]    ,   )						->						Optional[int]:
         snake_case								= self.num_labels
         snake_case								= LiltForTokenClassification(config=_A       )
         model.to(_A       )
         model.eval()
         snake_case								= 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				:   str    ,   _A				:   List[Any]    ,   _A				:   Union[str, Any]    ,   _A				:   Any    ,   _A				:   List[str]    ,   _A				:   List[str]    ,   _A				:   Optional[int]    ,   _A				:   Optional[Any]    ,   )						->						Optional[int]:
         snake_case								= LiltForQuestionAnswering(config=_A       )
         model.to(_A       )
         model.eval()
         snake_case								= 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				:   str       )						->						str:
         snake_case								= self.prepare_config_and_inputs()
         (
             (
             snake_case
         )					,							(
             snake_case
         )					,							(
             snake_case
         )					,							(
             snake_case
         )					,							(
             snake_case
         )					,							(
             snake_case
         )					,							(
             snake_case
         )					,							
         )								= config_and_inputs
         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 					lowerCamelCase		(  A_							,			A_							,			A_							,			unittest.TestCase  ):
     UpperCAmelCase__    :							Optional[int]									=		(
         (
             LiltModel,
             LiltForSequenceClassification,
             LiltForTokenClassification,
             LiltForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     UpperCAmelCase__    :							List[Any]									=		(
         {
             "feature-extraction": LiltModel,
             "question-answering": LiltForQuestionAnswering,
             "text-classification": LiltForSequenceClassification,
             "token-classification": LiltForTokenClassification,
             "zero-shot": LiltForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCAmelCase__    :							Optional[Any]									=		False
     UpperCAmelCase__    :							Optional[int]									=		False





     def 		UpperCAmelCase(self				:   Dict    ,   _A				:   Optional[Any]    ,   _A				:   Dict    ,   _A				:   Union[str, Any]    ,   _A				:   int    ,   _A				:   Union[str, Any]       )						->						int:
         return True





     def 		UpperCAmelCase(self				:   str       )						->						Tuple:
         snake_case								= LiltModelTester(self       )
         snake_case								= ConfigTester(self    ,   config_class=_A    ,   hidden_size=3_7       )





     def 		UpperCAmelCase(self				:   Optional[int]       )						->						List[str]:
         self.config_tester.run_common_tests()





     def 		UpperCAmelCase(self				:   Tuple       )						->						Dict:
         snake_case								= self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_A       )





     def 		UpperCAmelCase(self				:   int       )						->						Union[str, Any]:
         snake_case								= self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             snake_case								= type
             self.model_tester.create_and_check_model(*_A       )





     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						List[Any]:
         snake_case								= self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*_A       )





     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Optional[int]:
         snake_case								= self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*_A       )





     @slow
     def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Optional[Any]:
         for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case								= LiltModel.from_pretrained(_A       )
             self.assertIsNotNone(_A       )







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





     def 		UpperCAmelCase(self				:   Tuple       )						->						Optional[int]:
         snake_case								= LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"       ).to(_A       )

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

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

         snake_case								= torch.Size([1, 2, 7_6_8]       )
         snake_case								= torch.tensor(
             [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]    ,   device=_A    ,   )

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

