






"""simple docstring"""






import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase_   : Any   			= logging.get_logger(__name__)



def 					_A			(__a    ,				__a=False    ,				__a=False							) ->       Optional[int]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  int    						=		'''backbone.''' if is_semantic else ''''''

    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		[]
    for i in range(config.num_hidden_layers							):
        # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
        rename_keys.append((f'{prefix}blocks.{i}.norm1.weight', f'beit.encoder.layer.{i}.layernorm_before.weight')							)
        rename_keys.append((f'{prefix}blocks.{i}.norm1.bias', f'beit.encoder.layer.{i}.layernorm_before.bias')							)
        rename_keys.append(
            (f'{prefix}blocks.{i}.attn.proj.weight', f'beit.encoder.layer.{i}.attention.output.dense.weight')							)
        rename_keys.append(
            (f'{prefix}blocks.{i}.attn.proj.bias', f'beit.encoder.layer.{i}.attention.output.dense.bias')							)
        rename_keys.append((f'{prefix}blocks.{i}.norm2.weight', f'beit.encoder.layer.{i}.layernorm_after.weight')							)
        rename_keys.append((f'{prefix}blocks.{i}.norm2.bias', f'beit.encoder.layer.{i}.layernorm_after.bias')							)
        rename_keys.append((f'{prefix}blocks.{i}.mlp.fc1.weight', f'beit.encoder.layer.{i}.intermediate.dense.weight')							)
        rename_keys.append((f'{prefix}blocks.{i}.mlp.fc1.bias', f'beit.encoder.layer.{i}.intermediate.dense.bias')							)
        rename_keys.append((f'{prefix}blocks.{i}.mlp.fc2.weight', f'beit.encoder.layer.{i}.output.dense.weight')							)
        rename_keys.append((f'{prefix}blocks.{i}.mlp.fc2.bias', f'beit.encoder.layer.{i}.output.dense.bias')							)

    # projection layer + position embeddings
    rename_keys.extend(
        [
            (f'{prefix}cls_token', '''beit.embeddings.cls_token'''),
            (f'{prefix}patch_embed.proj.weight', '''beit.embeddings.patch_embeddings.projection.weight'''),
            (f'{prefix}patch_embed.proj.bias', '''beit.embeddings.patch_embeddings.projection.bias'''),
            (f'{prefix}pos_embed', '''beit.embeddings.position_embeddings'''),
        ]							)

    if has_lm_head:
        # mask token + layernorm
        rename_keys.extend(
            [
                ('''mask_token''', '''beit.embeddings.mask_token'''),
                ('''norm.weight''', '''layernorm.weight'''),
                ('''norm.bias''', '''layernorm.bias'''),
            ]							)
    else:
        # layernorm + classification head
        rename_keys.extend(
            [
                ('''fc_norm.weight''', '''beit.pooler.layernorm.weight'''),
                ('''fc_norm.bias''', '''beit.pooler.layernorm.bias'''),
                ('''head.weight''', '''classifier.weight'''),
                ('''head.bias''', '''classifier.bias'''),
            ]							)

    return rename_keys



def 					_A			(__a    ,				__a    ,				__a=False    ,				__a=False							) ->       Union[str, Any]:
    """simple docstring"""






    for i in range(config.num_hidden_layers							):
        SCREAMING_SNAKE_CASE_      :  Dict    						=		'''backbone.''' if is_semantic else ''''''
        # queries, keys and values
        SCREAMING_SNAKE_CASE_      :  List[str]    						=		state_dict.pop(f'{prefix}blocks.{i}.attn.qkv.weight'							)
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		state_dict.pop(f'{prefix}blocks.{i}.attn.q_bias'							)
        SCREAMING_SNAKE_CASE_      :  Any    						=		state_dict.pop(f'{prefix}blocks.{i}.attn.v_bias'							)

        SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		in_proj_weight[
            : config.hidden_size, :
        ]
        SCREAMING_SNAKE_CASE_      :  Dict    						=		q_bias
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		in_proj_weight[
            config.hidden_size : config.hidden_size * 2, :
        ]
        SCREAMING_SNAKE_CASE_      :  List[str]    						=		in_proj_weight[
            -config.hidden_size :, :
        ]
        SCREAMING_SNAKE_CASE_      :  Tuple    						=		v_bias

        # gamma_1 and gamma_2
        # we call them lambda because otherwise they are renamed when using .from_pretrained
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		state_dict.pop(f'{prefix}blocks.{i}.gamma_1'							)
        SCREAMING_SNAKE_CASE_      :  Dict    						=		state_dict.pop(f'{prefix}blocks.{i}.gamma_2'							)

        SCREAMING_SNAKE_CASE_      :  int    						=		gamma_a
        SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		gamma_a



def 					_A			(__a    ,				__a    ,				__a							) ->       List[Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		dct.pop(__a							)
    SCREAMING_SNAKE_CASE_      :  int    						=		val



def 					_A			() ->       List[Any]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  str    						=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
    SCREAMING_SNAKE_CASE_      :  Any    						=		Image.open(requests.get(__a    ,				stream=__a							).raw							)
    return im



@torch.no_grad()
def 					_A			(__a    ,				__a    ,				__a=False							) ->       int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		False if '''rvlcdip''' in checkpoint_url else True
    SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		BeitConfig(use_absolute_position_embeddings=__a    ,				use_mask_token=__a							)

    # size of the architecture
    if "large" in checkpoint_url or "dit-l" in checkpoint_url:
        SCREAMING_SNAKE_CASE_      :  List[str]    						=		10_24
        SCREAMING_SNAKE_CASE_      :  Tuple    						=		40_96
        SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		24
        SCREAMING_SNAKE_CASE_      :  Tuple    						=		16

    # labels
    if "rvlcdip" in checkpoint_url:
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		16
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		'''huggingface/label-files'''
        SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		'''rvlcdip-id2label.json'''
        SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		json.load(open(hf_hub_download(__a    ,				__a    ,				repo_type='''dataset'''							)    ,				'''r'''							)							)
        SCREAMING_SNAKE_CASE_      :  Any    						=		{int(__a							): v for k, v in idalabel.items()}
        SCREAMING_SNAKE_CASE_      :  str    						=		idalabel
        SCREAMING_SNAKE_CASE_      :  Tuple    						=		{v: k for k, v in idalabel.items()}

    # load state_dict of original model, remove and rename some keys
    SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		torch.hub.load_state_dict_from_url(__a    ,				map_location='''cpu'''							)['''model''']

    SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		create_rename_keys(__a    ,				has_lm_head=__a							)
    for src, dest in rename_keys:
        rename_key(__a    ,				__a    ,				__a							)
    read_in_q_k_v(__a    ,				__a    ,				has_lm_head=__a							)

    # load HuggingFace model
    SCREAMING_SNAKE_CASE_      :  Dict    						=		BeitForMaskedImageModeling(__a							) if has_lm_head else BeitForImageClassification(__a							)
    model.eval()
    model.load_state_dict(__a							)

    # Check outputs on an image
    SCREAMING_SNAKE_CASE_      :  Dict    						=		BeitImageProcessor(
        size=config.image_size    ,				resample=PILImageResampling.BILINEAR    ,				do_center_crop=__a							)
    SCREAMING_SNAKE_CASE_      :  int    						=		prepare_img()

    SCREAMING_SNAKE_CASE_      :  List[str]    						=		image_processor(images=__a    ,				return_tensors='''pt'''							)
    SCREAMING_SNAKE_CASE_      :  List[Any]    						=		encoding['''pixel_values''']

    SCREAMING_SNAKE_CASE_      :  Any    						=		model(__a							)
    SCREAMING_SNAKE_CASE_      :  Any    						=		outputs.logits

    # verify logits
    SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		[1, 16] if '''rvlcdip''' in checkpoint_url else [1, 1_96, 81_92]
    assert logits.shape == torch.Size(__a							), "Shape of logits not as expected"

    Path(__a							).mkdir(exist_ok=__a							)
    print(f'Saving model to {pytorch_dump_folder_path}'							)
    model.save_pretrained(__a							)
    print(f'Saving image processor to {pytorch_dump_folder_path}'							)
    image_processor.save_pretrained(__a							)

    if push_to_hub:
        if has_lm_head:
            SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		'''dit-base''' if '''base''' in checkpoint_url else '''dit-large'''
        else:
            SCREAMING_SNAKE_CASE_      :  Dict    						=		'''dit-base-finetuned-rvlcdip''' if '''dit-b''' in checkpoint_url else '''dit-large-finetuned-rvlcdip'''
        image_processor.push_to_hub(
            repo_path_or_name=Path(__a    ,				__a							)    ,				organization='''nielsr'''    ,				commit_message='''Add image processor'''    ,				use_temp_dir=__a    ,				)
        model.push_to_hub(
            repo_path_or_name=Path(__a    ,				__a							)    ,				organization='''nielsr'''    ,				commit_message='''Add model'''    ,				use_temp_dir=__a    ,				)


if __name__ == "__main__":
  UpperCAmelCase_   : str   			= argparse.ArgumentParser()

  parser.add_argument(
      """--checkpoint_url""",
      default="""https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth""",
      type=str,
      help="""URL to the original PyTorch checkpoint (.pth file).""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
  )
  parser.add_argument(
      """--push_to_hub""",
      action="""store_true""",
  )
  UpperCAmelCase_   : List[Any]   			= parser.parse_args()
  convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)










"""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     :  Any						,	lowercase_     :  List[Any]						,	lowercase_     :  List[str]=13						,	lowercase_     :  int=7						,	lowercase_     :  Any=True						,	lowercase_     :  str=True						,	lowercase_     :  List[Any]=True						,	lowercase_     :  List[Any]=True						,	lowercase_     :  Dict=99						,	lowercase_     :  Union[str, Any]=24						,	lowercase_     :  int=2						,	lowercase_     :  List[str]=6						,	lowercase_     :  Any=37						,	lowercase_     :  Dict="gelu"						,	lowercase_     :  List[str]=0.1						,	lowercase_     :  Dict=0.1						,	lowercase_     :  Union[str, Any]=512						,	lowercase_     :  List[str]=16						,	lowercase_     :  Any=2						,	lowercase_     :  Any=0.02						,	lowercase_     :  List[Any]=3						,	lowercase_     :  Optional[int]=None						,	lowercase_     :  str=1000						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		parent
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		seq_length
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		is_training
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		use_input_mask
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		use_token_type_ids
          SCREAMING_SNAKE_CASE_      :  int    						=		use_labels
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		vocab_size
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		hidden_size
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		num_hidden_layers
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		num_attention_heads
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		intermediate_size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		hidden_act
          SCREAMING_SNAKE_CASE_      :  int    						=		hidden_dropout_prob
          SCREAMING_SNAKE_CASE_      :  str    						=		attention_probs_dropout_prob
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		max_position_embeddings
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		type_vocab_size
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		type_sequence_label_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		initializer_range
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		num_labels
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		scope
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		range_bbox
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.vocab_size)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		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_      :  Optional[int]    						=		bbox[i, j, 3]
                      SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		bbox[i, j, 1]
                      SCREAMING_SNAKE_CASE_      :  str    						=		t
                  if bbox[i, j, 2] < bbox[i, j, 0]:
                      SCREAMING_SNAKE_CASE_      :  List[str]    						=		bbox[i, j, 2]
                      SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		bbox[i, j, 0]
                      SCREAMING_SNAKE_CASE_      :  List[str]    						=		t

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		None
          if self.use_input_mask:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		ids_tensor([self.batch_size, self.seq_length]						,	vocab_size=2)

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		None
          if self.use_token_type_ids:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.type_vocab_size)

          SCREAMING_SNAKE_CASE_      :  List[str]    						=		None
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		None
          if self.use_labels:
              SCREAMING_SNAKE_CASE_      :  int    						=		ids_tensor([self.batch_size]						,	self.type_sequence_label_size)
              SCREAMING_SNAKE_CASE_      :  Dict    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.num_labels)

          SCREAMING_SNAKE_CASE_      :  Any    						=		self.get_config()

          return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[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 _SCREAMING_SNAKE_CASE (						self     :  Optional[int]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  str						,	lowercase_     :  Optional[Any]						,	lowercase_     :  int						,	lowercase_     :  Optional[Any]						,	lowercase_     :  int						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		LiltModel(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model(lowercase_						,	bbox=lowercase_						,	attention_mask=lowercase_						,	token_type_ids=lowercase_)
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model(lowercase_						,	bbox=lowercase_						,	token_type_ids=lowercase_)
          SCREAMING_SNAKE_CASE_      :  int    						=		model(lowercase_						,	bbox=lowercase_)

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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.num_labels
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		LiltForTokenClassification(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		model(
              lowercase_						,	bbox=lowercase_						,	attention_mask=lowercase_						,	token_type_ids=lowercase_						,	labels=lowercase_)
          self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.seq_length, self.num_labels))
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple						,	lowercase_     :  str						,	lowercase_     :  Union[str, Any]						,	lowercase_     :  Any						,	lowercase_     :  Dict						,	lowercase_     :  List[str]						,	lowercase_     :  List[Any]						,	lowercase_     :  str						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		LiltForQuestionAnswering(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		model(
              lowercase_						,	bbox=lowercase_						,	attention_mask=lowercase_						,	token_type_ids=lowercase_						,	start_positions=lowercase_						,	end_positions=lowercase_						,	)
          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 _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  str    						=		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_
          )						,			
          )      :  List[str]    						=		config_and_inputs
          SCREAMING_SNAKE_CASE_      :  str    						=		{
              '''input_ids''': input_ids,
              '''bbox''': bbox,
              '''token_type_ids''': token_type_ids,
              '''attention_mask''': input_mask,
          }
          return config, inputs_dict




@require_torch
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		UpperCAmelCase__				,		UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  (
          (
              LiltModel,
              LiltForSequenceClassification,
              LiltForTokenClassification,
              LiltForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      __UpperCamelCase	 =  (
          {
              "feature-extraction": LiltModel,
              "question-answering": LiltForQuestionAnswering,
              "text-classification": LiltForSequenceClassification,
              "token-classification": LiltForTokenClassification,
              "zero-shot": LiltForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      def _SCREAMING_SNAKE_CASE (						self     :  Any						,	lowercase_     :  List[str]						,	lowercase_     :  Optional[int]						,	lowercase_     :  Optional[int]						,	lowercase_     :  str						,	lowercase_     :  str):




          '''simple docstring'''


          return True
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		LiltModelTester(self)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ConfigTester(self						,	config_class=lowercase_						,	hidden_size=37)
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          self.config_tester.run_common_tests()
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		type
              self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*lowercase_)



      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		LiltModel.from_pretrained(lowercase_)
              self.assertIsNotNone(lowercase_)




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






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base''').to(lowercase_)

          SCREAMING_SNAKE_CASE_      :  str    						=		torch.tensor([[1, 2]]						,	device=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]						,	device=lowercase_)

          # forward pass
          with torch.no_grad():
              SCREAMING_SNAKE_CASE_      :  Dict    						=		model(input_ids=lowercase_						,	bbox=lowercase_)

          SCREAMING_SNAKE_CASE_      :  str    						=		torch.Size([1, 2, 768])
          SCREAMING_SNAKE_CASE_      :  Dict    						=		torch.tensor(
              [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]						,	device=lowercase_						,	)

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


