




'''simple docstring'''







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class       _a  (     _a							,							_a							,							unittest.TestCase			):
       __a    :					str           = StableDiffusionXLPipeline
       __a    :					Union[str, Any]           = TEXT_TO_IMAGE_PARAMS
       __a    :					Optional[Any]           = TEXT_TO_IMAGE_BATCH_PARAMS
       __a    :					Union[str, Any]           = TEXT_TO_IMAGE_IMAGE_PARAMS
       __a    :					str           = TEXT_TO_IMAGE_IMAGE_PARAMS
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           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''')       ,    attention_head_dim=(2, 4)       ,    use_linear_projection=lowercase       ,    addition_embed_type='''text_time'''       ,    addition_time_embed_dim=8       ,    transformer_layers_per_block=(1, 2)       ,    projection_class_embeddings_input_dim=80       ,    cross_attention_dim=64       ,    )
           UpperCAmelCase      	=		EulerDiscreteScheduler(
               beta_start=0.0_0085       ,    beta_end=0.012       ,    steps_offset=1       ,    beta_schedule='''scaled_linear'''       ,    timestep_spacing='''leading'''       ,    )
           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       ,    sample_size=128       ,    )
           torch.manual_seed(0    )
           UpperCAmelCase      	=		CLIPTextConfig(
               bos_token_id=0       ,    eos_token_id=2       ,    hidden_size=32       ,    intermediate_size=37       ,    layer_norm_eps=1E-05       ,    num_attention_heads=4       ,    num_hidden_layers=5       ,    pad_token_id=1       ,    vocab_size=1_000       ,    hidden_act='''gelu'''       ,    projection_dim=32       ,    )
           UpperCAmelCase      	=		CLIPTextModel(lowercase    )
           UpperCAmelCase      	=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       ,    local_files_only=lowercase    )

           UpperCAmelCase      	=		CLIPTextModelWithProjection(lowercase    )
           UpperCAmelCase      	=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       ,    local_files_only=lowercase    )

           UpperCAmelCase      	=		{
               '''unet''': unet,
               '''scheduler''': scheduler,
               '''vae''': vae,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''text_encoder_2''': text_encoder_a,
               '''tokenizer_2''': tokenizer_a,
               # "safety_checker": None,
               # "feature_extractor": None,
           }
           return components
       def    A				(     self						:     int       ,    lowercase						:     List[str]       ,    lowercase						:     Union[str, Any]=0    ):



           '''simple docstring'''

           if str(lowercase    ).startswith('''mps'''    ):
               UpperCAmelCase      	=		torch.manual_seed(lowercase    )
           else:
               UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(lowercase    )
           UpperCAmelCase      	=		{
               '''prompt''': '''A painting of a squirrel eating a burger''',
               '''generator''': generator,
               '''num_inference_steps''': 2,
               '''guidance_scale''': 5.0,
               '''output_type''': '''numpy''',
           }
           return inputs
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
           UpperCAmelCase      	=		self.get_dummy_components()
           UpperCAmelCase      	=		StableDiffusionXLPipeline(**lowercase    )
           UpperCAmelCase      	=		sd_pipe.to(lowercase    )
           sd_pipe.set_progress_bar_config(disable=lowercase    )

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

           assert image.shape == (1, 64, 64, 3)
           UpperCAmelCase      	=		np.array([0.5873, 0.6128, 0.4797, 0.5122, 0.5674, 0.4639, 0.5227, 0.5149, 0.4747]    )

           assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1E-2
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.get_dummy_components()
           UpperCAmelCase      	=		StableDiffusionXLPipeline(**lowercase    )
           UpperCAmelCase      	=		sd_pipe.to(lowercase    )
           UpperCAmelCase      	=		sd_pipe.to(lowercase    )
           sd_pipe.set_progress_bar_config(disable=lowercase    )

           # forward without prompt embeds
           UpperCAmelCase      	=		self.get_dummy_inputs(lowercase    )
           UpperCAmelCase      	=		3 * ['''this is a negative prompt''']
           UpperCAmelCase      	=		negative_prompt
           UpperCAmelCase      	=		3 * [inputs['''prompt''']]

           UpperCAmelCase      	=		sd_pipe(**lowercase    )
           UpperCAmelCase      	=		output.images[0, -3:, -3:, -1]

           # forward with prompt embeds
           UpperCAmelCase      	=		self.get_dummy_inputs(lowercase    )
           UpperCAmelCase      	=		3 * ['''this is a negative prompt''']
           UpperCAmelCase      	=		3 * [inputs.pop('''prompt'''    )]

           (
               (
               UpperCAmelCase  
           )	,					(
               UpperCAmelCase  
           )	,					(
               UpperCAmelCase  
           )	,					(
               UpperCAmelCase  
           )	,					  
           )      	=		sd_pipe.encode_prompt(lowercase       ,    negative_prompt=lowercase    )

           UpperCAmelCase      	=		sd_pipe(
               **lowercase       ,    prompt_embeds=lowercase       ,    negative_prompt_embeds=lowercase       ,    pooled_prompt_embeds=lowercase       ,    negative_pooled_prompt_embeds=lowercase       ,    )
           UpperCAmelCase      	=		output.images[0, -3:, -3:, -1]

           # make sure that it's equal
           assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()    ).max() < 1E-4
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           super().test_attention_slicing_forward_pass(expected_max_diff=3E-3    )







       def    A				(     self						:     int    ):



           '''simple docstring'''

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






@slow
@require_torch_gpu
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     int    ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def    A				(     self						:     str       ,    lowercase						:     Dict       ,    lowercase						:     Union[str, Any]="cpu"       ,    lowercase						:     Any=torch.floataa       ,    lowercase						:     str=0    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch.Generator(device=lowercase    ).manual_seed(lowercase    )
           UpperCAmelCase      	=		np.random.RandomState(lowercase    ).standard_normal((1, 4, 64, 64)    )
           UpperCAmelCase      	=		torch.from_numpy(lowercase    ).to(device=lowercase       ,    dtype=lowercase    )
           UpperCAmelCase      	=		{
               '''prompt''': '''a photograph of an astronaut riding a horse''',
               '''latents''': latents,
               '''generator''': generator,
               '''num_inference_steps''': 3,
               '''guidance_scale''': 7.5,
               '''output_type''': '''numpy''',
           }
           return inputs







       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''    )
           pipe.to(lowercase    )
           pipe.set_progress_bar_config(disable=lowercase    )

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

           assert image.shape == (1, 512, 512, 3)
           UpperCAmelCase      	=		np.array([0.4_9493, 0.4_7896, 0.4_0798, 0.5_4214, 0.5_3212, 0.4_8202, 0.4_7656, 0.4_6329, 0.4_8506]    )
           assert np.abs(image_slice - expected_slice    ).max() < 7E-3










'''simple docstring'''







import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
   import torch


class       _a  (     unittest.TestCase							,							__a			):
       def    A				(     self						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_tool('''speech-to-text'''    )
           self.tool.setup()
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tool(torch.ones(3_000    )    )
           self.assertEqual(lowercase       ,    ''' you'''    )







       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tool(audio=torch.ones(3_000    )    )
           self.assertEqual(lowercase       ,    ''' you'''    )




