






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 		_snake_case	(	unittest.TestCase       ):
			_lowercase		:     Optional[int]        =				MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
			_lowercase		:     Union[str, Any]        =				TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING






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

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






			def  SCREAMING_SNAKE_CASE__     (							self		,       a		,       a)   ->							Dict:
						SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE							=			examples
						SCREAMING_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)},
						    ]		,       )
						SCREAMING_SNAKE_CASE							=			audio_classifier(a		,       top_k=1)
						self.assertEqual(
						    a		,       [
						        {'score': ANY(a), 'label': ANY(a)},
						    ]		,       )

						self.run_torchaudio(a)






			@require_torchaudio
			def  SCREAMING_SNAKE_CASE__     (							self		,       a)   ->							Union[str, Any]:
						import datasets

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






			@require_torch
			def  SCREAMING_SNAKE_CASE__     (							self)   ->							Union[str, Any]:
						SCREAMING_SNAKE_CASE							=			'anton-l/wav2vec2-random-tiny-classifier'

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

						SCREAMING_SNAKE_CASE							=			np.ones((8000,))
						SCREAMING_SNAKE_CASE							=			audio_classifier(a		,       top_k=4)

						SCREAMING_SNAKE_CASE							=			[
						    {'score': 0.08_42, 'label': 'no'},
						    {'score': 0.08_38, 'label': 'up'},
						    {'score': 0.08_37, 'label': 'go'},
						    {'score': 0.08_34, 'label': 'right'},
						]
						SCREAMING_SNAKE_CASE							=			[
						    {'score': 0.08_45, 'label': 'stop'},
						    {'score': 0.08_44, 'label': 'on'},
						    {'score': 0.08_41, 'label': 'right'},
						    {'score': 0.08_34, 'label': 'left'},
						]
						self.assertIn(nested_simplify(a		,       decimals=4)		,       [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2])

						SCREAMING_SNAKE_CASE							=			{'array': np.ones((8000,)), 'sampling_rate': audio_classifier.feature_extractor.sampling_rate}
						SCREAMING_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  SCREAMING_SNAKE_CASE__     (							self)   ->							List[str]:
						import datasets

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

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

						SCREAMING_SNAKE_CASE							=			np.array(dataset[3]['speech']		,       dtype=np.floataa)
						SCREAMING_SNAKE_CASE							=			audio_classifier(a		,       top_k=4)
						self.assertEqual(
						    nested_simplify(a		,       decimals=3)		,       [
						        {'score': 0.9_81, 'label': 'go'},
						        {'score': 0.0_07, 'label': 'up'},
						        {'score': 0.0_06, 'label': '_unknown_'},
						        {'score': 0.0_01, 'label': 'down'},
						    ]		,       )







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












'''simple docstring'''

import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


UpperCamelCase      					=False




class      A     (   unittest.TestCase    ):






 """simple docstring"""





 def 	_UpperCAmelCase							(				self			):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
 @property
 def 	_UpperCAmelCase							(				self			):
       return 12
 @property
 def 	_UpperCAmelCase							(				self			):
       return 12
 @property
 def 	_UpperCAmelCase							(				self			):
       return 32
 @property
 def 	_UpperCAmelCase							(				self			):
       torch.manual_seed(0			)
       UpperCamelCase_					: Union[str, Any]            =				VQModel(
           block_out_channels=[32, 64]      ,  in_channels=3      ,  out_channels=3      ,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]      ,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]      ,  latent_channels=3      ,  num_vq_embeddings=self.num_embed      ,  vq_embed_dim=3      ,  )
       return model
 @property
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: str            =				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""			)
       return tokenizer
 @property
 def 	_UpperCAmelCase							(				self			):
       torch.manual_seed(0			)
       UpperCamelCase_					: Any            =				CLIPTextConfig(
           bos_token_id=0      ,  eos_token_id=2      ,  hidden_size=self.text_embedder_hidden_size      ,  intermediate_size=37      ,  layer_norm_eps=1E-05      ,  num_attention_heads=4      ,  num_hidden_layers=5      ,  pad_token_id=1      ,  vocab_size=10_00      ,  )
       return CLIPTextModel(__lowerCAmelCase			)
 @property
 def 	_UpperCAmelCase							(				self			):
       torch.manual_seed(0			)

       UpperCamelCase_					: Optional[Any]            =				12
       UpperCamelCase_					: Optional[int]            =				12

       UpperCamelCase_					: Optional[Any]            =				{
           """attention_bias""": True,
           """cross_attention_dim""": 32,
           """attention_head_dim""": height * width,
           """num_attention_heads""": 1,
           """num_vector_embeds""": self.num_embed,
           """num_embeds_ada_norm""": self.num_embeds_ada_norm,
           """norm_num_groups""": 32,
           """sample_size""": width,
           """activation_fn""": """geglu-approximate""",
       }

       UpperCamelCase_					: Optional[Any]            =				TransformeraDModel(**__lowerCAmelCase			)
       return model
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Union[str, Any]            =				"""cpu"""

       UpperCamelCase_					: List[str]            =				self.dummy_vqvae
       UpperCamelCase_					: str            =				self.dummy_text_encoder
       UpperCamelCase_					: Optional[Any]            =				self.dummy_tokenizer
       UpperCamelCase_					: Optional[int]            =				self.dummy_transformer
       UpperCamelCase_					: Optional[Any]            =				VQDiffusionScheduler(self.num_embed			)
       UpperCamelCase_					: Union[str, Any]            =				LearnedClassifierFreeSamplingEmbeddings(learnable=__lowerCAmelCase			)

       UpperCamelCase_					: Tuple            =				VQDiffusionPipeline(
           vqvae=__lowerCAmelCase      ,  text_encoder=__lowerCAmelCase      ,  tokenizer=__lowerCAmelCase      ,  transformer=__lowerCAmelCase      ,  scheduler=__lowerCAmelCase      ,  learned_classifier_free_sampling_embeddings=__lowerCAmelCase      ,  )
       UpperCamelCase_					: Union[str, Any]            =				pipe.to(__lowerCAmelCase			)
       pipe.set_progress_bar_config(disable=__lowerCAmelCase			)

       UpperCamelCase_					: Optional[int]            =				"""teddy bear playing in the pool"""

       UpperCamelCase_					: Union[str, Any]            =				torch.Generator(device=__lowerCAmelCase			).manual_seed(0			)
       UpperCamelCase_					: List[Any]            =				pipe([prompt]      ,  generator=__lowerCAmelCase      ,  num_inference_steps=2      ,  output_type="""np"""			)
       UpperCamelCase_					: Dict            =				output.images

       UpperCamelCase_					: List[str]            =				torch.Generator(device=__lowerCAmelCase			).manual_seed(0			)
       UpperCamelCase_					: Dict            =				pipe(
           [prompt]      ,  generator=__lowerCAmelCase      ,  output_type="""np"""      ,  return_dict=__lowerCAmelCase      ,  num_inference_steps=2			)[0]

       UpperCamelCase_					: Union[str, Any]            =				image[0, -3:, -3:, -1]
       UpperCamelCase_					: Any            =				image_from_tuple[0, -3:, -3:, -1]

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

       UpperCamelCase_					: List[str]            =				np.array([0.65_51, 0.61_68, 0.50_08, 0.56_76, 0.56_59, 0.42_95, 0.60_73, 0.55_99, 0.49_92]			)

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





 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: int            =				"""cpu"""

       UpperCamelCase_					: List[Any]            =				self.dummy_vqvae
       UpperCamelCase_					: Union[str, Any]            =				self.dummy_text_encoder
       UpperCamelCase_					: int            =				self.dummy_tokenizer
       UpperCamelCase_					: Tuple            =				self.dummy_transformer
       UpperCamelCase_					: Tuple            =				VQDiffusionScheduler(self.num_embed			)
       UpperCamelCase_					: List[Any]            =				LearnedClassifierFreeSamplingEmbeddings(
           learnable=__lowerCAmelCase      ,  hidden_size=self.text_embedder_hidden_size      ,  length=tokenizer.model_max_length			)

       UpperCamelCase_					: Optional[Any]            =				VQDiffusionPipeline(
           vqvae=__lowerCAmelCase      ,  text_encoder=__lowerCAmelCase      ,  tokenizer=__lowerCAmelCase      ,  transformer=__lowerCAmelCase      ,  scheduler=__lowerCAmelCase      ,  learned_classifier_free_sampling_embeddings=__lowerCAmelCase      ,  )
       UpperCamelCase_					: List[Any]            =				pipe.to(__lowerCAmelCase			)
       pipe.set_progress_bar_config(disable=__lowerCAmelCase			)

       UpperCamelCase_					: Tuple            =				"""teddy bear playing in the pool"""

       UpperCamelCase_					: List[str]            =				torch.Generator(device=__lowerCAmelCase			).manual_seed(0			)
       UpperCamelCase_					: Tuple            =				pipe([prompt]      ,  generator=__lowerCAmelCase      ,  num_inference_steps=2      ,  output_type="""np"""			)
       UpperCamelCase_					: List[str]            =				output.images

       UpperCamelCase_					: Optional[int]            =				torch.Generator(device=__lowerCAmelCase			).manual_seed(0			)
       UpperCamelCase_					: List[str]            =				pipe(
           [prompt]      ,  generator=__lowerCAmelCase      ,  output_type="""np"""      ,  return_dict=__lowerCAmelCase      ,  num_inference_steps=2			)[0]

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

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

       UpperCamelCase_					: List[Any]            =				np.array([0.66_93, 0.60_75, 0.49_59, 0.57_01, 0.55_83, 0.43_33, 0.61_71, 0.56_84, 0.49_88]			)

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






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






 """simple docstring"""





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





 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[Any]            =				load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy"""			)

       UpperCamelCase_					: Optional[int]            =				VQDiffusionPipeline.from_pretrained("""microsoft/vq-diffusion-ithq"""			)
       UpperCamelCase_					: str            =				pipeline.to(__lowerCAmelCase			)
       pipeline.set_progress_bar_config(disable=__lowerCAmelCase			)

       # requires GPU generator for gumbel softmax
       # don't use GPU generator in tests though
       UpperCamelCase_					: List[Any]            =				torch.Generator(device=__lowerCAmelCase			).manual_seed(0			)
       UpperCamelCase_					: str            =				pipeline(
           """teddy bear playing in the pool"""      ,  num_images_per_prompt=1      ,  generator=__lowerCAmelCase      ,  output_type="""np"""      ,  )

       UpperCamelCase_					: Union[str, Any]            =				output.images[0]

       assert image.shape == (2_56, 2_56, 3)
       assert np.abs(expected_image - image			).max() < 2.0






