


import inspect
import unittest

from transformers import MobileNetVaConfig
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 transformers import MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation, MobileNetVaModel
 from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import MobileNetVaImageProcessor






class _lowerCamelCase(						_a   ):
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							str      		=		self.config_class(**self.inputs_dict)
           self.parent.assertTrue(hasattr(lowerCamelCase,      'tf_padding'))
           self.parent.assertTrue(hasattr(lowerCamelCase,      'depth_multiplier'))






class _lowerCamelCase:
       def __init__(					self,      lowerCamelCase,      lowerCamelCase=13,      lowerCamelCase=3,      lowerCamelCase=32,      lowerCamelCase=0.2_5,      lowerCamelCase=8,      lowerCamelCase=8,      lowerCamelCase=6,      lowerCamelCase=32,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase="relu6",      lowerCamelCase=12_80,      lowerCamelCase=0.1,      lowerCamelCase=0.0_2,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase=10,      lowerCamelCase=None,      )       ->   Dict:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		parent
           _lowercase       :							str      		=		batch_size
           _lowercase       :							Optional[Any]      		=		num_channels
           _lowercase       :							Union[str, Any]      		=		image_size
           _lowercase       :							Dict      		=		depth_multiplier
           _lowercase       :							List[str]      		=		depth_divisible_by
           _lowercase       :							int      		=		min_depth
           _lowercase       :							Union[str, Any]      		=		expand_ratio
           _lowercase       :							int      		=		tf_padding
           _lowercase       :							Optional[Any]      		=		output_stride
           _lowercase       :							List[str]      		=		first_layer_is_expansion
           _lowercase       :							Union[str, Any]      		=		finegrained_output
           _lowercase       :							List[str]      		=		hidden_act
           _lowercase       :							List[Any]      		=		last_hidden_size if finegrained_output else int(last_hidden_size * depth_multiplier)
           _lowercase       :							Optional[Any]      		=		classifier_dropout_prob
           _lowercase       :							int      		=		use_labels
           _lowercase       :							Union[str, Any]      		=		is_training
           _lowercase       :							Union[str, Any]      		=		num_labels
           _lowercase       :							Optional[Any]      		=		initializer_range
           _lowercase       :							List[Any]      		=		scope
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

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

           _lowercase       :							int      		=		None
           _lowercase       :							List[Any]      		=		None
           if self.use_labels:
               _lowercase       :							List[Any]      		=		ids_tensor([self.batch_size],      self.num_labels)
               _lowercase       :							Union[str, Any]      		=		ids_tensor([self.batch_size, self.image_size, self.image_size],      self.num_labels)

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

           return config, pixel_values, labels, pixel_labels
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           return MobileNetVaConfig(
               num_channels=self.num_channels,      image_size=self.image_size,      depth_multiplier=self.depth_multiplier,      depth_divisible_by=self.depth_divisible_by,      min_depth=self.min_depth,      expand_ratio=self.expand_ratio,      output_stride=self.output_stride,      first_layer_is_expansion=self.first_layer_is_expansion,      finegrained_output=self.finegrained_output,      hidden_act=self.hidden_act,      tf_padding=self.tf_padding,      classifier_dropout_prob=self.classifier_dropout_prob,      initializer_range=self.initializer_range,      )
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		MobileNetVaModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							List[Any]      		=		model(lowerCamelCase)
           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,
               ),      )
           self.parent.assertEqual(
               result.pooler_output.shape,      (self.batch_size, self.last_hidden_size),      )
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							Tuple      		=		self.num_labels
           _lowercase       :							int      		=		MobileNetVaForImageClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							str      		=		model(lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							int      		=		self.num_labels
           _lowercase       :							Union[str, Any]      		=		MobileNetVaForSemanticSegmentation(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[Any]      		=		model(lowerCamelCase)
           self.parent.assertEqual(
               result.logits.shape,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               ),      )
           _lowercase       :							Optional[int]      		=		model(lowerCamelCase,      labels=lowerCamelCase)
           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 			UpperCamelCase     (					self)       ->   List[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.prepare_config_and_inputs()
           _lowercase		,				_lowercase		,				_lowercase		,				_lowercase       :							List[str]      		=		config_and_inputs
           _lowercase       :							Optional[int]      		=		{'pixel_values': pixel_values}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(						_a, _a, unittest.TestCase   ):
       lowercase_ :	Union[str, Any]     =			(
           (MobileNetVaModel, MobileNetVaForImageClassification, MobileNetVaForSemanticSegmentation)
           if is_torch_available()
           else ()
       )
       lowercase_ :	List[Any]     =			(
           {
               """feature-extraction""": MobileNetVaModel,
               """image-classification""": MobileNetVaForImageClassification,
               """image-segmentation""": MobileNetVaForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       lowercase_ :	Dict     =			False
       lowercase_ :	Tuple     =			False
       lowercase_ :	int     =			False
       lowercase_ :	Optional[int]     =			False
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							int      		=		MobileNetVaModelTester(self)
           _lowercase       :							Any      		=		MobileNetVaConfigTester(self,      config_class=lowerCamelCase,      has_text_modality=lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           self.config_tester.run_common_tests()
       @unittest.skip(reason='MobileNetV2 does not use inputs_embeds')
       def 			UpperCamelCase     (					self)       ->   Optional[int]:




           """simple docstring"""

           pass
       @unittest.skip(reason='MobileNetV2 does not support input and output embeddings')
       def 			UpperCamelCase     (					self)       ->   str:




           """simple docstring"""

           pass
       @unittest.skip(reason='MobileNetV2 does not output attentions')
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           pass
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs_for_common()

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

               _lowercase       :							List[Any]      		=		['pixel_values']
               self.assertListEqual(arg_names[:1],      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							Tuple      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           def check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase):
               _lowercase       :							Union[str, Any]      		=		model_class(lowerCamelCase)
               model.to(lowerCamelCase)
               model.eval()

               with torch.no_grad():
                   _lowercase       :							Optional[int]      		=		model(**self._prepare_for_class(lowerCamelCase,      lowerCamelCase))

               _lowercase       :							List[str]      		=		outputs.hidden_states

               _lowercase       :							int      		=		16
               self.assertEqual(len(lowerCamelCase),      lowerCamelCase)

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

           for model_class in self.all_model_classes:
               _lowercase       :							Dict      		=		True
               check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               _lowercase       :							Tuple      		=		True

               check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							str      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase)




       @slow
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           for model_name in MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase       :							Any      		=		MobileNetVaModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)



def 				UpperCamelCase_(      )    ->						str:
    _lowercase       :							str      		=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
    return image






@require_torch
@require_vision
class _lowerCamelCase(						unittest.TestCase   ):
       @cached_property
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           return (
               MobileNetVaImageProcessor.from_pretrained('google/mobilenet_v2_1.0_224') if is_vision_available() else None
           )
       @slow
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           _lowercase       :							List[Any]      		=		MobileNetVaForImageClassification.from_pretrained('google/mobilenet_v2_1.0_224').to(lowerCamelCase)

           _lowercase       :							List[Any]      		=		self.default_image_processor
           _lowercase       :							Dict      		=		prepare_img()
           _lowercase       :							Optional[Any]      		=		image_processor(images=lowerCamelCase,      return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase       :							Any      		=		model(**lowerCamelCase)

           # verify the logits
           _lowercase       :							Optional[Any]      		=		torch.Size((1, 10_01))
           self.assertEqual(outputs.logits.shape,      lowerCamelCase)

           _lowercase       :							Dict      		=		torch.tensor([0.2_4_4_5, -1.1_9_9_3, 0.1_9_0_5]).to(lowerCamelCase)

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




       @slow
       def 			UpperCamelCase     (					self)       ->   Dict:




           """simple docstring"""

           _lowercase       :							Any      		=		MobileNetVaForSemanticSegmentation.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513')
           _lowercase       :							Optional[Any]      		=		model.to(lowerCamelCase)

           _lowercase       :							Any      		=		MobileNetVaImageProcessor.from_pretrained('google/deeplabv3_mobilenet_v2_1.0_513')

           _lowercase       :							Optional[int]      		=		prepare_img()
           _lowercase       :							List[Any]      		=		image_processor(images=lowerCamelCase,      return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase       :							Optional[Any]      		=		model(**lowerCamelCase)
           _lowercase       :							List[Any]      		=		outputs.logits

           # verify the logits
           _lowercase       :							List[Any]      		=		torch.Size((1, 21, 65, 65))
           self.assertEqual(logits.shape,      lowerCamelCase)

           _lowercase       :							Optional[int]      		=		torch.tensor(
               [
                   [[1_7.5_7_9_0, 1_7.7_5_8_1, 1_8.3_3_5_5], [1_8.3_2_5_7, 1_8.4_2_3_0, 1_8.8_9_7_3], [1_8.6_1_6_9, 1_8.8_6_5_0, 1_9.2_1_8_7]],
                   [[-2.1_5_9_5, -2.0_9_7_7, -2.3_7_4_1], [-2.4_2_2_6, -2.3_0_2_8, -2.6_8_3_5], [-2.7_8_1_9, -2.5_9_9_1, -2.7_7_0_6]],
                   [[4.2_0_5_8, 4.8_3_1_7, 4.7_6_3_8], [4.4_1_3_6, 5.0_3_6_1, 4.9_3_8_3], [4.5_0_2_8, 4.9_6_4_4, 4.8_7_3_4]],
               ],      device=lowerCamelCase,      )

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




import os
import unicodedata
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 :		int							      =  logging.get_logger(__name__)
snake_case :		List[str]							      =  {"vocab_file": "spiece.model"}

snake_case :		List[str]							      =  {
    "vocab_file": {
        "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/spiece.model",
        "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/spiece.model",
        "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model",
        "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model",
        "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/spiece.model",
        "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/spiece.model",
        "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model",
        "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model",
    }
}

snake_case :		Tuple							      =  {
    "albert-base-v1": 512,
    "albert-large-v1": 512,
    "albert-xlarge-v1": 512,
    "albert-xxlarge-v1": 512,
    "albert-base-v2": 512,
    "albert-large-v2": 512,
    "albert-xlarge-v2": 512,
    "albert-xxlarge-v2": 512,
}

snake_case :		List[str]							      =  "▁"





class       _snake_case					(     snake_case				):
			UpperCamelCase__          =    VOCAB_FILES_NAMES
			UpperCamelCase__          =    PRETRAINED_VOCAB_FILES_MAP
			UpperCamelCase__          =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES







			def __init__(				self						,   _a						,   _a=True						,   _a=True						,   _a=False						,   _a="[CLS]"						,   _a="[SEP]"						,   _a="<unk>"						,   _a="[SEP]"						,   _a="<pad>"						,   _a="[CLS]"						,   _a="[MASK]"						,   _a = None						,   **_a						,   ):
				# Mask token behave like a normal word, i.e. include the space before it and
				# is included in the raw text, there should be a match in a non-normalized sentence.
				__magic_name__		:		str	   =     (
				    AddedToken(_a						,   lstrip=_a						,   rstrip=_a						,   normalized=_a		)
				    if isinstance(_a						,   _a		)
				    else mask_token
				)

				__magic_name__		:		Union[str, Any]	   =     {} if sp_model_kwargs is None else sp_model_kwargs

				super().__init__(
				    do_lower_case=_a						,   remove_space=_a						,   keep_accents=_a						,   bos_token=_a						,   eos_token=_a						,   unk_token=_a						,   sep_token=_a						,   pad_token=_a						,   cls_token=_a						,   mask_token=_a						,   sp_model_kwargs=self.sp_model_kwargs						,   **_a						,   )

				__magic_name__		:		Dict	   =     do_lower_case
				__magic_name__		:		Tuple	   =     remove_space
				__magic_name__		:		Union[str, Any]	   =     keep_accents
				__magic_name__		:		Tuple	   =     vocab_file

				__magic_name__		:		int	   =     spm.SentencePieceProcessor(**self.sp_model_kwargs		)
				self.sp_model.Load(_a		)







			@property
			def 			SCREAMING_SNAKE_CASE    (				self		):
				return len(self.sp_model		)







			def 			SCREAMING_SNAKE_CASE    (				self		):
				__magic_name__		:		List[str]	   =     {self.convert_ids_to_tokens(_a		): i for i in range(self.vocab_size		)}
				vocab.update(self.added_tokens_encoder		)
				return vocab







			def __getstate__(				self		):
				__magic_name__		:		List[str]	   =     self.__dict__.copy()
				__magic_name__		:		Any	   =     None
				return state







			def __setstate__(				self						,   _a		):
				__magic_name__		:		Union[str, Any]	   =     d

				# for backward compatibility
				if not hasattr(self						,   "sp_model_kwargs"		):
					__magic_name__		:		str	   =     {}

				__magic_name__		:		Optional[int]	   =     spm.SentencePieceProcessor(**self.sp_model_kwargs		)
				self.sp_model.Load(self.vocab_file		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				if self.remove_space:
					__magic_name__		:		List[Any]	   =     " ".join(inputs.strip().split()		)
				else:
					__magic_name__		:		str	   =     inputs
				__magic_name__		:		int	   =     outputs.replace("``"						,   "\""		).replace("''"						,   "\""		)

				if not self.keep_accents:
					__magic_name__		:		str	   =     unicodedata.normalize("NFKD"						,   _a		)
					__magic_name__		:		Tuple	   =     "".join([c for c in outputs if not unicodedata.combining(_a		)]		)
				if self.do_lower_case:
					__magic_name__		:		int	   =     outputs.lower()

				return outputs







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				__magic_name__		:		Optional[Any]	   =     self.preprocess_text(_a		)
				__magic_name__		:		Dict	   =     self.sp_model.encode(_a						,   out_type=_a		)
				__magic_name__		:		Any	   =     []
				for piece in pieces:
					if len(_a		) > 1 and piece[-1] == str(","		) and piece[-2].isdigit():
						__magic_name__		:		Optional[Any]	   =     self.sp_model.EncodeAsPieces(piece[:-1].replace(_a						,   ""		)		)
						if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
							if len(cur_pieces[0]		) == 1:
								__magic_name__		:		List[str]	   =     cur_pieces[1:]
							else:
								__magic_name__		:		Optional[int]	   =     cur_pieces[0][1:]
						cur_pieces.append(piece[-1]		)
						new_pieces.extend(_a		)
					else:
						new_pieces.append(_a		)

				return new_pieces







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				return self.sp_model.PieceToId(_a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				return self.sp_model.IdToPiece(_a		)







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a		):
				__magic_name__		:		Any	   =     []
				__magic_name__		:		Union[str, Any]	   =     ""
				__magic_name__		:		int	   =     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(_a		) + token
						__magic_name__		:		List[Any]	   =     True
						__magic_name__		:		Optional[int]	   =     []
					else:
						current_sub_tokens.append(_a		)
						__magic_name__		:		Optional[Any]	   =     False
				out_string += self.sp_model.decode(_a		)
				return out_string.strip()







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a = None		):
				__magic_name__		:		List[str]	   =     [self.sep_token_id]
				__magic_name__		:		Union[str, Any]	   =     [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 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a = None						,   _a = False		):

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

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







			def 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a = None		):
				__magic_name__		:		Optional[int]	   =     [self.sep_token_id]
				__magic_name__		:		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 			SCREAMING_SNAKE_CASE    (				self						,   _a						,   _a = None		):
				if not os.path.isdir(_a		):
					logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''		)
					return
				__magic_name__		:		List[str]	   =     os.path.join(
				    _a						,   (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]		)

				if os.path.abspath(self.vocab_file		) != os.path.abspath(_a		) and os.path.isfile(self.vocab_file		):
					copyfile(self.vocab_file						,   _a		)
				elif not os.path.isfile(self.vocab_file		):
					with open(_a						,   "wb"		) as fi:
						__magic_name__		:		Union[str, Any]	   =     self.sp_model.serialized_model_proto()
						fi.write(_a		)

				return (out_vocab_file,)
