


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







    """simple docstring"""

    def __init__(			self     ,   __snake_case     ,   __snake_case=1_3     ,   __snake_case=7     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=True     ,   __snake_case=9_9     ,   __snake_case=2_4     ,   __snake_case=2     ,   __snake_case=6     ,   __snake_case=3_7     ,   __snake_case="gelu"     ,   __snake_case=0.1     ,   __snake_case=0.1     ,   __snake_case=5_1_2     ,   __snake_case=1_6     ,   __snake_case=2     ,   __snake_case=0.02     ,   __snake_case=3     ,   __snake_case=None     ,   __snake_case=1_0_0_0     ,   ):
         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 						a_     (			self       ):
         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 						a_     (			self       ):
         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 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   ):
         snake_case											=							LiltModel(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							model(__snake_case     ,   bbox=__snake_case     ,   attention_mask=__snake_case     ,   token_type_ids=__snake_case       )
         snake_case											=							model(__snake_case     ,   bbox=__snake_case     ,   token_type_ids=__snake_case       )
         snake_case											=							model(__snake_case     ,   bbox=__snake_case       )

         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 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   ):
         snake_case											=							self.num_labels
         snake_case											=							LiltForTokenClassification(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							model(
             __snake_case     ,   bbox=__snake_case     ,   attention_mask=__snake_case     ,   token_type_ids=__snake_case     ,   labels=__snake_case       )
         self.parent.assertEqual(result.logits.shape     ,   (self.batch_size, self.seq_length, self.num_labels)       )
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   ):
         snake_case											=							LiltForQuestionAnswering(config=__snake_case       )
         model.to(__snake_case       )
         model.eval()
         snake_case											=							model(
             __snake_case     ,   bbox=__snake_case     ,   attention_mask=__snake_case     ,   token_type_ids=__snake_case     ,   start_positions=__snake_case     ,   end_positions=__snake_case     ,   )
         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 						a_     (			self       ):
         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     A__   (       snake_case__			,   snake_case__			,   snake_case__			,   unittest.TestCase      ):







    """simple docstring"""

    __magic_name__         =						(
        (
            LiltModel,
            LiltForSequenceClassification,
            LiltForTokenClassification,
            LiltForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    __magic_name__         =						(
        {
            'feature-extraction': LiltModel,
            'question-answering': LiltForQuestionAnswering,
            'text-classification': LiltForSequenceClassification,
            'token-classification': LiltForTokenClassification,
            'zero-shot': LiltForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    __magic_name__         =						False
    __magic_name__         =						False
    def 						a_     (			self     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case     ,   __snake_case       ):
         return True
    def 						a_     (			self       ):
         snake_case											=							LiltModelTester(self       )
         snake_case											=							ConfigTester(self     ,   config_class=__snake_case     ,   hidden_size=3_7       )
    def 						a_     (			self       ):
         self.config_tester.run_common_tests()
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case       )
    def 						a_     (			self       ):
         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(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*__snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*__snake_case       )




    @slow
    def 						a_     (			self       ):
         for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case											=							LiltModel.from_pretrained(__snake_case       )
              self.assertIsNotNone(__snake_case       )






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







    """simple docstring"""

    def 						a_     (			self       ):
         snake_case											=							LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base'''       ).to(__snake_case       )

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

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

         snake_case											=							torch.Size([1, 2, 7_6_8]       )
         snake_case											=							torch.tensor(
             [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]     ,   device=__snake_case     ,   )

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








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     A__   (       unittest.TestCase      ):







    """simple docstring"""

    def 						a_     (			self       ):
         snake_case											=							'''ZinengTang/tvlt-base'''
         snake_case											=							tempfile.mkdtemp()
    def 						a_     (			self     ,   **__snake_case       ):
         return TvltImageProcessor.from_pretrained(self.checkpoint     ,   **__snake_case       )
    def 						a_     (			self     ,   **__snake_case       ):
         return TvltFeatureExtractor.from_pretrained(self.checkpoint     ,   **__snake_case       )
    def 						a_     (			self       ):
         shutil.rmtree(self.tmpdirname       )
    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_feature_extractor()

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

         self.assertIsInstance(processor.feature_extractor     ,   __snake_case       )
         self.assertIsInstance(processor.image_processor     ,   __snake_case       )
    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_feature_extractor()

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

         snake_case											=							np.ones([1_2_0_0_0]       )

         snake_case											=							feature_extractor(__snake_case     ,   return_tensors='''np'''       )
         snake_case											=							processor(audio=__snake_case     ,   return_tensors='''np'''       )

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

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

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

         snake_case											=							image_processor(__snake_case     ,   return_tensors='''np'''       )
         snake_case											=							processor(images=__snake_case     ,   return_tensors='''np'''       )

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

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

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

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

         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(__snake_case       ):
              processor()




    def 						a_     (			self       ):
         snake_case											=							self.get_image_processor()
         snake_case											=							self.get_feature_extractor()

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

         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'''     ,   )




