

'''simple docstring'''
import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
    import torch
    from torch import nn

    from transformers import ViTMAEForPreTraining, ViTMAEModel
    from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import ViTImageProcessor


class        a__  :


   def __init__(			self      ,    _UpperCamelCase      ,    _UpperCamelCase=13      ,    _UpperCamelCase=30      ,    _UpperCamelCase=2      ,    _UpperCamelCase=3      ,    _UpperCamelCase=True      ,    _UpperCamelCase=True      ,    _UpperCamelCase=32      ,    _UpperCamelCase=5      ,    _UpperCamelCase=4      ,    _UpperCamelCase=37      ,    _UpperCamelCase="gelu"      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=10      ,    _UpperCamelCase=0.0_2      ,    _UpperCamelCase=3      ,    _UpperCamelCase=0.6      ,    _UpperCamelCase=None      ,    ):





      """simple docstring"""





      _lowercase      :				List[Any]      					=       parent
      _lowercase      :				Union[str, Any]      					=       batch_size
      _lowercase      :				Optional[Any]      					=       image_size
      _lowercase      :				Any      					=       patch_size
      _lowercase      :				str      					=       num_channels
      _lowercase      :				Union[str, Any]      					=       is_training
      _lowercase      :				List[Any]      					=       use_labels
      _lowercase      :				Dict      					=       hidden_size
      _lowercase      :				Any      					=       num_hidden_layers
      _lowercase      :				Union[str, Any]      					=       num_attention_heads
      _lowercase      :				int      					=       intermediate_size
      _lowercase      :				Any      					=       hidden_act
      _lowercase      :				Tuple      					=       hidden_dropout_prob
      _lowercase      :				List[str]      					=       attention_probs_dropout_prob
      _lowercase      :				Optional[int]      					=       type_sequence_label_size
      _lowercase      :				str      					=       initializer_range
      _lowercase      :				str      					=       mask_ratio
      _lowercase      :				Optional[int]      					=       scope

      # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
      # (we add 1 for the [CLS] token)
      _lowercase      :				Union[str, Any]      					=       (image_size // patch_size) ** 2
      _lowercase      :				List[Any]      					=       int(math.ceil((1 - mask_ratio) * (num_patches + 1)  )  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[Any]      					=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

      _lowercase      :				Optional[Any]      					=       None
      if self.use_labels:
         _lowercase      :				Optional[Any]      					=       ids_tensor([self.batch_size]      ,    self.type_sequence_label_size  )

      _lowercase      :				List[Any]      					=       self.get_config()

      return config, pixel_values, labels


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      return ViTMAEConfig(
          image_size=self.image_size      ,    patch_size=self.patch_size      ,    num_channels=self.num_channels      ,    hidden_size=self.hidden_size      ,    num_hidden_layers=self.num_hidden_layers      ,    num_attention_heads=self.num_attention_heads      ,    intermediate_size=self.intermediate_size      ,    hidden_act=self.hidden_act      ,    hidden_dropout_prob=self.hidden_dropout_prob      ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,    is_decoder=_UpperCamelCase      ,    initializer_range=self.initializer_range      ,    mask_ratio=self.mask_ratio      ,    )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				Any      					=       ViTMAEModel(config=_UpperCamelCase  )
      model.to(_UpperCamelCase  )
      model.eval()
      _lowercase      :				Tuple      					=       model(_UpperCamelCase  )
      self.parent.assertEqual(result.last_hidden_state.shape      ,    (self.batch_size, self.seq_length, self.hidden_size)  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				List[str]      					=       ViTMAEForPreTraining(_UpperCamelCase  )
      model.to(_UpperCamelCase  )
      model.eval()
      _lowercase      :				Union[str, Any]      					=       model(_UpperCamelCase  )
      _lowercase      :				Tuple      					=       (self.image_size // self.patch_size) ** 2
      _lowercase      :				List[str]      					=       self.patch_size**2 * self.num_channels
      self.parent.assertEqual(result.logits.shape      ,    (self.batch_size, num_patches, expected_num_channels)  )

      # test greyscale images
      _lowercase      :				Optional[Any]      					=       1
      _lowercase      :				Union[str, Any]      					=       ViTMAEForPreTraining(_UpperCamelCase  )
      model.to(_UpperCamelCase  )
      model.eval()
      _lowercase      :				Any      					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
      _lowercase      :				Tuple      					=       model(_UpperCamelCase  )
      _lowercase      :				Dict      					=       self.patch_size**2
      self.parent.assertEqual(result.logits.shape      ,    (self.batch_size, num_patches, expected_num_channels)  )






   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       self.prepare_config_and_inputs()
      _lowercase					,				_lowercase					,				_lowercase      :				int      					=       config_and_inputs
      _lowercase      :				Tuple      					=       {"pixel_values": pixel_values}
      return config, inputs_dict




@require_torch
class        a__  (							lowerCamelCase_  ,				lowerCamelCase_  ,				unittest.TestCase  ):
   _SCREAMING_SNAKE_CASE   :					List[str]     	=							(ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE   :					str     	=							{'feature-extraction': ViTMAEModel} if is_torch_available() else {}

   _SCREAMING_SNAKE_CASE   :					Optional[Any]     	=							False
   _SCREAMING_SNAKE_CASE   :					Optional[int]     	=							False
   _SCREAMING_SNAKE_CASE   :					Dict     	=							False
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							False


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Tuple      					=       ViTMAEModelTester(self  )
      _lowercase      :				Optional[Any]      					=       ConfigTester(self      ,    config_class=_UpperCamelCase      ,    has_text_modality=_UpperCamelCase      ,    hidden_size=37  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      self.config_tester.run_common_tests()


   @unittest.skip(reason="ViTMAE does not use inputs_embeds"  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase					,				_lowercase      :				str      					=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase      :				Any      					=       model_class(_UpperCamelCase  )
         self.assertIsInstance(model.get_input_embeddings()      ,    (nn.Module)  )
         _lowercase      :				Optional[int]      					=       model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(_UpperCamelCase      ,    nn.Linear  )  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase					,				_lowercase      :				Any      					=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase      :				Optional[Any]      					=       model_class(_UpperCamelCase  )
         _lowercase      :				List[str]      					=       inspect.signature(model.forward  )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _lowercase      :				Tuple      					=       [*signature.parameters.keys()]

         _lowercase      :				Optional[int]      					=       ["pixel_values"]
         self.assertListEqual(arg_names[:1]      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[Any]      					=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				str      					=       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_pretraining(*_UpperCamelCase  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      np.random.seed(2  )

      _lowercase      :				Union[str, Any]      					=       int((pt_model.config.image_size // pt_model.config.patch_size) ** 2  )
      _lowercase      :				Optional[Any]      					=       np.random.uniform(size=(self.model_tester.batch_size, num_patches)  )
      _lowercase      :				Dict      					=       torch.from_numpy(_UpperCamelCase  )

      # Add `noise` argument.
      # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
      _lowercase      :				Tuple      					=       pt_noise

      super().check_pt_tf_models(_UpperCamelCase      ,    _UpperCamelCase      ,    _UpperCamelCase  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase					,				_lowercase      :				Tuple      					=       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         _lowercase      :				str      					=       model_class(_UpperCamelCase  )
         model.to(_UpperCamelCase  )
         model.eval()
         # make random mask reproducible
         torch.manual_seed(2  )
         with torch.no_grad():
            _lowercase      :				str      					=       model(**self._prepare_for_class(_UpperCamelCase      ,    _UpperCamelCase  )  )

         _lowercase      :				int      					=       outputs[0].cpu().numpy()
         _lowercase      :				Any      					=       0

         with tempfile.TemporaryDirectory() as tmpdirname:
            model.save_pretrained(_UpperCamelCase  )
            _lowercase      :				str      					=       model_class.from_pretrained(_UpperCamelCase  )
            model.to(_UpperCamelCase  )
            # make random mask reproducible
            torch.manual_seed(2  )
            with torch.no_grad():
               _lowercase      :				Any      					=       model(**self._prepare_for_class(_UpperCamelCase      ,    _UpperCamelCase  )  )

            # Make sure we don't have nans
            _lowercase      :				str      					=       after_outputs[0].cpu().numpy()
            _lowercase      :				Any      					=       0
            _lowercase      :				Tuple      					=       np.amax(np.abs(out_a - out_a  )  )
            self.assertLessEqual(_UpperCamelCase      ,    1E-5  )


   @unittest.skip(
       reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass


   @unittest.skip(
       reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass


   @unittest.skip(
       reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results."  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass


   @unittest.skip(reason="ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load"  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass


   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."  )
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      pass






   @slow
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowercase      :				List[str]      					=       ViTMAEModel.from_pretrained(_UpperCamelCase  )
         self.assertIsNotNone(_UpperCamelCase  )







def  _A		(     )      ->     int:
   _lowercase      :				Optional[Any]      					=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
   return image


@require_torch
@require_vision
class        a__  (							unittest.TestCase  ):


   @cached_property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      return ViTImageProcessor.from_pretrained("facebook/vit-mae-base"  ) if is_vision_available() else None






   @slow
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      np.random.seed(2  )

      _lowercase      :				Any      					=       ViTMAEForPreTraining.from_pretrained("facebook/vit-mae-base"  ).to(_UpperCamelCase  )

      _lowercase      :				Optional[int]      					=       self.default_image_processor
      _lowercase      :				List[Any]      					=       prepare_img()
      _lowercase      :				List[str]      					=       image_processor(images=_UpperCamelCase      ,    return_tensors="pt"  ).to(_UpperCamelCase  )

      # prepare a noise vector that will be also used for testing the TF model
      # (this way we can ensure that the PT and TF models operate on the same inputs)
      _lowercase      :				int      					=       ViTMAEConfig()
      _lowercase      :				Tuple      					=       int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2  )
      _lowercase      :				Dict      					=       np.random.uniform(size=(1, num_patches)  )

      # forward pass
      with torch.no_grad():
         _lowercase      :				List[str]      					=       model(**_UpperCamelCase      ,    noise=torch.from_numpy(_UpperCamelCase  ).to(device=_UpperCamelCase  )  )

      # verify the logits
      _lowercase      :				Optional[int]      					=       torch.Size((1, 196, 768)  )
      self.assertEqual(outputs.logits.shape      ,    _UpperCamelCase  )

      _lowercase      :				List[Any]      					=       torch.tensor(
          [[-0.0_5_4_8, -1.7_0_2_3, -0.9_3_2_5], [0.3_7_2_1, -0.5_6_7_0, -0.2_2_3_3], [0.8_2_3_5, -1.3_8_7_8, -0.3_5_2_4]]  )

      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]      ,    expected_slice.to(_UpperCamelCase  )      ,    atol=1E-4  )  )









'''simple docstring'''
import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


_snake_case         =  '▁'

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

_snake_case         =  {
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'}
}

_snake_case         =  {
    'google/pegasus-xsum': 512,
}


_snake_case         =  logging.get_logger(__name__)


class        a__  (							lowerCamelCase_  ):
   _SCREAMING_SNAKE_CASE   :					str     	=							VOCAB_FILES_NAMES

   _SCREAMING_SNAKE_CASE   :					Tuple     	=							VOCAB_FILES_NAMES
   _SCREAMING_SNAKE_CASE   :					Any     	=							PRETRAINED_VOCAB_FILES_MAP
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _SCREAMING_SNAKE_CASE   :					Union[str, Any]     	=							['input_ids', 'attention_mask']


   def __init__(			self      ,    _UpperCamelCase      ,    _UpperCamelCase="<pad>"      ,    _UpperCamelCase="</s>"      ,    _UpperCamelCase="<unk>"      ,    _UpperCamelCase="<mask_2>"      ,    _UpperCamelCase="<mask_1>"      ,    _UpperCamelCase=None      ,    _UpperCamelCase=103      ,    _UpperCamelCase = None      ,    **_UpperCamelCase      ,    ):





      """simple docstring"""





      _lowercase      :				Tuple      					=       offset
      if additional_special_tokens is not None:
         if not isinstance(_UpperCamelCase      ,    _UpperCamelCase  ):
            raise TypeError(
                f'''additional_special_tokens should be of type {type(_UpperCamelCase  )}, but is'''
                f''' {type(_UpperCamelCase  )}'''  )

         _lowercase      :				Dict      					=       (
             ([mask_token_sent] + additional_special_tokens)
             if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
             else additional_special_tokens
         )
         # fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
         additional_special_tokens_extended += [
             f'''<unk_{i}>''' for i in range(len(_UpperCamelCase  )      ,    self.offset - 1  )
         ]

         if len(set(_UpperCamelCase  )  ) != len(_UpperCamelCase  ):
            raise ValueError(
                "Please make sure that the provided additional_special_tokens do not contain an incorrectly"
                f''' shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}.'''  )
         _lowercase      :				List[str]      					=       additional_special_tokens_extended
      else:
         _lowercase      :				Dict      					=       [mask_token_sent] if mask_token_sent is not None else []
         additional_special_tokens += [f'''<unk_{i}>''' for i in range(2      ,    self.offset  )]

      _lowercase      :				int      					=       {} if sp_model_kwargs is None else sp_model_kwargs

      super().__init__(
          eos_token=_UpperCamelCase      ,    unk_token=_UpperCamelCase      ,    mask_token=_UpperCamelCase      ,    pad_token=_UpperCamelCase      ,    mask_token_sent=_UpperCamelCase      ,    offset=_UpperCamelCase      ,    additional_special_tokens=_UpperCamelCase      ,    sp_model_kwargs=self.sp_model_kwargs      ,    **_UpperCamelCase      ,    )
      _lowercase      :				Union[str, Any]      					=       mask_token_sent
      _lowercase      :				str      					=       vocab_file
      _lowercase      :				Dict      					=       spm.SentencePieceProcessor(**self.sp_model_kwargs  )
      self.sp_model.Load(_UpperCamelCase  )

      # add special tokens to encoder dict
      _lowercase      :				Dict[int, str]      					=       {
          0: self.pad_token,
          1: self.eos_token,
      }

      if self.mask_token_sent is not None:
         self.encoder.update(
             {
                 2: self.mask_token_sent,
                 3: self.mask_token,
             }  )

      if self.offset > 0:
         # entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
         # mask_token_sent is already added to list -> so start at 1
         self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1      ,    self.offset - 1  )}  )

      _lowercase      :				Dict[str, int]      					=       {v: k for k, v in self.encoder.items()}


   @property
   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      return len(self.sp_model  ) + self.offset


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Tuple      					=       {self.convert_ids_to_tokens(_UpperCamelCase  ): i for i in range(self.vocab_size  )}
      vocab.update(self.added_tokens_encoder  )
      return vocab


   def __getstate__(			self  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       self.__dict__.copy()
      _lowercase      :				Union[str, Any]      					=       None
      return state


   def __setstate__(			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				int      					=       d

      # for backward compatibility
      if not hasattr(self      ,    "sp_model_kwargs"  ):
         _lowercase      :				List[Any]      					=       {}

      _lowercase      :				Any      					=       spm.SentencePieceProcessor(**self.sp_model_kwargs  )
      self.sp_model.Load(self.vocab_file  )


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





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


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      if token in self.decoder:
         return self.decoder[token]
      elif token in self.added_tokens_decoder:
         return self.added_tokens_decoder[token]
      _lowercase      :				int      					=       self.sp_model.piece_to_id(_UpperCamelCase  )
      return sp_id + self.offset


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      if index in self.encoder:
         return self.encoder[index]
      elif index in self.added_tokens_encoder:
         return self.added_tokens_encoder[index]
      else:
         _lowercase      :				Any      					=       self.sp_model.IdToPiece(index - self.offset  )
      return token


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				Optional[int]      					=       []
      _lowercase      :				Optional[Any]      					=       ""
      for token in tokens:
         # make sure that special tokens are not decoded using sentencepiece model
         if token in self.all_special_tokens:
            out_string += self.sp_model.decode(_UpperCamelCase  ) + token
            _lowercase      :				Tuple      					=       []
         else:
            current_sub_tokens.append(_UpperCamelCase  )
      out_string += self.sp_model.decode(_UpperCamelCase  )
      return out_string.strip()


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase=False  ):





      """simple docstring"""





      return 1


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				int      					=       set(self.all_special_ids  )  # call it once instead of inside list comp
      all_special_ids.remove(self.unk_token_id  )  # <unk> is only sometimes special

      return [1 if x in all_special_ids else 0 for x in seq]


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase = None      ,    _UpperCamelCase = False  ):





      """simple docstring"""





      if already_has_special_tokens:
         return self._special_token_mask(_UpperCamelCase  )
      elif token_ids_a is None:
         return self._special_token_mask(_UpperCamelCase  ) + [1]
      else:
         return self._special_token_mask(token_ids_a + token_ids_a  ) + [1]


   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase=None  ):





      """simple docstring"""





      if token_ids_a is None:
         return token_ids_a + [self.eos_token_id]
      # We don't expect to process pairs, but leave the pair logic for API consistency
      return token_ids_a + token_ids_a + [self.eos_token_id]






   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase = None  ):





      """simple docstring"""





      if not os.path.isdir(_UpperCamelCase  ):
         logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''  )
         return
      _lowercase      :				List[Any]      					=       os.path.join(
          _UpperCamelCase      ,    (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]  )

      if os.path.abspath(self.vocab_file  ) != os.path.abspath(_UpperCamelCase  ) and os.path.isfile(self.vocab_file  ):
         copyfile(self.vocab_file      ,    _UpperCamelCase  )
      elif not os.path.isfile(self.vocab_file  ):
         with open(_UpperCamelCase      ,    "wb"  ) as fi:
            _lowercase      :				Optional[int]      					=       self.sp_model.serialized_model_proto()
            fi.write(_UpperCamelCase  )

      return (out_vocab_file,)






