

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




				def    a							( self	):
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




				@property
				def    a							( self	):
											snake_case_          =   1
											snake_case_          =   3
											snake_case_          =   (32, 32)

											snake_case_          =   floats_tensor((batch_size, num_channels) + sizes				,       rng=random.Random(0	)	).to(lowerCAmelCase__	)
											return image




				@property
				def    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   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    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   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    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   RobertaSeriesConfig(
											    hidden_size=32				,       project_dim=32				,       intermediate_size=37				,       layer_norm_eps=1e-0_5				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=5006				,       )
											return RobertaSeriesModelWithTransformation(lowerCAmelCase__	)




				@property
				def    a							( self	):
											def extract(*snake_case				,       **snake_case	):







																		class 			lowercase    :




																						def __init__( self	):
																													snake_case_          =   torch.ones([0]	)




																						def    a							( self				,       snake_case	):
																													self.pixel_values.to(lowerCAmelCase__	)
																													return self



																		return Out()

											return extract




				def    a							( self	):
											snake_case_          =   "cpu"  # ensure determinism for the device-dependent torch.Generator
											snake_case_          =   self.dummy_cond_unet
											snake_case_          =   PNDMScheduler(skip_prk_steps=lowerCAmelCase__	)
											snake_case_          =   self.dummy_vae
											snake_case_          =   self.dummy_text_encoder
											snake_case_          =   XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'	)
											snake_case_          =   77

											snake_case_          =   self.dummy_image.to(lowerCAmelCase__	)
											snake_case_          =   init_image / 2 + 0.5

											# make sure here that pndm scheduler skips prk
											snake_case_          =   AltDiffusionImgaImgPipeline(
											    unet=lowerCAmelCase__				,       scheduler=lowerCAmelCase__				,       vae=lowerCAmelCase__				,       text_encoder=lowerCAmelCase__				,       tokenizer=lowerCAmelCase__				,       safety_checker=lowerCAmelCase__				,       feature_extractor=self.dummy_extractor				,       )
											snake_case_          =   VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor				,       do_normalize=lowerCAmelCase__	)
											snake_case_          =   alt_pipe.to(lowerCAmelCase__	)
											alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__	)

											snake_case_          =   "A painting of a squirrel eating a burger"
											snake_case_          =   torch.Generator(device=lowerCAmelCase__	).manual_seed(0	)
											snake_case_          =   alt_pipe(
											    [prompt]				,       generator=lowerCAmelCase__				,       guidance_scale=6.0				,       num_inference_steps=2				,       output_type='np'				,       image=lowerCAmelCase__				,       )

											snake_case_          =   output.images

											snake_case_          =   torch.Generator(device=lowerCAmelCase__	).manual_seed(0	)
											snake_case_          =   alt_pipe(
											    [prompt]				,       generator=lowerCAmelCase__				,       guidance_scale=6.0				,       num_inference_steps=2				,       output_type='np'				,       image=lowerCAmelCase__				,       return_dict=lowerCAmelCase__				,       )[0]

											snake_case_          =   image[0, -3:, -3:, -1]
											snake_case_          =   image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											snake_case_          =   np.array([0.44_27, 0.37_31, 0.42_49, 0.49_41, 0.45_46, 0.41_48, 0.41_93, 0.46_66, 0.44_99]	)

											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    a							( self	):
											snake_case_          =   self.dummy_cond_unet
											snake_case_          =   PNDMScheduler(skip_prk_steps=lowerCAmelCase__	)
											snake_case_          =   self.dummy_vae
											snake_case_          =   self.dummy_text_encoder
											snake_case_          =   XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'	)
											snake_case_          =   77

											snake_case_          =   self.dummy_image.to(lowerCAmelCase__	)

											# put models in fp16
											snake_case_          =   unet.half()
											snake_case_          =   vae.half()
											snake_case_          =   bert.half()

											# make sure here that pndm scheduler skips prk
											snake_case_          =   AltDiffusionImgaImgPipeline(
											    unet=lowerCAmelCase__				,       scheduler=lowerCAmelCase__				,       vae=lowerCAmelCase__				,       text_encoder=lowerCAmelCase__				,       tokenizer=lowerCAmelCase__				,       safety_checker=lowerCAmelCase__				,       feature_extractor=self.dummy_extractor				,       )
											snake_case_          =   VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor				,       do_normalize=lowerCAmelCase__	)
											snake_case_          =   alt_pipe.to(lowerCAmelCase__	)
											alt_pipe.set_progress_bar_config(disable=lowerCAmelCase__	)

											snake_case_          =   "A painting of a squirrel eating a burger"
											snake_case_          =   torch.manual_seed(0	)
											snake_case_          =   alt_pipe(
											    [prompt]				,       generator=lowerCAmelCase__				,       num_inference_steps=2				,       output_type='np'				,       image=lowerCAmelCase__				,       ).images

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




				@unittest.skipIf(torch_device != 'cuda'				,       'This test requires a GPU'	)
				def    a							( self	):
											snake_case_          =   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
											snake_case_          =   init_image.resize((760, 504)	)

											snake_case_          =   "BAAI/AltDiffusion"
											snake_case_          =   AltDiffusionImgaImgPipeline.from_pretrained(
											    lowerCAmelCase__				,       safety_checker=lowerCAmelCase__				,       )
											pipe.to(lowerCAmelCase__	)
											pipe.set_progress_bar_config(disable=lowerCAmelCase__	)
											pipe.enable_attention_slicing()

											snake_case_          =   "A fantasy landscape, trending on artstation"

											snake_case_          =   torch.manual_seed(0	)
											snake_case_          =   pipe(
											    prompt=lowerCAmelCase__				,       image=lowerCAmelCase__				,       strength=0.75				,       guidance_scale=7.5				,       generator=lowerCAmelCase__				,       output_type='np'				,       )
											snake_case_          =   output.images[0]

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

											assert image.shape == (504, 760, 3)
											snake_case_          =   np.array([0.93_58, 0.93_97, 0.95_99, 0.99_01, 1.00_00, 1.00_00, 0.98_82, 1.00_00, 1.00_00]	)

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







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




				def    a							( self	):
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




				def    a							( self	):
											snake_case_          =   load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
											    '/img2img/sketch-mountains-input.jpg'	)
											snake_case_          =   init_image.resize((768, 512)	)
											snake_case_          =   load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'	)

											snake_case_          =   "BAAI/AltDiffusion"
											snake_case_          =   AltDiffusionImgaImgPipeline.from_pretrained(
											    lowerCAmelCase__				,       safety_checker=lowerCAmelCase__				,       )
											pipe.to(lowerCAmelCase__	)
											pipe.set_progress_bar_config(disable=lowerCAmelCase__	)
											pipe.enable_attention_slicing()

											snake_case_          =   "A fantasy landscape, trending on artstation"

											snake_case_          =   torch.manual_seed(0	)
											snake_case_          =   pipe(
											    prompt=lowerCAmelCase__				,       image=lowerCAmelCase__				,       strength=0.75				,       guidance_scale=7.5				,       generator=lowerCAmelCase__				,       output_type='np'				,       )
											snake_case_          =   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_torch_available


_UpperCAmelCase		:       Tuple						    =	{
    """configuration_xlm_roberta_xl""": [
        """XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XLMRobertaXLConfig""",
        """XLMRobertaXLOnnxConfig""",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase		:       int						    =	[
					    """XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """XLMRobertaXLForCausalLM""",
					    """XLMRobertaXLForMaskedLM""",
					    """XLMRobertaXLForMultipleChoice""",
					    """XLMRobertaXLForQuestionAnswering""",
					    """XLMRobertaXLForSequenceClassification""",
					    """XLMRobertaXLForTokenClassification""",
					    """XLMRobertaXLModel""",
					    """XLMRobertaXLPreTrainedModel""",
					]

if TYPE_CHECKING:
					from .configuration_xlm_roberta_xl import (
					    XLM_ROBERTA_XL_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    XLMRobertaXLConfig,
					    XLMRobertaXLOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm_roberta_xl import (
										    XLM_ROBERTA_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMRobertaXLForCausalLM,
										    XLMRobertaXLForMaskedLM,
										    XLMRobertaXLForMultipleChoice,
										    XLMRobertaXLForQuestionAnswering,
										    XLMRobertaXLForSequenceClassification,
										    XLMRobertaXLForTokenClassification,
										    XLMRobertaXLModel,
										    XLMRobertaXLPreTrainedModel,
										)

else:
					import sys

					_UpperCAmelCase		:       Optional[Any]						    =	_LazyModule(__name__, globals()["""__file__"""], _import_structure)




