


import argparse
import json
from collections import OrderedDict
from functools import partial
from pathlib import Path

import timm
import torch
from huggingface_hub import hf_hub_download

from transformers import LevitConfig, LevitForImageClassificationWithTeacher, LevitImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase		   =			logging.get_logger()




def       a_ (       SCREAMING_SNAKE_CASE__   : int						,     SCREAMING_SNAKE_CASE__   : str						,     SCREAMING_SNAKE_CASE__   : LevitConfig						,     SCREAMING_SNAKE_CASE__   : Path						,     SCREAMING_SNAKE_CASE__   : bool = True	):
       '''simple docstring'''





       print(F'''Converting {name}...'''	)

       with torch.no_grad():
              if hidden_sizes == 128:
                     if name[-1] == "S":
                            _lowerCamelCase			:						Optional[int]            =timm.create_model('levit_128s'						,     pretrained=SCREAMING_SNAKE_CASE__	)
                     else:
                            _lowerCamelCase			:						Tuple            =timm.create_model('levit_128'						,     pretrained=SCREAMING_SNAKE_CASE__	)
              if hidden_sizes == 192:
                     _lowerCamelCase			:						Union[str, Any]            =timm.create_model('levit_192'						,     pretrained=SCREAMING_SNAKE_CASE__	)
              if hidden_sizes == 256:
                     _lowerCamelCase			:						List[Any]            =timm.create_model('levit_256'						,     pretrained=SCREAMING_SNAKE_CASE__	)
              if hidden_sizes == 384:
                     _lowerCamelCase			:						Optional[Any]            =timm.create_model('levit_384'						,     pretrained=SCREAMING_SNAKE_CASE__	)

              from_model.eval()
              _lowerCamelCase			:						Union[str, Any]            =LevitForImageClassificationWithTeacher(SCREAMING_SNAKE_CASE__	).eval()
              _lowerCamelCase			:						Optional[int]            =OrderedDict()

              _lowerCamelCase			:						Union[str, Any]            =from_model.state_dict()
              _lowerCamelCase			:						str            =list(from_model.state_dict().keys()	)
              _lowerCamelCase			:						Optional[Any]            =list(our_model.state_dict().keys()	)
              print(len(SCREAMING_SNAKE_CASE__	)						,     len(SCREAMING_SNAKE_CASE__	)	)
              for i in range(len(SCREAMING_SNAKE_CASE__	)	):
                     _lowerCamelCase			:						Optional[int]            =weights[og_keys[i]]
              our_model.load_state_dict(SCREAMING_SNAKE_CASE__	)

              _lowerCamelCase			:						int            =torch.randn((2, 3, 224, 224)	)
              _lowerCamelCase			:						Optional[int]            =from_model(SCREAMING_SNAKE_CASE__	)
              _lowerCamelCase			:						str            =our_model(SCREAMING_SNAKE_CASE__	).logits

       assert torch.allclose(SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__	), "The model logits don't match the original one."

       _lowerCamelCase			:						Optional[Any]            =name
       print(SCREAMING_SNAKE_CASE__	)

       if push_to_hub:
              our_model.save_pretrained(save_directory / checkpoint_name	)
              _lowerCamelCase			:						Union[str, Any]            =LevitImageProcessor()
              image_processor.save_pretrained(save_directory / checkpoint_name	)

              print(F'''Pushed {checkpoint_name}'''	)




def       a_ (       SCREAMING_SNAKE_CASE__   : Path						,     SCREAMING_SNAKE_CASE__   : str = None						,     SCREAMING_SNAKE_CASE__   : bool = True	):
       '''simple docstring'''





       _lowerCamelCase			:						List[str]            ='imagenet-1k-id2label.json'
       _lowerCamelCase			:						Union[str, Any]            =1_000
       _lowerCamelCase			:						List[str]            =(1, num_labels)

       _lowerCamelCase			:						str            ='huggingface/label-files'
       _lowerCamelCase			:						Any            =num_labels
       _lowerCamelCase			:						List[str]            =json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__						,     repo_type='dataset'	)						,     'r'	)	)
       _lowerCamelCase			:						List[str]            ={int(SCREAMING_SNAKE_CASE__	): v for k, v in idalabel.items()}

       _lowerCamelCase			:						Union[str, Any]            =idalabel
       _lowerCamelCase			:						Any            ={v: k for k, v in idalabel.items()}

       _lowerCamelCase			:						str            =partial(SCREAMING_SNAKE_CASE__						,     num_labels=SCREAMING_SNAKE_CASE__						,     idalabel=SCREAMING_SNAKE_CASE__						,     labelaid=SCREAMING_SNAKE_CASE__	)

       _lowerCamelCase			:						str            ={
           'levit-128S': 128,
           'levit-128': 128,
           'levit-192': 192,
           'levit-256': 256,
           'levit-384': 384,
       }

       _lowerCamelCase			:						Optional[int]            ={
           'levit-128S': ImageNetPreTrainedConfig(
               hidden_sizes=[128, 256, 384]						,     num_attention_heads=[4, 6, 8]						,     depths=[2, 3, 4]						,     key_dim=[16, 16, 16]						,     drop_path_rate=0						,     ),
           'levit-128': ImageNetPreTrainedConfig(
               hidden_sizes=[128, 256, 384]						,     num_attention_heads=[4, 8, 12]						,     depths=[4, 4, 4]						,     key_dim=[16, 16, 16]						,     drop_path_rate=0						,     ),
           'levit-192': ImageNetPreTrainedConfig(
               hidden_sizes=[192, 288, 384]						,     num_attention_heads=[3, 5, 6]						,     depths=[4, 4, 4]						,     key_dim=[32, 32, 32]						,     drop_path_rate=0						,     ),
           'levit-256': ImageNetPreTrainedConfig(
               hidden_sizes=[256, 384, 512]						,     num_attention_heads=[4, 6, 8]						,     depths=[4, 4, 4]						,     key_dim=[32, 32, 32]						,     drop_path_rate=0						,     ),
           'levit-384': ImageNetPreTrainedConfig(
               hidden_sizes=[384, 512, 768]						,     num_attention_heads=[6, 9, 12]						,     depths=[4, 4, 4]						,     key_dim=[32, 32, 32]						,     drop_path_rate=0.1						,     ),
       }

       if model_name:
              convert_weight_and_push(
                  names_to_hidden_sizes[model_name]						,     SCREAMING_SNAKE_CASE__						,     names_to_config[model_name]						,     SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__	)
       else:
              for model_name, config in names_to_config.items():
                     convert_weight_and_push(names_to_hidden_sizes[model_name]						,     SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__	)
       return config, expected_shape


if __name__ == "__main__":
 lowerCamelCase		   =			argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--model_name',
     default=None,
     type=str,
     help='The name of the model you wish to convert, it must be one of the supported Levit* architecture,',
 )
 parser.add_argument(
     '--pytorch_dump_folder_path',
     default='levit-dump-folder/',
     type=Path,
     required=False,
     help='Path to the output PyTorch model directory.',
 )
 parser.add_argument('--push_to_hub', action='store_true', help='Push model and image processor to the hub')
 parser.add_argument(
     '--no-push_to_hub',
     dest='push_to_hub',
     action='store_false',
     help='Do not push model and image processor to the hub',
 )

 lowerCamelCase		   =			parser.parse_args()
 lowerCamelCase		   =			args.pytorch_dump_folder_path
 pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
 convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)






import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


lowerCamelCase		   =			get_tests_dir('fixtures/spiece.model')




@require_sentencepiece
@require_tokenizers
class A    (  UpperCamelCase_       ,				unittest.TestCase	):
      UpperCamelCase__				:    Dict =DebertaVaTokenizer
      UpperCamelCase__				:    Union[str, Any] =DebertaVaTokenizerFast
      UpperCamelCase__				:    Optional[int] =True
      UpperCamelCase__				:    Tuple =True






      def 			lowerCamelCase			(   self		:	Tuple					)   ->		Optional[Any]:
             """simple docstring"""




             super().setUp()

             # We have a SentencePiece fixture for testing
             _lowerCamelCase			:						Optional[Any]            =DebertaVaTokenizer(lowercase_     ,  unk_token='<unk>'					)
             tokenizer.save_pretrained(self.tmpdirname					)






      def 			lowerCamelCase			(   self		:	Optional[Any]     ,  lowercase_		:	List[Any]					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						Dict            ='this is a test'
             _lowerCamelCase			:						List[Any]            ='this is a test'
             return input_text, output_text






      def 			lowerCamelCase			(   self		:	int					)   ->		str:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            ='<pad>'
             _lowerCamelCase			:						Union[str, Any]            =0

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowercase_					)     ,  lowercase_					)
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowercase_					)     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            =list(self.get_tokenizer().get_vocab().keys()					)
             self.assertEqual(vocab_keys[0]     ,  '<pad>'					)
             self.assertEqual(vocab_keys[1]     ,  '<unk>'					)
             self.assertEqual(vocab_keys[-1]     ,  '[PAD]'					)
             self.assertEqual(len(lowercase_					)     ,  3_0001					)






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		Union[str, Any]:
             """simple docstring"""




             self.assertEqual(self.get_tokenizer().vocab_size     ,  3_0000					)






      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						List[str]            =' \tHeLLo!how  \n Are yoU?  '
             _lowerCamelCase			:						List[Any]            =['▁hello', '!', 'how', '▁are', '▁you', '?']
             # fmt: on

             _lowerCamelCase			:						Any            =DebertaVaTokenizer(lowercase_     ,  do_lower_case=lowercase_					)
             _lowerCamelCase			:						Dict            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Optional[Any]            =DebertaVaTokenizerFast(lowercase_     ,  do_lower_case=lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)






      @unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'					)
      def 			lowerCamelCase			(   self		:	Tuple					)   ->		int:
             """simple docstring"""




             pass






      @unittest.skip('There is an inconsistency between slow and fast tokenizer due to a bug in the fast one.'					)
      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[Any]:
             """simple docstring"""




             pass






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		str:
             """simple docstring"""




             _lowerCamelCase			:						Optional[Any]            ='I was born in 92000, and this is falsé.'
             _lowerCamelCase			:						int            =['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
             # fmt: on

             _lowerCamelCase			:						int            =DebertaVaTokenizer(lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						List[Any]            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Union[str, Any]            =DebertaVaTokenizerFast(lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Tuple            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Dict:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            ='I was born in 92000, and this is falsé.'
             _lowerCamelCase			:						Union[str, Any]            =['▁i', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
             # fmt: on

             _lowerCamelCase			:						Optional[int]            =DebertaVaTokenizer(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Any            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						List[Any]            =DebertaVaTokenizerFast(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Optional[int]            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						int            ='I was born in 92000, and this is falsé.'
             _lowerCamelCase			:						Union[str, Any]            =['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
             # fmt: on

             _lowerCamelCase			:						Any            =DebertaVaTokenizer(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Tuple            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Tuple            =DebertaVaTokenizerFast(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						str            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Optional[Any]					)   ->		Any:
             """simple docstring"""




             _lowerCamelCase			:						Any            ='I was born in 92000, and this is falsé.'
             _lowerCamelCase			:						Optional[int]            =['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', '▁', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '▁', '.', ]
             # fmt: on

             _lowerCamelCase			:						Optional[Any]            =DebertaVaTokenizer(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Dict            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						List[str]            =DebertaVaTokenizerFast(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Optional[int]:
             """simple docstring"""




             _lowerCamelCase			:						int            =' \tHeLLo!how  \n Are yoU?  '
             _lowerCamelCase			:						Optional[Any]            =['▁', '<unk>', 'e', '<unk>', 'o', '!', 'how', '▁', '<unk>', 're', '▁yo', '<unk>', '?']
             # fmt: on

             _lowerCamelCase			:						Optional[int]            =DebertaVaTokenizer(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Any            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Optional[Any]            =DebertaVaTokenizerFast(lowercase_     ,  do_lower_case=lowercase_     ,  split_by_punct=lowercase_					)
             _lowerCamelCase			:						Any            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)

             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            =self.get_tokenizer()
             _lowerCamelCase			:						Dict            =self.get_rust_tokenizer()

             _lowerCamelCase			:						str            ='I was born in 92000, and this is falsé.'

             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_ids_to_tokens(tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)
             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						List[str]            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             _lowerCamelCase			:						Optional[int]            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Any            =self.get_rust_tokenizer()
             _lowerCamelCase			:						List[Any]            =tokenizer.encode(lowercase_					)
             _lowerCamelCase			:						str            =rust_tokenizer.encode(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Union[str, Any]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            ='This is a test'
             _lowerCamelCase			:						Optional[int]            =[13, 1, 4398, 25, 21, 1289]
             _lowerCamelCase			:						List[Any]            =['▁', 'T', 'his', '▁is', '▁a', '▁test']
             _lowerCamelCase			:						Optional[int]            =['▁', '<unk>', 'his', '▁is', '▁a', '▁test']

             _lowerCamelCase			:						Optional[Any]            =DebertaVaTokenizer(lowercase_     ,  keep_accents=lowercase_					)
             _lowerCamelCase			:						Any            =DebertaVaTokenizerFast(lowercase_     ,  keep_accents=lowercase_					)

             _lowerCamelCase			:						Any            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Tuple            =tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Union[str, Any]            =tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Dict            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Optional[int]            =rust_tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Any            =rust_tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             # fmt: off
             _lowerCamelCase			:						Optional[Any]            ='I was born in 92000, and this is falsé.'
             _lowerCamelCase			:						str            =[13, 1, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]
             _lowerCamelCase			:						Optional[int]            =['▁', 'I', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.', ]
             _lowerCamelCase			:						Dict            =['▁', '<unk>', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.', ]
             # fmt: on

             _lowerCamelCase			:						Any            =tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						List[Any]            =tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Optional[Any]            =tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)

             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.encode(lowercase_     ,  add_special_tokens=lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						List[str]            =rust_tokenizer.tokenize(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)
             _lowerCamelCase			:						Union[str, Any]            =rust_tokenizer.convert_ids_to_tokens(lowercase_					)
             self.assertListEqual(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						int            =DebertaVaTokenizer(lowercase_					)

             _lowerCamelCase			:						str            =tokenizer.encode('sequence builders'					)
             _lowerCamelCase			:						List[Any]            =tokenizer.encode('multi-sequence build'					)

             _lowerCamelCase			:						List[Any]            =tokenizer.build_inputs_with_special_tokens(lowercase_					)
             _lowerCamelCase			:						Dict            =tokenizer.build_inputs_with_special_tokens(lowercase_     ,  lowercase_					)

             self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]     ,  lowercase_					)
             self.assertEqual(
                 [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]     ,  lowercase_     ,  )






      @slow
      def 			lowerCamelCase			(   self		:	Dict					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Dict            ={'input_ids': [[1, 3_9867, 36, 1_9390, 486, 27, 3_5052, 8_1436, 18, 6_0685, 1225, 7, 3_5052, 8_1436, 18, 9367, 1_6899, 18, 1_5937, 53, 594, 773, 18, 1_6287, 3_0465, 36, 1_5937, 6, 4_1139, 38, 3_6979, 6_0763, 191, 6, 3_4132, 99, 6, 5_0538, 390, 4_3230, 6, 3_4132, 2779, 2_0850, 14, 699, 1072, 1194, 36, 382, 1_0901, 53, 7, 699, 1072, 2084, 36, 2_0422, 630, 53, 19, 105, 3049, 1896, 1053, 1_6899, 1506, 11, 3_7978, 4243, 7, 1237, 3_1869, 200, 1_6566, 654, 6, 3_5052, 8_1436, 7, 5_5630, 1_3593, 4, 2], [1, 26, 1_5011, 13, 667, 8, 1053, 18, 2_3611, 1237, 7_2356, 1_2820, 34, 10_4134, 1209, 35, 1_3313, 6627, 21, 202, 347, 7, 164, 2399, 11, 46, 4485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1232, 2864, 1_5785, 1_4951, 105, 5, 8581, 1250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=lowercase_     ,  model_name='microsoft/deberta-v2-xlarge'     ,  revision='ad6e42c1532ddf3a15c39246b63f5559d558b670'     ,  )


