
import argparse
import collections

import numpy as np
import torch
from flax import traverse_util
from tax import checkpoints

from transformers import MTaConfig, UMTaEncoderModel, UMTaForConditionalGeneration
from transformers.utils import logging


logging.set_verbosity_info()




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Tuple						,  _lowerCamelCase :			Union[str, Any]						,  _lowerCamelCase :			Union[str, Any])					->    Dict:






							'''simple docstring'''





							return params[F'{prefix}/{prefix}/relpos_bias/rel_embedding'][:, i, :]




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			List[str]						,  _lowerCamelCase :			List[str]						,  _lowerCamelCase :			Optional[int]						,  _lowerCamelCase :			int="attention")					->    Any:






							'''simple docstring'''





							__UpperCamelCase	:   List[str]			   =					np.ascontiguousarray(params[F'{prefix}/{prefix}/{layer_name}/key/kernel'][:, i, :, :])
							__UpperCamelCase	:   Optional[Any]			   =					k_tmp.reshape(k_tmp.shape[0]						,  k_tmp.shape[1] * k_tmp.shape[2])
							__UpperCamelCase	:   str			   =					np.ascontiguousarray(params[F'{prefix}/{prefix}/{layer_name}/out/kernel'][:, i, :, :])
							__UpperCamelCase	:   int			   =					o_tmp.reshape(o_tmp.shape[0] * o_tmp.shape[1]						,  o_tmp.shape[2])
							__UpperCamelCase	:   Optional[int]			   =					np.ascontiguousarray(params[F'{prefix}/{prefix}/{layer_name}/query/kernel'][:, i, :, :])
							__UpperCamelCase	:   Any			   =					q_tmp.reshape(q_tmp.shape[0]						,  q_tmp.shape[1] * q_tmp.shape[2])
							__UpperCamelCase	:   Dict			   =					np.ascontiguousarray(params[F'{prefix}/{prefix}/{layer_name}/value/kernel'][:, i, :, :])
							__UpperCamelCase	:   str			   =					v_tmp.reshape(v_tmp.shape[0]						,  v_tmp.shape[1] * v_tmp.shape[2])
							return k, o, q, v




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Tuple						,  _lowerCamelCase :			Union[str, Any]						,  _lowerCamelCase :			Dict						,  _lowerCamelCase :			int=False)					->    Dict:






							'''simple docstring'''





							if split_mlp_wi:
														__UpperCamelCase	:   List[Any]			   =					params[F'{prefix}/{prefix}/mlp/wi_0/kernel'][:, i, :]
														__UpperCamelCase	:   List[Any]			   =					params[F'{prefix}/{prefix}/mlp/wi_1/kernel'][:, i, :]
														__UpperCamelCase	:   List[str]			   =					(wi_a, wi_a)
							else:
														__UpperCamelCase	:   List[str]			   =					params[F'{prefix}/{prefix}/mlp/wi/kernel'][:, i, :]

							__UpperCamelCase	:   Tuple			   =					params[F'{prefix}/{prefix}/mlp/wo/kernel'][:, i, :]
							return wi, wo




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Dict						,  _lowerCamelCase :			Optional[Any]						,  _lowerCamelCase :			Any						,  _lowerCamelCase :			List[str])					->    int:






							'''simple docstring'''





							return params[F'{prefix}/{prefix}/{layer_name}/scale'][:, i]




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Dict						,  *, _lowerCamelCase :			Tuple						,  _lowerCamelCase :			Any						,  _lowerCamelCase :			Dict = False)					->    List[str]:






							'''simple docstring'''





							__UpperCamelCase	:   str			   =					traverse_util.flatten_dict(variables["target"])
							__UpperCamelCase	:   Dict			   =					{"""/""".join(_lowercase): v for k, v in old.items()}

							# v1.1 models have a gated GeLU with wi_0 and wi_1 instead of wi
							__UpperCamelCase	:   Any			   =					"""encoder/encoder/mlp/wi_0/kernel""" in old
							print("Split MLP:"						,  _lowercase)

							__UpperCamelCase	:   int			   =					collections.OrderedDict()

							# Shared embeddings.
							__UpperCamelCase	:   Any			   =					old["""token_embedder/embedding"""]

							# Encoder.
							for i in range(_lowercase):
														# Block i, layer 0 (Self Attention).
														__UpperCamelCase	:   str			   =					tax_layer_norm_lookup(_lowercase						,  _lowercase						,  "encoder"						,  "pre_attention_layer_norm")
														__UpperCamelCase	:   Tuple			   =					tax_attention_lookup(_lowercase						,  _lowercase						,  "encoder"						,  "attention")
														__UpperCamelCase	:   Optional[Any]			   =					layer_norm
														__UpperCamelCase	:   Union[str, Any]			   =					k.T
														__UpperCamelCase	:   Union[str, Any]			   =					o.T
														__UpperCamelCase	:   Tuple			   =					q.T
														__UpperCamelCase	:   str			   =					v.T

														# Block i, layer 1 (MLP).
														__UpperCamelCase	:   Optional[int]			   =					tax_layer_norm_lookup(_lowercase						,  _lowercase						,  "encoder"						,  "pre_mlp_layer_norm")
														__UpperCamelCase	:   List[Any]			   =					tax_mlp_lookup(_lowercase						,  _lowercase						,  "encoder"						,  _lowercase)
														__UpperCamelCase	:   Any			   =					layer_norm
														if split_mlp_wi:
																					__UpperCamelCase	:   Tuple			   =					wi[0].T
																					__UpperCamelCase	:   List[Any]			   =					wi[1].T
														else:
																					__UpperCamelCase	:   List[Any]			   =					wi.T
														__UpperCamelCase	:   Tuple			   =					wo.T
														if scalable_attention:
																					# convert the rel_embedding of each layer
																					__UpperCamelCase	:   Union[str, Any]			   =					tax_relpos_bias_lookup(
																					    _lowercase						,  _lowercase						,  "encoder").T

							__UpperCamelCase	:   List[Any]			   =					old["""encoder/encoder_norm/scale"""]

							if not scalable_attention:
														__UpperCamelCase	:   Optional[int]			   =					tax_relpos_bias_lookup(
														    _lowercase						,  0						,  "encoder").T
														__UpperCamelCase	:   List[Any]			   =					tax_relpos_bias_lookup(
														    _lowercase						,  0						,  "decoder").T

							if not is_encoder_only:
														# Decoder.
														for i in range(_lowercase):
																					# Block i, layer 0 (Self Attention).
																					__UpperCamelCase	:   List[Any]			   =					tax_layer_norm_lookup(_lowercase						,  _lowercase						,  "decoder"						,  "pre_self_attention_layer_norm")
																					__UpperCamelCase	:   Dict			   =					tax_attention_lookup(_lowercase						,  _lowercase						,  "decoder"						,  "self_attention")
																					__UpperCamelCase	:   List[Any]			   =					layer_norm
																					__UpperCamelCase	:   str			   =					k.T
																					__UpperCamelCase	:   Dict			   =					o.T
																					__UpperCamelCase	:   str			   =					q.T
																					__UpperCamelCase	:   Optional[int]			   =					v.T

																					# Block i, layer 1 (Cross Attention).
																					__UpperCamelCase	:   Union[str, Any]			   =					tax_layer_norm_lookup(_lowercase						,  _lowercase						,  "decoder"						,  "pre_cross_attention_layer_norm")
																					__UpperCamelCase	:   Any			   =					tax_attention_lookup(_lowercase						,  _lowercase						,  "decoder"						,  "encoder_decoder_attention")
																					__UpperCamelCase	:   Optional[int]			   =					layer_norm
																					__UpperCamelCase	:   Union[str, Any]			   =					k.T
																					__UpperCamelCase	:   Tuple			   =					o.T
																					__UpperCamelCase	:   int			   =					q.T
																					__UpperCamelCase	:   Optional[int]			   =					v.T

																					# Block i, layer 2 (MLP).
																					__UpperCamelCase	:   Any			   =					tax_layer_norm_lookup(_lowercase						,  _lowercase						,  "decoder"						,  "pre_mlp_layer_norm")
																					__UpperCamelCase	:   List[str]			   =					tax_mlp_lookup(_lowercase						,  _lowercase						,  "decoder"						,  _lowercase)
																					__UpperCamelCase	:   List[str]			   =					layer_norm
																					if split_mlp_wi:
																												__UpperCamelCase	:   int			   =					wi[0].T
																												__UpperCamelCase	:   Optional[int]			   =					wi[1].T
																					else:
																												__UpperCamelCase	:   Union[str, Any]			   =					wi.T
																					__UpperCamelCase	:   Tuple			   =					wo.T

																					if scalable_attention:
																												# convert the rel_embedding of each layer
																												__UpperCamelCase	:   Tuple			   =					tax_relpos_bias_lookup(_lowercase						,  _lowercase						,  "decoder").T

														__UpperCamelCase	:   int			   =					old["""decoder/decoder_norm/scale"""]

														# LM Head (only in v1.1 checkpoints, in v1.0 embeddings are used instead)
														if "decoder/logits_dense/kernel" in old:
																					__UpperCamelCase	:   Dict			   =					old["""decoder/logits_dense/kernel"""].T

							return new




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			List[Any]						,  _lowerCamelCase :			List[str])					->    Tuple:






							'''simple docstring'''





							__UpperCamelCase	:   Union[str, Any]			   =					collections.OrderedDict([(k, torch.from_numpy(v.copy())) for (k, v) in converted_params.items()])

							# Add what is missing.
							if "encoder.embed_tokens.weight" not in state_dict:
														__UpperCamelCase	:   Union[str, Any]			   =					state_dict["""shared.weight"""]

							if not is_encoder_only:
														if "decoder.embed_tokens.weight" not in state_dict:
																					__UpperCamelCase	:   Optional[int]			   =					state_dict["""shared.weight"""]

														if "lm_head.weight" not in state_dict:  # For old 1.0 models.
																					print("Using shared word embeddings as lm_head.")
																					__UpperCamelCase	:   Any			   =					state_dict["""shared.weight"""]

							return state_dict




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Tuple						,  _lowerCamelCase :			int						,  _lowerCamelCase :			Optional[Any]						,  _lowerCamelCase :			List[str]						,  _lowerCamelCase :			Any)					->    Any:






							'''simple docstring'''





							__UpperCamelCase	:   Union[str, Any]			   =					checkpoints.load_tax_checkpoint(_lowercase)
							__UpperCamelCase	:   Optional[int]			   =					convert_tax_to_pytorch(
							    _lowercase						,  num_layers=config.num_layers						,  is_encoder_only=_lowercase						,  scalable_attention=_lowercase)
							__UpperCamelCase	:   str			   =					make_state_dict(_lowercase						,  _lowercase)
							model.load_state_dict(_lowercase						,  strict=_lowercase)




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			str						,  _lowerCamelCase :			Optional[int]						,  _lowerCamelCase :			List[str]						,  _lowerCamelCase :			Tuple = False						,  _lowerCamelCase :			Tuple = False						,  )					->    Optional[int]:






							'''simple docstring'''





							__UpperCamelCase	:   Optional[Any]			   =					MTaConfig.from_json_file(_lowercase)
							print(F'Building PyTorch model from configuration: {config}')
							# Non-v1.1 checkpoints could also use T5Model, but this works for all.
							# The v1.0 checkpoints will simply have an LM head that is the word embeddings.
							if is_encoder_only:
														__UpperCamelCase	:   Optional[int]			   =					UMTaEncoderModel(_lowercase)
							else:
														__UpperCamelCase	:   Dict			   =					UMTaForConditionalGeneration(_lowercase)

							# Load weights from tf checkpoint
							load_tax_weights_in_ta(_lowercase						,  _lowercase						,  _lowercase						,  _lowercase						,  _lowercase)

							# Save pytorch-model
							print(F'Save PyTorch model to {pytorch_dump_path}')
							model.save_pretrained(_lowercase)

							# Verify that we can load the checkpoint.
							model.from_pretrained(_lowercase)
							print("Done")


if __name__ == "__main__":
		lowercase  :					Optional[int]													=       argparse.ArgumentParser(description='Converts a native T5X checkpoint into a PyTorch checkpoint.')
		# Required parameters
		parser.add_argument(
		    '--t5x_checkpoint_path', default=None, type=str, required=True, help='Path to the T5X checkpoint.'
		)
		parser.add_argument(
		    '--config_file',
		    default=None,
		    type=str,
		    required=True,
		    help='The config json file corresponding to the pre-trained T5 model.\nThis specifies the model architecture.',
		)
		parser.add_argument(
		    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
		)
		parser.add_argument(
		    '--is_encoder_only', action='store_true', help='Check if the model is encoder-decoder model', default=False
		)
		parser.add_argument(
		    '--scalable_attention',
		    action='store_true',
		    help='Whether the model uses scaled attention (umt5 model)',
		    default=False,
		)
		lowercase  :					List[str]													=       parser.parse_args()
		convert_tax_checkpoint_to_pytorch(
		    args.tax_checkpoint_path,
		    args.config_file,
		    args.pytorch_dump_path,
		    args.is_encoder_only,
		    args.scalable_attention,
		)




'''simple docstring'''




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


a   :			Any					  =    get_tests_dir("""fixtures/spiece.model""")

@require_sentencepiece
@require_tokenizers
class 			UpperCamelCase_ (							__magic_name__      ,     unittest.TestCase			):
	lowercase          = AlbertTokenizer
	lowercase          = AlbertTokenizerFast
	lowercase          = True
	lowercase          = True
	lowercase          = True





	def  _lowercase(  self    )			->			str:
								super().setUp()

								# We have a SentencePiece fixture for testing
								UpperCAmelCase     :		Optional[int]							     =		AlbertTokenizer(A    )
								tokenizer.save_pretrained(self.tmpdirname    )





	def  _lowercase(  self		,		A    )			->			int:
								UpperCAmelCase     :		Optional[int]							     =		"""this is a test"""
								UpperCAmelCase     :		Dict							     =		"""this is a test"""
								return input_text, output_text





	def  _lowercase(  self    )			->			int:
								UpperCAmelCase     :		Tuple							     =		"""<pad>"""
								UpperCAmelCase     :		Optional[int]							     =		0

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





	def  _lowercase(  self    )			->			Any:
								UpperCAmelCase     :		str							     =		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    )		,		30000    )





	def  _lowercase(  self    )			->			Tuple:
								self.assertEqual(self.get_tokenizer().vocab_size		,		30000    )





	def  _lowercase(  self    )			->			Union[str, Any]:
								if not self.test_rust_tokenizer:
															return

								UpperCAmelCase     :		int							     =		self.get_tokenizer()
								UpperCAmelCase     :		List[str]							     =		self.get_rust_tokenizer()

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

								UpperCAmelCase     :		str							     =		tokenizer.tokenize(A    )
								UpperCAmelCase     :		Optional[int]							     =		rust_tokenizer.tokenize(A    )
								self.assertListEqual(A		,		A    )

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

								UpperCAmelCase     :		Optional[Any]							     =		self.get_rust_tokenizer()
								UpperCAmelCase     :		Union[str, Any]							     =		tokenizer.encode(A    )
								UpperCAmelCase     :		Optional[int]							     =		rust_tokenizer.encode(A    )
								self.assertListEqual(A		,		A    )





	def  _lowercase(  self    )			->			Any:
								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     :		str							     =		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  _lowercase(  self    )			->			Optional[Any]:
								UpperCAmelCase     :		str							     =		AlbertTokenizer(A    )

								UpperCAmelCase     :		Optional[int]							     =		tokenizer.encode("""sequence builders"""    )
								UpperCAmelCase     :		Any							     =		tokenizer.encode("""multi-sequence build"""    )

								UpperCAmelCase     :		Optional[Any]							     =		tokenizer.build_inputs_with_special_tokens(A    )
								UpperCAmelCase     :		List[str]							     =		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  _lowercase(  self    )			->			Dict:
								# fmt: off
								UpperCAmelCase     :		Tuple							     =		{"""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, 21970, 13, 5, 6092, 167, 28, 7103, 2153, 673, 8, 7028, 12051, 18, 17, 7103, 2153, 673, 8, 3515, 18684, 8, 4461, 6, 1927, 297, 8, 12060, 2607, 18, 13, 5, 4461, 15, 10538, 38, 8, 135, 15, 822, 58, 15, 993, 10363, 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, 10641, 6, 29, 84, 2512, 2430, 782, 18684, 2761, 19, 808, 2430, 2556, 17, 855, 1480, 9477, 4091, 128, 11712, 15, 7103, 2153, 673, 17, 24883, 9990, 9, 3], [2, 11502, 25, 1006, 20, 782, 8, 11809, 855, 1732, 19393, 18667, 37, 367, 21018, 69, 1854, 34, 11860, 19124, 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, 17659, 84, 14, 16792, 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"""		,		)

