



"""simple docstring"""


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_    (  SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     unittest.TestCase       ):



						"""simple docstring"""
						__UpperCamelCase	       =							StableDiffusionImageVariationPipeline
						__UpperCamelCase	       =							IMAGE_VARIATION_PARAMS
						__UpperCamelCase	       =							IMAGE_VARIATION_BATCH_PARAMS
						__UpperCamelCase	       =							frozenset([]       )
						# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
						__UpperCamelCase	       =							frozenset([]       )






						def 			UpperCAmelCase__  (      self				:List[Any]      )       ->    Any:
												torch.manual_seed(0      )
												UpperCAmelCase    =				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     ,						)
												UpperCAmelCase    =				PNDMScheduler(skip_prk_steps=UpperCAmelCase_      )
												torch.manual_seed(0      )
												UpperCAmelCase    =				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      )
												UpperCAmelCase    =				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     ,						)
												UpperCAmelCase    =				CLIPVisionModelWithProjection(UpperCAmelCase_      )
												UpperCAmelCase    =				CLIPImageProcessor(crop_size=32     ,						size=32      )

												UpperCAmelCase    =				{
												    'unet': unet,
												    'scheduler': scheduler,
												    'vae': vae,
												    'image_encoder': image_encoder,
												    'feature_extractor': feature_extractor,
												    'safety_checker': None,
												}
												return components






						def 			UpperCAmelCase__  (      self				:int     ,						lowercase_				:Dict     ,						lowercase_				:List[str]=0      )       ->    Any:
												UpperCAmelCase    =				floats_tensor((1, 3, 32, 32)     ,						rng=random.Random(UpperCAmelCase_      )      )
												UpperCAmelCase    =				image.cpu().permute(0     ,						2     ,						3     ,						1      )[0]
												UpperCAmelCase    =				Image.fromarray(np.uinta(UpperCAmelCase_      )      ).convert('RGB'      ).resize((32, 32)      )
												if str(UpperCAmelCase_      ).startswith('mps'      ):
																		UpperCAmelCase    =				torch.manual_seed(UpperCAmelCase_      )
												else:
																		UpperCAmelCase    =				torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
												UpperCAmelCase    =				{
												    'image': image,
												    'generator': generator,
												    'num_inference_steps': 2,
												    'guidance_scale': 6.0,
												    'output_type': 'numpy',
												}
												return inputs






						def 			UpperCAmelCase__  (      self				:Any      )       ->    Union[str, Any]:
												UpperCAmelCase    =				'cpu'  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase    =				self.get_dummy_components()
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline(**UpperCAmelCase_      )
												UpperCAmelCase    =				sd_pipe.to(UpperCAmelCase_      )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

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

												assert image.shape == (1, 64, 64, 3)
												UpperCAmelCase    =				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 			UpperCAmelCase__  (      self				:Dict      )       ->    Tuple:
												UpperCAmelCase    =				'cpu'  # ensure determinism for the device-dependent torch.Generator
												UpperCAmelCase    =				self.get_dummy_components()
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline(**UpperCAmelCase_      )
												UpperCAmelCase    =				sd_pipe.to(UpperCAmelCase_      )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

												UpperCAmelCase    =				self.get_dummy_inputs(UpperCAmelCase_      )
												UpperCAmelCase    =				2 * [inputs['image']]
												UpperCAmelCase    =				sd_pipe(**UpperCAmelCase_      )

												UpperCAmelCase    =				output.images

												UpperCAmelCase    =				image[-1, -3:, -3:, -1]

												assert image.shape == (2, 64, 64, 3)
												UpperCAmelCase    =				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 			UpperCAmelCase__  (      self				:List[Any]      )       ->    str:
												super().test_inference_batch_single_identical(expected_max_diff=3E-3      )







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



						"""simple docstring"""






						def 			UpperCAmelCase__  (      self				:Optional[Any]      )       ->    Any:
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def 			UpperCAmelCase__  (      self				:Optional[Any]     ,						lowercase_				:Any     ,						lowercase_				:Any="cpu"     ,						lowercase_				:int=torch.floataa     ,						lowercase_				:List[str]=0      )       ->    int:
												UpperCAmelCase    =				torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
												UpperCAmelCase    =				load_image(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/input_image_vermeer.png'      )
												UpperCAmelCase    =				np.random.RandomState(UpperCAmelCase_      ).standard_normal((1, 4, 64, 64)      )
												UpperCAmelCase    =				torch.from_numpy(UpperCAmelCase_      ).to(device=UpperCAmelCase_     ,						dtype=UpperCAmelCase_      )
												UpperCAmelCase    =				{
												    'image': init_image,
												    'latents': latents,
												    'generator': generator,
												    'num_inference_steps': 3,
												    'guidance_scale': 7.5,
												    'output_type': 'numpy',
												}
												return inputs






						def 			UpperCAmelCase__  (      self				:int      )       ->    Union[str, Any]:
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline.from_pretrained(
												    'lambdalabs/sd-image-variations-diffusers'     ,						safety_checker=UpperCAmelCase_      )
												UpperCAmelCase    =				sd_pipe.to(UpperCAmelCase_      )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

												UpperCAmelCase    =				self.get_inputs(UpperCAmelCase_      )
												UpperCAmelCase    =				sd_pipe(**UpperCAmelCase_      ).images
												UpperCAmelCase    =				image[0, -3:, -3:, -1].flatten()

												assert image.shape == (1, 5_12, 5_12, 3)
												UpperCAmelCase    =				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 			UpperCAmelCase__  (      self				:List[str]      )       ->    Tuple:
												UpperCAmelCase    =				0

												def callback_fn(lowercase_				:int     ,						lowercase_				:int     ,						lowercase_				:torch.FloatTensor      ) -> None:
																		UpperCAmelCase    =				True
																		nonlocal number_of_steps
																		number_of_steps += 1
																		if step == 1:
																								UpperCAmelCase    =				latents.detach().cpu().numpy()
																								assert latents.shape == (1, 4, 64, 64)
																								UpperCAmelCase    =				latents[0, -3:, -3:, -1]
																								UpperCAmelCase    =				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:
																								UpperCAmelCase    =				latents.detach().cpu().numpy()
																								assert latents.shape == (1, 4, 64, 64)
																								UpperCAmelCase    =				latents[0, -3:, -3:, -1]
																								UpperCAmelCase    =				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

												UpperCAmelCase    =				False

												UpperCAmelCase    =				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()

												UpperCAmelCase    =				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 			UpperCAmelCase__  (      self				:List[str]      )       ->    int:
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

												UpperCAmelCase    =				'fusing/sd-image-variations-diffusers'
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline.from_pretrained(
												    UpperCAmelCase_     ,						safety_checker=UpperCAmelCase_     ,						torch_dtype=torch.floataa      )
												UpperCAmelCase    =				pipe.to(UpperCAmelCase_      )
												pipe.set_progress_bar_config(disable=UpperCAmelCase_      )
												pipe.enable_attention_slicing(1      )
												pipe.enable_sequential_cpu_offload()

												UpperCAmelCase    =				self.get_inputs(UpperCAmelCase_     ,						dtype=torch.floataa      )
												UpperCAmelCase    =				pipe(**UpperCAmelCase_      )

												UpperCAmelCase    =				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       ):



						"""simple docstring"""






						def 			UpperCAmelCase__  (      self				:Dict      )       ->    int:
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def 			UpperCAmelCase__  (      self				:List[str]     ,						lowercase_				:int     ,						lowercase_				:Dict="cpu"     ,						lowercase_				:List[Any]=torch.floataa     ,						lowercase_				:Any=0      )       ->    List[Any]:
												UpperCAmelCase    =				torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
												UpperCAmelCase    =				load_image(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/input_image_vermeer.png'      )
												UpperCAmelCase    =				np.random.RandomState(UpperCAmelCase_      ).standard_normal((1, 4, 64, 64)      )
												UpperCAmelCase    =				torch.from_numpy(UpperCAmelCase_      ).to(device=UpperCAmelCase_     ,						dtype=UpperCAmelCase_      )
												UpperCAmelCase    =				{
												    'image': init_image,
												    'latents': latents,
												    'generator': generator,
												    'num_inference_steps': 50,
												    'guidance_scale': 7.5,
												    'output_type': 'numpy',
												}
												return inputs






						def 			UpperCAmelCase__  (      self				:int      )       ->    Optional[Any]:
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'      )
												sd_pipe.to(UpperCAmelCase_      )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

												UpperCAmelCase    =				self.get_inputs(UpperCAmelCase_      )
												UpperCAmelCase    =				sd_pipe(**UpperCAmelCase_      ).images[0]

												UpperCAmelCase    =				load_numpy(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'      )
												UpperCAmelCase    =				np.abs(expected_image - image      ).max()
												assert max_diff < 1E-3






						def 			UpperCAmelCase__  (      self				:List[str]      )       ->    Optional[int]:
												UpperCAmelCase    =				StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'      )
												UpperCAmelCase    =				DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config      )
												sd_pipe.to(UpperCAmelCase_      )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

												UpperCAmelCase    =				self.get_inputs(UpperCAmelCase_      )
												UpperCAmelCase    =				25
												UpperCAmelCase    =				sd_pipe(**UpperCAmelCase_      ).images[0]

												UpperCAmelCase    =				load_numpy(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'      )
												UpperCAmelCase    =				np.abs(expected_image - image      ).max()
												assert max_diff < 1E-3










"""simple docstring"""


from collections import Counter

def 				_lowerCAmelCase   (     lowercase_		):
						return sum(socks_by_color // 2 for socks_by_color in Counter(lowercase_		).values()		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				snake_case_         = [int(x) for x in input("""Enter socks by color :""").rstrip().split()]
				print(f'''sock_merchant({colors}) = {sock_merchant(colors)}''')





