


'''simple docstring'''
import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()
class    lowercase	(							unittest.TestCase					):

		"""simple docstring"""

		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


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




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[Any]												= 1
							UpperCamelCase__   :Any												= 3
							UpperCamelCase__   :Tuple												= (32, 32)

							UpperCamelCase__   :Tuple												= floats_tensor((batch_size, num_channels) + sizes    ,   rng=random.Random(0							)							).to(UpperCamelCase_							)
							return image




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__   :Dict												= 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    ,   )
							return model




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__   :str												= 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    ,   )
							return model




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							torch.manual_seed(0							)
							UpperCamelCase__   :Optional[int]												= RobertaSeriesConfig(
							    hidden_size=32    ,   project_dim=32    ,   intermediate_size=37    ,   layer_norm_eps=1e-05    ,   num_attention_heads=4    ,   num_hidden_layers=5    ,   pad_token_id=1    ,   vocab_size=5006    ,   )
							return RobertaSeriesModelWithTransformation(UpperCamelCase_							)




		@property
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							def extract(*UpperCamelCase_    ,   **UpperCamelCase_							):
												class    lowercase	:

														"""simple docstring"""

														def __init__(		self							):

																			'''simple docstring'''


																			UpperCamelCase__   :Optional[int]												= torch.ones([0]							)




														def     lowerCAmelCase__				(		self    ,   UpperCamelCase_							):

																			'''simple docstring'''


																			self.pixel_values.to(UpperCamelCase_							)
																			return self



												return Out()

							return extract




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Any												= 'cpu'  # ensure determinism for the device-dependent torch.Generator
							UpperCamelCase__   :List[Any]												= self.dummy_cond_unet
							UpperCamelCase__   :Union[str, Any]												= PNDMScheduler(skip_prk_steps=UpperCamelCase_							)
							UpperCamelCase__   :Optional[Any]												= self.dummy_vae
							UpperCamelCase__   :List[Any]												= self.dummy_text_encoder
							UpperCamelCase__   :Any												= XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
							UpperCamelCase__   :Tuple												= 77

							UpperCamelCase__   :int												= self.dummy_image.to(UpperCamelCase_							)
							UpperCamelCase__   :int												= init_image / 2 + 0.5

							# make sure here that pndm scheduler skips prk
							UpperCamelCase__   :Union[str, Any]												= AltDiffusionImgaImgPipeline(
							    unet=UpperCamelCase_    ,   scheduler=UpperCamelCase_    ,   vae=UpperCamelCase_    ,   text_encoder=UpperCamelCase_    ,   tokenizer=UpperCamelCase_    ,   safety_checker=UpperCamelCase_    ,   feature_extractor=self.dummy_extractor    ,   )
							UpperCamelCase__   :List[Any]												= VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor    ,   do_normalize=UpperCamelCase_							)
							UpperCamelCase__   :Optional[int]												= alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__   :Optional[Any]												= 'A painting of a squirrel eating a burger'
							UpperCamelCase__   :Dict												= torch.Generator(device=UpperCamelCase_							).manual_seed(0							)
							UpperCamelCase__   :Any												= alt_pipe(
							    [prompt]    ,   generator=UpperCamelCase_    ,   guidance_scale=6.0    ,   num_inference_steps=2    ,   output_type='''np'''    ,   image=UpperCamelCase_    ,   )

							UpperCamelCase__   :Optional[int]												= output.images

							UpperCamelCase__   :Optional[Any]												= torch.Generator(device=UpperCamelCase_							).manual_seed(0							)
							UpperCamelCase__   :Optional[Any]												= alt_pipe(
							    [prompt]    ,   generator=UpperCamelCase_    ,   guidance_scale=6.0    ,   num_inference_steps=2    ,   output_type='''np'''    ,   image=UpperCamelCase_    ,   return_dict=UpperCamelCase_    ,   )[0]

							UpperCamelCase__   :Optional[int]												= image[0, -3:, -3:, -1]
							UpperCamelCase__   :Dict												= image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 32, 32, 3)
							UpperCamelCase__   :int												= np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499]							)

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




		@unittest.skipIf(torch_device != '''cuda'''    ,   '''This test requires a GPU'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :List[Any]												= self.dummy_cond_unet
							UpperCamelCase__   :Tuple												= PNDMScheduler(skip_prk_steps=UpperCamelCase_							)
							UpperCamelCase__   :str												= self.dummy_vae
							UpperCamelCase__   :Optional[Any]												= self.dummy_text_encoder
							UpperCamelCase__   :Optional[Any]												= XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''							)
							UpperCamelCase__   :Optional[Any]												= 77

							UpperCamelCase__   :str												= self.dummy_image.to(UpperCamelCase_							)

							# put models in fp16
							UpperCamelCase__   :List[str]												= unet.half()
							UpperCamelCase__   :List[Any]												= vae.half()
							UpperCamelCase__   :Any												= bert.half()

							# make sure here that pndm scheduler skips prk
							UpperCamelCase__   :Union[str, Any]												= AltDiffusionImgaImgPipeline(
							    unet=UpperCamelCase_    ,   scheduler=UpperCamelCase_    ,   vae=UpperCamelCase_    ,   text_encoder=UpperCamelCase_    ,   tokenizer=UpperCamelCase_    ,   safety_checker=UpperCamelCase_    ,   feature_extractor=self.dummy_extractor    ,   )
							UpperCamelCase__   :List[str]												= VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor    ,   do_normalize=UpperCamelCase_							)
							UpperCamelCase__   :Any												= alt_pipe.to(UpperCamelCase_							)
							alt_pipe.set_progress_bar_config(disable=UpperCamelCase_							)

							UpperCamelCase__   :int												= 'A painting of a squirrel eating a burger'
							UpperCamelCase__   :Optional[Any]												= torch.manual_seed(0							)
							UpperCamelCase__   :Union[str, Any]												= alt_pipe(
							    [prompt]    ,   generator=UpperCamelCase_    ,   num_inference_steps=2    ,   output_type='''np'''    ,   image=UpperCamelCase_    ,   ).images

							assert image.shape == (1, 32, 32, 3)




		@unittest.skipIf(torch_device != '''cuda'''    ,   '''This test requires a GPU'''							)
		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :int												= load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/img2img/sketch-mountains-input.jpg'''							)
							# resize to resolution that is divisible by 8 but not 16 or 32
							UpperCamelCase__   :str												= init_image.resize((760, 504)							)

							UpperCamelCase__   :Optional[int]												= 'BAAI/AltDiffusion'
							UpperCamelCase__   :str												= AltDiffusionImgaImgPipeline.from_pretrained(
							    UpperCamelCase_    ,   safety_checker=UpperCamelCase_    ,   )
							pipe.to(UpperCamelCase_							)
							pipe.set_progress_bar_config(disable=UpperCamelCase_							)
							pipe.enable_attention_slicing()

							UpperCamelCase__   :List[str]												= 'A fantasy landscape, trending on artstation'

							UpperCamelCase__   :Any												= torch.manual_seed(0							)
							UpperCamelCase__   :Dict												= pipe(
							    prompt=UpperCamelCase_    ,   image=UpperCamelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   generator=UpperCamelCase_    ,   output_type='''np'''    ,   )
							UpperCamelCase__   :List[str]												= output.images[0]

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

							assert image.shape == (504, 760, 3)
							UpperCamelCase__   :Optional[Any]												= np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000]							)

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



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

		"""simple docstring"""

		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


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




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Union[str, Any]												= load_image(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
							    '''/img2img/sketch-mountains-input.jpg'''							)
							UpperCamelCase__   :str												= init_image.resize((768, 512)							)
							UpperCamelCase__   :Any												= load_numpy(
							    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'''							)

							UpperCamelCase__   :str												= 'BAAI/AltDiffusion'
							UpperCamelCase__   :Optional[Any]												= AltDiffusionImgaImgPipeline.from_pretrained(
							    UpperCamelCase_    ,   safety_checker=UpperCamelCase_    ,   )
							pipe.to(UpperCamelCase_							)
							pipe.set_progress_bar_config(disable=UpperCamelCase_							)
							pipe.enable_attention_slicing()

							UpperCamelCase__   :int												= 'A fantasy landscape, trending on artstation'

							UpperCamelCase__   :List[Any]												= torch.manual_seed(0							)
							UpperCamelCase__   :int												= pipe(
							    prompt=UpperCamelCase_    ,   image=UpperCamelCase_    ,   strength=0.75    ,   guidance_scale=7.5    ,   generator=UpperCamelCase_    ,   output_type='''np'''    ,   )
							UpperCamelCase__   :Union[str, Any]												= output.images[0]

							assert image.shape == (512, 768, 3)
							# img2img is flaky across GPUs even in fp32, so using MAE here
							assert np.abs(expected_image - image							).max() < 1e-2



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE       :      List[str]												= {
    "configuration_speech_to_text": ["SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP", "Speech2TextConfig"],
    "processing_speech_to_text": ["Speech2TextProcessor"],
}

try:
 if not is_sentencepiece_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Union[str, Any]												= ["Speech2TextTokenizer"]

try:
 if not is_speech_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      int												= ["Speech2TextFeatureExtractor"]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      Optional[Any]												= [
     "TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "TFSpeech2TextForConditionalGeneration",
     "TFSpeech2TextModel",
     "TFSpeech2TextPreTrainedModel",
 ]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE       :      str												= [
     "SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "Speech2TextForConditionalGeneration",
     "Speech2TextModel",
     "Speech2TextPreTrainedModel",
 ]


if TYPE_CHECKING:
 from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
 from .processing_speech_to_text import SpeechaTextProcessor

 try:
  if not is_sentencepiece_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_speech_to_text import SpeechaTextTokenizer

 try:
  if not is_speech_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_speech_to_text import (
      TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFSpeechaTextForConditionalGeneration,
      TFSpeechaTextModel,
      TFSpeechaTextPreTrainedModel,
  )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_speech_to_text import (
      SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
      SpeechaTextForConditionalGeneration,
      SpeechaTextModel,
      SpeechaTextPreTrainedModel,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE       :      Optional[Any]												= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


