

'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import CLIPImageProcessor, CLIPProcessor







@require_vision
class 		lowerCAmelCase__  ( unittest.TestCase   ):



 """simple docstring"""



 def  UpperCAmelCase__						(						self   :			Any     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = tempfile.mkdtemp()

      # fmt: off
      __SCREAMING_SNAKE_CASE      = ["""l""", """o""", """w""", """e""", """r""", """s""", """t""", """i""", """d""", """n""", """lo""", """l</w>""", """w</w>""", """r</w>""", """t</w>""", """low</w>""", """er</w>""", """lowest</w>""", """newer</w>""", """wider""", """<unk>""", """<|startoftext|>""", """<|endoftext|>"""]
      # fmt: on
      __SCREAMING_SNAKE_CASE      = dict(zip(__SCREAMING_SNAKE_CASE   ,				range(len(__SCREAMING_SNAKE_CASE     )     )     )     )
      __SCREAMING_SNAKE_CASE      = ["""#version: 0.2""", """l o""", """lo w</w>""", """e r</w>""", """"""]
      __SCREAMING_SNAKE_CASE      = {"""unk_token""": """<unk>"""}

      __SCREAMING_SNAKE_CASE      = os.path.join(self.tmpdirname   ,				VOCAB_FILES_NAMES["""vocab_file"""]     )
      __SCREAMING_SNAKE_CASE      = os.path.join(self.tmpdirname   ,				VOCAB_FILES_NAMES["""merges_file"""]     )
      with open(self.vocab_file   ,				"""w"""   ,				encoding="""utf-8"""     ) as fp:
           fp.write(json.dumps(__SCREAMING_SNAKE_CASE     ) + """\n"""     )
      with open(self.merges_file   ,				"""w"""   ,				encoding="""utf-8"""     ) as fp:
           fp.write("""\n""".join(__SCREAMING_SNAKE_CASE     )     )

      __SCREAMING_SNAKE_CASE      = {
          """do_resize""": True,
          """size""": 20,
          """do_center_crop""": True,
          """crop_size""": 18,
          """do_normalize""": True,
          """image_mean""": [0.48145466, 0.4578275, 0.40821073],
          """image_std""": [0.26862954, 0.26130258, 0.27577711],
      }
      __SCREAMING_SNAKE_CASE      = os.path.join(self.tmpdirname   ,				__SCREAMING_SNAKE_CASE     )
      with open(self.image_processor_file   ,				"""w"""   ,				encoding="""utf-8"""     ) as fp:
           json.dump(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Union[str, Any]   ,				**__SCREAMING_SNAKE_CASE   :			Any     )    ->					List[Any]:


      """simple docstring"""




      return CLIPTokenizer.from_pretrained(self.tmpdirname   ,				**__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Optional[int]   ,				**__SCREAMING_SNAKE_CASE   :			Optional[Any]     )    ->					Any:


      """simple docstring"""




      return CLIPTokenizerFast.from_pretrained(self.tmpdirname   ,				**__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[str]   ,				**__SCREAMING_SNAKE_CASE   :			Any     )    ->					str:


      """simple docstring"""




      return CLIPImageProcessor.from_pretrained(self.tmpdirname   ,				**__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					Tuple:


      """simple docstring"""




      shutil.rmtree(self.tmpdirname     )
 def  UpperCAmelCase__						(						self   :			str     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = [np.random.randint(255   ,				size=(3, 30, 400)   ,				dtype=np.uinta     )]

      __SCREAMING_SNAKE_CASE      = [Image.fromarray(np.moveaxis(__SCREAMING_SNAKE_CASE   ,				0   ,				-1     )     ) for x in image_inputs]

      return image_inputs
 def  UpperCAmelCase__						(						self   :			Tuple     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      = self.get_rust_tokenizer()
      __SCREAMING_SNAKE_CASE      = self.get_image_processor()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )
      processor_slow.save_pretrained(self.tmpdirname     )
      __SCREAMING_SNAKE_CASE      = CLIPProcessor.from_pretrained(self.tmpdirname   ,				use_fast=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )
      processor_fast.save_pretrained(self.tmpdirname     )
      __SCREAMING_SNAKE_CASE      = CLIPProcessor.from_pretrained(self.tmpdirname     )

      self.assertEqual(processor_slow.tokenizer.get_vocab()   ,				tokenizer_slow.get_vocab()     )
      self.assertEqual(processor_fast.tokenizer.get_vocab()   ,				tokenizer_fast.get_vocab()     )
      self.assertEqual(tokenizer_slow.get_vocab()   ,				tokenizer_fast.get_vocab()     )
      self.assertIsInstance(processor_slow.tokenizer   ,				__SCREAMING_SNAKE_CASE     )
      self.assertIsInstance(processor_fast.tokenizer   ,				__SCREAMING_SNAKE_CASE     )

      self.assertEqual(processor_slow.image_processor.to_json_string()   ,				image_processor.to_json_string()     )
      self.assertEqual(processor_fast.image_processor.to_json_string()   ,				image_processor.to_json_string()     )
      self.assertIsInstance(processor_slow.image_processor   ,				__SCREAMING_SNAKE_CASE     )
      self.assertIsInstance(processor_fast.image_processor   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=self.get_tokenizer()   ,				image_processor=self.get_image_processor()     )
      processor.save_pretrained(self.tmpdirname     )

      __SCREAMING_SNAKE_CASE      = self.get_tokenizer(bos_token="""(BOS)"""   ,				eos_token="""(EOS)"""     )
      __SCREAMING_SNAKE_CASE      = self.get_image_processor(do_normalize=__SCREAMING_SNAKE_CASE   ,				padding_value=1.0     )

      __SCREAMING_SNAKE_CASE      = CLIPProcessor.from_pretrained(
          self.tmpdirname   ,				bos_token="""(BOS)"""   ,				eos_token="""(EOS)"""   ,				do_normalize=__SCREAMING_SNAKE_CASE   ,				padding_value=1.0     )

      self.assertEqual(processor.tokenizer.get_vocab()   ,				tokenizer_add_kwargs.get_vocab()     )
      self.assertIsInstance(processor.tokenizer   ,				__SCREAMING_SNAKE_CASE     )

      self.assertEqual(processor.image_processor.to_json_string()   ,				image_processor_add_kwargs.to_json_string()     )
      self.assertIsInstance(processor.image_processor   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_image_processor()
      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      = image_processor(__SCREAMING_SNAKE_CASE   ,				return_tensors="""np"""     )
      __SCREAMING_SNAKE_CASE      = processor(images=__SCREAMING_SNAKE_CASE   ,				return_tensors="""np"""     )

      for key in input_image_proc.keys():
           self.assertAlmostEqual(input_image_proc[key].sum()   ,				input_processor[key].sum()   ,				delta=1E-2     )
 def  UpperCAmelCase__						(						self   :			str     )    ->					Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_image_processor()
      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = """lower newer"""

      __SCREAMING_SNAKE_CASE      = processor(text=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokenizer(__SCREAMING_SNAKE_CASE     )

      for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]   ,				encoded_processor[key]     )
 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_image_processor()
      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = """lower newer"""
      __SCREAMING_SNAKE_CASE      = self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      = processor(text=__SCREAMING_SNAKE_CASE   ,				images=__SCREAMING_SNAKE_CASE     )

      self.assertListEqual(list(inputs.keys()     )   ,				["""input_ids""", """attention_mask""", """pixel_values"""]     )

      # test if it raises when no input is passed
      with pytest.raises(__SCREAMING_SNAKE_CASE     ):
           processor()
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_image_processor()
      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      __SCREAMING_SNAKE_CASE      = processor.batch_decode(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.batch_decode(__SCREAMING_SNAKE_CASE     )

      self.assertListEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )


 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_image_processor()
      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = CLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE   ,				image_processor=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = """lower newer"""
      __SCREAMING_SNAKE_CASE      = self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      = processor(text=__SCREAMING_SNAKE_CASE   ,				images=__SCREAMING_SNAKE_CASE     )

      self.assertListEqual(list(inputs.keys()     )   ,				processor.model_input_names     )









'''simple docstring'''



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



 """simple docstring"""



 def __init__(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			str=13   ,				__SCREAMING_SNAKE_CASE   :			int=7   ,				__SCREAMING_SNAKE_CASE   :			List[str]=True   ,				__SCREAMING_SNAKE_CASE   :			Any=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			str=True   ,				__SCREAMING_SNAKE_CASE   :			Dict=99   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=24   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			Any=6   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]=37   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]="gelu"   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=0.1   ,				__SCREAMING_SNAKE_CASE   :			int=512   ,				__SCREAMING_SNAKE_CASE   :			str=16   ,				__SCREAMING_SNAKE_CASE   :			Any=2   ,				__SCREAMING_SNAKE_CASE   :			List[str]=0.02   ,				__SCREAMING_SNAKE_CASE   :			int=3   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]=None   ,				__SCREAMING_SNAKE_CASE   :			List[Any]=1_000   ,				)    ->					int:


      """simple docstring"""




      __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  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Optional[int]:


      """simple docstring"""




      __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  UpperCAmelCase__						(						self   :			str     )    ->					int:


      """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   :			int   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			int   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = model(__SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_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  UpperCAmelCase__						(						self   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Union[str, Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				)    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.num_labels
      __SCREAMING_SNAKE_CASE      = LiltForTokenClassification(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				labels=__SCREAMING_SNAKE_CASE     )
      self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)     )
 def  UpperCAmelCase__						(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			List[str]   ,				__SCREAMING_SNAKE_CASE   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Optional[Any]   ,				)    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltForQuestionAnswering(config=__SCREAMING_SNAKE_CASE     )
      model.to(__SCREAMING_SNAKE_CASE     )
      model.eval()
      __SCREAMING_SNAKE_CASE      = model(
          __SCREAMING_SNAKE_CASE   ,				bbox=__SCREAMING_SNAKE_CASE   ,				attention_mask=__SCREAMING_SNAKE_CASE   ,				token_type_ids=__SCREAMING_SNAKE_CASE   ,				start_positions=__SCREAMING_SNAKE_CASE   ,				end_positions=__SCREAMING_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  UpperCAmelCase__						(						self   :			Dict     )    ->					str:


      """simple docstring"""




      __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 		lowerCAmelCase__  ( a					,   a					,   a					,   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  UpperCAmelCase__						(						self   :			Optional[int]   ,				__SCREAMING_SNAKE_CASE   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			Dict   ,				__SCREAMING_SNAKE_CASE   :			str   ,				__SCREAMING_SNAKE_CASE   :			int     )    ->					str:


      """simple docstring"""




      return True
 def  UpperCAmelCase__						(						self   :			List[Any]     )    ->					Dict:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModelTester(self     )
      __SCREAMING_SNAKE_CASE      = ConfigTester(self   ,				config_class=__SCREAMING_SNAKE_CASE   ,				hidden_size=37     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					Any:


      """simple docstring"""




      self.config_tester.run_common_tests()
 def  UpperCAmelCase__						(						self   :			Optional[Any]     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[str]     )    ->					Optional[Any]:


      """simple docstring"""




      __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(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			int     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Any     )    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE     )


 @slow
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					int:


      """simple docstring"""




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







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



 """simple docstring"""



 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = LiltModel.from_pretrained("""SCUT-DLVCLab/lilt-roberta-en-base"""     ).to(__SCREAMING_SNAKE_CASE     )

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

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

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

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






