






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







      '''simple docstring'''

      lowerCamelCase__			:							List[str]					=      StableDiffusionImageVariationPipeline
      lowerCamelCase__			:							List[str]					=      IMAGE_VARIATION_PARAMS
      lowerCamelCase__			:							List[str]					=      IMAGE_VARIATION_BATCH_PARAMS
      lowerCamelCase__			:							Tuple					=      frozenset([]					)
      # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
      lowerCamelCase__			:							Optional[int]					=      frozenset([]					)




      def      a__				(self   ):

       '''simple docstring'''



       torch.manual_seed(0   )
       lowerCamelCase__	:     int								=		UNetaDConditionModel(
           block_out_channels=(3_2, 6_4),	layers_per_block=2,	sample_size=3_2,	in_channels=4,	out_channels=4,	down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D'),	up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D'),	cross_attention_dim=3_2,	)
       lowerCamelCase__	:     Optional[int]								=		PNDMScheduler(skip_prk_steps=lowerCamelCase_   )
       torch.manual_seed(0   )
       lowerCamelCase__	:     Union[str, Any]								=		AutoencoderKL(
           block_out_channels=[3_2, 6_4],	in_channels=3,	out_channels=3,	down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D'],	up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D'],	latent_channels=4,	)
       torch.manual_seed(0   )
       lowerCamelCase__	:     int								=		CLIPVisionConfig(
           hidden_size=3_2,	projection_dim=3_2,	intermediate_size=3_7,	layer_norm_eps=1e-05,	num_attention_heads=4,	num_hidden_layers=5,	image_size=3_2,	patch_size=4,	)
       lowerCamelCase__	:     Optional[int]								=		CLIPVisionModelWithProjection(lowerCamelCase_   )
       lowerCamelCase__	:     List[Any]								=		CLIPImageProcessor(crop_size=3_2,	size=3_2   )

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




      def      a__				(self,	lowerCamelCase_,	lowerCamelCase_=0   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		floats_tensor((1, 3, 3_2, 3_2),	rng=random.Random(lowerCamelCase_   )   )
       lowerCamelCase__	:     Union[str, Any]								=		image.cpu().permute(0,	2,	3,	1   )[0]
       lowerCamelCase__	:     Tuple								=		Image.fromarray(np.uinta(lowerCamelCase_   )   ).convert('RGB'   ).resize((3_2, 3_2)   )
       if str(lowerCamelCase_   ).startswith('mps'   ):
        lowerCamelCase__	:     Optional[int]								=		torch.manual_seed(lowerCamelCase_   )
       else:
        lowerCamelCase__	:     Optional[Any]								=		torch.Generator(device=lowerCamelCase_   ).manual_seed(lowerCamelCase_   )
       lowerCamelCase__	:     Optional[int]								=		{
           'image': image,
           'generator': generator,
           'num_inference_steps': 2,
           'guidance_scale': 6.0,
           'output_type': 'numpy',
       }
       return inputs




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Any								=		'cpu'  # ensure determinism for the device-dependent torch.Generator
       lowerCamelCase__	:     str								=		self.get_dummy_components()
       lowerCamelCase__	:     Union[str, Any]								=		StableDiffusionImageVariationPipeline(**lowerCamelCase_   )
       lowerCamelCase__	:     Dict								=		sd_pipe.to(lowerCamelCase_   )
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_   )

       lowerCamelCase__	:     Dict								=		self.get_dummy_inputs(lowerCamelCase_   )
       lowerCamelCase__	:     str								=		sd_pipe(**lowerCamelCase_   ).images
       lowerCamelCase__	:     int								=		image[0, -3:, -3:, -1]

       assert image.shape == (1, 6_4, 6_4, 3)
       lowerCamelCase__	:     List[Any]								=		np.array([0.5_239, 0.5_723, 0.4_796, 0.5_049, 0.5_550, 0.4_685, 0.5_329, 0.4_891, 0.4_921]   )

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




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[int]								=		'cpu'  # ensure determinism for the device-dependent torch.Generator
       lowerCamelCase__	:     List[Any]								=		self.get_dummy_components()
       lowerCamelCase__	:     Dict								=		StableDiffusionImageVariationPipeline(**lowerCamelCase_   )
       lowerCamelCase__	:     Dict								=		sd_pipe.to(lowerCamelCase_   )
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_   )

       lowerCamelCase__	:     str								=		self.get_dummy_inputs(lowerCamelCase_   )
       lowerCamelCase__	:     int								=		2 * [inputs['image']]
       lowerCamelCase__	:     Any								=		sd_pipe(**lowerCamelCase_   )

       lowerCamelCase__	:     Tuple								=		output.images

       lowerCamelCase__	:     Tuple								=		image[-1, -3:, -3:, -1]

       assert image.shape == (2, 6_4, 6_4, 3)
       lowerCamelCase__	:     Tuple								=		np.array([0.6_892, 0.5_637, 0.5_836, 0.5_771, 0.6_254, 0.6_409, 0.5_580, 0.5_569, 0.5_289]   )

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





      def      a__				(self   ):

       '''simple docstring'''



       super().test_inference_batch_single_identical(expected_max_diff=3e-3   )



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







      '''simple docstring'''

      def      a__				(self   ):

       '''simple docstring'''



       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




      def      a__				(self,	lowerCamelCase_,	lowerCamelCase_="cpu",	lowerCamelCase_=torch.floataa,	lowerCamelCase_=0   ):

       '''simple docstring'''



       lowerCamelCase__	:     Dict								=		torch.Generator(device=lowerCamelCase_   ).manual_seed(lowerCamelCase_   )
       lowerCamelCase__	:     List[Any]								=		load_image(
           'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
           '/stable_diffusion_imgvar/input_image_vermeer.png'   )
       lowerCamelCase__	:     Optional[Any]								=		np.random.RandomState(lowerCamelCase_   ).standard_normal((1, 4, 6_4, 6_4)   )
       lowerCamelCase__	:     Tuple								=		torch.from_numpy(lowerCamelCase_   ).to(device=lowerCamelCase_,	dtype=lowerCamelCase_   )
       lowerCamelCase__	:     Tuple								=		{
           'image': init_image,
           'latents': latents,
           'generator': generator,
           'num_inference_steps': 3,
           'guidance_scale': 7.5,
           'output_type': 'numpy',
       }
       return inputs




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Tuple								=		StableDiffusionImageVariationPipeline.from_pretrained(
           'lambdalabs/sd-image-variations-diffusers',	safety_checker=lowerCamelCase_   )
       lowerCamelCase__	:     str								=		sd_pipe.to(lowerCamelCase_   )
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_   )

       lowerCamelCase__	:     Any								=		self.get_inputs(lowerCamelCase_   )
       lowerCamelCase__	:     Union[str, Any]								=		sd_pipe(**lowerCamelCase_   ).images
       lowerCamelCase__	:     List[Any]								=		image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       lowerCamelCase__	:     str								=		np.array([0.84_491, 0.90_789, 0.75_708, 0.78_734, 0.83_485, 0.70_099, 0.66_938, 0.68_727, 0.61_379]   )
       assert np.abs(image_slice - expected_slice   ).max() < 6e-3




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[str]								=		0

       def callback_fn(lowerCamelCase_,	lowerCamelCase_,	lowerCamelCase_   ) -> None:
        lowerCamelCase__	:     Dict								=		True
        nonlocal number_of_steps
        number_of_steps += 1
        if step == 1:
         lowerCamelCase__	:     Union[str, Any]								=		latents.detach().cpu().numpy()
         assert latents.shape == (1, 4, 6_4, 6_4)
         lowerCamelCase__	:     int								=		latents[0, -3:, -3:, -1]
         lowerCamelCase__	:     Any								=		np.array(
             [-0.1_621, 0.2_837, -0.7_979, -0.1_221, -1.3_057, 0.7_681, -2.1_191, 0.0_464, 1.6_309]   )

         assert np.abs(latents_slice.flatten() - expected_slice   ).max() < 5e-2
        elif step == 2:
         lowerCamelCase__	:     List[Any]								=		latents.detach().cpu().numpy()
         assert latents.shape == (1, 4, 6_4, 6_4)
         lowerCamelCase__	:     str								=		latents[0, -3:, -3:, -1]
         lowerCamelCase__	:     List[Any]								=		np.array([0.6_299, 1.7_500, 1.1_992, -2.1_582, -1.8_994, 0.7_334, -0.7_090, 1.0_137, 1.5_273]   )

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

       lowerCamelCase__	:     Union[str, Any]								=		False

       lowerCamelCase__	:     str								=		StableDiffusionImageVariationPipeline.from_pretrained(
           'fusing/sd-image-variations-diffusers',	safety_checker=lowerCamelCase_,	torch_dtype=torch.floataa,	)
       pipe.to(lowerCamelCase_   )
       pipe.set_progress_bar_config(disable=lowerCamelCase_   )
       pipe.enable_attention_slicing()

       lowerCamelCase__	:     Tuple								=		self.get_inputs(lowerCamelCase_,	dtype=torch.floataa   )
       pipe(**lowerCamelCase_,	callback=lowerCamelCase_,	callback_steps=1   )
       assert callback_fn.has_been_called
       assert number_of_steps == inputs["num_inference_steps"]





      def      a__				(self   ):

       '''simple docstring'''



       torch.cuda.empty_cache()
       torch.cuda.reset_max_memory_allocated()
       torch.cuda.reset_peak_memory_stats()

       lowerCamelCase__	:     Optional[int]								=		'fusing/sd-image-variations-diffusers'
       lowerCamelCase__	:     List[str]								=		StableDiffusionImageVariationPipeline.from_pretrained(
           lowerCamelCase_,	safety_checker=lowerCamelCase_,	torch_dtype=torch.floataa   )
       lowerCamelCase__	:     Dict								=		pipe.to(lowerCamelCase_   )
       pipe.set_progress_bar_config(disable=lowerCamelCase_   )
       pipe.enable_attention_slicing(1   )
       pipe.enable_sequential_cpu_offload()

       lowerCamelCase__	:     Optional[Any]								=		self.get_inputs(lowerCamelCase_,	dtype=torch.floataa   )
       lowerCamelCase__	:     List[str]								=		pipe(**lowerCamelCase_   )

       lowerCamelCase__	:     List[str]								=		torch.cuda.max_memory_allocated()
       # make sure that less than 2.6 GB is allocated
       assert mem_bytes < 2.6 * 1_0**9



@nightly
@require_torch_gpu
class 						a_ (      unittest.TestCase					):







      '''simple docstring'''

      def      a__				(self   ):

       '''simple docstring'''



       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




      def      a__				(self,	lowerCamelCase_,	lowerCamelCase_="cpu",	lowerCamelCase_=torch.floataa,	lowerCamelCase_=0   ):

       '''simple docstring'''



       lowerCamelCase__	:     str								=		torch.Generator(device=lowerCamelCase_   ).manual_seed(lowerCamelCase_   )
       lowerCamelCase__	:     List[str]								=		load_image(
           'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
           '/stable_diffusion_imgvar/input_image_vermeer.png'   )
       lowerCamelCase__	:     Dict								=		np.random.RandomState(lowerCamelCase_   ).standard_normal((1, 4, 6_4, 6_4)   )
       lowerCamelCase__	:     Optional[Any]								=		torch.from_numpy(lowerCamelCase_   ).to(device=lowerCamelCase_,	dtype=lowerCamelCase_   )
       lowerCamelCase__	:     str								=		{
           'image': init_image,
           'latents': latents,
           'generator': generator,
           'num_inference_steps': 5_0,
           'guidance_scale': 7.5,
           'output_type': 'numpy',
       }
       return inputs




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Dict								=		StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'   )
       sd_pipe.to(lowerCamelCase_   )
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_   )

       lowerCamelCase__	:     Dict								=		self.get_inputs(lowerCamelCase_   )
       lowerCamelCase__	:     List[Any]								=		sd_pipe(**lowerCamelCase_   ).images[0]

       lowerCamelCase__	:     Optional[int]								=		load_numpy(
           'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
           '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'   )
       lowerCamelCase__	:     List[str]								=		np.abs(expected_image - image   ).max()
       assert max_diff < 1e-3





      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     int								=		StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'   )
       lowerCamelCase__	:     int								=		DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config   )
       sd_pipe.to(lowerCamelCase_   )
       sd_pipe.set_progress_bar_config(disable=lowerCamelCase_   )

       lowerCamelCase__	:     Union[str, Any]								=		self.get_inputs(lowerCamelCase_   )
       lowerCamelCase__	:     Union[str, Any]								=		2_5
       lowerCamelCase__	:     Any								=		sd_pipe(**lowerCamelCase_   ).images[0]

       lowerCamelCase__	:     List[Any]								=		load_numpy(
           'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
           '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'   )
       lowerCamelCase__	:     str								=		np.abs(expected_image - image   ).max()
       assert max_diff < 1e-3









"""simple docstring"""
import unittest

from cer import CER


A_     :					Union[str, Any]							=     CER()



class 						a_ (      unittest.TestCase					):







      '''simple docstring'''

      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['White House']
       lowerCamelCase__	:     List[str]								=		['white house']
       # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.1_818_181_818   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		['were wolf']
       lowerCamelCase__	:     Union[str, Any]								=		['werewolf']
       # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.1_111_111   ) < 1e-6   )

       lowerCamelCase__	:     List[Any]								=		['werewolf']
       lowerCamelCase__	:     Optional[Any]								=		['weae     wolf']
       # S = 1, D = 1, I = 0, N = 8, CER = 0.25
       lowerCamelCase__	:     List[str]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.25   ) < 1e-6   )

       # consecutive whitespaces case 1
       lowerCamelCase__	:     Optional[Any]								=		['were wolf']
       lowerCamelCase__	:     Tuple								=		['were               wolf']
       # S = 0, D = 0, I = 0, N = 9, CER = 0
       lowerCamelCase__	:     Tuple								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )

       # consecutive whitespaces case 2
       lowerCamelCase__	:     Any								=		['were   wolf']
       lowerCamelCase__	:     int								=		['were               wolf']
       # S = 0, D = 0, I = 0, N = 9, CER = 0
       lowerCamelCase__	:     Optional[int]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['werewolf']
       lowerCamelCase__	:     Optional[int]								=		['weaewolf']
       # S = 1, D = 0, I = 0, N = 8, CER = 0.125
       lowerCamelCase__	:     Union[str, Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     int								=		['werewolf']
       lowerCamelCase__	:     Union[str, Any]								=		['wereawolf']
       # S = 0, D = 1, I = 0, N = 8, CER = 0.125
       lowerCamelCase__	:     Any								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[Any]								=		['werewolf']
       lowerCamelCase__	:     Dict								=		['wereolf']
       # S = 0, D = 0, I = 1, N = 8, CER = 0.125
       lowerCamelCase__	:     int								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[int]								=		['werewolf']
       lowerCamelCase__	:     Tuple								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertEqual(lowerCamelCase_,	0.0   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[str]								=		['werewolf', 'I am your father']
       lowerCamelCase__	:     List[Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertEqual(lowerCamelCase_,	0.0   )

       lowerCamelCase__	:     Dict								=		['werewolf', 'I am your father', 'doge']
       lowerCamelCase__	:     int								=		['werxwolf', 'I       am your father', 'doge']
       # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
       lowerCamelCase__	:     Optional[int]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.03_571_428   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		['My hovercraft', 'is full of eels']
       lowerCamelCase__	:     List[Any]								=		['My hovercraft is full', ' of eels']
       # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
       # whitespace at the front of " of eels" will be strip during preporcessing
       # so need to insert 2 whitespaces
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_,	concatenate_texts=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.071_428   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['我能吞下玻璃而不伤身体']
       lowerCamelCase__	:     Any								=		[' 能吞虾玻璃而 不霜身体啦']
       # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
       lowerCamelCase__	:     List[str]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.4_545_454_545   ) < 1e-6   )

       lowerCamelCase__	:     Optional[Any]								=		['我能吞下玻璃', '而不伤身体']
       lowerCamelCase__	:     Optional[Any]								=		['我    能 吞 下 玻 璃', '而不伤身体']
       # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.454_545_454_545   ) < 1e-6   )

       lowerCamelCase__	:     Optional[int]								=		['我能吞下玻璃而不伤身体']
       lowerCamelCase__	:     Union[str, Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertFalse(lowerCamelCase_,	0.0   )





      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[int]								=		['']
       lowerCamelCase__	:     Optional[int]								=		['Hypothesis']
       with self.assertRaises(lowerCamelCase_   ):
        cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )


if __name__ == "__main__":
      unittest.main()

