





'''simple docstring'''



import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase					,    __UpperCamelCase					,    unittest.TestCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						Union[str, Any]      =   AutoencoderKL
     UpperCAmelCase__       :						Tuple      =   '''sample'''
     UpperCAmelCase__       :						Optional[int]      =   1E-2

     @property
     def 	UpperCamelCase(					self	):
       _snake_case     		=				4
       _snake_case     		=				3
       _snake_case     		=				(32, 32)

       _snake_case     		=				floats_tensor((batch_size, num_channels) + sizes	).to(lowerCamelCase	)

       return {"sample": image}

     @property
     def 	UpperCamelCase(					self	):
       return (3, 32, 32)

     @property
     def 	UpperCamelCase(					self	):
       return (3, 32, 32)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				{
           "block_out_channels": [32, 64],
           "in_channels": 3,
           "out_channels": 3,
           "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
           "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
           "latent_channels": 4,
       }
       _snake_case     		=				self.dummy_input
       return init_dict, inputs_dict

     def 	UpperCamelCase(					self	):
       pass

     def 	UpperCamelCase(					self	):
       pass

     @unittest.skipIf(torch_device == "mps"						,   "Gradient checkpointing skipped on MPS"	)
     def 	UpperCamelCase(					self	):
       # enable deterministic behavior for gradient checkpointing
       _snake_case		,		_snake_case     		=				self.prepare_init_args_and_inputs_for_common()
       _snake_case     		=				self.model_class(**lowerCamelCase	)
       model.to(lowerCamelCase	)

       assert not model.is_gradient_checkpointing and model.training

       _snake_case     		=				model(**lowerCamelCase	).sample
       # run the backwards pass on the model. For backwards pass, for simplicity purpose,
       # we won't calculate the loss and rather backprop on out.sum()
       model.zero_grad()

       _snake_case     		=				torch.randn_like(lowerCamelCase	)
       _snake_case     		=				(out - labels).mean()
       loss.backward()

       # re-instantiate the model now enabling gradient checkpointing
       _snake_case     		=				self.model_class(**lowerCamelCase	)
       # clone model
       model_a.load_state_dict(model.state_dict()	)
       model_a.to(lowerCamelCase	)
       model_a.enable_gradient_checkpointing()

       assert model_a.is_gradient_checkpointing and model_a.training

       _snake_case     		=				model_a(**lowerCamelCase	).sample
       # run the backwards pass on the model. For backwards pass, for simplicity purpose,
       # we won't calculate the loss and rather backprop on out.sum()
       model_a.zero_grad()
       _snake_case     		=				(out_a - labels).mean()
       loss_a.backward()

       # compare the output and parameters gradients
       self.assertTrue((loss - loss_a).abs() < 1e-5	)
       _snake_case     		=				dict(model.named_parameters()	)
       _snake_case     		=				dict(model_a.named_parameters()	)
       for name, param in named_params.items():
         self.assertTrue(torch_all_close(param.grad.data						,   named_params_a[name].grad.data						,   atol=5e-5	)	)

     def 	UpperCamelCase(					self	):
       _snake_case		,		_snake_case     		=				AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"						,   output_loading_info=lowerCamelCase	)
       self.assertIsNotNone(lowerCamelCase	)
       self.assertEqual(len(loading_info["missing_keys"]	)						,   0	)

       model.to(lowerCamelCase	)
       _snake_case     		=				model(**self.dummy_input	)

       assert image is not None, "Make sure output is not None"






     def 	UpperCamelCase(					self	):
       _snake_case     		=				AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"	)
       _snake_case     		=				model.to(lowerCamelCase	)
       model.eval()

       if torch_device == "mps":
         _snake_case     		=				torch.manual_seed(0	)
       else:
         _snake_case     		=				torch.Generator(device=lowerCamelCase	).manual_seed(0	)

       _snake_case     		=				torch.randn(
           1						,   model.config.in_channels						,   model.config.sample_size						,   model.config.sample_size						,   generator=torch.manual_seed(0	)						,   )
       _snake_case     		=				image.to(lowerCamelCase	)
       with torch.no_grad():
         _snake_case     		=				model(lowerCamelCase						,   sample_posterior=lowerCamelCase						,   generator=lowerCamelCase	).sample

       _snake_case     		=				output[0, -1, -3:, -3:].flatten().cpu()

       # Since the VAE Gaussian prior's generator is seeded on the appropriate device,
       # the expected output slices are not the same for CPU and GPU.
       if torch_device == "mps":
         _snake_case     		=				torch.tensor(
             [
                 -4.0078e-01,
                 -3.8323e-04,
                 -1.2681e-01,
                 -1.1462e-01,
                 2.0095e-01,
                 1.0893e-01,
                 -8.8247e-02,
                 -3.0361e-01,
                 -9.8644e-03,
             ]	)
       elif torch_device == "cpu":
         _snake_case     		=				torch.tensor(
             [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]	)
       else:
         _snake_case     		=				torch.tensor(
             [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]	)

       self.assertTrue(torch_all_close(lowerCamelCase						,   lowerCamelCase						,   rtol=1e-2	)	)







@slow
class       __SCREAMING_SNAKE_CASE	(						unittest.TestCase			):



     '''simple docstring'''






     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase	):
       return F'''gaussian_noise_s={seed}_shape={"_".join([str(lowerCamelCase	) for s in shape]	)}.npy'''

     def 	UpperCamelCase(					self	):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()

     def 	UpperCamelCase(					self						,   lowerCamelCase=0						,   lowerCamelCase=(4, 3, 512, 512)						,   lowerCamelCase=False	):
       _snake_case     		=				torch.floataa if fpaa else torch.floataa
       _snake_case     		=				torch.from_numpy(load_hf_numpy(self.get_file_format(lowerCamelCase						,   lowerCamelCase	)	)	).to(lowerCamelCase	).to(lowerCamelCase	)
       return image

     def 	UpperCamelCase(					self						,   lowerCamelCase="CompVis/stable-diffusion-v1-4"						,   lowerCamelCase=False	):
       _snake_case     		=				"fp16" if fpaa else None
       _snake_case     		=				torch.floataa if fpaa else torch.floataa

       _snake_case     		=				AutoencoderKL.from_pretrained(
           lowerCamelCase						,   subfolder="vae"						,   torch_dtype=lowerCamelCase						,   revision=lowerCamelCase						,   )
       model.to(lowerCamelCase	).eval()

       return model

     def 	UpperCamelCase(					self						,   lowerCamelCase=0	):
       if torch_device == "mps":
         return torch.manual_seed(lowerCamelCase	)
       return torch.Generator(device=lowerCamelCase	).manual_seed(lowerCamelCase	)

     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
             [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
             # fmt: on
         ]	)
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model()
       _snake_case     		=				self.get_sd_image(lowerCamelCase	)
       _snake_case     		=				self.get_generator(lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model(lowerCamelCase						,   generator=lowerCamelCase						,   sample_posterior=lowerCamelCase	).sample

       assert sample.shape == image.shape

       _snake_case     		=				sample[-1, -2:, -2:, :2].flatten().float().cpu()
       _snake_case     		=				torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice	)

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=3e-3	)

     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
             [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
             # fmt: on
         ]	)
     @require_torch_gpu
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model(fpaa=lowerCamelCase	)
       _snake_case     		=				self.get_sd_image(lowerCamelCase						,   fpaa=lowerCamelCase	)
       _snake_case     		=				self.get_generator(lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model(lowerCamelCase						,   generator=lowerCamelCase						,   sample_posterior=lowerCamelCase	).sample

       assert sample.shape == image.shape

       _snake_case     		=				sample[-1, -2:, :2, -2:].flatten().float().cpu()
       _snake_case     		=				torch.tensor(lowerCamelCase	)

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=1e-2	)

     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
             [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
             # fmt: on
         ]	)
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model()
       _snake_case     		=				self.get_sd_image(lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model(lowerCamelCase	).sample

       assert sample.shape == image.shape

       _snake_case     		=				sample[-1, -2:, -2:, :2].flatten().float().cpu()
       _snake_case     		=				torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice	)

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=3e-3	)

     @parameterized.expand(
         [
             # fmt: off
             [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
             [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
             # fmt: on
         ]	)
     @require_torch_gpu
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model()
       _snake_case     		=				self.get_sd_image(lowerCamelCase						,   shape=(3, 4, 64, 64)	)

       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       assert list(sample.shape	) == [3, 3, 512, 512]

       _snake_case     		=				sample[-1, -2:, :2, -2:].flatten().cpu()
       _snake_case     		=				torch.tensor(lowerCamelCase	)

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=1e-3	)

     @parameterized.expand(
         [
             # fmt: off
             [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
             [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
             # fmt: on
         ]	)
     @require_torch_gpu
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model(fpaa=lowerCamelCase	)
       _snake_case     		=				self.get_sd_image(lowerCamelCase						,   shape=(3, 4, 64, 64)						,   fpaa=lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       assert list(sample.shape	) == [3, 3, 512, 512]

       _snake_case     		=				sample[-1, -2:, :2, -2:].flatten().float().cpu()
       _snake_case     		=				torch.tensor(lowerCamelCase	)

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=5e-3	)

     @parameterized.expand([(13,), (16,), (27,)]	)
     @require_torch_gpu
     @unittest.skipIf(not is_xformers_available()						,   reason="xformers is not required when using PyTorch 2.0."	)
     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model(fpaa=lowerCamelCase	)
       _snake_case     		=				self.get_sd_image(lowerCamelCase						,   shape=(3, 4, 64, 64)						,   fpaa=lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       assert list(sample.shape	) == [3, 3, 512, 512]

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=1e-1	)

     @parameterized.expand([(13,), (16,), (37,)]	)
     @require_torch_gpu
     @unittest.skipIf(not is_xformers_available()						,   reason="xformers is not required when using PyTorch 2.0."	)
     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model()
       _snake_case     		=				self.get_sd_image(lowerCamelCase						,   shape=(3, 4, 64, 64)	)

       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
         _snake_case     		=				model.decode(lowerCamelCase	).sample

       assert list(sample.shape	) == [3, 3, 512, 512]

       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=1e-2	)






     @parameterized.expand(
         [
             # fmt: off
             [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
             [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
             # fmt: on
         ]	)
     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.get_sd_vae_model()
       _snake_case     		=				self.get_sd_image(lowerCamelCase	)
       _snake_case     		=				self.get_generator(lowerCamelCase	)

       with torch.no_grad():
         _snake_case     		=				model.encode(lowerCamelCase	).latent_dist
         _snake_case     		=				dist.sample(generator=lowerCamelCase	)

       assert list(sample.shape	) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

       _snake_case     		=				sample[0, -1, -3:, -3:].flatten().cpu()
       _snake_case     		=				torch.tensor(lowerCamelCase	)

       _snake_case     		=				3e-3 if torch_device != "mps" else 1e-2
       assert torch_all_close(lowerCamelCase						,   lowerCamelCase						,   atol=lowerCamelCase	)









'''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


__magic_name__   :						Optional[int]    =			logging.get_logger(__name__)

__magic_name__   :						str    =			"""▁"""

__magic_name__   :						int    =			{"""vocab_file""": """sentencepiece.bpe.model"""}

__magic_name__   :						List[str]    =			{
    """vocab_file""": {
        """facebook/xglm-564M""": """https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model""",
    }
}

__magic_name__   :						Union[str, Any]    =			{
    """facebook/xglm-564M""": 2_048,
}


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






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

     def __init__(					self						,   lowerCamelCase						,   lowerCamelCase="<s>"						,   lowerCamelCase="</s>"						,   lowerCamelCase="</s>"						,   lowerCamelCase="<s>"						,   lowerCamelCase="<unk>"						,   lowerCamelCase="<pad>"						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       _snake_case     		=				{} if sp_model_kwargs is None else sp_model_kwargs

       # Compatibility with the original tokenizer
       _snake_case     		=				7
       _snake_case     		=				[F'''<madeupword{i}>''' for i in range(self.num_madeup_words	)]

       _snake_case     		=				kwargs.get("additional_special_tokens"						,   []	)
       kwargs["additional_special_tokens"] += [
           word for word in madeup_words if word not in kwargs["additional_special_tokens"]
       ]

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

       _snake_case     		=				spm.SentencePieceProcessor(**self.sp_model_kwargs	)
       self.sp_model.Load(str(lowerCamelCase	)	)
       _snake_case     		=				vocab_file

       # Original fairseq vocab and spm vocab must be "aligned":
       # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
       # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
       # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
       # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

       # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
       _snake_case     		=				1

       # Mimic fairseq token-to-id alignment for the first 4 token
       _snake_case     		=				{"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

       _snake_case     		=				len(self.sp_model	)
       _snake_case     		=				{F'''<madeupword{i}>''': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words	)}
       self.fairseq_tokens_to_ids.update(lowerCamelCase	)

       _snake_case     		=				{v: k for k, v in self.fairseq_tokens_to_ids.items()}

     def __getstate__(					self	):
       _snake_case     		=				self.__dict__.copy()
       _snake_case     		=				None
       _snake_case     		=				self.sp_model.serialized_model_proto()
       return state

     def __setstate__(					self						,   lowerCamelCase	):
       _snake_case     		=				d

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

       _snake_case     		=				spm.SentencePieceProcessor(**self.sp_model_kwargs	)
       self.sp_model.LoadFromSerializedProto(self.sp_model_proto	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None	):

       if token_ids_a is None:
         return [self.sep_token_id] + token_ids_a
       _snake_case     		=				[self.sep_token_id]
       return sep + token_ids_a + sep + sep + token_ids_a

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None						,   lowerCamelCase = False	):

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

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

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None	):
       _snake_case     		=				[self.sep_token_id]

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

     @property
     def 	UpperCamelCase(					self	):
       return len(self.sp_model	) + self.fairseq_offset + self.num_madeup_words

     def 	UpperCamelCase(					self	):
       _snake_case     		=				{self.convert_ids_to_tokens(lowerCamelCase	): i for i in range(self.vocab_size	)}
       vocab.update(self.added_tokens_encoder	)
       return vocab

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       return self.sp_model.encode(lowerCamelCase						,   out_type=lowerCamelCase	)

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       if token in self.fairseq_tokens_to_ids:
         return self.fairseq_tokens_to_ids[token]
       _snake_case     		=				self.sp_model.PieceToId(lowerCamelCase	)

       # Need to return unknown token if the SP model returned 0
       return spm_id + self.fairseq_offset if spm_id else self.unk_token_id

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       if index in self.fairseq_ids_to_tokens:
         return self.fairseq_ids_to_tokens[index]
       return self.sp_model.IdToPiece(index - self.fairseq_offset	)

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       _snake_case     		=				"".join(lowerCamelCase	).replace(lowerCamelCase						,   " "	).strip()
       return out_string






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

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

       return (out_vocab_file,)


