





import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        NystromformerForMaskedLM,
        NystromformerForMultipleChoice,
        NystromformerForQuestionAnswering,
        NystromformerForSequenceClassification,
        NystromformerForTokenClassification,
        NystromformerModel,
    )
    from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST



class  A__       :





      def __init__(			self	,							A_	,							A_=13	,							A_=7	,							A_=True	,							A_=True	,							A_=True	,							A_=True	,							A_=99	,							A_=32	,							A_=5	,							A_=4	,							A_=37	,							A_="gelu"	,							A_=0.1	,							A_=0.1	,							A_=512	,							A_=16	,							A_=2	,							A_=0.02	,							A_=3	,							A_=4	,							A_=None	,							):
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       parent
       UpperCamelCase     : Any	     =       batch_size
       UpperCamelCase     : Optional[int]	     =       seq_length
       UpperCamelCase     : Optional[int]	     =       is_training
       UpperCamelCase     : Union[str, Any]	     =       use_input_mask
       UpperCamelCase     : str	     =       use_token_type_ids
       UpperCamelCase     : str	     =       use_labels
       UpperCamelCase     : Optional[Any]	     =       vocab_size
       UpperCamelCase     : Dict	     =       hidden_size
       UpperCamelCase     : Tuple	     =       num_hidden_layers
       UpperCamelCase     : Optional[Any]	     =       num_attention_heads
       UpperCamelCase     : str	     =       intermediate_size
       UpperCamelCase     : int	     =       hidden_act
       UpperCamelCase     : Optional[int]	     =       hidden_dropout_prob
       UpperCamelCase     : Dict	     =       attention_probs_dropout_prob
       UpperCamelCase     : Dict	     =       max_position_embeddings
       UpperCamelCase     : Union[str, Any]	     =       type_vocab_size
       UpperCamelCase     : Any	     =       type_sequence_label_size
       UpperCamelCase     : Dict	     =       initializer_range
       UpperCamelCase     : List[str]	     =       num_labels
       UpperCamelCase     : str	     =       num_choices
       UpperCamelCase     : Tuple	     =       scope





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Any	     =       ids_tensor([self.batch_size, self.seq_length]	,							self.vocab_size       )

       UpperCamelCase     : Dict	     =       None
       if self.use_input_mask:
        UpperCamelCase     : Tuple	     =       random_attention_mask([self.batch_size, self.seq_length]       )

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

       UpperCamelCase     : List[str]	     =       None
       UpperCamelCase     : Any	     =       None
       UpperCamelCase     : Tuple	     =       None
       if self.use_labels:
        UpperCamelCase     : Optional[int]	     =       ids_tensor([self.batch_size]	,							self.type_sequence_label_size       )
        UpperCamelCase     : List[str]	     =       ids_tensor([self.batch_size, self.seq_length]	,							self.num_labels       )
        UpperCamelCase     : Dict	     =       ids_tensor([self.batch_size]	,							self.num_choices       )

       UpperCamelCase     : str	     =       self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return NystromformerConfig(
           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	,							is_decoder=A_	,							initializer_range=self.initializer_range	,							)





      def 	__UpperCamelCase(			self	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : int	     =       NystromformerModel(config=A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : Dict	     =       model(A_	,							attention_mask=A_	,							token_type_ids=A_       )
       UpperCamelCase     : str	     =       model(A_	,							token_type_ids=A_       )
       UpperCamelCase     : Tuple	     =       model(A_       )
       self.parent.assertEqual(result.last_hidden_state.shape	,							(self.batch_size, self.seq_length, self.hidden_size)       )





      def 	__UpperCamelCase(			self	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       NystromformerForMaskedLM(config=A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : str	     =       model(A_	,							attention_mask=A_	,							token_type_ids=A_	,							labels=A_       )
       self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.seq_length, self.vocab_size)       )





      def 	__UpperCamelCase(			self	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       NystromformerForQuestionAnswering(config=A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : Dict	     =       model(
           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	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       self.num_labels
       UpperCamelCase     : List[str]	     =       NystromformerForSequenceClassification(A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : Any	     =       model(A_	,							attention_mask=A_	,							token_type_ids=A_	,							labels=A_       )
       self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.num_labels)       )





      def 	__UpperCamelCase(			self	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : str	     =       self.num_labels
       UpperCamelCase     : List[Any]	     =       NystromformerForTokenClassification(config=A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : Dict	     =       model(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	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       self.num_choices
       UpperCamelCase     : List[Any]	     =       NystromformerForMultipleChoice(config=A_       )
       model.to(A_       )
       model.eval()
       UpperCamelCase     : Any	     =       input_ids.unsqueeze(1       ).expand(-1	,							self.num_choices	,							-1       ).contiguous()
       UpperCamelCase     : str	     =       token_type_ids.unsqueeze(1       ).expand(-1	,							self.num_choices	,							-1       ).contiguous()
       UpperCamelCase     : List[Any]	     =       input_mask.unsqueeze(1       ).expand(-1	,							self.num_choices	,							-1       ).contiguous()
       UpperCamelCase     : Union[str, Any]	     =       model(
           A_	,							attention_mask=A_	,							token_type_ids=A_	,							labels=A_	,							)
       self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.num_choices)       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   (
           UpperCamelCase
       )     ,   
       )     : Optional[Any]	     =       config_and_inputs
       UpperCamelCase     : Optional[Any]	     =       {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict



@require_torch
class  A__       (	__snake_case	,       __snake_case	,       unittest.TestCase      ):
      _UpperCAmelCase     :Tuple						   =       (
          (
              NystromformerModel,
              NystromformerForMaskedLM,
              NystromformerForMultipleChoice,
              NystromformerForQuestionAnswering,
              NystromformerForSequenceClassification,
              NystromformerForTokenClassification,
          )
          if is_torch_available()
          else ()
      )
      _UpperCAmelCase     :List[str]						   =       (
          {
              'feature-extraction': NystromformerModel,
              'fill-mask': NystromformerForMaskedLM,
              'question-answering': NystromformerForQuestionAnswering,
              'text-classification': NystromformerForSequenceClassification,
              'token-classification': NystromformerForTokenClassification,
              'zero-shot': NystromformerForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      _UpperCAmelCase     :Tuple						   =       False
      _UpperCAmelCase     :int						   =       False





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       NystromformerModelTester(self       )
       UpperCamelCase     : int	     =       ConfigTester(self	,							config_class=A_	,							hidden_size=37       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       self.config_tester.run_common_tests()





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : str	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
        UpperCamelCase     : Optional[int]	     =       type
        self.model_tester.create_and_check_model(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*A_       )





      @slow
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCamelCase     : Union[str, Any]	     =       NystromformerModel.from_pretrained(A_       )
        self.assertIsNotNone(A_       )



@require_torch
class  A__       (	unittest.TestCase      ):





      @slow
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : int	     =       NystromformerModel.from_pretrained("uw-madison/nystromformer-512"       )
       UpperCamelCase     : Optional[Any]	     =       torch.tensor([[0, 1, 2, 3, 4, 5]]       )

       with torch.no_grad():
        UpperCamelCase     : List[Any]	     =       model(A_       )[0]

       UpperCamelCase     : Union[str, Any]	     =       torch.Size((1, 6, 768)       )
       self.assertEqual(output.shape	,							A_       )

       UpperCamelCase     : int	     =       torch.tensor(
           [[[-0.45_32, -0.09_36, 0.51_37], [-0.26_76, 0.06_28, 0.61_86], [-0.36_29, -0.17_26, 0.47_16]]]       )

       self.assertTrue(torch.allclose(output[:, :3, :3]	,							A_	,							atol=1e-4       )       )





      @slow
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       "the [MASK] of Belgium is Brussels"

       UpperCamelCase     : Any	     =       AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"       )
       UpperCamelCase     : Dict	     =       NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"       )

       UpperCamelCase     : List[Any]	     =       tokenizer(A_	,							return_tensors="pt"       )

       with torch.no_grad():
        UpperCamelCase     : List[str]	     =       model(encoding.input_ids       ).logits

       UpperCamelCase     : Dict	     =       token_logits[:, 2, :].argmax(-1       )[0]

       self.assertEqual(tokenizer.decode(A_       )	,							"capital"       )







import unittest

from transformers import AlbertTokenizer, AlbertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__lowerCamelCase	:					Dict			  =					get_tests_dir("""fixtures/spiece.model""")



@require_sentencepiece
@require_tokenizers
class  A__       (	__snake_case	,       unittest.TestCase      ):
      _UpperCAmelCase     :int						   =       AlbertTokenizer
      _UpperCAmelCase     :int						   =       AlbertTokenizerFast
      _UpperCAmelCase     :int						   =       True
      _UpperCAmelCase     :List[str]						   =       True
      _UpperCAmelCase     :Optional[Any]						   =       True





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       super().setUp()

       # We have a SentencePiece fixture for testing
       UpperCamelCase     : List[str]	     =       AlbertTokenizer(A_       )
       tokenizer.save_pretrained(self.tmpdirname       )





      def 	__UpperCamelCase(			self	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       "this is a test"
       UpperCamelCase     : List[Any]	     =       "this is a test"
       return input_text, output_text





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       "<pad>"
       UpperCamelCase     : Dict	     =       0

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





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       list(self.get_tokenizer().get_vocab().keys()       )

       self.assertEqual(vocab_keys[0]	,							"<pad>"       )
       self.assertEqual(vocab_keys[1]	,							"<unk>"       )
       self.assertEqual(vocab_keys[-1]	,							"▁eloquent"       )
       self.assertEqual(len(A_       )	,							3_0000       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




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





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       if not self.test_rust_tokenizer:
        return

       UpperCamelCase     : Any	     =       self.get_tokenizer()
       UpperCamelCase     : Optional[int]	     =       self.get_rust_tokenizer()

       UpperCamelCase     : List[Any]	     =       "I was born in 92000, and this is falsé."

       UpperCamelCase     : Optional[Any]	     =       tokenizer.tokenize(A_       )
       UpperCamelCase     : Optional[int]	     =       rust_tokenizer.tokenize(A_       )
       self.assertListEqual(A_	,							A_       )

       UpperCamelCase     : Optional[Any]	     =       tokenizer.encode(A_	,							add_special_tokens=A_       )
       UpperCamelCase     : Optional[int]	     =       rust_tokenizer.encode(A_	,							add_special_tokens=A_       )
       self.assertListEqual(A_	,							A_       )

       UpperCamelCase     : List[Any]	     =       self.get_rust_tokenizer()
       UpperCamelCase     : Union[str, Any]	     =       tokenizer.encode(A_       )
       UpperCamelCase     : Optional[int]	     =       rust_tokenizer.encode(A_       )
       self.assertListEqual(A_	,							A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       AlbertTokenizer(A_	,							keep_accents=A_       )

       UpperCamelCase     : Optional[int]	     =       tokenizer.tokenize("This is a test"       )
       self.assertListEqual(A_	,							["▁this", "▁is", "▁a", "▁test"]       )

       self.assertListEqual(tokenizer.convert_tokens_to_ids(A_       )	,							[48, 25, 21, 1289]       )

       UpperCamelCase     : Optional[Any]	     =       tokenizer.tokenize("I was born in 92000, and this is falsé."       )
       self.assertListEqual(
           A_	,							["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "é", "."]       )
       UpperCamelCase     : Optional[int]	     =       tokenizer.convert_tokens_to_ids(A_       )
       self.assertListEqual(A_	,							[31, 23, 386, 19, 561, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]       )

       UpperCamelCase     : List[str]	     =       tokenizer.convert_ids_to_tokens(A_       )
       self.assertListEqual(
           A_	,							["▁i", "▁was", "▁born", "▁in", "▁9", "2000", ",", "▁and", "▁this", "▁is", "▁fal", "s", "<unk>", "."]	,							)





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       AlbertTokenizer(A_       )

       UpperCamelCase     : Dict	     =       tokenizer.encode("sequence builders"       )
       UpperCamelCase     : Tuple	     =       tokenizer.encode("multi-sequence build"       )

       UpperCamelCase     : str	     =       tokenizer.build_inputs_with_special_tokens(A_       )
       UpperCamelCase     : int	     =       tokenizer.build_inputs_with_special_tokens(A_	,							A_       )

       assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
       assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
           tokenizer.sep_token_id
       ]





      @slow
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       {"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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "input_ids": [[2, 2_1970, 13, 5, 6092, 167, 28, 7103, 2153, 673, 8, 7028, 1_2051, 18, 17, 7103, 2153, 673, 8, 3515, 1_8684, 8, 4461, 6, 1927, 297, 8, 1_2060, 2607, 18, 13, 5, 4461, 15, 1_0538, 38, 8, 135, 15, 822, 58, 15, 993, 1_0363, 15, 1460, 8005, 4461, 15, 993, 255, 2328, 9, 9, 9, 6, 26, 1112, 816, 3260, 13, 5, 103, 2377, 6, 17, 1112, 816, 2782, 13, 5, 103, 1_0641, 6, 29, 84, 2512, 2430, 782, 1_8684, 2761, 19, 808, 2430, 2556, 17, 855, 1480, 9477, 4091, 128, 1_1712, 15, 7103, 2153, 673, 17, 2_4883, 9990, 9, 3], [2, 1_1502, 25, 1006, 20, 782, 8, 1_1809, 855, 1732, 1_9393, 1_8667, 37, 367, 2_1018, 69, 1854, 34, 1_1860, 1_9124, 27, 156, 225, 17, 193, 4141, 19, 65, 9124, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 14, 2231, 886, 2385, 1_7659, 84, 14, 1_6792, 1952, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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=A_	,							model_name="albert-base-v2"	,							revision="6b6560eaf5ff2e250b00c50f380c5389a9c2d82e"	,							)
