




'''simple docstring'''


import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
_snake_case				:				Tuple       							=		logging.get_logger(__name__)
def 		snake_case_   (UpperCamelCase	:  List[Any]			,						UpperCamelCase	:  Optional[int]=False				):





							'''simple docstring'''


							_a     					=    []

							# fmt: off
							# stem:
							rename_keys.append(('''cls_token''', '''vit.embeddings.cls_token''')				)
							rename_keys.append(('''pos_embed''', '''vit.embeddings.position_embeddings''')				)

							rename_keys.append(('''patch_embed.proj.weight''', '''vit.embeddings.patch_embeddings.projection.weight''')				)
							rename_keys.append(('''patch_embed.proj.bias''', '''vit.embeddings.patch_embeddings.projection.bias''')				)

							# backbone
							rename_keys.append(('''patch_embed.backbone.stem.conv.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight''')				)
							rename_keys.append(('''patch_embed.backbone.stem.norm.weight''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight''')				)
							rename_keys.append(('''patch_embed.backbone.stem.norm.bias''', '''vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias''')				)

							for stage_idx in range(len(config.backbone_config.depths				)				):
														for layer_idx in range(config.backbone_config.depths[stage_idx]				):
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight')				)
																					rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias')				)

														rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight')				)
														rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight')				)
														rename_keys.append((f'patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias', f'vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias')				)

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

							if base_model:
														# layernorm + pooler
														rename_keys.extend(
														    [
														        ('''norm.weight''', '''layernorm.weight'''),
														        ('''norm.bias''', '''layernorm.bias'''),
														        ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
														        ('''pre_logits.fc.bias''', '''pooler.dense.bias'''),
														    ]				)

														# if just the base model, we should remove "vit" from all keys that start with "vit"
														_a     					=    [(pair[0], pair[1][4:]) if pair[1].startswith('''vit'''				) else pair for pair in rename_keys]
							else:
														# layernorm + classification head
														rename_keys.extend(
														    [
														        ('''norm.weight''', '''vit.layernorm.weight'''),
														        ('''norm.bias''', '''vit.layernorm.bias'''),
														        ('''head.weight''', '''classifier.weight'''),
														        ('''head.bias''', '''classifier.bias'''),
														    ]				)
							# fmt: on

							return rename_keys
def 		snake_case_   (UpperCamelCase	:  Any			,						UpperCamelCase	:  List[str]			,						UpperCamelCase	:  List[Any]=False				):





							'''simple docstring'''


							for i in range(config.num_hidden_layers				):
														if base_model:
																					_a     					=    ''''''
														else:
																					_a     					=    '''vit.'''
														# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
														_a     					=    state_dict.pop(f'blocks.{i}.attn.qkv.weight'				)
														_a     					=    state_dict.pop(f'blocks.{i}.attn.qkv.bias'				)
														# next, add query, keys and values (in that order) to the state dict
														_a     					=    in_proj_weight[
														    : config.hidden_size, :
														]
														_a     					=    in_proj_bias[: config.hidden_size]
														_a     					=    in_proj_weight[
														    config.hidden_size : config.hidden_size * 2, :
														]
														_a     					=    in_proj_bias[
														    config.hidden_size : config.hidden_size * 2
														]
														_a     					=    in_proj_weight[
														    -config.hidden_size :, :
														]
														_a     					=    in_proj_bias[-config.hidden_size :]
def 		snake_case_   (UpperCamelCase	:  Any				):





							'''simple docstring'''


							_a     					=    ['''head.weight''', '''head.bias''']
							for k in ignore_keys:
														state_dict.pop(UpperCamelCase			,						UpperCamelCase				)
def 		snake_case_   (UpperCamelCase	:  Union[str, Any]			,						UpperCamelCase	:  Optional[int]			,						UpperCamelCase	:  Tuple				):





							'''simple docstring'''


							_a     					=    dct.pop(UpperCamelCase				)
							_a     					=    val
def 		snake_case_   ():





							'''simple docstring'''


							_a     					=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''
							_a     					=    Image.open(requests.get(UpperCamelCase			,						stream=UpperCamelCase				).raw				)
							return im
@torch.no_grad()
def 		snake_case_   (UpperCamelCase	:  Any			,						UpperCamelCase	:  Optional[Any]			,						UpperCamelCase	:  Union[str, Any]=False				):





							'''simple docstring'''


							_a     					=    BitConfig(
							    global_padding='''same'''			,						layer_type='''bottleneck'''			,						depths=(3, 4, 9)			,						out_features=['''stage3''']			,						embedding_dynamic_padding=UpperCamelCase			,						)
							_a     					=    ViTHybridConfig(backbone_config=UpperCamelCase			,						image_size=384			,						num_labels=1000				)
							_a     					=    False

							# load original model from timm
							_a     					=    timm.create_model(UpperCamelCase			,						pretrained=UpperCamelCase				)
							timm_model.eval()

							# load state_dict of original model, remove and rename some keys
							_a     					=    timm_model.state_dict()
							if base_model:
														remove_classification_head_(UpperCamelCase				)
							_a     					=    create_rename_keys(UpperCamelCase			,						UpperCamelCase				)
							for src, dest in rename_keys:
														rename_key(UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase				)
							read_in_q_k_v(UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase				)

							_a     					=    '''huggingface/label-files'''
							_a     					=    '''imagenet-1k-id2label.json'''
							_a     					=    json.load(open(hf_hub_download(UpperCamelCase			,						UpperCamelCase			,						repo_type='''dataset'''				)			,						'''r'''				)				)
							_a     					=    {int(UpperCamelCase				): v for k, v in idalabel.items()}
							_a     					=    idalabel
							_a     					=    {v: k for k, v in idalabel.items()}

							# load HuggingFace model
							if vit_name[-5:] == "in21k":
														_a     					=    ViTHybridModel(UpperCamelCase				).eval()
							else:
														_a     					=    ViTHybridForImageClassification(UpperCamelCase				).eval()
							model.load_state_dict(UpperCamelCase				)

							# create image processor
							_a     					=    create_transform(**resolve_data_config({}			,						model=UpperCamelCase				)				)
							_a     					=    transform.transforms

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

							_a     					=    ViTHybridImageProcessor(
							    do_resize=UpperCamelCase			,						size={'''shortest_edge''': timm_transforms[0].size}			,						resample=pillow_resamplings[timm_transforms[0].interpolation.value]			,						do_center_crop=UpperCamelCase			,						crop_size={'''height''': timm_transforms[1].size[0], '''width''': timm_transforms[1].size[1]}			,						do_normalize=UpperCamelCase			,						image_mean=timm_transforms[-1].mean.tolist()			,						image_std=timm_transforms[-1].std.tolist()			,						)

							_a     					=    prepare_img()
							_a     					=    transform(UpperCamelCase				).unsqueeze(0				)
							_a     					=    processor(UpperCamelCase			,						return_tensors='''pt'''				).pixel_values

							# verify pixel values
							assert torch.allclose(UpperCamelCase			,						UpperCamelCase				)

							# verify logits
							with torch.no_grad():
														_a     					=    model(UpperCamelCase				)
														_a     					=    outputs.logits

							print('''Predicted class:'''			,						logits.argmax(-1				).item()				)
							if base_model:
														_a     					=    timm_model.forward_features(UpperCamelCase				)
														assert timm_pooled_output.shape == outputs.pooler_output.shape
														assert torch.allclose(UpperCamelCase			,						outputs.pooler_output			,						atol=1e-3				)
							else:
														_a     					=    timm_model(UpperCamelCase				)
														assert timm_logits.shape == outputs.logits.shape
														assert torch.allclose(UpperCamelCase			,						outputs.logits			,						atol=1e-3				)
							print('''Looks ok!'''				)

							if pytorch_dump_folder_path is not None:
														Path(UpperCamelCase				).mkdir(exist_ok=UpperCamelCase				)
														print(f'Saving model {vit_name} to {pytorch_dump_folder_path}'				)
														model.save_pretrained(UpperCamelCase				)
														print(f'Saving processor to {pytorch_dump_folder_path}'				)
														processor.save_pretrained(UpperCamelCase				)

							if push_to_hub:
														print(f'Pushing model and processor to the hub {vit_name}'				)
														model.push_to_hub(f'ybelkada/{vit_name}'				)
														processor.push_to_hub(f'ybelkada/{vit_name}'				)


if __name__ == "__main__":
				_snake_case				:				Any       							=		argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--vit_name',
				    default='vit_base_r50_s16_384',
				    type=str,
				    help='Name of the hybrid ViT timm model you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
				)
				parser.add_argument(
				    '--push_to_hub', action='store_true', help='Whether to upload the model to the HuggingFace hub.'
				)

				_snake_case				:				str       							=		parser.parse_args()
				convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)







'''simple docstring'''


import os
import re
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_snake_case				:				str       							=		logging.get_logger(__name__)

_snake_case				:				Tuple       							=		{'vocab_file': 'spiece.model'}

_snake_case				:				Optional[int]       							=		{
    'vocab_file': {
        'google/bigbird-roberta-base': 'https://huggingface.co/google/bigbird-roberta-base/resolve/main/spiece.model',
        'google/bigbird-roberta-large': (
            'https://huggingface.co/google/bigbird-roberta-large/resolve/main/spiece.model'
        ),
        'google/bigbird-base-trivia-itc': (
            'https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/spiece.model'
        ),
    }
}

_snake_case				:				Tuple       							=		{
    'google/bigbird-roberta-base': 4096,
    'google/bigbird-roberta-large': 4096,
    'google/bigbird-base-trivia-itc': 4096,
}

class       A   (		_a   ):
							lowercase_          =    VOCAB_FILES_NAMES
							lowercase_          =    PRETRAINED_VOCAB_FILES_MAP
							lowercase_          =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase_          =    ['input_ids', 'attention_mask']
							lowercase_          =    []







							def __init__(  self	:  Optional[Any]							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Optional[int]="<unk>"							,      lowerCAmelCase_	:  Tuple="<s>"							,      lowerCAmelCase_	:  List[str]="</s>"							,      lowerCAmelCase_	:  int="<pad>"							,      lowerCAmelCase_	:  Union[str, Any]="[SEP]"							,      lowerCAmelCase_	:  Dict="[MASK]"							,      lowerCAmelCase_	:  Optional[int]="[CLS]"							,      lowerCAmelCase_	:  Optional[Dict[str, Any]] = None							,      **lowerCAmelCase_	:  Union[str, Any]							,      )      ->							None:


														"""simple docstring"""


														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else bos_token
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else eos_token
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else unk_token
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else pad_token
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else cls_token
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else sep_token

														# Mask token behave like a normal word, i.e. include the space before it
														_a     					=    AddedToken(lowerCAmelCase_							,      lstrip=lowerCAmelCase_							,      rstrip=lowerCAmelCase_ ) if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ) else mask_token

														_a     					=    {} if sp_model_kwargs is None else sp_model_kwargs

														super().__init__(
														    bos_token=lowerCAmelCase_							,      eos_token=lowerCAmelCase_							,      unk_token=lowerCAmelCase_							,      pad_token=lowerCAmelCase_							,      sep_token=lowerCAmelCase_							,      mask_token=lowerCAmelCase_							,      cls_token=lowerCAmelCase_							,      sp_model_kwargs=self.sp_model_kwargs							,      **lowerCAmelCase_							,      )

														_a     					=    vocab_file

														_a     					=    spm.SentencePieceProcessor(**self.sp_model_kwargs )
														self.sp_model.Load(lowerCAmelCase_ )







							@property
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							int:


														"""simple docstring"""


														return self.sp_model.get_piece_size()







							def        __lowerCAmelCase      (  self	:  str )      ->							List[str]:


														"""simple docstring"""


														_a     					=    {self.convert_ids_to_tokens(lowerCAmelCase_ ): i for i in range(self.vocab_size )}
														vocab.update(self.added_tokens_encoder )
														return vocab







							def __getstate__(  self	:  str )      ->							Tuple:


														"""simple docstring"""


														_a     					=    self.__dict__.copy()
														_a     					=    None
														return state







							def __setstate__(  self	:  List[str]							,      lowerCAmelCase_	:  Any )      ->							Dict:


														"""simple docstring"""


														_a     					=    d

														# for backward compatibility
														if not hasattr(self							,      '''sp_model_kwargs''' ):
																					_a     					=    {}

														_a     					=    spm.SentencePieceProcessor(**self.sp_model_kwargs )
														self.sp_model.Load(self.vocab_file )







							def        __lowerCAmelCase      (  self	:  Optional[int]							,      lowerCAmelCase_	:  str )      ->							List[str]:


														"""simple docstring"""


														return self.sp_model.encode(lowerCAmelCase_							,      out_type=lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  List[str] )      ->							int:


														"""simple docstring"""


														return self.sp_model.piece_to_id(lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Tuple )      ->							str:


														"""simple docstring"""


														_a     					=    self.sp_model.IdToPiece(lowerCAmelCase_ )
														return token







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  Union[str, Any] )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    []
														_a     					=    ''''''
														_a     					=    False
														for token in tokens:
																					# make sure that special tokens are not decoded using sentencepiece model
																					if token in self.all_special_tokens:
																												if not prev_is_special:
																																			out_string += " "
																												out_string += self.sp_model.decode(lowerCAmelCase_ ) + token
																												_a     					=    True
																												_a     					=    []
																					else:
																												current_sub_tokens.append(lowerCAmelCase_ )
																												_a     					=    False
														out_string += self.sp_model.decode(lowerCAmelCase_ )
														return out_string.strip()







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  List[int]							,      lowerCAmelCase_	:  bool = False							,      lowerCAmelCase_	:  bool = None							,      lowerCAmelCase_	:  bool = True							,      **lowerCAmelCase_	:  Tuple							,      )      ->							str:


														"""simple docstring"""


														_a     					=    kwargs.pop('''use_source_tokenizer'''							,      lowerCAmelCase_ )

														_a     					=    self.convert_ids_to_tokens(lowerCAmelCase_							,      skip_special_tokens=lowerCAmelCase_ )

														# To avoid mixing byte-level and unicode for byte-level BPT
														# we need to build string separately for added tokens and byte-level tokens
														# cf. https://github.com/huggingface/transformers/issues/1133
														_a     					=    []
														_a     					=    []
														for token in filtered_tokens:
																					if skip_special_tokens and token in self.all_special_ids:
																												continue
																					if token in self.added_tokens_encoder:
																												if current_sub_text:
																																			sub_texts.append(self.convert_tokens_to_string(lowerCAmelCase_ ) )
																																			_a     					=    []
																												sub_texts.append(lowerCAmelCase_ )
																					else:
																												current_sub_text.append(lowerCAmelCase_ )
														if current_sub_text:
																					sub_texts.append(self.convert_tokens_to_string(lowerCAmelCase_ ) )

														# Mimic the behavior of the Rust tokenizer:
														# No space before [MASK] and [SEP]
														if spaces_between_special_tokens:
																					_a     					=    re.sub(R''' (\[(MASK|SEP)\])'''							,      R'''\1'''							,      ''' '''.join(lowerCAmelCase_ ) )
														else:
																					_a     					=    ''''''.join(lowerCAmelCase_ )

														_a     					=    (
														    clean_up_tokenization_spaces
														    if clean_up_tokenization_spaces is not None
														    else self.clean_up_tokenization_spaces
														)
														if clean_up_tokenization_spaces:
																					_a     					=    self.clean_up_tokenization(lowerCAmelCase_ )
																					return clean_text
														else:
																					return text







							def        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Optional[str] = None )      ->							Tuple[str]:


														"""simple docstring"""


														if not os.path.isdir(lowerCAmelCase_ ):
																					logger.error(F'Vocabulary path ({save_directory}) should be a directory' )
																					return
														_a     					=    os.path.join(
														    lowerCAmelCase_							,      (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )

														if os.path.abspath(self.vocab_file ) != os.path.abspath(lowerCAmelCase_ ) and os.path.isfile(self.vocab_file ):
																					copyfile(self.vocab_file							,      lowerCAmelCase_ )
														elif not os.path.isfile(self.vocab_file ):
																					with open(lowerCAmelCase_							,      '''wb''' ) as fi:
																												_a     					=    self.sp_model.serialized_model_proto()
																												fi.write(lowerCAmelCase_ )

														return (out_vocab_file,)







							def        __lowerCAmelCase      (  self	:  int							,      lowerCAmelCase_	:  List[int]							,      lowerCAmelCase_	:  Optional[List[int]] = None )      ->							List[int]:


														"""simple docstring"""


														if token_ids_a is None:
																					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
														_a     					=    [self.cls_token_id]
														_a     					=    [self.sep_token_id]
														return cls + token_ids_a + sep + token_ids_a + sep







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  List[int]							,      lowerCAmelCase_	:  Optional[List[int]] = None							,      lowerCAmelCase_	:  bool = False )      ->							List[int]:


														"""simple docstring"""


														if already_has_special_tokens:
																					return super().get_special_tokens_mask(
																					    token_ids_a=lowerCAmelCase_							,      token_ids_a=lowerCAmelCase_							,      already_has_special_tokens=lowerCAmelCase_ )

														if token_ids_a is None:
																					return [1] + ([0] * len(lowerCAmelCase_ )) + [1]
														return [1] + ([0] * len(lowerCAmelCase_ )) + [1] + ([0] * len(lowerCAmelCase_ )) + [1]







							def        __lowerCAmelCase      (  self	:  Tuple							,      lowerCAmelCase_	:  List[int]							,      lowerCAmelCase_	:  Optional[List[int]] = None )      ->							List[int]:


														"""simple docstring"""


														_a     					=    [self.sep_token_id]
														_a     					=    [self.cls_token_id]
														if token_ids_a is None:
																					return len(cls + token_ids_a + sep ) * [0]
														return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]

