





'''simple docstring'''






import argparse
import re
from pathlib import Path

import requests
import torch
from PIL import Image
from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor

from transformers import (
    EfficientFormerConfig,
    EfficientFormerForImageClassificationWithTeacher,
    EfficientFormerImageProcessor,
)
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling





def       lowercase_      (		lowercase__				,  lowercase__						)   ->Optional[Any]:
						_snake_case:   List[Any]  					=		old_name

						if "patch_embed" in old_name:
												_snake_case:   List[Any]  					=		old_name.split('.'						)

												if layer == "0":
																		_snake_case:   Union[str, Any]  					=		old_name.replace('0'				,  'convolution1'						)
												elif layer == "1":
																		_snake_case:   Optional[int]  					=		old_name.replace('1'				,  'batchnorm_before'						)
												elif layer == "3":
																		_snake_case:   Optional[int]  					=		old_name.replace('3'				,  'convolution2'						)
												else:
																		_snake_case:   Any  					=		old_name.replace('4'				,  'batchnorm_after'						)

						if "network" in old_name and re.search(R'\d\.\d'				,  lowercase__						):
												_snake_case:   Optional[int]  					=		R'\b\d{2}\b'
												if bool(re.search(lowercase__				,  lowercase__						)						):
																		_snake_case:   str  					=		re.search(R'\d\.\d\d.'				,  lowercase__						).group()
												else:
																		_snake_case:   List[str]  					=		re.search(R'\d\.\d.'				,  lowercase__						).group()
												if int(match[0]						) < 6:
																		_snake_case:   Dict  					=		old_name.replace(lowercase__				,  ''						)
																		_snake_case:   Any  					=		trimmed_name.replace('network'				,  match[0] + '.meta4D_layers.blocks.' + match[2:-1]						)
																		_snake_case:   Optional[Any]  					=		'intermediate_stages.' + trimmed_name
												else:
																		_snake_case:   int  					=		old_name.replace(lowercase__				,  ''						)
																		if int(match[2]						) < num_meta4D_last_stage:
																								_snake_case:   Any  					=		trimmed_name.replace('network'				,  'meta4D_layers.blocks.' + match[2]						)
																		else:
																								_snake_case:   str  					=		str(int(match[2]						) - num_meta4D_last_stage						)
																								_snake_case:   List[str]  					=		trimmed_name.replace('network'				,  'meta3D_layers.blocks.' + layer_index						)
																								if "norm1" in old_name:
																														_snake_case:   Any  					=		trimmed_name.replace('norm1'				,  'layernorm1'						)
																								elif "norm2" in old_name:
																														_snake_case:   Any  					=		trimmed_name.replace('norm2'				,  'layernorm2'						)
																								elif "fc1" in old_name:
																														_snake_case:   Optional[int]  					=		trimmed_name.replace('fc1'				,  'linear_in'						)
																								elif "fc2" in old_name:
																														_snake_case:   List[Any]  					=		trimmed_name.replace('fc2'				,  'linear_out'						)

																		_snake_case:   List[Any]  					=		'last_stage.' + trimmed_name

						elif "network" in old_name and re.search(R'.\d.'				,  lowercase__						):
												_snake_case:   Tuple  					=		old_name.replace('network'				,  'intermediate_stages'						)

						if "fc" in new_name:
												_snake_case:   Tuple  					=		new_name.replace('fc'				,  'convolution'						)
						elif ("norm1" in new_name) and ("layernorm1" not in new_name):
												_snake_case:   str  					=		new_name.replace('norm1'				,  'batchnorm_before'						)
						elif ("norm2" in new_name) and ("layernorm2" not in new_name):
												_snake_case:   str  					=		new_name.replace('norm2'				,  'batchnorm_after'						)
						if "proj" in new_name:
												_snake_case:   Tuple  					=		new_name.replace('proj'				,  'projection'						)
						if "dist_head" in new_name:
												_snake_case:   Optional[Any]  					=		new_name.replace('dist_head'				,  'distillation_classifier'						)
						elif "head" in new_name:
												_snake_case:   int  					=		new_name.replace('head'				,  'classifier'						)
						elif "patch_embed" in new_name:
												_snake_case:   List[str]  					=		'efficientformer.' + new_name
						elif new_name == "norm.weight" or new_name == "norm.bias":
												_snake_case:   Union[str, Any]  					=		new_name.replace('norm'				,  'layernorm'						)
												_snake_case:   int  					=		'efficientformer.' + new_name
						else:
												_snake_case:   List[Any]  					=		'efficientformer.encoder.' + new_name

						return new_name





def       lowercase_      (		lowercase__				,  lowercase__						)   ->Dict:
						for key in checkpoint.copy().keys():
												_snake_case:   List[Any]  					=		checkpoint.pop(lowercase__						)
												_snake_case:   int  					=		val

						return checkpoint





def       lowercase_      (		)   ->Optional[int]:
						_snake_case:   Any  					=		'http://images.cocodataset.org/val2017/000000039769.jpg'
						_snake_case:   int  					=		Image.open(requests.get(lowercase__				,  stream=lowercase__						).raw						)

						return image





def       lowercase_      (		lowercase__				,  lowercase__				,  lowercase__				,  lowercase__						)   ->Optional[int]:
						_snake_case:   Optional[Any]  					=		torch.load(lowercase__				,  map_location='cpu'						)['model']
						_snake_case:   Tuple  					=		EfficientFormerConfig.from_json_file(lowercase__						)
						_snake_case:   List[str]  					=		EfficientFormerForImageClassificationWithTeacher(lowercase__						)
						_snake_case:   Optional[Any]  					=		'_'.join(checkpoint_path.split('/'						)[-1].split('.'						)[0].split('_'						)[:-1]						)

						_snake_case:   Optional[Any]  					=		config.depths[-1] - config.num_metaad_blocks + 1
						_snake_case:   Dict  					=		convert_torch_checkpoint(lowercase__				,  lowercase__						)

						model.load_state_dict(lowercase__						)
						model.eval()

						_snake_case:   Dict  					=		{
						    'bilinear': PILImageResampling.BILINEAR,
						    'bicubic': PILImageResampling.BICUBIC,
						    'nearest': PILImageResampling.NEAREST,
						}

						# prepare image
						_snake_case:   List[Any]  					=		prepare_img()
						_snake_case:   str  					=		256
						_snake_case:   str  					=		224
						_snake_case:   Union[str, Any]  					=		EfficientFormerImageProcessor(
						    size={'shortest_edge': image_size}				,  crop_size={'height': crop_size, 'width': crop_size}				,  resample=pillow_resamplings['bicubic']				,  )
						_snake_case:   Union[str, Any]  					=		processor(images=lowercase__				,  return_tensors='pt'						).pixel_values

						# original processing pipeline
						_snake_case:   Any  					=		Compose(
						    [
						        Resize(lowercase__				,  interpolation=pillow_resamplings['bicubic']						),
						        CenterCrop(lowercase__						),
						        ToTensor(),
						        Normalize(lowercase__				,  lowercase__						),
						    ]						)
						_snake_case:   Optional[Any]  					=		image_transforms(lowercase__						).unsqueeze(0						)

						assert torch.allclose(lowercase__				,  lowercase__						)

						_snake_case:   str  					=		model(lowercase__						)
						_snake_case:   List[str]  					=		outputs.logits

						_snake_case:   Optional[int]  					=		(1, 1000)

						if "l1" in model_name:
												_snake_case:   Union[str, Any]  					=		torch.Tensor(
												    [-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9, -0.5_1_2_4, 0.4_1_8_3, -0.6_7_9_3, -1.3_7_7_7, -0.0_8_9_3, -0.7_3_5_8, -2.4_3_2_8]						)
												assert torch.allclose(logits[0, :10]				,  lowercase__				,  atol=1e-3						)
												assert logits.shape == expected_shape
						elif "l3" in model_name:
												_snake_case:   Optional[Any]  					=		torch.Tensor(
												    [-1.3_1_5_0, -1.5_4_5_6, -1.2_5_5_6, -0.8_4_9_6, -0.7_1_2_7, -0.7_8_9_7, -0.9_7_2_8, -0.3_0_5_2, 0.3_7_5_1, -0.3_1_2_7]						)
												assert torch.allclose(logits[0, :10]				,  lowercase__				,  atol=1e-3						)
												assert logits.shape == expected_shape
						elif "l7" in model_name:
												_snake_case:   List[Any]  					=		torch.Tensor(
												    [-1.0_2_8_3, -1.4_1_3_1, -0.5_6_4_4, -1.3_1_1_5, -0.5_7_8_5, -1.2_0_4_9, -0.7_5_2_8, 0.1_9_9_2, -0.3_8_2_2, -0.0_8_7_8]						)
												assert logits.shape == expected_shape
						else:
												raise ValueError(
												    F'''Unknown model checkpoint: {checkpoint_path}. Supported version of efficientformer are l1, l3 and l7'''						)

						# Save Checkpoints
						Path(lowercase__						).mkdir(exist_ok=lowercase__						)
						model.save_pretrained(lowercase__						)
						print(F'''Checkpoint successfuly converted. Model saved at {pytorch_dump_path}'''						)
						processor.save_pretrained(lowercase__						)
						print(F'''Processor successfuly saved at {pytorch_dump_path}'''						)

						if push_to_hub:
												print('Pushing model to the hub...'						)

												model.push_to_hub(
												    repo_id=F'''Bearnardd/{pytorch_dump_path}'''				,  commit_message='Add model'				,  use_temp_dir=lowercase__				,  )
												processor.push_to_hub(
												    repo_id=F'''Bearnardd/{pytorch_dump_path}'''				,  commit_message='Add image processor'				,  use_temp_dir=lowercase__				,  )


if __name__ == "__main__":
		A   : List[str]            =			argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    '--pytorch_model_path',
		    default=None,
		    type=str,
		    required=True,
		    help='Path to EfficientFormer pytorch checkpoint.',
		)
		parser.add_argument(
		    '--config_file',
		    default=None,
		    type=str,
		    required=True,
		    help='The json file for EfficientFormer model config.',
		)
		parser.add_argument(
		    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
		)

		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',
		)
		parser.set_defaults(push_to_hub=True)

		A   : Dict            =			parser.parse_args()
		convert_efficientformer_checkpoint(
		    checkpoint_path=args.pytorch_model_path,
		    efficientformer_config_file=args.config_file,
		    pytorch_dump_path=args.pytorch_dump_path,
		    push_to_hub=args.push_to_hub,
		)












'''simple docstring'''






import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


A   : Tuple             =			'▁'

A   : Optional[Any]             =			get_tests_dir('fixtures/test_sentencepiece.model')







@require_sentencepiece
@require_tokenizers
class 			lowerCamelCase					(						__UpperCAmelCase     ,							unittest.TestCase  ):
					_SCREAMING_SNAKE_CASE							   =    BigBirdTokenizer
					_SCREAMING_SNAKE_CASE							   =    BigBirdTokenizerFast
					_SCREAMING_SNAKE_CASE							   =    True
					_SCREAMING_SNAKE_CASE							   =    True


					def    SCREAMING_SNAKE_CASE_		(					self	:  str       ):





											'''simple docstring'''





											super().setUp()

											_snake_case:   Dict  					=		self.tokenizer_class(__snake_case       ,     keep_accents=__snake_case       )
											tokenizer.save_pretrained(self.tmpdirname       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  Union[str, Any]       ):





											'''simple docstring'''





											_snake_case:   List[str]  					=		'<s>'
											_snake_case:   Tuple  					=		1

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


					def    SCREAMING_SNAKE_CASE_		(					self	:  int       ):





											'''simple docstring'''





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

											self.assertEqual(vocab_keys[0]       ,     '<unk>'       )
											self.assertEqual(vocab_keys[1]       ,     '<s>'       )
											self.assertEqual(vocab_keys[-1]       ,     '[MASK]'       )
											self.assertEqual(len(__snake_case       )       ,     10_04       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  int       ):





											'''simple docstring'''





											self.assertEqual(self.get_tokenizer().vocab_size       ,     10_00       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  List[str]       ):





											'''simple docstring'''





											if not self.test_rust_tokenizer:
																	return

											_snake_case:   Optional[int]  					=		self.get_tokenizer()
											_snake_case:   Union[str, Any]  					=		self.get_rust_tokenizer()

											_snake_case:   List[str]  					=		'I was born in 92000, and this is falsé.'

											_snake_case:   str  					=		tokenizer.tokenize(__snake_case       )
											_snake_case:   Dict  					=		rust_tokenizer.tokenize(__snake_case       )
											self.assertListEqual(__snake_case       ,     __snake_case       )

											_snake_case:   Union[str, Any]  					=		tokenizer.encode(__snake_case       ,     add_special_tokens=__snake_case       )
											_snake_case:   List[Any]  					=		rust_tokenizer.encode(__snake_case       ,     add_special_tokens=__snake_case       )
											self.assertListEqual(__snake_case       ,     __snake_case       )

											_snake_case:   Optional[int]  					=		self.get_rust_tokenizer()
											_snake_case:   int  					=		tokenizer.encode(__snake_case       )
											_snake_case:   Tuple  					=		rust_tokenizer.encode(__snake_case       )
											self.assertListEqual(__snake_case       ,     __snake_case       )


					def    SCREAMING_SNAKE_CASE_		(					self	:  str       ):





											'''simple docstring'''





											_snake_case:   Tuple  					=		BigBirdTokenizer(__snake_case       ,     keep_accents=__snake_case       )

											_snake_case:   Optional[int]  					=		tokenizer.tokenize('This is a test'       )
											self.assertListEqual(__snake_case       ,     ['▁This', '▁is', '▁a', '▁t', 'est']       )

											self.assertListEqual(
											    tokenizer.convert_tokens_to_ids(__snake_case       )       ,     [2_85, 46, 10, 1_70, 3_82]       ,     )

											_snake_case:   Any  					=		tokenizer.tokenize('I was born in 92000, and this is falsé.'       )
											self.assertListEqual(
											    __snake_case       ,     [
											        SPIECE_UNDERLINE + 'I',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '9',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        's',
											        'é',
											        '.',
											    ]       ,     )
											_snake_case:   List[Any]  					=		tokenizer.convert_tokens_to_ids(__snake_case       )
											self.assertListEqual(
											    __snake_case       ,     [8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]       ,     )

											_snake_case:   Optional[Any]  					=		tokenizer.convert_ids_to_tokens(__snake_case       )
											self.assertListEqual(
											    __snake_case       ,     [
											        SPIECE_UNDERLINE + 'I',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '<unk>',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        's',
											        '<unk>',
											        '.',
											    ]       ,     )


					@cached_property
					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											return BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base'       )


					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  Dict       ):





											'''simple docstring'''





											_snake_case:   Dict  					=		'Hello World!'
											_snake_case:   Optional[int]  					=		[65, 1_85_36, 22_60, 1_01, 66]

											self.assertListEqual(__snake_case       ,     self.big_tokenizer.encode(__snake_case       )       )


					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  Union[str, Any]       ):





											'''simple docstring'''





											_snake_case:   str  					=		(
											    'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'
											    ' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'
											)
											# fmt: off
											_snake_case:   str  					=		[65, 8_71, 4_19, 3_58, 9_46, 9_91, 25_21, 4_52, 3_58, 13_57, 3_87, 77_51, 35_36, 1_12, 9_85, 4_56, 1_26, 8_65, 9_38, 54_00, 57_34, 4_58, 13_68, 4_67, 7_86, 24_62, 52_46, 11_59, 6_33, 8_65, 45_19, 4_57, 5_82, 8_52, 25_57, 4_27, 9_16, 5_08, 4_05, 3_43_24, 4_97, 3_91, 4_08, 1_13_42, 12_44, 3_85, 1_00, 9_38, 9_85, 4_56, 5_74, 3_62, 1_25_97, 32_00, 31_29, 11_72, 66]  # noqa: E231
											# fmt: on
											self.assertListEqual(__snake_case       ,     self.big_tokenizer.encode(__snake_case       )       )


					@require_torch
					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  Optional[int]       ):





											'''simple docstring'''





											import torch

											from transformers import BigBirdConfig, BigBirdModel

											# Build sequence
											_snake_case:   Tuple  					=		list(self.big_tokenizer.get_vocab().keys()       )[:10]
											_snake_case:   Union[str, Any]  					=		' '.join(__snake_case       )
											_snake_case:   Optional[Any]  					=		self.big_tokenizer.encode_plus(__snake_case       ,     return_tensors='pt'       ,     return_token_type_ids=__snake_case       )
											_snake_case:   int  					=		self.big_tokenizer.batch_encode_plus(
											    [sequence + ' ' + sequence]       ,     return_tensors='pt'       ,     return_token_type_ids=__snake_case       )

											_snake_case:   int  					=		BigBirdConfig(attention_type='original_full'       )
											_snake_case:   int  					=		BigBirdModel(__snake_case       )

											assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

											with torch.no_grad():
																	model(**__snake_case       )
																	model(**__snake_case       )


					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  List[Any]       ):





											'''simple docstring'''





											_snake_case:   Tuple  					=		BigBirdTokenizer.from_pretrained('google/bigbird-roberta-base'       )
											_snake_case:   Optional[Any]  					=		tokenizer.decode(tokenizer('Paris is the [MASK].'       ).input_ids       )

											self.assertTrue(decoded_text == '[CLS] Paris is the[MASK].[SEP]'       )




					@slow
					def    SCREAMING_SNAKE_CASE_		(					self	:  int       ):





											'''simple docstring'''





											_snake_case:   Dict  					=		{'input_ids': [[65, 3_92_86, 4_58, 3_63_35, 20_01, 4_56, 1_30_73, 1_32_66, 4_55, 1_13, 77_46, 17_41, 1_11_57, 3_91, 1_30_73, 1_32_66, 4_55, 1_13, 39_67, 3_54_12, 1_13, 49_36, 1_09, 38_70, 23_77, 1_13, 3_00_84, 4_57_20, 4_58, 1_34, 1_74_96, 1_12, 5_03, 1_16_72, 1_13, 1_18, 1_12, 56_65, 1_33_47, 3_86_87, 1_12, 14_96, 3_13_89, 1_12, 32_68, 4_72_64, 1_34, 9_62, 1_12, 1_63_77, 80_35, 2_31_30, 4_30, 1_21_69, 1_55_18, 2_85_92, 4_58, 1_46, 4_16_97, 1_09, 3_91, 1_21_69, 1_55_18, 1_66_89, 4_58, 1_46, 4_13_58, 1_09, 4_52, 7_26, 40_34, 1_11, 7_63, 3_54_12, 50_82, 3_88, 19_03, 1_11, 90_51, 3_91, 28_70, 4_89_18, 19_00, 11_23, 5_50, 9_98, 1_12, 95_86, 1_59_85, 4_55, 3_91, 4_10, 2_29_55, 3_76_36, 1_14, 66], [65, 4_48, 1_74_96, 4_19, 36_63, 3_85, 7_63, 1_13, 2_75_33, 28_70, 32_83, 1_30_43, 16_39, 2_47_13, 5_23, 6_56, 2_40_13, 1_85_50, 25_21, 5_17, 2_70_14, 2_12_44, 4_20, 12_12, 14_65, 3_91, 9_27, 48_33, 3_88, 5_78, 1_17_86, 1_14, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 4_84, 21_69, 76_87, 2_19_32, 1_81_46, 7_26, 3_63, 1_70_32, 33_91, 1_14, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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], [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]]}  # noqa: E501
											# fmt: on

											self.tokenizer_integration_test_util(
											    expected_encoding=__snake_case       ,     model_name='google/bigbird-roberta-base'       ,     revision='215c99f1600e06f83acce68422f2035b2b5c3510'       ,     )





