'''simple docstring'''
import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
      from transformers.models.mobilevitva.modeling_mobilevitva import (
          MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
          make_divisible,
      )


if is_vision_available():
      from PIL import Image

      from transformers import MobileViTImageProcessor







class lowerCamelCase				(						lowerCamelCase       ):




  '''simple docstring'''



  def 			lowerCAmelCase__			(   self      :							List[str]	)					->List[str]:
        UpperCAmelCase_      =	self.config_class(**self.inputs_dict	)
        self.parent.assertTrue(hasattr(UpperCAmelCase__	,				'''width_multiplier'''	)	)







class lowerCamelCase				:




  '''simple docstring'''



  def __init__(   self      :							str	,				UpperCAmelCase__      :							Optional[Any]	,				UpperCAmelCase__      :							Optional[Any]=13	,				UpperCAmelCase__      :							Any=64	,				UpperCAmelCase__      :							Optional[int]=2	,				UpperCAmelCase__      :							Any=3	,				UpperCAmelCase__      :							Any="swish"	,				UpperCAmelCase__      :							Tuple=3	,				UpperCAmelCase__      :							Any=32	,				UpperCAmelCase__      :							List[Any]=0.1	,				UpperCAmelCase__      :							List[str]=0.02	,				UpperCAmelCase__      :							List[str]=True	,				UpperCAmelCase__      :							List[str]=True	,				UpperCAmelCase__      :							Optional[int]=10	,				UpperCAmelCase__      :							Any=None	,				UpperCAmelCase__      :							str=0.25	,				UpperCAmelCase__      :							List[str]=0.0	,				UpperCAmelCase__      :							Dict=0.0	,				)					->Dict:
        UpperCAmelCase_      =	parent
        UpperCAmelCase_      =	batch_size
        UpperCAmelCase_      =	image_size
        UpperCAmelCase_      =	patch_size
        UpperCAmelCase_      =	num_channels
        UpperCAmelCase_      =	make_divisible(512 * width_multiplier	,				divisor=8	)
        UpperCAmelCase_      =	hidden_act
        UpperCAmelCase_      =	conv_kernel_size
        UpperCAmelCase_      =	output_stride
        UpperCAmelCase_      =	classifier_dropout_prob
        UpperCAmelCase_      =	use_labels
        UpperCAmelCase_      =	is_training
        UpperCAmelCase_      =	num_labels
        UpperCAmelCase_      =	initializer_range
        UpperCAmelCase_      =	scope
        UpperCAmelCase_      =	width_multiplier
        UpperCAmelCase_      =	ffn_dropout
        UpperCAmelCase_      =	attn_dropout






  def 			lowerCAmelCase__			(   self      :							List[str]	)					->List[str]:
        UpperCAmelCase_      =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

        UpperCAmelCase_      =	None
        UpperCAmelCase_      =	None
        if self.use_labels:
              UpperCAmelCase_      =	ids_tensor([self.batch_size]	,				self.num_labels	)
              UpperCAmelCase_      =	ids_tensor([self.batch_size, self.image_size, self.image_size]	,				self.num_labels	)

        UpperCAmelCase_      =	self.get_config()

        return config, pixel_values, labels, pixel_labels






  def 			lowerCAmelCase__			(   self      :							str	)					->Optional[Any]:
        return MobileViTVaConfig(
            image_size=self.image_size	,				patch_size=self.patch_size	,				num_channels=self.num_channels	,				hidden_act=self.hidden_act	,				conv_kernel_size=self.conv_kernel_size	,				output_stride=self.output_stride	,				classifier_dropout_prob=self.classifier_dropout_prob	,				initializer_range=self.initializer_range	,				width_multiplier=self.width_multiplier	,				ffn_dropout=self.ffn_dropout_prob	,				attn_dropout=self.attn_dropout_prob	,				)






  def 			lowerCAmelCase__			(   self      :							Any	,				UpperCAmelCase__      :							Any	,				UpperCAmelCase__      :							Tuple	,				UpperCAmelCase__      :							int	,				UpperCAmelCase__      :							Optional[Any]	)					->Union[str, Any]:
        UpperCAmelCase_      =	MobileViTVaModel(config=UpperCAmelCase__	)
        model.to(UpperCAmelCase__	)
        model.eval()
        UpperCAmelCase_      =	model(UpperCAmelCase__	)
        self.parent.assertEqual(
            result.last_hidden_state.shape	,				(
                self.batch_size,
                self.last_hidden_size,
                self.image_size // self.output_stride,
                self.image_size // self.output_stride,
            )	,				)






  def 			lowerCAmelCase__			(   self      :							Union[str, Any]	,				UpperCAmelCase__      :							Union[str, Any]	,				UpperCAmelCase__      :							str	,				UpperCAmelCase__      :							Optional[Any]	,				UpperCAmelCase__      :							List[Any]	)					->int:
        UpperCAmelCase_      =	self.num_labels
        UpperCAmelCase_      =	MobileViTVaForImageClassification(UpperCAmelCase__	)
        model.to(UpperCAmelCase__	)
        model.eval()
        UpperCAmelCase_      =	model(UpperCAmelCase__	,				labels=UpperCAmelCase__	)
        self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_labels)	)






  def 			lowerCAmelCase__			(   self      :							int	,				UpperCAmelCase__      :							Optional[Any]	,				UpperCAmelCase__      :							str	,				UpperCAmelCase__      :							Tuple	,				UpperCAmelCase__      :							Tuple	)					->Any:
        UpperCAmelCase_      =	self.num_labels
        UpperCAmelCase_      =	MobileViTVaForSemanticSegmentation(UpperCAmelCase__	)
        model.to(UpperCAmelCase__	)
        model.eval()
        UpperCAmelCase_      =	model(UpperCAmelCase__	)
        self.parent.assertEqual(
            result.logits.shape	,				(
                self.batch_size,
                self.num_labels,
                self.image_size // self.output_stride,
                self.image_size // self.output_stride,
            )	,				)
        UpperCAmelCase_      =	model(UpperCAmelCase__	,				labels=UpperCAmelCase__	)
        self.parent.assertEqual(
            result.logits.shape	,				(
                self.batch_size,
                self.num_labels,
                self.image_size // self.output_stride,
                self.image_size // self.output_stride,
            )	,				)






  def 			lowerCAmelCase__			(   self      :							Optional[int]	)					->int:
        UpperCAmelCase_      =	self.prepare_config_and_inputs()
        UpperCAmelCase_   ,		UpperCAmelCase_   ,		UpperCAmelCase_   ,		UpperCAmelCase_      =	config_and_inputs
        UpperCAmelCase_      =	{'''pixel_values''': pixel_values}
        return config, inputs_dict







@require_torch
class lowerCamelCase				(						lowerCamelCase  ,		lowerCamelCase  ,		unittest.TestCase       ):




  '''simple docstring'''



  lowerCAmelCase__      				=						(
      (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
      if is_torch_available()
      else ()
  )

  lowerCAmelCase__      				=						(
      {
          'feature-extraction': MobileViTVaModel,
          'image-classification': MobileViTVaForImageClassification,
          'image-segmentation': MobileViTVaForSemanticSegmentation,
      }
      if is_torch_available()
      else {}
  )

  lowerCAmelCase__      				=						False
  lowerCAmelCase__      				=						False
  lowerCAmelCase__      				=						False
  lowerCAmelCase__      				=						False






  def 			lowerCAmelCase__			(   self      :							List[str]	)					->List[str]:
        UpperCAmelCase_      =	MobileViTVaModelTester(self	)
        UpperCAmelCase_      =	MobileViTVaConfigTester(self	,				config_class=UpperCAmelCase__	,				has_text_modality=UpperCAmelCase__	)






  def 			lowerCAmelCase__			(   self      :							List[str]	)					->Union[str, Any]:
        self.config_tester.run_common_tests()






  @unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''	)
  def 			lowerCAmelCase__			(   self      :							List[Any]	)					->int:
        pass






  @unittest.skip(reason='''MobileViTV2 does not support input and output embeddings'''	)
  def 			lowerCAmelCase__			(   self      :							Union[str, Any]	)					->int:
        pass






  @unittest.skip(reason='''MobileViTV2 does not output attentions'''	)
  def 			lowerCAmelCase__			(   self      :							Tuple	)					->str:
        pass






  @require_torch_multi_gpu
  @unittest.skip(reason='''Got `CUDA error: misaligned address` for tests after this one being run.'''	)
  def 			lowerCAmelCase__			(   self      :							Any	)					->Any:
        pass






  @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''	)
  def 			lowerCAmelCase__			(   self      :							str	)					->Optional[int]:
        pass






  def 			lowerCAmelCase__			(   self      :							Any	)					->Optional[Any]:
        UpperCAmelCase_   ,		UpperCAmelCase_      =	self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              UpperCAmelCase_      =	model_class(UpperCAmelCase__	)
              UpperCAmelCase_      =	inspect.signature(model.forward	)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              UpperCAmelCase_      =	[*signature.parameters.keys()]

              UpperCAmelCase_      =	['''pixel_values''']
              self.assertListEqual(arg_names[:1]	,				UpperCAmelCase__	)






  def 			lowerCAmelCase__			(   self      :							Dict	)					->Union[str, Any]:
        UpperCAmelCase_      =	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*UpperCAmelCase__	)






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


        def check_hidden_states_output(UpperCAmelCase__      :							Tuple	,				UpperCAmelCase__      :							Union[str, Any]	,				UpperCAmelCase__      :							Optional[int]	):
              UpperCAmelCase_      =	model_class(UpperCAmelCase__	)
              model.to(UpperCAmelCase__	)
              model.eval()

              with torch.no_grad():
                    UpperCAmelCase_      =	model(**self._prepare_for_class(UpperCAmelCase__	,				UpperCAmelCase__	)	)

              UpperCAmelCase_      =	outputs.hidden_states

              UpperCAmelCase_      =	5
              self.assertEqual(len(UpperCAmelCase__	)	,				UpperCAmelCase__	)

              # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
              # with the width and height being successively divided by 2.
              UpperCAmelCase_      =	2
              for i in range(len(UpperCAmelCase__	)	):
                    self.assertListEqual(
                        list(hidden_states[i].shape[-2:]	)	,				[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]	,				)
                    divisor *= 2

              self.assertEqual(self.model_tester.output_stride	,				divisor // 2	)

        UpperCAmelCase_   ,		UpperCAmelCase_      =	self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              UpperCAmelCase_      =	True
              check_hidden_states_output(UpperCAmelCase__	,				UpperCAmelCase__	,				UpperCAmelCase__	)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              UpperCAmelCase_      =	True

              check_hidden_states_output(UpperCAmelCase__	,				UpperCAmelCase__	,				UpperCAmelCase__	)






  def 			lowerCAmelCase__			(   self      :							Tuple	)					->List[Any]:
        UpperCAmelCase_      =	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase__	)






  def 			lowerCAmelCase__			(   self      :							Tuple	)					->Union[str, Any]:
        UpperCAmelCase_      =	self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_semantic_segmentation(*UpperCAmelCase__	)






  @slow
  def 			lowerCAmelCase__			(   self      :							Union[str, Any]	)					->List[Any]:


        for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_      =	MobileViTVaModel.from_pretrained(UpperCAmelCase__	)
              self.assertIsNotNone(UpperCAmelCase__	)






def 			__lowerCamelCase							(   ):


      '''simple docstring'''


      UpperCAmelCase_      =	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
      return image







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




  '''simple docstring'''



  @cached_property
  def 			lowerCAmelCase__			(   self      :							int	)					->Union[str, Any]:
        return (
            MobileViTImageProcessor.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''	)
            if is_vision_available()
            else None
        )






  @slow
  def 			lowerCAmelCase__			(   self      :							Tuple	)					->str:
        UpperCAmelCase_      =	MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''	).to(
            UpperCAmelCase__	)

        UpperCAmelCase_      =	self.default_image_processor
        UpperCAmelCase_      =	prepare_img()
        UpperCAmelCase_      =	image_processor(images=UpperCAmelCase__	,				return_tensors='''pt'''	).to(UpperCAmelCase__	)

        # forward pass
        with torch.no_grad():
              UpperCAmelCase_      =	model(**UpperCAmelCase__	)

        # verify the logits
        UpperCAmelCase_      =	torch.Size((1, 1000)	)
        self.assertEqual(outputs.logits.shape	,				UpperCAmelCase__	)

        UpperCAmelCase_      =	torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]	).to(UpperCAmelCase__	)

        self.assertTrue(torch.allclose(outputs.logits[0, :3]	,				UpperCAmelCase__	,				atol=1e-4	)	)






  @slow
  def 			lowerCAmelCase__			(   self      :							Optional[int]	)					->Dict:
        UpperCAmelCase_      =	MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''	)
        UpperCAmelCase_      =	model.to(UpperCAmelCase__	)

        UpperCAmelCase_      =	MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''	)

        UpperCAmelCase_      =	prepare_img()
        UpperCAmelCase_      =	image_processor(images=UpperCAmelCase__	,				return_tensors='''pt'''	).to(UpperCAmelCase__	)

        # forward pass
        with torch.no_grad():
              UpperCAmelCase_      =	model(**UpperCAmelCase__	)
        UpperCAmelCase_      =	outputs.logits

        # verify the logits
        UpperCAmelCase_      =	torch.Size((1, 21, 32, 32)	)
        self.assertEqual(logits.shape	,				UpperCAmelCase__	)

        UpperCAmelCase_      =	torch.tensor(
            [
                [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
                [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
                [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
            ]	,				device=UpperCAmelCase__	,				)

        self.assertTrue(torch.allclose(logits[0, :3, :3, :3]	,				UpperCAmelCase__	,				atol=1e-4	)	)






  @slow
  def 			lowerCAmelCase__			(   self      :							Optional[int]	)					->Dict:
        UpperCAmelCase_      =	MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''	)
        UpperCAmelCase_      =	model.to(UpperCAmelCase__	)

        UpperCAmelCase_      =	MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''	)

        UpperCAmelCase_      =	prepare_img()
        UpperCAmelCase_      =	image_processor(images=UpperCAmelCase__	,				return_tensors='''pt'''	).to(UpperCAmelCase__	)

        # forward pass
        with torch.no_grad():
              UpperCAmelCase_      =	model(**UpperCAmelCase__	)

        UpperCAmelCase_      =	outputs.logits.detach().cpu()

        UpperCAmelCase_      =	image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase__	,				target_sizes=[(50, 60)]	)
        UpperCAmelCase_      =	torch.Size((50, 60)	)
        self.assertEqual(segmentation[0].shape	,				UpperCAmelCase__	)

        UpperCAmelCase_      =	image_processor.post_process_semantic_segmentation(outputs=UpperCAmelCase__	)
        UpperCAmelCase_      =	torch.Size((32, 32)	)
        self.assertEqual(segmentation[0].shape	,				UpperCAmelCase__	)









import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
						from .tokenization_big_bird import BigBirdTokenizer
else:
						__UpperCamelCase     		=							None

__UpperCamelCase     		=							logging.get_logger(__name__)
__UpperCamelCase     		=							{'vocab_file': 'spiece.model', 'tokenizer_file': 'tokenizer.json'}

__UpperCamelCase     		=							{
    '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'
        ),
    },
    'tokenizer_file': {
        'google/bigbird-roberta-base': (
            'https://huggingface.co/google/bigbird-roberta-base/resolve/main/tokenizer.json'
        ),
        'google/bigbird-roberta-large': (
            'https://huggingface.co/google/bigbird-roberta-large/resolve/main/tokenizer.json'
        ),
        'google/bigbird-base-trivia-itc': (
            'https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/tokenizer.json'
        ),
    },
}

__UpperCamelCase     		=							{
    'google/bigbird-roberta-base': 4_0_9_6,
    'google/bigbird-roberta-large': 4_0_9_6,
    'google/bigbird-base-trivia-itc': 4_0_9_6,
}


__UpperCamelCase     		=							'▁'







class 							lowerCamelCase__						(				UpperCAmelCase   ):






			"""simple docstring"""






			_UpperCamelCase		:       Dict 			=		VOCAB_FILES_NAMES
			_UpperCamelCase		:       int 			=		PRETRAINED_VOCAB_FILES_MAP
			_UpperCamelCase		:       List[Any] 			=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			_UpperCamelCase		:       Optional[Any] 			=		BigBirdTokenizer
			_UpperCamelCase		:       Dict 			=		['input_ids', 'attention_mask']
			_UpperCamelCase		:       List[int] 			=		[]




			def __init__(				self   ,    snake_case=None   ,    snake_case=None   ,    snake_case="<unk>"   ,    snake_case="<s>"   ,    snake_case="</s>"   ,    snake_case="<pad>"   ,    snake_case="[SEP]"   ,    snake_case="[MASK]"   ,    snake_case="[CLS]"   ,    **snake_case   ,    ):

						'''simple docstring'''


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

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

						super().__init__(
						    snake_case   ,    tokenizer_file=snake_case   ,    bos_token=snake_case   ,    eos_token=snake_case   ,    unk_token=snake_case   ,    sep_token=snake_case   ,    pad_token=snake_case   ,    cls_token=snake_case   ,    mask_token=snake_case   ,    **snake_case   ,    )

						UpperCamelCase__       =							vocab_file
						UpperCamelCase__       =							False if not self.vocab_file else True




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case = None  ):

						'''simple docstring'''


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




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case = None   ,    snake_case = False  ):

						'''simple docstring'''


						if already_has_special_tokens:
									if token_ids_a is not None:
												raise ValueError(
												    "You should not supply a second sequence if the provided sequence of "
												    "ids is already formatted with special tokens for the model."  )
									return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

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




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case = None  ):

						'''simple docstring'''


						UpperCamelCase__       =							[self.sep_token_id]
						UpperCamelCase__       =							[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   ,    snake_case   ,    snake_case = None  ):

						'''simple docstring'''


						if not self.can_save_slow_tokenizer:
									raise ValueError(
									    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
									    "tokenizer."  )

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

						if os.path.abspath(self.vocab_file  ) != os.path.abspath(snake_case  ):
									copyfile(self.vocab_file   ,    snake_case  )

						return (out_vocab_file,)


