




import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
					from transformers import (
					    FlaxBertModel,
					    FlaxCLIPVisionModel,
					    FlaxVisionTextDualEncoderModel,
					    FlaxViTModel,
					    VisionTextDualEncoderConfig,
					    VisionTextDualEncoderProcessor,
					)
					from transformers.modeling_flax_pytorch_utils import (
					    convert_pytorch_state_dict_to_flax,
					    load_flax_weights_in_pytorch_model,
					)


if is_torch_available():
					import torch

					from transformers import VisionTextDualEncoderModel

if is_vision_available():
					from PIL import Image







def      lowerCamelCase_						(			UpperCamelCase__							: List[str] )	->			Dict:





				"""simple docstring"""


				if isinstance(UpperCamelCase__					,	collections.abc.Iterable ):
								return x
				return (x, x)







@require_flax
class        __lowerCAmelCase					:

			"""simple docstring"""







			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> str:



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Any:



							'''simple docstring'''
							pass


			def  lowercase_       ( self				)       -> Any:



							'''simple docstring'''
							pass


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       np.abs((a - b)				).max()
							self.assertLessEqual(lowerCamelCase__     ,		lowerCamelCase__     ,		f"""Difference between torch and flax is {diff} (>= {tol})."""				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__=None     ,		**lowerCamelCase__				)       -> Any:



							'''simple docstring'''
							__lowerCamelCase									=       VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__     ,		lowerCamelCase__				)

							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel(lowerCamelCase__				)

							__lowerCamelCase									=       model(input_ids=lowerCamelCase__     ,		pixel_values=lowerCamelCase__     ,		attention_mask=lowerCamelCase__				)

							self.assertEqual(output['text_embeds'].shape     ,		(input_ids.shape[0], config.projection_dim)				)
							self.assertEqual(output['image_embeds'].shape     ,		(pixel_values.shape[0], config.projection_dim)				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__=None     ,		**lowerCamelCase__				)       -> Optional[Any]:



							'''simple docstring'''
							__lowerCamelCase			,		__lowerCamelCase									=       self.get_vision_text_model(lowerCamelCase__     ,		lowerCamelCase__				)
							__lowerCamelCase									=       {'vision_model': vision_model, 'text_model': text_model}
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__				)

							__lowerCamelCase									=       model(input_ids=lowerCamelCase__     ,		pixel_values=lowerCamelCase__     ,		attention_mask=lowerCamelCase__				)

							self.assertEqual(output['text_embeds'].shape     ,		(input_ids.shape[0], model.config.projection_dim)				)
							self.assertEqual(output['image_embeds'].shape     ,		(pixel_values.shape[0], model.config.projection_dim)				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__=None     ,		**lowerCamelCase__				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase			,		__lowerCamelCase									=       self.get_vision_text_model(lowerCamelCase__     ,		lowerCamelCase__				)
							__lowerCamelCase									=       {'vision_model': vision_model, 'text_model': text_model}
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__				)

							__lowerCamelCase									=       model(input_ids=lowerCamelCase__     ,		pixel_values=lowerCamelCase__     ,		attention_mask=lowerCamelCase__				)
							__lowerCamelCase									=       output[0]

							with tempfile.TemporaryDirectory() as tmpdirname:
											model.save_pretrained(lowerCamelCase__				)
											__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__				)

											__lowerCamelCase									=       model(input_ids=lowerCamelCase__     ,		pixel_values=lowerCamelCase__     ,		attention_mask=lowerCamelCase__				)
											__lowerCamelCase									=       after_output[0]
											__lowerCamelCase									=       np.amax(np.abs(out_a - out_a				)				)
											self.assertLessEqual(lowerCamelCase__     ,		1e-3				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__=None     ,		**lowerCamelCase__				)       -> List[str]:



							'''simple docstring'''
							__lowerCamelCase			,		__lowerCamelCase									=       self.get_vision_text_model(lowerCamelCase__     ,		lowerCamelCase__				)
							__lowerCamelCase									=       {'vision_model': vision_model, 'text_model': text_model}
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**lowerCamelCase__				)

							__lowerCamelCase									=       model(
							    input_ids=lowerCamelCase__     ,		pixel_values=lowerCamelCase__     ,		attention_mask=lowerCamelCase__     ,		output_attentions=lowerCamelCase__				)

							__lowerCamelCase									=       output.vision_model_output.attentions
							self.assertEqual(len(lowerCamelCase__				)     ,		vision_config.num_hidden_layers				)

							# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
							__lowerCamelCase									=       to_atuple(vision_model.config.image_size				)
							__lowerCamelCase									=       to_atuple(vision_model.config.patch_size				)
							__lowerCamelCase									=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
							__lowerCamelCase									=       num_patches + 1
							self.assertEqual(vision_attentions[0].shape[-3:]     ,		(vision_config.num_attention_heads, seq_len, seq_len)				)

							__lowerCamelCase									=       output.text_model_output.attentions
							self.assertEqual(len(lowerCamelCase__				)     ,		text_config.num_hidden_layers				)

							self.assertEqual(
							    text_attentions[0].shape[-3:]     ,		(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])     ,		)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> Dict:



							'''simple docstring'''
							pt_model.to(lowerCamelCase__				)
							pt_model.eval()

							# prepare inputs
							__lowerCamelCase									=       inputs_dict
							__lowerCamelCase									=       {k: torch.tensor(v.tolist()				) for k, v in flax_inputs.items()}

							with torch.no_grad():
											__lowerCamelCase									=       pt_model(**lowerCamelCase__				).to_tuple()

							__lowerCamelCase									=       fx_model(**lowerCamelCase__				).to_tuple()
							self.assertEqual(len(lowerCamelCase__				)     ,		len(lowerCamelCase__				)     ,		'Output lengths differ between Flax and PyTorch'				)
							for fx_output, pt_output in zip(fx_outputs[:4]     ,		pt_outputs[:4]				):
											self.assert_almost_equals(lowerCamelCase__     ,		pt_output.numpy()     ,		4e-2				)

							# PT -> Flax
							with tempfile.TemporaryDirectory() as tmpdirname:
											pt_model.save_pretrained(lowerCamelCase__				)
											__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__     ,		from_pt=lowerCamelCase__				)

							__lowerCamelCase									=       fx_model_loaded(**lowerCamelCase__				).to_tuple()
							self.assertEqual(len(lowerCamelCase__				)     ,		len(lowerCamelCase__				)     ,		'Output lengths differ between Flax and PyTorch'				)
							for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]     ,		pt_outputs[:4]				):
											self.assert_almost_equals(lowerCamelCase__     ,		pt_output.numpy()     ,		4e-2				)

							# Flax -> PT
							with tempfile.TemporaryDirectory() as tmpdirname:
											fx_model.save_pretrained(lowerCamelCase__				)
											__lowerCamelCase									=       VisionTextDualEncoderModel.from_pretrained(lowerCamelCase__     ,		from_flax=lowerCamelCase__				)

							pt_model_loaded.to(lowerCamelCase__				)
							pt_model_loaded.eval()

							with torch.no_grad():
											__lowerCamelCase									=       pt_model_loaded(**lowerCamelCase__				).to_tuple()

							self.assertEqual(len(lowerCamelCase__				)     ,		len(lowerCamelCase__				)     ,		'Output lengths differ between Flax and PyTorch'				)
							for fx_output, pt_output_loaded in zip(fx_outputs[:4]     ,		pt_outputs_loaded[:4]				):
											self.assert_almost_equals(lowerCamelCase__     ,		pt_output_loaded.numpy()     ,		4e-2				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__     ,		lowerCamelCase__				)

							__lowerCamelCase									=       VisionTextDualEncoderModel(lowerCamelCase__				)
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel(lowerCamelCase__				)

							__lowerCamelCase									=       convert_pytorch_state_dict_to_flax(pt_model.state_dict()     ,		lowerCamelCase__				)
							__lowerCamelCase									=       fx_state

							self.check_pt_flax_equivalence(lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       VisionTextDualEncoderConfig.from_vision_text_configs(lowerCamelCase__     ,		lowerCamelCase__				)

							__lowerCamelCase									=       VisionTextDualEncoderModel(lowerCamelCase__				)
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel(lowerCamelCase__				)

							__lowerCamelCase									=       load_flax_weights_in_pytorch_model(lowerCamelCase__     ,		fx_model.params				)

							self.check_pt_flax_equivalence(lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)


			def  lowercase_       ( self				)       -> int:



							'''simple docstring'''
							__lowerCamelCase									=       self.prepare_config_and_inputs()
							self.check_model_from_pretrained_configs(**lowerCamelCase__				)


			def  lowercase_       ( self				)       -> Dict:



							'''simple docstring'''
							__lowerCamelCase									=       self.prepare_config_and_inputs()
							self.check_vision_text_dual_encoder_from_pretrained(**lowerCamelCase__				)


			def  lowercase_       ( self				)       -> Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.prepare_config_and_inputs()
							self.check_save_load(**lowerCamelCase__				)


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



							'''simple docstring'''
							__lowerCamelCase									=       self.prepare_config_and_inputs()
							self.check_vision_text_output_attention(**lowerCamelCase__				)


			@is_pt_flax_cross_test
			def  lowercase_       ( self				)       -> List[Any]:



							'''simple docstring'''
							__lowerCamelCase									=       self.prepare_config_and_inputs()
							__lowerCamelCase									=       config_inputs_dict.pop('vision_config'				)
							__lowerCamelCase									=       config_inputs_dict.pop('text_config'				)

							__lowerCamelCase									=       config_inputs_dict

							self.check_equivalence_pt_to_flax(lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)
							self.check_equivalence_flax_to_pt(lowerCamelCase__     ,		lowerCamelCase__     ,		lowerCamelCase__				)






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



							'''simple docstring'''
							__lowerCamelCase			,		__lowerCamelCase									=       self.get_pretrained_model_and_inputs()

							__lowerCamelCase									=       model_a(**lowerCamelCase__				)
							__lowerCamelCase									=       outputs[0]

							with tempfile.TemporaryDirectory() as tmp_dirname:
											model_a.save_pretrained(lowerCamelCase__				)
											__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_pretrained(lowerCamelCase__				)

											__lowerCamelCase									=       model_a(**lowerCamelCase__				)
											__lowerCamelCase									=       after_outputs[0]
											__lowerCamelCase									=       np.amax(np.abs(out_a - out_a				)				)
											self.assertLessEqual(lowerCamelCase__     ,		1e-5				)







@require_flax
class        __lowerCAmelCase					(			__magic_name__     ,							unittest.TestCase					):

			"""simple docstring"""







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



							'''simple docstring'''
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
							    'hf-internal-testing/tiny-random-vit'     ,		'hf-internal-testing/tiny-bert'     ,		vision_from_pt=lowerCamelCase__     ,		text_from_pt=lowerCamelCase__     ,		)
							__lowerCamelCase									=       13
							__lowerCamelCase									=       floats_tensor(
							    [
							        batch_size,
							        model.config.vision_config.num_channels,
							        model.config.vision_config.image_size,
							        model.config.vision_config.image_size,
							    ]				)
							__lowerCamelCase									=       ids_tensor([batch_size, 4]     ,		model.config.text_config.vocab_size				)
							__lowerCamelCase									=       random_attention_mask([batch_size, 4]				)
							__lowerCamelCase									=       {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

							return model, inputs


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> List[str]:



							'''simple docstring'''
							__lowerCamelCase									=       FlaxViTModel(lowerCamelCase__				)
							__lowerCamelCase									=       FlaxBertModel(lowerCamelCase__				)
							return vision_model, text_model






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



							'''simple docstring'''
							__lowerCamelCase									=       FlaxViTModelTester(self				)
							__lowerCamelCase									=       FlaxBertModelTester(self				)
							__lowerCamelCase									=       vit_model_tester.prepare_config_and_inputs()
							__lowerCamelCase									=       bert_model_tester.prepare_config_and_inputs()

							__lowerCamelCase			,		__lowerCamelCase									=       vision_config_and_inputs

							__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase									=       text_config_and_inputs

							# make sure that cross attention layers are added
							return {
							    "text_config": text_config,
							    "vision_config": vision_config,
							    "pixel_values": pixel_values,
							    "attention_mask": attention_mask,
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							}







@require_torch
class        __lowerCAmelCase					(			__magic_name__     ,							unittest.TestCase					):

			"""simple docstring"""







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



							'''simple docstring'''
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
							    'hf-internal-testing/tiny-random-clip'     ,		'hf-internal-testing/tiny-bert'     ,		vision_from_pt=lowerCamelCase__     ,		text_from_pt=lowerCamelCase__     ,		)
							__lowerCamelCase									=       13
							__lowerCamelCase									=       floats_tensor(
							    [
							        batch_size,
							        model.config.vision_config.num_channels,
							        model.config.vision_config.image_size,
							        model.config.vision_config.image_size,
							    ]				)
							__lowerCamelCase									=       ids_tensor([batch_size, 4]     ,		model.config.text_config.vocab_size				)
							__lowerCamelCase									=       random_attention_mask([batch_size, 4]				)
							__lowerCamelCase									=       {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

							return model, inputs


			def  lowercase_       ( self     ,		lowerCamelCase__     ,		lowerCamelCase__				)       -> Union[str, Any]:



							'''simple docstring'''
							__lowerCamelCase									=       FlaxCLIPVisionModel(lowerCamelCase__				)
							__lowerCamelCase									=       FlaxBertModel(lowerCamelCase__				)
							return vision_model, text_model






			def  lowercase_       ( self				)       -> Tuple:



							'''simple docstring'''
							__lowerCamelCase									=       FlaxCLIPVisionModelTester(self				)
							__lowerCamelCase									=       FlaxBertModelTester(self				)
							__lowerCamelCase									=       clip_model_tester.prepare_config_and_inputs()
							__lowerCamelCase									=       bert_model_tester.prepare_config_and_inputs()

							__lowerCamelCase			,		__lowerCamelCase									=       vision_config_and_inputs

							__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase			,		__lowerCamelCase									=       text_config_and_inputs

							# make sure that cross attention layers are added
							return {
							    "text_config": text_config,
							    "vision_config": vision_config,
							    "pixel_values": pixel_values,
							    "attention_mask": attention_mask,
							    "input_ids": input_ids,
							    "token_type_ids": token_type_ids,
							}







@require_flax
@require_vision
class        __lowerCAmelCase					(			unittest.TestCase					):

			"""simple docstring"""







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



							'''simple docstring'''
							__lowerCamelCase									=       FlaxVisionTextDualEncoderModel.from_pretrained('clip-italian/clip-italian'     ,		logit_scale_init_value=1.0				)
							__lowerCamelCase									=       VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'				)

							__lowerCamelCase									=       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
							__lowerCamelCase									=       processor(
							    text=['una foto di un gatto', 'una foto di un cane']     ,		images=lowerCamelCase__     ,		padding=lowerCamelCase__     ,		return_tensors='np'				)

							__lowerCamelCase									=       model(**lowerCamelCase__				)

							# verify the logits
							self.assertEqual(outputs.logits_per_image.shape     ,		(inputs.pixel_values.shape[0], inputs.input_ids.shape[0])				)
							self.assertEqual(
							    outputs.logits_per_text.shape     ,		(inputs.input_ids.shape[0], inputs.pixel_values.shape[0])     ,		)

							__lowerCamelCase									=       np.array([[1.2_28_47_27, 0.3_10_41_22]]				)

							self.assertTrue(np.allclose(outputs.logits_per_image     ,		lowerCamelCase__     ,		atol=1e-3				)				)








import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
__A								=       data_utils.TransfoXLTokenizer
__A								=       data_utils.TransfoXLCorpus
__A								=       data_utils
__A								=       data_utils







def      lowerCamelCase_						(			UpperCamelCase__							: int					,	UpperCamelCase__							: str					,	UpperCamelCase__							: Optional[Any]					,	UpperCamelCase__							: Tuple )	->			Tuple:





				"""simple docstring"""


				if transfo_xl_dataset_file:
								# Convert a pre-processed corpus (see original TensorFlow repo)
								with open(UpperCamelCase__					,	'rb' ) as fp:
												__lowerCamelCase									=       pickle.load(UpperCamelCase__					,	encoding='latin1' )
								# Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
								__lowerCamelCase									=       pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
								print(F"""Save vocabulary to {pytorch_vocab_dump_path}""" )
								__lowerCamelCase									=       corpus.vocab.__dict__
								torch.save(UpperCamelCase__					,	UpperCamelCase__ )

								__lowerCamelCase									=       corpus.__dict__
								corpus_dict_no_vocab.pop('vocab'					,	UpperCamelCase__ )
								__lowerCamelCase									=       pytorch_dump_folder_path + '/' + CORPUS_NAME
								print(F"""Save dataset to {pytorch_dataset_dump_path}""" )
								torch.save(UpperCamelCase__					,	UpperCamelCase__ )

				if tf_checkpoint_path:
								# Convert a pre-trained TensorFlow model
								__lowerCamelCase									=       os.path.abspath(UpperCamelCase__ )
								__lowerCamelCase									=       os.path.abspath(UpperCamelCase__ )

								print(F"""Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.""" )
								# Initialise PyTorch model
								if transfo_xl_config_file == "":
												__lowerCamelCase									=       TransfoXLConfig()
								else:
												__lowerCamelCase									=       TransfoXLConfig.from_json_file(UpperCamelCase__ )
								print(F"""Building PyTorch model from configuration: {config}""" )
								__lowerCamelCase									=       TransfoXLLMHeadModel(UpperCamelCase__ )

								__lowerCamelCase									=       load_tf_weights_in_transfo_xl(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__ )
								# Save pytorch-model
								__lowerCamelCase									=       os.path.join(UpperCamelCase__					,	UpperCamelCase__ )
								__lowerCamelCase									=       os.path.join(UpperCamelCase__					,	UpperCamelCase__ )
								print(F"""Save PyTorch model to {os.path.abspath(UpperCamelCase__ )}""" )
								torch.save(model.state_dict()					,	UpperCamelCase__ )
								print(F"""Save configuration file to {os.path.abspath(UpperCamelCase__ )}""" )
								with open(UpperCamelCase__					,	'w'					,	encoding='utf-8' ) as f:
												f.write(config.to_json_string() )


if __name__ == "__main__":
					__A								=       argparse.ArgumentParser()
					parser.add_argument(
					    "--pytorch_dump_folder_path",
					    default=None,
					    type=str,
					    required=True,
					    help="Path to the folder to store the PyTorch model or dataset/vocab.",
					)
					parser.add_argument(
					    "--tf_checkpoint_path",
					    default="",
					    type=str,
					    help="An optional path to a TensorFlow checkpoint path to be converted.",
					)
					parser.add_argument(
					    "--transfo_xl_config_file",
					    default="",
					    type=str,
					    help=(
					        "An optional config json file corresponding to the pre-trained BERT model. \n"
					        "This specifies the model architecture."
					    ),
					)
					parser.add_argument(
					    "--transfo_xl_dataset_file",
					    default="",
					    type=str,
					    help="An optional dataset file to be converted in a vocabulary.",
					)
					__A								=       parser.parse_args()
					convert_transfo_xl_checkpoint_to_pytorch(
					    args.tf_checkpoint_path,
					    args.transfo_xl_config_file,
					    args.pytorch_dump_folder_path,
					    args.transfo_xl_dataset_file,
					)


