





"""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  __A       (  a      ,   a      ,   unittest.TestCase      ):
				__A								=			AutoencoderKL
				__A								=			"""sample"""
				__A								=			1E-2


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

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

								return {"sample": image}


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


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


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


				def _snake_case    (						self							):
								pass


				def _snake_case    (						self							):
								pass


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

								assert not model.is_gradient_checkpointing and model.training

								lowerCamelCase			=model(**UpperCAmelCase_							).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()

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

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

								assert model_a.is_gradient_checkpointing and model_a.training

								lowerCamelCase			=model_a(**UpperCAmelCase_							).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()
								lowerCamelCase			=(out_a - labels).mean()
								loss_a.backward()

								# compare the output and parameters gradients
								self.assertTrue((loss - loss_a).abs() < 1E-5							)
								lowerCamelCase			=dict(model.named_parameters()							)
								lowerCamelCase			=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 _snake_case    (						self							):
								lowerCamelCase	,					lowerCamelCase			=AutoencoderKL.from_pretrained("""fusing/autoencoder-kl-dummy"""				,	output_loading_info=UpperCAmelCase_							)
								self.assertIsNotNone(UpperCAmelCase_							)
								self.assertEqual(len(loading_info["""missing_keys"""]							)				,	0							)

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

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


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

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

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

								lowerCamelCase			=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":
												lowerCamelCase			=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":
												lowerCamelCase			=torch.tensor(
												    [-0.1_3_5_2, 0.0_8_7_8, 0.0_4_1_9, -0.0_8_1_8, -0.1_0_6_9, 0.0_6_8_8, -0.1_4_5_8, -0.4_4_4_6, -0.0_0_2_6]							)
								else:
												lowerCamelCase			=torch.tensor(
												    [-0.2_4_2_1, 0.4_6_4_2, 0.2_5_0_7, -0.0_4_3_8, 0.0_6_8_2, 0.3_1_6_0, -0.2_0_1_8, -0.0_7_2_7, 0.2_4_8_5]							)

								self.assertTrue(torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	rtol=1E-2							)							)




@slow
class  __A       (  unittest.TestCase      ):


				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								return f"""gaussian_noise_s={seed}_shape={"_".join([str(UpperCAmelCase_							) for s in shape]							)}.npy"""


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


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


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

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

								return model


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


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.1_6_0_3, 0.9_8_7_8, -0.0_4_9_5, -0.0_7_9_0, -0.2_7_0_9, 0.8_3_7_5, -0.2_0_6_0, -0.0_8_2_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
				        [47, [-0.2_3_7_6, 0.1_1_6_8, 0.1_3_3_2, -0.4_8_4_0, -0.2_5_0_8, -0.0_7_9_1, -0.0_4_9_3, -0.4_0_8_9], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
				        # fmt: on
				    ]							)
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model()
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_							)
								lowerCamelCase			=self.get_generator(UpperCAmelCase_							)

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

								assert sample.shape == image.shape

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	atol=3E-3							)


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.0_5_1_3, 0.0_2_8_9, 1.3_7_9_9, 0.2_1_6_6, -0.2_5_7_3, -0.0_8_7_1, 0.5_1_0_3, -0.0_9_9_9]],
				        [47, [-0.4_1_2_8, -0.1_3_2_0, -0.3_7_0_4, 0.1_9_6_5, -0.4_1_1_6, -0.2_3_3_2, -0.3_3_4_0, 0.2_2_4_7]],
				        # fmt: on
				    ]							)
				@require_torch_gpu
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model(fpaa=UpperCAmelCase_							)
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_				,	fpaa=UpperCAmelCase_							)
								lowerCamelCase			=self.get_generator(UpperCAmelCase_							)

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

								assert sample.shape == image.shape

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	atol=1E-2							)


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.1_6_0_9, 0.9_8_6_6, -0.0_4_8_7, -0.0_7_7_7, -0.2_7_1_6, 0.8_3_6_8, -0.2_0_5_5, -0.0_8_1_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
				        [47, [-0.2_3_7_7, 0.1_1_4_7, 0.1_3_3_3, -0.4_8_4_1, -0.2_5_0_6, -0.0_8_0_5, -0.0_4_9_1, -0.4_0_8_5], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
				        # fmt: on
				    ]							)
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model()
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_							)

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

								assert sample.shape == image.shape

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	atol=3E-3							)


				@parameterized.expand(
				    [
				        # fmt: off
				        [13, [-0.2_0_5_1, -0.1_8_0_3, -0.2_3_1_1, -0.2_1_1_4, -0.3_2_9_2, -0.3_5_7_4, -0.2_9_5_3, -0.3_3_2_3]],
				        [37, [-0.2_6_3_2, -0.2_6_2_5, -0.2_1_9_9, -0.2_7_4_1, -0.4_5_3_9, -0.4_9_9_0, -0.3_7_2_0, -0.4_9_2_5]],
				        # fmt: on
				    ]							)
				@require_torch_gpu
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model()
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_				,	shape=(3, 4, 64, 64)							)

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

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

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	atol=1E-3							)


				@parameterized.expand(
				    [
				        # fmt: off
				        [27, [-0.0_3_6_9, 0.0_2_0_7, -0.0_7_7_6, -0.0_6_8_2, -0.1_7_4_7, -0.1_9_3_0, -0.1_4_6_5, -0.2_0_3_9]],
				        [16, [-0.1_6_2_8, -0.2_1_3_4, -0.2_7_4_7, -0.2_6_4_2, -0.3_7_7_4, -0.4_4_0_4, -0.3_6_8_7, -0.4_2_7_7]],
				        # fmt: on
				    ]							)
				@require_torch_gpu
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model(fpaa=UpperCAmelCase_							)
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_				,	shape=(3, 4, 64, 64)				,	fpaa=UpperCAmelCase_							)

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

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

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	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 _snake_case    (						self				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model(fpaa=UpperCAmelCase_							)
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_				,	shape=(3, 4, 64, 64)				,	fpaa=UpperCAmelCase_							)

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

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

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	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 _snake_case    (						self				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model()
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_				,	shape=(3, 4, 64, 64)							)

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

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

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

								assert torch_all_close(UpperCAmelCase_				,	UpperCAmelCase_				,	atol=1E-2							)


				@parameterized.expand(
				    [
				        # fmt: off
				        [33, [-0.3_0_0_1, 0.0_9_1_8, -2.6_9_8_4, -3.9_7_2_0, -3.2_0_9_9, -5.0_3_5_3, 1.7_3_3_8, -0.2_0_6_5, 3.4_2_6_7]],
				        [47, [-1.5_0_3_0, -4.3_8_7_1, -6.0_3_5_5, -9.1_1_5_7, -1.6_6_6_1, -2.7_8_5_3, 2.1_6_0_7, -5.0_8_2_3, 2.5_6_3_3]],
				        # fmt: on
				    ]							)
				def _snake_case    (						self				,	UpperCAmelCase_				,	UpperCAmelCase_							):
								lowerCamelCase			=self.get_sd_vae_model()
								lowerCamelCase			=self.get_sd_image(UpperCAmelCase_							)
								lowerCamelCase			=self.get_generator(UpperCAmelCase_							)

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

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

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

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












from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels





