

import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class     a__  (    unittest.TestCase	):
			"""simple docstring"""







			@property
			def    UpperCamelCase						(			self				)     ->  List[str]:
							'''simple docstring'''






							torch.manual_seed(0				)
							A__						=	UNetaDModel(
							    block_out_channels=(32, 64)					,					layers_per_block=2					,					sample_size=32					,					in_channels=3					,					out_channels=3					,					down_block_types=("DownBlock2D", "AttnDownBlock2D")					,					up_block_types=("AttnUpBlock2D", "UpBlock2D")					,					)
							return model


			@property
			def    UpperCamelCase						(			self				)     ->  Any:
							'''simple docstring'''






							torch.manual_seed(0				)
							A__						=	VQModel(
							    block_out_channels=[32, 64]					,					in_channels=3					,					out_channels=3					,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,					latent_channels=3					,					)
							return model


			@property
			def    UpperCamelCase						(			self				)     ->  Any:
							'''simple docstring'''






							torch.manual_seed(0				)
							A__						=	CLIPTextConfig(
							    bos_token_id=0					,					eos_token_id=2					,					hidden_size=32					,					intermediate_size=37					,					layer_norm_eps=1e-05					,					num_attention_heads=4					,					num_hidden_layers=5					,					pad_token_id=1					,					vocab_size=1000					,					)
							return CLIPTextModel(lowercase				)


			def    UpperCamelCase						(			self				)     ->  int:
							'''simple docstring'''






							A__						=	self.dummy_uncond_unet
							A__						=	DDIMScheduler()
							A__						=	self.dummy_vq_model

							A__						=	LDMPipeline(unet=lowercase					,					vqvae=lowercase					,					scheduler=lowercase				)
							ldm.to(lowercase				)
							ldm.set_progress_bar_config(disable=lowercase				)

							A__						=	torch.manual_seed(0				)
							A__						=	ldm(generator=lowercase					,					num_inference_steps=2					,					output_type="numpy"				).images

							A__						=	torch.manual_seed(0				)
							A__						=	ldm(generator=lowercase					,					num_inference_steps=2					,					output_type="numpy"					,					return_dict=lowercase				)[0]

							A__						=	image[0, -3:, -3:, -1]
							A__						=	image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							A__						=	np.array([0.8512, 0.818, 0.6411, 0.6808, 0.4465, 0.5618, 0.46, 0.6231, 0.5172]				)
							A__						=	1e-2 if torch_device != "mps" else 3e-2

							assert np.abs(image_slice.flatten() - expected_slice				).max() < tolerance
							assert np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < tolerance

@slow
@require_torch
class     a__  (    unittest.TestCase	):
			"""simple docstring"""







			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							A__						=	LDMPipeline.from_pretrained("CompVis/ldm-celebahq-256"				)
							ldm.to(lowercase				)
							ldm.set_progress_bar_config(disable=lowercase				)

							A__						=	torch.manual_seed(0				)
							A__						=	ldm(generator=lowercase					,					num_inference_steps=5					,					output_type="numpy"				).images

							A__						=	image[0, -3:, -3:, -1]

							assert image.shape == (1, 256, 256, 3)
							A__						=	np.array([0.4399, 0.4_4975, 0.4_6825, 0.474, 0.4359, 0.4581, 0.4_5095, 0.4341, 0.4447]				)
							A__						=	1e-2 if torch_device != "mps" else 3e-2

							assert np.abs(image_slice.flatten() - expected_slice				).max() < tolerance









import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


lowercase  							=					{
    "cola": 2,
    "mnli": 3,
    "mrpc": 2,
    "sst-2": 2,
    "sts-b": 1,
    "qqp": 2,
    "qnli": 2,
    "rte": 2,
    "wnli": 2,
}


logging.set_verbosity_info()





def 						__UpperCAmelCase			(     a_							,     a_							,     a_							,     a_=None):
							# Initialise PyTorch model
							snake_case_				=							XLNetConfig.from_json_file(a_)

							snake_case_				=							finetuning_task.lower() if finetuning_task is not None else ''
							if finetuning_task in GLUE_TASKS_NUM_LABELS:
														print(f'''Building PyTorch XLNetForSequenceClassification model from configuration: {config}''')
														snake_case_				=							finetuning_task
														snake_case_				=							GLUE_TASKS_NUM_LABELS[finetuning_task]
														snake_case_				=							XLNetForSequenceClassification(a_)
							elif "squad" in finetuning_task:
														snake_case_				=							finetuning_task
														snake_case_				=							XLNetForQuestionAnswering(a_)
							else:
														snake_case_				=							XLNetLMHeadModel(a_)

							# Load weights from tf checkpoint
							load_tf_weights_in_xlnet(a_							,     a_							,     a_)

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


if __name__ == "__main__":
	lowercase  							=					argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
	)
	parser.add_argument(
	    "--xlnet_config_file",
	    default=None,
	    type=str,
	    required=True,
	    help=(
	        "The config json file corresponding to the pre-trained XLNet model. \n"
	        "This specifies the model architecture."
	    ),
	)
	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(
	    "--finetuning_task",
	    default=None,
	    type=str,
	    help="Name of a task on which the XLNet TensorFlow model was fine-tuned",
	)
	lowercase  							=					parser.parse_args()
	print(args)

	convert_xlnet_checkpoint_to_pytorch(
	    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
	)





