




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    EulerAncestralDiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionInstructPixaPixPipeline,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.utils import floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






class 					__magic_name__							( UpperCAmelCase__		,      UpperCAmelCase__		,      UpperCAmelCase__		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		StableDiffusionInstructPixaPixPipeline
				__UpperCamelCase    						=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width', 'cross_attention_kwargs'}
				__UpperCamelCase    						=		TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
				__UpperCamelCase    						=		IMAGE_TO_IMAGE_IMAGE_PARAMS
				__UpperCamelCase    						=		IMAGE_TO_IMAGE_IMAGE_PARAMS





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							torch.manual_seed(0				)
							lowerCamelCase       =      UNetaDConditionModel(
							    block_out_channels=(32, 64)	,				layers_per_block=2	,				sample_size=32	,				in_channels=8	,				out_channels=4	,				down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")	,				up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")	,				cross_attention_dim=32	,				)
							lowerCamelCase       =      PNDMScheduler(skip_prk_steps=_a				)
							torch.manual_seed(0				)
							lowerCamelCase       =      AutoencoderKL(
							    block_out_channels=[32, 64]	,				in_channels=3	,				out_channels=3	,				down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]	,				up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]	,				latent_channels=4	,				)
							torch.manual_seed(0				)
							lowerCamelCase       =      CLIPTextConfig(
							    bos_token_id=0	,				eos_token_id=2	,				hidden_size=32	,				intermediate_size=37	,				layer_norm_eps=1e-0_5	,				num_attention_heads=4	,				num_hidden_layers=5	,				pad_token_id=1	,				vocab_size=1_000	,				)
							lowerCamelCase       =      CLIPTextModel(_a				)
							lowerCamelCase       =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

							lowerCamelCase       =      {
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """safety_checker""": None,
							    """feature_extractor""": None,
							}
							return components





				def      _lowerCAmelCase       ( self	,				_a	,				_a=0				):





							"""simple docstring"""
							lowerCamelCase       =      floats_tensor((1, 3, 32, 32)	,				rng=random.Random(_a				)				).to(_a				)
							lowerCamelCase       =      image.cpu().permute(0	,				2	,				3	,				1				)[0]
							lowerCamelCase       =      Image.fromarray(np.uinta(_a				)				).convert("""RGB"""				)
							if str(_a				).startswith("""mps"""				):
										lowerCamelCase       =      torch.manual_seed(_a				)
							else:
										lowerCamelCase       =      torch.Generator(device=_a				).manual_seed(_a				)
							lowerCamelCase       =      {
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """image""": image,
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 6.0,
							    """image_guidance_scale""": 1,
							    """output_type""": """numpy""",
							}
							return inputs





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline(**_a				)
							lowerCamelCase       =      sd_pipe.to(_a				)
							sd_pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      sd_pipe(**_a				).images
							lowerCamelCase       =      image[0, -3:, -3:, -1]
							assert image.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.7_526, 0.3_750, 0.4_547, 0.6_117, 0.5_866, 0.5_016, 0.4_327, 0.5_642, 0.4_815]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline(**_a				)
							lowerCamelCase       =      sd_pipe.to(_a				)
							sd_pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      """french fries"""
							lowerCamelCase       =      sd_pipe(**_a	,				negative_prompt=_a				)
							lowerCamelCase       =      output.images
							lowerCamelCase       =      image[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.7_511, 0.3_642, 0.4_553, 0.6_236, 0.5_797, 0.5_013, 0.4_343, 0.5_611, 0.4_831]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline(**_a				)
							lowerCamelCase       =      sd_pipe.to(_a				)
							sd_pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      [inputs["""prompt"""]] * 2

							lowerCamelCase       =      np.array(inputs["""image"""]				).astype(np.floataa				) / 255.0
							lowerCamelCase       =      torch.from_numpy(_a				).unsqueeze(0				).to(_a				)
							lowerCamelCase       =      image / 2 + 0.5
							lowerCamelCase       =      image.permute(0	,				3	,				1	,				2				)
							lowerCamelCase       =      image.repeat(2	,				1	,				1	,				1				)

							lowerCamelCase       =      sd_pipe(**_a				).images
							lowerCamelCase       =      image[-1, -3:, -3:, -1]

							assert image.shape == (2, 32, 32, 3)
							lowerCamelCase       =      np.array([0.5_812, 0.5_748, 0.5_222, 0.5_908, 0.5_695, 0.7_174, 0.6_804, 0.5_523, 0.5_579]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """cpu"""  # ensure determinism for the device-dependent torch.Generator
							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      EulerAncestralDiscreteScheduler(
							    beta_start=0.00_085	,				beta_end=0.012	,				beta_schedule="""scaled_linear"""				)
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline(**_a				)
							lowerCamelCase       =      sd_pipe.to(_a				)
							sd_pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      self.get_dummy_inputs(_a				)
							lowerCamelCase       =      sd_pipe(**_a				).images
							lowerCamelCase       =      image[0, -3:, -3:, -1]

							lowerCamelCase       =      [round(_a	,				4				) for x in image_slice.flatten().tolist()]
							print(""",""".join([str(_a				) for x in slice]				)				)

							assert image.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.7_417, 0.3_842, 0.4_732, 0.5_776, 0.5_891, 0.5_139, 0.4_052, 0.5_673, 0.4_986]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							super().test_inference_batch_single_identical(expected_max_diff=3e-3				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_dummy_components()
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline(**_a				)
							lowerCamelCase       =      VaeImageProcessor(do_resize=_a	,				do_normalize=_a				)
							lowerCamelCase       =      pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      pipe(**self.get_dummy_inputs_by_type(_a	,				input_image_type="""pt"""				)				)[0]

							lowerCamelCase       =      components["""vae"""]
							lowerCamelCase       =      self.get_dummy_inputs_by_type(_a	,				input_image_type="""pt"""				)

							for image_param in self.image_latents_params:
										if image_param in inputs.keys():
													lowerCamelCase       =      vae.encode(inputs[image_param]				).latent_dist.mode()

							lowerCamelCase       =      pipe(**_a				)[0]

							lowerCamelCase       =      np.abs(out - out_latents_inputs				).max()
							self.assertLess(_a	,				1e-4	,				"""passing latents as image input generate different result from passing image"""				)






@slow
@require_torch_gpu
class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()





				def      _lowerCAmelCase       ( self	,				_a=0				):





							"""simple docstring"""
							lowerCamelCase       =      torch.manual_seed(_a				)
							lowerCamelCase       =      load_image(
							    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_pix2pix/example.jpg"""				)
							lowerCamelCase       =      {
							    """prompt""": """turn him into a cyborg""",
							    """image""": image,
							    """generator""": generator,
							    """num_inference_steps""": 3,
							    """guidance_scale""": 7.5,
							    """image_guidance_scale""": 1.0,
							    """output_type""": """numpy""",
							}
							return inputs





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    """timbrooks/instruct-pix2pix"""	,				safety_checker=_a				)
							pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing()

							lowerCamelCase       =      self.get_inputs()
							lowerCamelCase       =      pipe(**_a				).images
							lowerCamelCase       =      image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      np.array([0.5_902, 0.6_015, 0.6_027, 0.5_983, 0.6_092, 0.6_061, 0.5_765, 0.5_785, 0.5_555]				)

							assert np.abs(expected_slice - image_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    """timbrooks/instruct-pix2pix"""	,				safety_checker=_a				)
							lowerCamelCase       =      LMSDiscreteScheduler.from_config(pipe.scheduler.config				)
							pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing()

							lowerCamelCase       =      self.get_inputs()
							lowerCamelCase       =      pipe(**_a				).images
							lowerCamelCase       =      image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      np.array([0.6_578, 0.6_817, 0.6_972, 0.6_761, 0.6_856, 0.6_916, 0.6_428, 0.6_516, 0.6_301]				)

							assert np.abs(expected_slice - image_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    """timbrooks/instruct-pix2pix"""	,				safety_checker=_a				)
							lowerCamelCase       =      DDIMScheduler.from_config(pipe.scheduler.config				)
							pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing()

							lowerCamelCase       =      self.get_inputs()
							lowerCamelCase       =      pipe(**_a				).images
							lowerCamelCase       =      image[0, -3:, -3:, -1].flatten()

							assert image.shape == (1, 512, 512, 3)
							lowerCamelCase       =      np.array([0.3_828, 0.3_834, 0.3_818, 0.3_792, 0.3_865, 0.3_752, 0.3_792, 0.3_847, 0.3_753]				)

							assert np.abs(expected_slice - image_slice				).max() < 1e-3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      0

							def callback_fn(_a	,				_a	,				_a				) -> None:
										lowerCamelCase       =      True
										nonlocal number_of_steps
										number_of_steps += 1
										if step == 1:
													lowerCamelCase       =      latents.detach().cpu().numpy()
													assert latents.shape == (1, 4, 64, 64)
													lowerCamelCase       =      latents[0, -3:, -3:, -1]
													lowerCamelCase       =      np.array([-0.2_463, -0.4_644, -0.9_756, 1.5_176, 1.4_414, 0.7_866, 0.9_897, 0.8_521, 0.7_983]				)

													assert np.abs(latents_slice.flatten() - expected_slice				).max() < 5e-2
										elif step == 2:
													lowerCamelCase       =      latents.detach().cpu().numpy()
													assert latents.shape == (1, 4, 64, 64)
													lowerCamelCase       =      latents[0, -3:, -3:, -1]
													lowerCamelCase       =      np.array([-0.2_644, -0.4_626, -0.9_653, 1.5_176, 1.4_551, 0.7_686, 0.9_805, 0.8_452, 0.8_115]				)

													assert np.abs(latents_slice.flatten() - expected_slice				).max() < 5e-2

							lowerCamelCase       =      False

							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    """timbrooks/instruct-pix2pix"""	,				safety_checker=_a	,				torch_dtype=torch.floataa				)
							lowerCamelCase       =      pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing()

							lowerCamelCase       =      self.get_inputs()
							pipe(**_a	,				callback=_a	,				callback_steps=1				)
							assert callback_fn.has_been_called
							assert number_of_steps == 3





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							torch.cuda.empty_cache()
							torch.cuda.reset_max_memory_allocated()
							torch.cuda.reset_peak_memory_stats()

							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    """timbrooks/instruct-pix2pix"""	,				safety_checker=_a	,				torch_dtype=torch.floataa				)
							lowerCamelCase       =      pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing(1				)
							pipe.enable_sequential_cpu_offload()

							lowerCamelCase       =      self.get_inputs()
							lowerCamelCase       =      pipe(**_a				)

							lowerCamelCase       =      torch.cuda.max_memory_allocated()
							# make sure that less than 2.2 GB is allocated
							assert mem_bytes < 2.2 * 10**9





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_inputs()
							# resize to resolution that is divisible by 8 but not 16 or 32
							lowerCamelCase       =      inputs["""image"""].resize((504, 504)				)

							lowerCamelCase       =      """timbrooks/instruct-pix2pix"""
							lowerCamelCase       =      StableDiffusionInstructPixaPixPipeline.from_pretrained(
							    _a	,				safety_checker=_a	,				)
							pipe.to(_a				)
							pipe.set_progress_bar_config(disable=_a				)
							pipe.enable_attention_slicing()

							lowerCamelCase       =      pipe(**_a				)
							lowerCamelCase       =      output.images[0]

							lowerCamelCase       =      image[255:258, 383:386, -1]

							assert image.shape == (504, 504, 3)
							lowerCamelCase       =      np.array([0.2_726, 0.2_529, 0.2_664, 0.2_655, 0.2_641, 0.2_642, 0.2_591, 0.2_649, 0.2_590]				)

							assert np.abs(image_slice.flatten() - expected_slice				).max() < 5e-3









"""simple docstring"""




import random

import torch
from huggingface_hub import HfApi

from diffusers import UNetaDModel


lowerCAmelCase							:    List[str]  							=							HfApi()

lowerCAmelCase							:    Tuple  							=							{}
# fmt: off
lowerCAmelCase							:    List[str]  							=							torch.tensor([
    -0.7_5_1_5, -1.6_8_8_3, 0.2_4_2_0, 0.0_3_0_0, 0.6_3_4_7, 1.3_4_3_3, -1.1_7_4_3, -3.7_4_6_7,
    1.2_3_4_2, -2.2_4_8_5, 0.4_6_3_6, 0.8_0_7_6, -0.7_9_9_1, 0.3_9_6_9, 0.8_4_9_8, 0.9_1_8_9,
    -1.8_8_8_7, -3.3_5_2_2, 0.7_6_3_9, 0.2_0_4_0, 0.6_2_7_1, -2.7_1_4_8, -1.6_3_1_6, 3.0_8_3_9,
    0.3_1_8_6, 0.2_7_2_1, -0.9_7_5_9, -1.2_4_6_1, 2.6_2_5_7, 1.3_5_5_7
])
lowerCAmelCase							:    Dict  							=							torch.tensor([
    -2.3_6_3_9, -2.5_3_4_4, 0.0_0_5_4, -0.6_6_7_4, 1.5_9_9_0, 1.0_1_5_8, 0.3_1_2_4, -2.1_4_3_6,
    1.8_7_9_5, -2.5_4_2_9, -0.1_5_6_6, -0.3_9_7_3, 1.2_4_9_0, 2.6_4_4_7, 1.2_2_8_3, -0.5_2_0_8,
    -2.8_1_5_4, -3.5_1_1_9, 2.3_8_3_8, 1.2_0_3_3, 1.7_2_0_1, -2.1_2_5_6, -1.4_5_7_6, 2.7_9_4_8,
    2.4_2_0_4, -0.9_7_5_2, -1.2_5_4_6, 0.8_0_2_7, 3.2_7_5_8, 3.1_3_6_5
])
lowerCAmelCase							:    str  							=							torch.tensor([
    -0.6_5_3_1, -0.6_8_9_1, -0.3_1_7_2, -0.5_3_7_5, -0.9_1_4_0, -0.5_3_6_7, -0.1_1_7_5, -0.7_8_6_9,
    -0.3_8_0_8, -0.4_5_1_3, -0.2_0_9_8, -0.0_0_8_3, 0.3_1_8_3, 0.5_1_4_0, 0.2_2_4_7, -0.1_3_0_4,
    -0.1_3_0_2, -0.2_8_0_2, -0.2_0_8_4, -0.2_0_2_5, -0.4_9_6_7, -0.4_8_7_3, -0.0_8_6_1, 0.6_9_2_5,
    0.0_2_5_0, 0.1_2_9_0, -0.1_5_4_3, 0.6_3_1_6, 1.0_4_6_0, 1.4_9_4_3
])
lowerCAmelCase							:    List[Any]  							=							torch.tensor([
    0.0_9_1_1, 0.1_1_0_7, 0.0_1_8_2, 0.0_4_3_5, -0.0_8_0_5, -0.0_6_0_8, 0.0_3_8_1, 0.2_1_7_2,
    -0.0_2_8_0, 0.1_3_2_7, -0.0_2_9_9, -0.0_2_5_5, -0.0_0_5_0, -0.1_1_7_0, -0.1_0_4_6, 0.0_3_0_9,
    0.1_3_6_7, 0.1_7_2_8, -0.0_5_3_3, -0.0_7_4_8, -0.0_5_3_4, 0.1_6_2_4, 0.0_3_8_4, -0.1_8_0_5,
    -0.0_7_0_7, 0.0_6_4_2, 0.0_2_2_0, -0.0_1_3_4, -0.1_3_3_3, -0.1_5_0_5
])
lowerCAmelCase							:    int  							=							torch.tensor([
    0.1_3_2_1, 0.1_3_3_7, 0.0_4_4_0, 0.0_6_2_2, -0.0_5_9_1, -0.0_3_7_0, 0.0_5_0_3, 0.2_1_3_3,
    -0.0_1_7_7, 0.1_4_1_5, -0.0_1_1_6, -0.0_1_1_2, 0.0_0_4_4, -0.0_9_8_0, -0.0_7_8_9, 0.0_3_9_5,
    0.1_5_0_2, 0.1_7_8_5, -0.0_4_8_8, -0.0_5_1_4, -0.0_4_0_4, 0.1_5_3_9, 0.0_4_5_4, -0.1_5_5_9,
    -0.0_6_6_5, 0.0_6_5_9, 0.0_3_8_3, -0.0_0_0_5, -0.1_2_6_6, -0.1_3_8_6
])
lowerCAmelCase							:    int  							=							torch.tensor([
    0.1_1_5_4, 0.1_2_1_8, 0.0_3_0_7, 0.0_5_2_6, -0.0_7_1_1, -0.0_5_4_1, 0.0_3_6_6, 0.2_0_7_8,
    -0.0_2_6_7, 0.1_3_1_7, -0.0_2_2_6, -0.0_1_9_3, -0.0_0_1_4, -0.1_0_5_5, -0.0_9_0_2, 0.0_3_3_0,
    0.1_3_9_1, 0.1_7_0_9, -0.0_5_6_2, -0.0_6_9_3, -0.0_5_6_0, 0.1_4_8_2, 0.0_3_8_1, -0.1_6_8_3,
    -0.0_6_8_1, 0.0_6_6_1, 0.0_3_3_1, -0.0_0_4_6, -0.1_2_6_8, -0.1_4_3_1
])
lowerCAmelCase							:    Union[str, Any]  							=							torch.tensor([
    0.1_1_9_2, 0.1_2_4_0, 0.0_4_1_4, 0.0_6_0_6, -0.0_5_5_7, -0.0_4_1_2, 0.0_4_3_0, 0.2_0_4_2,
    -0.0_2_0_0, 0.1_3_8_5, -0.0_1_1_5, -0.0_1_3_2, 0.0_0_1_7, -0.0_9_6_5, -0.0_8_0_2, 0.0_3_9_8,
    0.1_4_3_3, 0.1_7_4_7, -0.0_4_5_8, -0.0_5_3_3, -0.0_4_0_7, 0.1_5_4_5, 0.0_4_1_9, -0.1_5_7_4,
    -0.0_6_4_5, 0.0_6_2_6, 0.0_3_4_1, -0.0_0_1_0, -0.1_1_9_9, -0.1_3_9_0
])
lowerCAmelCase							:    List[str]  							=							torch.tensor([
    0.1_0_7_5, 0.1_0_7_4, 0.0_2_0_5, 0.0_4_3_1, -0.0_7_7_4, -0.0_6_0_7, 0.0_2_9_8, 0.2_0_4_2,
    -0.0_3_2_0, 0.1_2_6_7, -0.0_2_8_1, -0.0_2_5_0, -0.0_0_6_4, -0.1_0_9_1, -0.0_9_4_6, 0.0_2_9_0,
    0.1_3_2_8, 0.1_6_5_0, -0.0_5_8_0, -0.0_7_3_8, -0.0_5_8_6, 0.1_4_4_0, 0.0_3_3_7, -0.1_7_4_6,
    -0.0_7_1_2, 0.0_6_0_5, 0.0_2_5_0, -0.0_0_9_9, -0.1_3_1_6, -0.1_4_7_3
])
lowerCAmelCase							:    Optional[int]  							=							torch.tensor([
    -1.4_5_7_2, -2.0_4_8_1, -0.0_4_1_4, -0.6_0_0_5, 1.4_1_3_6, 0.5_8_4_8, 0.4_0_2_8, -2.7_3_3_0,
    1.2_2_1_2, -2.1_2_2_8, 0.2_1_5_5, 0.4_0_3_9, 0.7_6_6_2, 2.0_5_3_5, 0.7_4_7_7, -0.3_2_4_3,
    -2.1_7_5_8, -2.7_6_4_8, 1.6_9_4_7, 0.7_0_2_6, 1.2_3_3_8, -1.6_0_7_8, -0.8_6_8_2, 2.2_8_1_0,
    1.8_5_7_4, -0.5_7_1_8, -0.5_5_8_6, -0.0_1_8_6, 2.3_4_1_5, 2.1_2_5_1])
lowerCAmelCase							:    Any  							=							torch.tensor([
    -1.3_6_9_0, -1.9_7_2_0, -0.4_0_9_0, -0.6_9_6_6, 1.4_6_6_0, 0.9_9_3_8, -0.1_3_8_5, -2.7_3_2_4,
    0.7_7_3_6, -1.8_9_1_7, 0.2_9_2_3, 0.4_2_9_3, 0.1_6_9_3, 1.4_1_1_2, 1.1_8_8_7, -0.3_1_8_1,
    -2.2_1_6_0, -2.6_3_8_1, 1.3_1_7_0, 0.8_1_6_3, 0.9_2_4_0, -1.6_5_4_4, -0.6_0_9_9, 2.5_2_5_9,
    1.6_4_3_0, -0.9_0_9_0, -0.9_3_9_2, -0.0_1_2_6, 2.4_2_6_8, 2.3_2_6_6
])
lowerCAmelCase							:    Union[str, Any]  							=							torch.tensor([
    -1.3_5_2_5, -1.9_6_2_8, -0.3_9_5_6, -0.6_8_6_0, 1.4_6_6_4, 1.0_0_1_4, -0.1_2_5_9, -2.7_2_1_2,
    0.7_7_7_2, -1.8_8_1_1, 0.2_9_9_6, 0.4_3_8_8, 0.1_7_0_4, 1.4_0_2_9, 1.1_7_0_1, -0.3_0_2_7,
    -2.2_0_5_3, -2.6_2_8_7, 1.3_3_5_0, 0.8_1_3_1, 0.9_2_7_4, -1.6_2_9_2, -0.6_0_9_8, 2.5_1_3_1,
    1.6_5_0_5, -0.8_9_5_8, -0.9_2_9_8, -0.0_1_5_1, 2.4_2_5_7, 2.3_3_5_5
])
lowerCAmelCase							:    str  							=							torch.tensor([
    -2.0_5_8_5, -2.7_8_9_7, -0.2_8_5_0, -0.8_9_4_0, 1.9_0_5_2, 0.5_7_0_2, 0.6_3_4_5, -3.8_9_5_9,
    1.5_9_3_2, -3.2_3_1_9, 0.1_9_7_4, 0.0_2_8_7, 1.7_5_6_6, 2.6_5_4_3, 0.8_3_8_7, -0.5_3_5_1,
    -3.2_7_3_6, -4.3_3_7_5, 2.9_0_2_9, 1.6_3_9_0, 1.4_6_4_0, -2.1_7_0_1, -1.9_0_1_3, 2.9_3_4_1,
    3.4_9_8_1, -0.6_2_5_5, -1.1_6_4_4, -0.1_5_9_1, 3.7_0_9_7, 3.2_0_6_6
])
lowerCAmelCase							:    List[str]  							=							torch.tensor([
    -2.3_1_3_9, -2.5_5_9_4, -0.0_1_9_7, -0.6_7_8_5, 1.7_0_0_1, 1.1_6_0_6, 0.3_0_7_5, -2.1_7_4_0,
    1.8_0_7_1, -2.5_6_3_0, -0.0_9_2_6, -0.3_8_1_1, 1.2_1_1_6, 2.6_2_4_6, 1.2_7_3_1, -0.5_3_9_8,
    -2.8_1_5_3, -3.6_1_4_0, 2.3_8_9_3, 1.3_2_6_2, 1.6_2_5_8, -2.1_8_5_6, -1.3_2_6_7, 2.8_3_9_5,
    2.3_7_7_9, -1.0_6_2_3, -1.2_4_6_8, 0.8_9_5_9, 3.3_3_6_7, 3.2_2_4_3
])
lowerCAmelCase							:    Optional[Any]  							=							torch.tensor([
    -2.0_6_2_8, -2.7_6_6_7, -0.2_0_8_9, -0.8_2_6_3, 2.0_5_3_9, 0.5_9_9_2, 0.6_4_9_5, -3.8_3_3_6,
    1.6_0_2_5, -3.2_8_1_7, 0.1_7_2_1, -0.0_6_3_3, 1.7_5_1_6, 2.7_0_3_9, 0.8_1_0_0, -0.5_9_0_8,
    -3.2_1_1_3, -4.4_3_4_3, 2.9_2_5_7, 1.3_6_3_2, 1.5_5_6_2, -2.1_4_8_9, -1.9_8_9_4, 3.0_5_6_0,
    3.3_3_9_6, -0.7_3_2_8, -1.0_4_1_7, 0.0_3_8_3, 3.7_0_9_3, 3.2_3_4_3
])
lowerCAmelCase							:    int  							=							torch.tensor([
    -1.4_5_7_4, -2.0_5_6_9, -0.0_4_7_3, -0.6_1_1_7, 1.4_0_1_8, 0.5_7_6_9, 0.4_1_2_9, -2.7_3_4_4,
    1.2_2_4_1, -2.1_3_9_7, 0.2_0_0_0, 0.3_9_3_7, 0.7_6_1_6, 2.0_4_5_3, 0.7_3_2_4, -0.3_3_9_1,
    -2.1_7_4_6, -2.7_7_4_4, 1.6_9_6_3, 0.6_9_2_1, 1.2_1_8_7, -1.6_1_7_2, -0.8_8_7_7, 2.2_4_3_9,
    1.8_4_7_1, -0.5_8_3_9, -0.5_6_0_5, -0.0_4_6_4, 2.3_2_5_0, 2.1_2_1_9
])
# fmt: on

lowerCAmelCase							:    Optional[int]  							=							api.list_models(filter="""diffusers""")
for mod in models:
					if "google" in mod.author or mod.modelId == "CompVis/ldm-celebahq-256":
										lowerCAmelCase							:    Dict  							=							"""/home/patrick/google_checkpoints/""" + mod.modelId.split("""/""")[-1]

										print(F"""Started running {mod.modelId}!!!""")

										if mod.modelId.startswith("""CompVis"""):
															lowerCAmelCase							:    str  							=							UNetaDModel.from_pretrained(local_checkpoint, subfolder="""unet""")
										else:
															lowerCAmelCase							:    Optional[Any]  							=							UNetaDModel.from_pretrained(local_checkpoint)

										torch.manual_seed(0)
										random.seed(0)

										lowerCAmelCase							:    Dict  							=							torch.randn(1, model.config.in_channels, model.config.sample_size, model.config.sample_size)
										lowerCAmelCase							:    List[Any]  							=							torch.tensor([10] * noise.shape[0])
										with torch.no_grad():
															lowerCAmelCase							:    Optional[int]  							=							model(noise, time_step).sample

										assert torch.allclose(
										    logits[0, 0, 0, :30], results["""_""".join("""_""".join(mod.modelId.split("""/""")).split("""-"""))], atol=1e-3
										)
										print(F"""{mod.modelId} has passed successfully!!!""")



