






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 					UpperCamelCase_ (     unittest.TestCase							):



	'''simple docstring'''




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




	@property
	def 				_UpperCamelCase     (			self   )			->       Union[str, Any]:
								snake_case_           =				1
								snake_case_           =				3
								snake_case_           =				(32, 32)

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




	@property
	def 				_UpperCamelCase     (			self   )			->       Any:
								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 				_UpperCamelCase     (			self   )			->       str:
								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 				_UpperCamelCase     (			self   )			->       Tuple:
								torch.manual_seed(0   )
								snake_case_           =				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=50_06			,     )
								return RobertaSeriesModelWithTransformation(a   )




	@property
	def 				_UpperCamelCase     (			self   )			->       Dict:
								def extract(*a			,     **a   ):




															class 					UpperCamelCase_ :



																'''simple docstring'''




																def __init__(			self   )			->       List[str]:
																							snake_case_           =				torch.ones([0]   )






																def 				_UpperCamelCase     (			self			,     a   )			->       Dict:
																							self.pixel_values.to(a   )
																							return self






															return Out()

								return extract




	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				'cpu'  # ensure determinism for the device-dependent torch.Generator
								snake_case_           =				self.dummy_cond_unet
								snake_case_           =				PNDMScheduler(skip_prk_steps=a   )
								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(a   )
								snake_case_           =				init_image / 2 + 0.5

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

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

								snake_case_           =				output.images

								snake_case_           =				torch.Generator(device=a   ).manual_seed(0   )
								snake_case_           =				alt_pipe(
								    [prompt]			,     generator=a			,     guidance_scale=6.0			,     num_inference_steps=2			,     output_type='np'			,     image=a			,     return_dict=a			,     )[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.4_427, 0.3_731, 0.4_249, 0.4_941, 0.4_546, 0.4_148, 0.4_193, 0.4_666, 0.4_499]   )

								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 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				self.dummy_cond_unet
								snake_case_           =				PNDMScheduler(skip_prk_steps=a   )
								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(a   )

								# 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=a			,     scheduler=a			,     vae=a			,     text_encoder=a			,     tokenizer=a			,     safety_checker=a			,     feature_extractor=self.dummy_extractor			,     )
								snake_case_           =				VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor			,     do_normalize=a   )
								snake_case_           =				alt_pipe.to(a   )
								alt_pipe.set_progress_bar_config(disable=a   )

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

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






	@unittest.skipIf(torch_device != 'cuda'			,     'This test requires a GPU'   )
	def 				_UpperCamelCase     (			self   )			->       str:
								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((7_60, 5_04)   )

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

								snake_case_           =				'A fantasy landscape, trending on artstation'

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

								snake_case_           =				image[2_55:2_58, 3_83:3_86, -1]

								assert image.shape == (5_04, 7_60, 3)
								snake_case_           =				np.array([0.9_358, 0.9_397, 0.9_599, 0.9_901, 1.0_000, 1.0_000, 0.9_882, 1.0_000, 1.0_000]   )

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






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



	'''simple docstring'''




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






	def 				_UpperCamelCase     (			self   )			->       Dict:
								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((7_68, 5_12)   )
								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(
								    a			,     safety_checker=a			,     )
								pipe.to(a   )
								pipe.set_progress_bar_config(disable=a   )
								pipe.enable_attention_slicing()

								snake_case_           =				'A fantasy landscape, trending on artstation'

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

								assert image.shape == (5_12, 7_68, 3)
								# img2img is flaky across GPUs even in fp32, so using MAE here
								assert np.abs(expected_image - image   ).max() < 1E-2













import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY




@is_pipeline_test
class 					UpperCamelCase_ (     unittest.TestCase							):



	'''simple docstring'''




	lowerCAmelCase						=					MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
	lowerCAmelCase						=					TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a   )			->       Union[str, Any]:
								snake_case_           =				AudioClassificationPipeline(model=a			,     feature_extractor=a   )

								# test with a raw waveform
								snake_case_           =				np.zeros((3_40_00,)   )
								snake_case_           =				np.zeros((1_40_00,)   )
								return audio_classifier, [audioa, audio]




	def 				_UpperCamelCase     (			self			,     a			,     a   )			->       Tuple:
								snake_case_     ,						snake_case_           =				examples
								snake_case_           =				audio_classifier(a   )
								# by default a model is initialized with num_labels=2
								self.assertEqual(
								    a			,     [
								        {'score': ANY(a   ), 'label': ANY(a   )},
								        {'score': ANY(a   ), 'label': ANY(a   )},
								    ]			,     )
								snake_case_           =				audio_classifier(a			,     top_k=1   )
								self.assertEqual(
								    a			,     [
								        {'score': ANY(a   ), 'label': ANY(a   )},
								    ]			,     )

								self.run_torchaudio(a   )




	@require_torchaudio
	def 				_UpperCamelCase     (			self			,     a   )			->       List[str]:
								import datasets

								# test with a local file
								snake_case_           =				datasets.load_dataset('hf-internal-testing/librispeech_asr_dummy'			,     'clean'			,     split='validation'   )
								snake_case_           =				dataset[0]['audio']['array']
								snake_case_           =				audio_classifier(a   )
								self.assertEqual(
								    a			,     [
								        {'score': ANY(a   ), 'label': ANY(a   )},
								        {'score': ANY(a   ), 'label': ANY(a   )},
								    ]			,     )




	@require_torch
	def 				_UpperCamelCase     (			self   )			->       Dict:
								snake_case_           =				'anton-l/wav2vec2-random-tiny-classifier'

								snake_case_           =				pipeline('audio-classification'			,     model=a   )

								snake_case_           =				np.ones((80_00,)   )
								snake_case_           =				audio_classifier(a			,     top_k=4   )

								snake_case_           =				[
								    {'score': 0.0_842, 'label': 'no'},
								    {'score': 0.0_838, 'label': 'up'},
								    {'score': 0.0_837, 'label': 'go'},
								    {'score': 0.0_834, 'label': 'right'},
								]
								snake_case_           =				[
								    {'score': 0.0_845, 'label': 'stop'},
								    {'score': 0.0_844, 'label': 'on'},
								    {'score': 0.0_841, 'label': 'right'},
								    {'score': 0.0_834, 'label': 'left'},
								]
								self.assertIn(nested_simplify(a			,     decimals=4   )			,     [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]   )

								snake_case_           =				{'array': np.ones((80_00,)   ), 'sampling_rate': audio_classifier.feature_extractor.sampling_rate}
								snake_case_           =				audio_classifier(a			,     top_k=4   )
								self.assertIn(nested_simplify(a			,     decimals=4   )			,     [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]   )




	@require_torch
	@slow
	def 				_UpperCamelCase     (			self   )			->       str:
								import datasets

								snake_case_           =				'superb/wav2vec2-base-superb-ks'

								snake_case_           =				pipeline('audio-classification'			,     model=a   )
								snake_case_           =				datasets.load_dataset('anton-l/superb_dummy'			,     'ks'			,     split='test'   )

								snake_case_           =				np.array(dataset[3]['speech']			,     dtype=np.floataa   )
								snake_case_           =				audio_classifier(a			,     top_k=4   )
								self.assertEqual(
								    nested_simplify(a			,     decimals=3   )			,     [
								        {'score': 0.981, 'label': 'go'},
								        {'score': 0.007, 'label': 'up'},
								        {'score': 0.006, 'label': '_unknown_'},
								        {'score': 0.001, 'label': 'down'},
								    ]			,     )






	@require_tf
	@unittest.skip('Audio classification is not implemented for TF'   )
	def 				_UpperCamelCase     (			self   )			->       Optional[int]:
								pass





