
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   :					Tuple       ,					_A   :					List[Any]       ,					_A   :					Any=1_3       ,					_A   :					Union[str, Any]=7       ,					_A   :					Tuple=True       ,					_A   :					Any=True       ,					_A   :					Optional[Any]=True       ,					_A   :					Optional[int]=True       ,					_A   :					Dict=9_9       ,					_A   :					str=2_4       ,					_A   :					Optional[Any]=2       ,					_A   :					Tuple=6       ,					_A   :					str=3_7       ,					_A   :					Dict="gelu"       ,					_A   :					int=0.1       ,					_A   :					Tuple=0.1       ,					_A   :					Dict=5_1_2       ,					_A   :					List[str]=1_6       ,					_A   :					Optional[Any]=2       ,					_A   :					str=0.02       ,					_A   :					Dict=3       ,					_A   :					Tuple=None       ,					_A   :					List[Any]=1_0_0_0       ,					)		->		Union[str, 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   :					Tuple     )		->		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   :					str     )		->		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 	UpperCAmelCase(self   :					str       ,					_A   :					Tuple       ,					_A   :					Optional[Any]       ,					_A   :					Any       ,					_A   :					List[Any]       ,					_A   :					Union[str, Any]       ,					_A   :					str       ,					_A   :					Optional[Any]       ,					)		->		List[Any]:
         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   :					Tuple       ,					_A   :					Optional[int]       ,					_A   :					Tuple       ,					_A   :					Optional[int]       ,					_A   :					Optional[Any]       ,					_A   :					Dict       ,					_A   :					str       ,					_A   :					Any       ,					)		->		Union[str, Any]:
         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   :					List[Any]       ,					_A   :					List[Any]       ,					_A   :					Tuple       ,					_A   :					Dict       ,					_A   :					Union[str, Any]       ,					_A   :					Optional[Any]       ,					_A   :					int       ,					_A   :					Any       ,					)		->		Tuple:
         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   :					Dict     )		->		int:
         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__       :							Dict     =	(
         (
             LiltModel,
             LiltForSequenceClassification,
             LiltForTokenClassification,
             LiltForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     UpperCAmelCase__       :							Union[str, Any]     =	(
         {
             "feature-extraction": LiltModel,
             "question-answering": LiltForQuestionAnswering,
             "text-classification": LiltForSequenceClassification,
             "token-classification": LiltForTokenClassification,
             "zero-shot": LiltForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCAmelCase__       :							str     =	False
     UpperCAmelCase__       :							Optional[Any]     =	False





     def 	UpperCAmelCase(self   :					List[Any]       ,					_A   :					List[Any]       ,					_A   :					Union[str, Any]       ,					_A   :					Tuple       ,					_A   :					Any       ,					_A   :					List[Any]     )		->		str:
         return True





     def 	UpperCAmelCase(self   :					Dict     )		->		Optional[Any]:
         snake_case				  =      LiltModelTester(self     )
         snake_case				  =      ConfigTester(self       ,					config_class=_A       ,					hidden_size=3_7     )





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





     def 	UpperCAmelCase(self   :					List[str]     )		->		str:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_A     )





     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Optional[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   :					Tuple     )		->		List[str]:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*_A     )





     def 	UpperCAmelCase(self   :					str     )		->		int:
         snake_case				  =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*_A     )





     @slow
     def 	UpperCAmelCase(self   :					Tuple     )		->		Tuple:
         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   :					Optional[int]     )		->		Tuple:
         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     )     )



import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import MobileNetVaImageProcessor







class   lowerCamelCase	(						unittest.TestCase						):





     def __init__(self   :					Optional[int]       ,					_A   :					Dict       ,					_A   :					Optional[int]=7       ,					_A   :					Union[str, Any]=3       ,					_A   :					Tuple=1_8       ,					_A   :					str=3_0       ,					_A   :					Union[str, Any]=4_0_0       ,					_A   :					Optional[Any]=True       ,					_A   :					Union[str, Any]=None       ,					_A   :					str=True       ,					_A   :					Optional[int]=None       ,					)		->		int:
         snake_case				  =      size if size is not None else {"shortest_edge": 2_0}
         snake_case				  =      crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
         snake_case				  =      parent
         snake_case				  =      batch_size
         snake_case				  =      num_channels
         snake_case				  =      image_size
         snake_case				  =      min_resolution
         snake_case				  =      max_resolution
         snake_case				  =      do_resize
         snake_case				  =      size
         snake_case				  =      do_center_crop
         snake_case				  =      crop_size





     def 	UpperCAmelCase(self   :					str     )		->		int:
         return {
             "do_resize": self.do_resize,
             "size": self.size,
             "do_center_crop": self.do_center_crop,
             "crop_size": self.crop_size,
         }







@require_torch
@require_vision
class   lowerCamelCase	(						A_							,				unittest.TestCase						):
     UpperCAmelCase__       :							Optional[int]     =	MobileNetVaImageProcessor if is_vision_available() else None





     def 	UpperCAmelCase(self   :					Dict     )		->		List[Any]:
         snake_case				  =      MobileNetVaImageProcessingTester(self     )





     @property
     def 	UpperCAmelCase(self   :					Union[str, Any]     )		->		Tuple:
         return self.image_processor_tester.prepare_image_processor_dict()





     def 	UpperCAmelCase(self   :					Tuple     )		->		Tuple:
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         self.assertTrue(hasattr(_A       ,					"do_resize"     )     )
         self.assertTrue(hasattr(_A       ,					"size"     )     )
         self.assertTrue(hasattr(_A       ,					"do_center_crop"     )     )
         self.assertTrue(hasattr(_A       ,					"crop_size"     )     )





     def 	UpperCAmelCase(self   :					int     )		->		List[Any]:
         snake_case				  =      self.image_processing_class.from_dict(self.image_processor_dict     )
         self.assertEqual(image_processor.size       ,					{"shortest_edge": 2_0}     )
         self.assertEqual(image_processor.crop_size       ,					{"height": 1_8, "width": 1_8}     )

         snake_case				  =      self.image_processing_class.from_dict(self.image_processor_dict       ,					size=4_2       ,					crop_size=8_4     )
         self.assertEqual(image_processor.size       ,					{"shortest_edge": 4_2}     )
         self.assertEqual(image_processor.crop_size       ,					{"height": 8_4, "width": 8_4}     )





     def 	UpperCAmelCase(self   :					Any     )		->		Tuple:
         pass





     def 	UpperCAmelCase(self   :					Tuple     )		->		Tuple:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random PIL images
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					Image.Image     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)





     def 	UpperCAmelCase(self   :					Tuple     )		->		List[Any]:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random numpy tensors
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A       ,					numpify=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					np.ndarray     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)





     def 	UpperCAmelCase(self   :					List[str]     )		->		List[str]:
         # Initialize image_processing
         snake_case				  =      self.image_processing_class(**self.image_processor_dict     )
         # create random PyTorch tensors
         snake_case				  =      prepare_image_inputs(self.image_processor_tester       ,					equal_resolution=_A       ,					torchify=_A     )
         for image in image_inputs:
             self.assertIsInstance(_A       ,					torch.Tensor     )

         # Test not batched input
         snake_case				  =      image_processing(image_inputs[0]       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

         # Test batched
         snake_case				  =      image_processing(_A       ,					return_tensors="pt"     ).pixel_values
         self.assertEqual(
             encoded_images.shape       ,					(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.crop_size["height"],
                 self.image_processor_tester.crop_size["width"],
             )       ,					)

