code: 
  
  
  import gc
  import random
  import unittest
  
  import numpy as np
  import torch
  from PIL import Image
  from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection
  
  from diffusers import (
      AutoencoderKL,
      DPMSolverMultistepScheduler,
      PNDMScheduler,
      StableDiffusionImageVariationPipeline,
      UNetaDConditionModel,
  )
  from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
  from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu
  
  from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
  from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin
  
  
  enable_full_determinism()
  
  
  
  class 			a      (      UpperCamelCase_      ,UpperCamelCase_      ,UpperCamelCase_      ,unittest.TestCase   ):
  		__lowercase													=		StableDiffusionImageVariationPipeline
  		__lowercase													=		IMAGE_VARIATION_PARAMS
  		__lowercase													=		IMAGE_VARIATION_BATCH_PARAMS
  		__lowercase													=		frozenset([]   )
  		# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
  		__lowercase													=		frozenset([]   )
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Any:
  						'''simple docstring'''
  
  
  						torch.manual_seed(0							)
  						A__     :							Any   				=UNetaDConditionModel(
  						    block_out_channels=(32, 64)	,     layers_per_block=2	,     sample_size=32	,     in_channels=4	,     out_channels=4	,     down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')	,     up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')	,     cross_attention_dim=32	,     )
  						A__     :							Optional[Any]   				=PNDMScheduler(skip_prk_steps=UpperCAmelCase_							)
  						torch.manual_seed(0							)
  						A__     :							List[Any]   				=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							)
  						A__     :							List[Any]   				=CLIPVisionConfig(
  						    hidden_size=32	,     projection_dim=32	,     intermediate_size=37	,     layer_norm_eps=1E-05	,     num_attention_heads=4	,     num_hidden_layers=5	,     image_size=32	,     patch_size=4	,     )
  						A__     :							Optional[Any]   				=CLIPVisionModelWithProjection(UpperCAmelCase_							)
  						A__     :							List[Any]   				=CLIPImageProcessor(crop_size=32	,     size=32							)
  
  						A__     :							str   				={
  						    'unet': unet,
  						    'scheduler': scheduler,
  						    'vae': vae,
  						    'image_encoder': image_encoder,
  						    'feature_extractor': feature_extractor,
  						    'safety_checker': None,
  						}
  						return components
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase=0							)->			str:
  						'''simple docstring'''
  
  
  						A__     :							Dict   				=floats_tensor((1, 3, 32, 32)	,     rng=random.Random(UpperCAmelCase_							)							)
  						A__     :							Optional[int]   				=image.cpu().permute(0	,     2	,     3	,     1							)[0]
  						A__     :							Dict   				=Image.fromarray(np.uinta(UpperCAmelCase_							)							).convert('''RGB'''							).resize((32, 32)							)
  						if str(UpperCAmelCase_							).startswith('''mps'''							):
  										A__     :							str   				=torch.manual_seed(UpperCAmelCase_							)
  						else:
  										A__     :							Optional[int]   				=torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
  						A__     :							List[str]   				={
  						    'image': image,
  						    'generator': generator,
  						    'num_inference_steps': 2,
  						    'guidance_scale': 6.0,
  						    'output_type': 'numpy',
  						}
  						return inputs
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Dict:
  						'''simple docstring'''
  
  
  						A__     :							List[str]   				='cpu'  # ensure determinism for the device-dependent torch.Generator
  						A__     :							List[str]   				=self.get_dummy_components()
  						A__     :							List[Any]   				=StableDiffusionImageVariationPipeline(**UpperCAmelCase_							)
  						A__     :							Optional[Any]   				=sd_pipe.to(UpperCAmelCase_							)
  						sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  
  						A__     :							Optional[int]   				=self.get_dummy_inputs(UpperCAmelCase_							)
  						A__     :							List[Any]   				=sd_pipe(**UpperCAmelCase_							).images
  						A__     :							Any   				=image[0, -3:, -3:, -1]
  
  						assert image.shape == (1, 64, 64, 3)
  						A__     :							Any   				=np.array([0.5239, 0.5723, 0.4796, 0.5049, 0.5550, 0.4685, 0.5329, 0.4891, 0.4921]							)
  
  						assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			List[str]:
  						'''simple docstring'''
  
  
  						A__     :							Dict   				='cpu'  # ensure determinism for the device-dependent torch.Generator
  						A__     :							Any   				=self.get_dummy_components()
  						A__     :							Any   				=StableDiffusionImageVariationPipeline(**UpperCAmelCase_							)
  						A__     :							int   				=sd_pipe.to(UpperCAmelCase_							)
  						sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  
  						A__     :							Tuple   				=self.get_dummy_inputs(UpperCAmelCase_							)
  						A__     :							List[str]   				=2 * [inputs['image']]
  						A__     :							Optional[int]   				=sd_pipe(**UpperCAmelCase_							)
  
  						A__     :							List[str]   				=output.images
  
  						A__     :							int   				=image[-1, -3:, -3:, -1]
  
  						assert image.shape == (2, 64, 64, 3)
  						A__     :							Optional[int]   				=np.array([0.6892, 0.5637, 0.5836, 0.5771, 0.6254, 0.6409, 0.5580, 0.5569, 0.5289]							)
  
  						assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Dict:
  						'''simple docstring'''
  
  
  						super().test_inference_batch_single_identical(expected_max_diff=3E-3							)
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class 			a      (      unittest.TestCase   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[int]:
  						'''simple docstring'''
  
  
  						super().tearDown()
  						gc.collect()
  						torch.cuda.empty_cache()
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase="cpu"	,     __UpperCamelCase=torch.floataa	,     __UpperCamelCase=0							)->			str:
  						'''simple docstring'''
  
  
  						A__     :							List[Any]   				=torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
  						A__     :							List[str]   				=load_image(
  						    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
  						    '''/stable_diffusion_imgvar/input_image_vermeer.png'''							)
  						A__     :							Any   				=np.random.RandomState(UpperCAmelCase_							).standard_normal((1, 4, 64, 64)							)
  						A__     :							Tuple   				=torch.from_numpy(UpperCAmelCase_							).to(device=UpperCAmelCase_	,     dtype=UpperCAmelCase_							)
  						A__     :							str   				={
  						    'image': init_image,
  						    'latents': latents,
  						    'generator': generator,
  						    'num_inference_steps': 3,
  						    'guidance_scale': 7.5,
  						    'output_type': 'numpy',
  						}
  						return inputs
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Optional[int]:
  						'''simple docstring'''
  
  
  						A__     :							Dict   				=StableDiffusionImageVariationPipeline.from_pretrained(
  						    '''lambdalabs/sd-image-variations-diffusers'''	,     safety_checker=UpperCAmelCase_							)
  						A__     :							int   				=sd_pipe.to(UpperCAmelCase_							)
  						sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  
  						A__     :							Any   				=self.get_inputs(UpperCAmelCase_							)
  						A__     :							List[str]   				=sd_pipe(**UpperCAmelCase_							).images
  						A__     :							int   				=image[0, -3:, -3:, -1].flatten()
  
  						assert image.shape == (1, 5_12, 5_12, 3)
  						A__     :							Optional[Any]   				=np.array([0.8_4491, 0.9_0789, 0.7_5708, 0.7_8734, 0.8_3485, 0.7_0099, 0.6_6938, 0.6_8727, 0.6_1379]							)
  						assert np.abs(image_slice - expected_slice							).max() < 6E-3
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			int:
  						'''simple docstring'''
  
  
  						A__     :							str   				=0
  
  						def callback_fn(__UpperCamelCase	,     __UpperCamelCase	,     __UpperCamelCase							) -> None:
  										A__     :							Optional[int]   				=True
  										nonlocal number_of_steps
  										number_of_steps += 1
  										if step == 1:
  														A__     :							List[str]   				=latents.detach().cpu().numpy()
  														assert latents.shape == (1, 4, 64, 64)
  														A__     :							Dict   				=latents[0, -3:, -3:, -1]
  														A__     :							Any   				=np.array(
  														    [-0.1621, 0.2837, -0.7979, -0.1221, -1.3057, 0.7681, -2.1191, 0.0464, 1.6309]							)
  
  														assert np.abs(latents_slice.flatten() - expected_slice							).max() < 5E-2
  										elif step == 2:
  														A__     :							List[Any]   				=latents.detach().cpu().numpy()
  														assert latents.shape == (1, 4, 64, 64)
  														A__     :							Union[str, Any]   				=latents[0, -3:, -3:, -1]
  														A__     :							Optional[int]   				=np.array([0.6299, 1.7500, 1.1992, -2.1582, -1.8994, 0.7334, -0.7090, 1.0137, 1.5273]							)
  
  														assert np.abs(latents_slice.flatten() - expected_slice							).max() < 5E-2
  
  						A__     :							Dict   				=False
  
  						A__     :							List[Any]   				=StableDiffusionImageVariationPipeline.from_pretrained(
  						    '''fusing/sd-image-variations-diffusers'''	,     safety_checker=UpperCAmelCase_	,     torch_dtype=torch.floataa	,     )
  						pipe.to(UpperCAmelCase_							)
  						pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  						pipe.enable_attention_slicing()
  
  						A__     :							Optional[Any]   				=self.get_inputs(UpperCAmelCase_	,     dtype=torch.floataa							)
  						pipe(**UpperCAmelCase_	,     callback=UpperCAmelCase_	,     callback_steps=1							)
  						assert callback_fn.has_been_called
  						assert number_of_steps == inputs["num_inference_steps"]
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						torch.cuda.empty_cache()
  						torch.cuda.reset_max_memory_allocated()
  						torch.cuda.reset_peak_memory_stats()
  
  						A__     :							Optional[int]   				='fusing/sd-image-variations-diffusers'
  						A__     :							int   				=StableDiffusionImageVariationPipeline.from_pretrained(
  						    UpperCAmelCase_	,     safety_checker=UpperCAmelCase_	,     torch_dtype=torch.floataa							)
  						A__     :							int   				=pipe.to(UpperCAmelCase_							)
  						pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  						pipe.enable_attention_slicing(1							)
  						pipe.enable_sequential_cpu_offload()
  
  						A__     :							str   				=self.get_inputs(UpperCAmelCase_	,     dtype=torch.floataa							)
  						A__     :							List[str]   				=pipe(**UpperCAmelCase_							)
  
  						A__     :							int   				=torch.cuda.max_memory_allocated()
  						# make sure that less than 2.6 GB is allocated
  						assert mem_bytes < 2.6 * 10**9
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class 			a      (      unittest.TestCase   ):
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			Union[str, Any]:
  						'''simple docstring'''
  
  
  						super().tearDown()
  						gc.collect()
  						torch.cuda.empty_cache()
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self	,     __UpperCamelCase	,     __UpperCamelCase="cpu"	,     __UpperCamelCase=torch.floataa	,     __UpperCamelCase=0							)->			Optional[int]:
  						'''simple docstring'''
  
  
  						A__     :							int   				=torch.Generator(device=UpperCAmelCase_							).manual_seed(UpperCAmelCase_							)
  						A__     :							Optional[Any]   				=load_image(
  						    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
  						    '''/stable_diffusion_imgvar/input_image_vermeer.png'''							)
  						A__     :							Tuple   				=np.random.RandomState(UpperCAmelCase_							).standard_normal((1, 4, 64, 64)							)
  						A__     :							int   				=torch.from_numpy(UpperCAmelCase_							).to(device=UpperCAmelCase_	,     dtype=UpperCAmelCase_							)
  						A__     :							List[str]   				={
  						    'image': init_image,
  						    'latents': latents,
  						    'generator': generator,
  						    'num_inference_steps': 50,
  						    'guidance_scale': 7.5,
  						    'output_type': 'numpy',
  						}
  						return inputs
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			List[str]:
  						'''simple docstring'''
  
  
  						A__     :							Union[str, Any]   				=StableDiffusionImageVariationPipeline.from_pretrained('''fusing/sd-image-variations-diffusers'''							)
  						sd_pipe.to(UpperCAmelCase_							)
  						sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  
  						A__     :							Optional[Any]   				=self.get_inputs(UpperCAmelCase_							)
  						A__     :							int   				=sd_pipe(**UpperCAmelCase_							).images[0]
  
  						A__     :							int   				=load_numpy(
  						    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
  						    '''/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'''							)
  						A__     :							Optional[Any]   				=np.abs(expected_image - image							).max()
  						assert max_diff < 1E-3
  
  
  
  
  
  
  		def       lowerCAmelCase_  (  self							)->			int:
  						'''simple docstring'''
  
  
  						A__     :							Optional[Any]   				=StableDiffusionImageVariationPipeline.from_pretrained('''fusing/sd-image-variations-diffusers'''							)
  						A__     :							str   				=DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config							)
  						sd_pipe.to(UpperCAmelCase_							)
  						sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_							)
  
  						A__     :							Dict   				=self.get_inputs(UpperCAmelCase_							)
  						A__     :							Optional[Any]   				=25
  						A__     :							Optional[Any]   				=sd_pipe(**UpperCAmelCase_							).images[0]
  
  						A__     :							Tuple   				=load_numpy(
  						    '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
  						    '''/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'''							)
  						A__     :							str   				=np.abs(expected_image - image							).max()
  						assert max_diff < 1E-3
  
  
  
  
style_context: 
  
  
  import argparse
  import copy
  import json
  import multiprocessing
  import os
  import time
  
  from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
  from huggingface_hub import ModelFilter, hf_api
  
  import transformers
  from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
  from transformers.image_processing_utils import BaseImageProcessor
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							)			->							Tuple:
  				A__     :							List[Any]   				=set()
  				# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
  				for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
  								A__     :							Optional[int]   				=getattr(transformers.models.auto,	snake_case_,	snake_case_	)
  								if module is None:
  												continue
  								# all mappings in a single auto modeling file
  								A__     :							Optional[int]   				=[
  								    x
  								    for x in dir(snake_case_	)
  								    if x.endswith('''_MAPPING_NAMES'''	)
  								    and (x.startswith('''MODEL_'''	) or x.startswith('''TF_MODEL_'''	) or x.startswith('''FLAX_MODEL_'''	))
  								]
  								for name in mapping_names:
  												A__     :							Any   				=getattr(snake_case_,	snake_case_	)
  												if mapping is not None:
  																for v in mapping.values():
  																				if isinstance(snake_case_,	(list, tuple)	):
  																								model_names.update(snake_case_	)
  																				elif isinstance(snake_case_,	snake_case_	):
  																								model_names.add(snake_case_	)
  
  				return sorted(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							)			->							Optional[Any]:
  				# All model names defined in auto mappings
  				A__     :							int   				=set(get_all_model_names()	)
  
  				with open('''tests/utils/tiny_model_summary.json'''	) as fp:
  								A__     :							Union[str, Any]   				=json.load(snake_case_	)
  				A__     :							int   				=set()
  				for model_base_name in tiny_model_info:
  								tiny_models_names.update(tiny_model_info[model_base_name]['''model_classes''']	)
  
  				# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
  				A__     :							Optional[Any]   				=model_names.difference(snake_case_	)
  				for model_name in copy.copy(snake_case_	):
  								if not model_name.startswith('''TF'''	) and f'TF{model_name}' in not_on_hub:
  												tiny_models_names.remove(snake_case_	)
  								elif model_name.startswith('''TF'''	) and model_name[2:] in not_on_hub:
  												tiny_models_names.remove(snake_case_	)
  
  				return sorted(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							Tuple:
  				A__     :							Dict   				=COMPOSITE_MODELS.values()
  
  				# All tiny model base names on Hub
  				A__     :							Union[str, Any]   				=get_all_model_names()
  				A__     :							Optional[Any]   				=hf_api.list_models(
  				    filter=ModelFilter(
  				        author='''hf-internal-testing''',	)	)
  				A__     :							str   				=set()
  				for x in models:
  								A__     :							List[Any]   				=x.modelId
  								A__				,  A__     :							List[str]   				=model.split('''/'''	)
  								if not model.startswith('''tiny-random-'''	):
  												continue
  								A__     :							str   				=model.replace('''tiny-random-''',	''''''	)
  								if not model[0].isupper():
  												continue
  								if model not in model_names and model not in special_models:
  												continue
  								_models.add(snake_case_	)
  
  				A__     :							Dict   				=sorted(_models	)
  				# All tiny model names on Hub
  				A__     :							Optional[int]   				={}
  				for model in models:
  								A__     :							Optional[int]   				=f'hf-internal-testing/tiny-random-{model}'
  								A__     :							str   				=model.split('''-'''	)[0]
  								try:
  												A__     :							int   				=hf_api.repo_info(snake_case_	)
  												A__     :							Optional[int]   				={
  												    '''tokenizer_classes''': set(),
  												    '''processor_classes''': set(),
  												    '''model_classes''': set(),
  												    '''sha''': repo_info.sha,
  												}
  								except Exception:
  												continue
  								try:
  												time.sleep(1	)
  												A__     :							List[str]   				=AutoTokenizer.from_pretrained(snake_case_	)
  												content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=AutoTokenizer.from_pretrained(snake_case_,	use_fast=snake_case_	)
  												content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=AutoImageProcessor.from_pretrained(snake_case_	)
  												content["processor_classes"].add(img_p.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							Optional[int]   				=AutoFeatureExtractor.from_pretrained(snake_case_	)
  												if not isinstance(snake_case_,	snake_case_	):
  																content["processor_classes"].add(feat_p.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							Tuple   				=getattr(snake_case_,	snake_case_	)
  												A__     :							Tuple   				=model_class.from_pretrained(snake_case_	)
  												content["model_classes"].add(m.__class__.__name__	)
  								except Exception:
  												pass
  								try:
  												time.sleep(1	)
  												A__     :							int   				=getattr(snake_case_,	f'TF{model}'	)
  												A__     :							Union[str, Any]   				=model_class.from_pretrained(snake_case_	)
  												content["model_classes"].add(m.__class__.__name__	)
  								except Exception:
  												pass
  
  								A__     :							List[str]   				=sorted(content['''tokenizer_classes''']	)
  								A__     :							Tuple   				=sorted(content['''processor_classes''']	)
  								A__     :							Optional[Any]   				=sorted(content['''model_classes''']	)
  
  								A__     :							List[Any]   				=content
  								with open(os.path.join(snake_case_,	'''hub_tiny_model_summary.json'''	),	'''w'''	) as fp:
  												json.dump(snake_case_,	snake_case_,	ensure_ascii=snake_case_,	indent=4	)
  
  
  if __name__ == "__main__":
  						__lowerCamelCase       :       Any				   =			argparse.ArgumentParser()
  						parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
  						__lowerCamelCase       :       int				   =			parser.parse_args()
  
  						# This has to be `spawn` to avoid hanging forever!
  						multiprocessing.set_start_method("spawn")
  
  						__lowerCamelCase       :       Any				   =			"tiny_models"
  						__lowerCamelCase       :       Optional[int]				   =			True
  						__lowerCamelCase       :       int				   =			None
  						__lowerCamelCase       :       str				   =			get_tiny_model_names_from_repo()
  						__lowerCamelCase       :       List[Any]				   =			True
  						__lowerCamelCase       :       List[Any]				   =			True
  						__lowerCamelCase       :       Optional[Any]				   =			"hf-internal-testing"
  
  						create_tiny_models(
  						    output_path,
  						    all,
  						    model_types,
  						    models_to_skip,
  						    no_check,
  						    upload,
  						    organization,
  						    token=os.environ.get("TOKEN", None),
  						    num_workers=args.num_workers,
  						)
  
  
  
  