"""simple docstring"""






import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
from transformers.utils import logging


logging.set_verbosity_info()
__A			   = logging.get_logger(__name__)



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  Any:
   # initialize config
   if "resnet-50" in model_name:
      lowercase__:   Dict					=      ResNetConfig.from_pretrained('''microsoft/resnet-50''' )
   elif "resnet-101" in model_name:
      lowercase__:   Tuple					=      ResNetConfig.from_pretrained('''microsoft/resnet-101''' )
   else:
      raise ValueError('''Model name should include either resnet50 or resnet101''' )

   lowercase__:   List[Any]					=      DetrConfig(use_timm_backbone=__UpperCAmelCase       ,    backbone_config=__UpperCAmelCase )

   # set label attributes
   lowercase__:   Optional[Any]					=      '''panoptic''' in model_name
   if is_panoptic:
      lowercase__:   Any					=      2_5_0
   else:
      lowercase__:   List[str]					=      9_1
      lowercase__:   List[str]					=      '''huggingface/label-files'''
      lowercase__:   Any					=      '''coco-detection-id2label.json'''
      lowercase__:   Union[str, Any]					=      json.load(open(hf_hub_download(__UpperCAmelCase       ,    __UpperCAmelCase       ,    repo_type='''dataset''' )       ,    '''r''' ) )
      lowercase__:   int					=      {int(__UpperCAmelCase ): v for k, v in idalabel.items()}
      lowercase__:   Optional[Any]					=      idalabel
      lowercase__:   int					=      {v: k for k, v in idalabel.items()}

   return config, is_panoptic



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  Optional[Any]:
   # here we list all keys to be renamed (original name on the left, our name on the right)
   lowercase__:   int					=      []

   # stem
   # fmt: off
   rename_keys.append(('''backbone.0.body.conv1.weight''', '''backbone.conv_encoder.model.embedder.embedder.convolution.weight''') )
   rename_keys.append(('''backbone.0.body.bn1.weight''', '''backbone.conv_encoder.model.embedder.embedder.normalization.weight''') )
   rename_keys.append(('''backbone.0.body.bn1.bias''', '''backbone.conv_encoder.model.embedder.embedder.normalization.bias''') )
   rename_keys.append(('''backbone.0.body.bn1.running_mean''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_mean''') )
   rename_keys.append(('''backbone.0.body.bn1.running_var''', '''backbone.conv_encoder.model.embedder.embedder.normalization.running_var''') )
   # stages
   for stage_idx in range(len(config.backbone_config.depths ) ):
      for layer_idx in range(config.backbone_config.depths[stage_idx] ):
         # shortcut
         if layer_idx == 0:
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var""",
                ) )
         # 3 convs
         for i in range(3 ):
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean""",
                ) )
            rename_keys.append(
                (
                    F"""backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var""",
                    F"""backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var""",
                ) )
    # fmt: on

   for i in range(config.encoder_layers ):
      # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
      rename_keys.append(
          (
              F"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""",
              F"""encoder.layers.{i}.self_attn.out_proj.weight""",
          ) )
      rename_keys.append(
          (F"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", F"""encoder.layers.{i}.self_attn.out_proj.bias""") )
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""encoder.layers.{i}.fc1.weight""") )
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""encoder.layers.{i}.fc1.bias""") )
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""encoder.layers.{i}.fc2.weight""") )
      rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""encoder.layers.{i}.fc2.bias""") )
      rename_keys.append(
          (F"""transformer.encoder.layers.{i}.norm1.weight""", F"""encoder.layers.{i}.self_attn_layer_norm.weight""") )
      rename_keys.append(
          (F"""transformer.encoder.layers.{i}.norm1.bias""", F"""encoder.layers.{i}.self_attn_layer_norm.bias""") )
      rename_keys.append(
          (F"""transformer.encoder.layers.{i}.norm2.weight""", F"""encoder.layers.{i}.final_layer_norm.weight""") )
      rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""encoder.layers.{i}.final_layer_norm.bias""") )
      # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
      rename_keys.append(
          (
              F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""",
              F"""decoder.layers.{i}.self_attn.out_proj.weight""",
          ) )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""decoder.layers.{i}.self_attn.out_proj.bias""") )
      rename_keys.append(
          (
              F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""",
              F"""decoder.layers.{i}.encoder_attn.out_proj.weight""",
          ) )
      rename_keys.append(
          (
              F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""",
              F"""decoder.layers.{i}.encoder_attn.out_proj.bias""",
          ) )
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""decoder.layers.{i}.fc1.weight""") )
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""decoder.layers.{i}.fc1.bias""") )
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""decoder.layers.{i}.fc2.weight""") )
      rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""decoder.layers.{i}.fc2.bias""") )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.norm1.weight""", F"""decoder.layers.{i}.self_attn_layer_norm.weight""") )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.norm1.bias""", F"""decoder.layers.{i}.self_attn_layer_norm.bias""") )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.norm2.weight""", F"""decoder.layers.{i}.encoder_attn_layer_norm.weight""") )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.norm2.bias""", F"""decoder.layers.{i}.encoder_attn_layer_norm.bias""") )
      rename_keys.append(
          (F"""transformer.decoder.layers.{i}.norm3.weight""", F"""decoder.layers.{i}.final_layer_norm.weight""") )
      rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""decoder.layers.{i}.final_layer_norm.bias""") )

   # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
   rename_keys.extend(
       [
           ('''input_proj.weight''', '''input_projection.weight'''),
           ('''input_proj.bias''', '''input_projection.bias'''),
           ('''query_embed.weight''', '''query_position_embeddings.weight'''),
           ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
           ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
           ('''class_embed.weight''', '''class_labels_classifier.weight'''),
           ('''class_embed.bias''', '''class_labels_classifier.bias'''),
           ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
           ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
           ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
           ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
           ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
           ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
       ] )

   return rename_keys



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )  ->  Dict:
   lowercase__:   Dict					=      state_dict.pop(__UpperCAmelCase )
   lowercase__:   Any					=      val



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase=False )  ->  Optional[Any]:
   lowercase__:   Dict					=      ''''''
   if is_panoptic:
      lowercase__:   List[str]					=      '''detr.'''

   # first: transformer encoder
   for i in range(6 ):
      # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
      lowercase__:   Tuple					=      state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight""" )
      lowercase__:   Union[str, Any]					=      state_dict.pop(F"""{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias""" )
      # next, add query, keys and values (in that order) to the state dict
      lowercase__:   int					=      in_proj_weight[:2_5_6, :]
      lowercase__:   Any					=      in_proj_bias[:2_5_6]
      lowercase__:   int					=      in_proj_weight[2_5_6:5_1_2, :]
      lowercase__:   Any					=      in_proj_bias[2_5_6:5_1_2]
      lowercase__:   str					=      in_proj_weight[-2_5_6:, :]
      lowercase__:   Union[str, Any]					=      in_proj_bias[-2_5_6:]
   # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
   for i in range(6 ):
      # read in weights + bias of input projection layer of self-attention
      lowercase__:   int					=      state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight""" )
      lowercase__:   Dict					=      state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias""" )
      # next, add query, keys and values (in that order) to the state dict
      lowercase__:   int					=      in_proj_weight[:2_5_6, :]
      lowercase__:   Dict					=      in_proj_bias[:2_5_6]
      lowercase__:   Any					=      in_proj_weight[2_5_6:5_1_2, :]
      lowercase__:   Dict					=      in_proj_bias[2_5_6:5_1_2]
      lowercase__:   Tuple					=      in_proj_weight[-2_5_6:, :]
      lowercase__:   Union[str, Any]					=      in_proj_bias[-2_5_6:]
      # read in weights + bias of input projection layer of cross-attention
      lowercase__:   Any					=      state_dict.pop(
          F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight""" )
      lowercase__:   int					=      state_dict.pop(F"""{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias""" )
      # next, add query, keys and values (in that order) of cross-attention to the state dict
      lowercase__:   Dict					=      in_proj_weight_cross_attn[:2_5_6, :]
      lowercase__:   Optional[int]					=      in_proj_bias_cross_attn[:2_5_6]
      lowercase__:   int					=      in_proj_weight_cross_attn[2_5_6:5_1_2, :]
      lowercase__:   str					=      in_proj_bias_cross_attn[2_5_6:5_1_2]
      lowercase__:   List[str]					=      in_proj_weight_cross_attn[-2_5_6:, :]
      lowercase__:   Tuple					=      in_proj_bias_cross_attn[-2_5_6:]



def SCREAMING_SNAKE_CASE__			(   )  ->  Union[str, Any]:
   lowercase__:   Dict					=      '''http://images.cocodataset.org/val2017/000000039769.jpg'''
   lowercase__:   str					=      Image.open(requests.get(__UpperCAmelCase       ,    stream=__UpperCAmelCase ).raw )

   return im



@torch.no_grad()
def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase=None       ,    __UpperCAmelCase=False )  ->  int:
   lowercase__, lowercase__:   List[Any]					=      get_detr_config(__UpperCAmelCase )

   # load original model from torch hub
   lowercase__:   List[Any]					=      {
       '''detr-resnet-50''': '''detr_resnet50''',
       '''detr-resnet-101''': '''detr_resnet101''',
   }
   logger.info(F"""Converting model {model_name}...""" )
   lowercase__:   str					=      torch.hub.load('''facebookresearch/detr'''       ,    model_name_to_original_name[model_name]       ,    pretrained=__UpperCAmelCase ).eval()
   lowercase__:   Any					=      detr.state_dict()
   # rename keys
   for src, dest in create_rename_keys(__UpperCAmelCase ):
      if is_panoptic:
         lowercase__:   Union[str, Any]					=      '''detr.''' + src
      rename_key(__UpperCAmelCase       ,    __UpperCAmelCase       ,    __UpperCAmelCase )
   # query, key and value matrices need special treatment
   read_in_q_k_v(__UpperCAmelCase       ,    is_panoptic=__UpperCAmelCase )
   # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
   lowercase__:   Any					=      '''detr.model.''' if is_panoptic else '''model.'''
   for key in state_dict.copy().keys():
      if is_panoptic:
         if (
             key.startswith('''detr''' )
             and not key.startswith('''class_labels_classifier''' )
             and not key.startswith('''bbox_predictor''' )
         ):
            lowercase__:   List[str]					=      state_dict.pop(__UpperCAmelCase )
            lowercase__:   List[str]					=      val
         elif "class_labels_classifier" in key or "bbox_predictor" in key:
            lowercase__:   str					=      state_dict.pop(__UpperCAmelCase )
            lowercase__:   List[Any]					=      val
         elif key.startswith('''bbox_attention''' ) or key.startswith('''mask_head''' ):
            continue
         else:
            lowercase__:   Dict					=      state_dict.pop(__UpperCAmelCase )
            lowercase__:   Any					=      val
      else:
         if not key.startswith('''class_labels_classifier''' ) and not key.startswith('''bbox_predictor''' ):
            lowercase__:   Dict					=      state_dict.pop(__UpperCAmelCase )
            lowercase__:   List[str]					=      val

    # finally, create HuggingFace model and load state dict
   lowercase__:   List[Any]					=      DetrForSegmentation(__UpperCAmelCase ) if is_panoptic else DetrForObjectDetection(__UpperCAmelCase )
   model.load_state_dict(__UpperCAmelCase )
   model.eval()

   # verify our conversion on an image
   lowercase__:   Optional[int]					=      '''coco_panoptic''' if is_panoptic else '''coco_detection'''
   lowercase__:   List[Any]					=      DetrImageProcessor(format=__UpperCAmelCase )

   lowercase__:   Optional[int]					=      processor(images=prepare_img()       ,    return_tensors='''pt''' )
   lowercase__:   Optional[int]					=      encoding['''pixel_values''']

   lowercase__:   Optional[Any]					=      detr(__UpperCAmelCase )
   lowercase__:   Union[str, Any]					=      model(__UpperCAmelCase )

   assert torch.allclose(outputs.logits       ,    original_outputs['''pred_logits''']       ,    atol=1e-3 )
   assert torch.allclose(outputs.pred_boxes       ,    original_outputs['''pred_boxes''']       ,    atol=1e-3 )
   if is_panoptic:
      assert torch.allclose(outputs.pred_masks       ,    original_outputs['''pred_masks''']       ,    atol=1e-4 )
   print('''Looks ok!''' )

   if pytorch_dump_folder_path is not None:
      # Save model and image processor
      logger.info(F"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}...""" )
      Path(__UpperCAmelCase ).mkdir(exist_ok=__UpperCAmelCase )
      model.save_pretrained(__UpperCAmelCase )
      processor.save_pretrained(__UpperCAmelCase )

   if push_to_hub:
      # Upload model and image processor to the hub
      logger.info('''Uploading PyTorch model and image processor to the hub...''' )
      model.push_to_hub(F"""nielsr/{model_name}""" )
      processor.push_to_hub(F"""nielsr/{model_name}""" )


if __name__ == "__main__":
       __A			   = argparse.ArgumentParser()

       parser.add_argument(
           "--model_name",
           default="detr-resnet-50",
           type=str,
           choices=["detr-resnet-50", "detr-resnet-101"],
           help="Name of the DETR model you'd like to convert.",
       )
       parser.add_argument(
           "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
       )
       parser.add_argument("--push_to_hub", action="store_true", help="Whether to push the model to the hub or not.")
       __A			   = parser.parse_args()
       convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)

"""simple docstring"""






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ....tokenization_utils_fast import PreTrainedTokenizerFast
from ....utils import logging
from .tokenization_retribert import RetriBertTokenizer


__A			   = logging.get_logger(__name__)

__A			   = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

__A			   = {
    "vocab_file": {
        "yjernite/retribert-base-uncased": (
            "https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "yjernite/retribert-base-uncased": (
            "https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/tokenizer.json"
        ),
    },
}

__A			   = {
    "yjernite/retribert-base-uncased": 5_1_2,
}


__A			   = {
    "yjernite/retribert-base-uncased": {"do_lower_case": True},
}


class     UpperCAmelCase						(_UpperCAmelCase  ):



    """simple docstring"""

    _UpperCAmelCase	:Dict						    = VOCAB_FILES_NAMES
    _UpperCAmelCase	:str						    = PRETRAINED_VOCAB_FILES_MAP
    _UpperCAmelCase	:Optional[int]						    = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    _UpperCAmelCase	:Optional[int]						    = PRETRAINED_INIT_CONFIGURATION
    _UpperCAmelCase	:str						    = RetriBertTokenizer
    _UpperCAmelCase	:List[str]						    = ["input_ids", "attention_mask"]






    def __init__(   self    ,			_UpperCAmelCase=None    ,			_UpperCAmelCase=None    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase="[UNK]"    ,			_UpperCAmelCase="[SEP]"    ,			_UpperCAmelCase="[PAD]"    ,			_UpperCAmelCase="[CLS]"    ,			_UpperCAmelCase="[MASK]"    ,			_UpperCAmelCase=True    ,			_UpperCAmelCase=None    ,			**_UpperCAmelCase    ,			):
       super().__init__(
           _UpperCAmelCase    ,			tokenizer_file=_UpperCAmelCase    ,			do_lower_case=_UpperCAmelCase    ,			unk_token=_UpperCAmelCase    ,			sep_token=_UpperCAmelCase    ,			pad_token=_UpperCAmelCase    ,			cls_token=_UpperCAmelCase    ,			mask_token=_UpperCAmelCase    ,			tokenize_chinese_chars=_UpperCAmelCase    ,			strip_accents=_UpperCAmelCase    ,			**_UpperCAmelCase    ,			)

       lowercase__:   Optional[Any]					=      json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
       if (
           normalizer_state.get('''lowercase'''    ,			_UpperCAmelCase							) != do_lower_case
           or normalizer_state.get('''strip_accents'''    ,			_UpperCAmelCase							) != strip_accents
           or normalizer_state.get('''handle_chinese_chars'''    ,			_UpperCAmelCase							) != tokenize_chinese_chars
       ):
          lowercase__:   str					=      getattr(_UpperCAmelCase    ,			normalizer_state.pop('''type'''							)							)
          lowercase__:   Optional[Any]					=      do_lower_case
          lowercase__:   Tuple					=      strip_accents
          lowercase__:   str					=      tokenize_chinese_chars
          lowercase__:   Union[str, Any]					=      normalizer_class(**_UpperCAmelCase							)

       lowercase__:   List[str]					=      do_lower_case






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase=None							):
       lowercase__:   Union[str, Any]					=      [self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
          output += token_ids_a + [self.sep_token_id]

       return output






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase = None							):
       lowercase__:   Optional[int]					=      [self.sep_token_id]
       lowercase__:   Union[str, Any]					=      [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]






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase = None							):
       lowercase__:   List[str]					=      self._tokenizer.model.save(_UpperCAmelCase    ,			name=_UpperCAmelCase							)
       return tuple(_UpperCAmelCase							)
