
"""simple docstring"""







from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
							from ...feature_extraction_utils import FeatureExtractionMixin
							from ...tokenization_utils_base import PreTrainedTokenizerBase
							from ...utils import TensorType

lowerCamelCase__        =		logging.get_logger(__name__)

lowerCamelCase__        =		{
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
lowerCamelCase__        =		[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1_058, 1_220, 1_267, 1_279, 1_303, 1_343, 1_377,
    1_391, 1_635, 1_782, 1_875, 2_162, 2_361, 2_488, 3_467, 4_008, 4_211,
    4_600, 4_808, 5_299, 5_855, 6_329, 7_203, 9_609, 9_959, 10_563, 10_786,
    11_420, 11_709, 11_907, 13_163, 13_697, 13_700, 14_808, 15_306, 16_410, 16_791,
    17_992, 19_203, 19_510, 20_724, 22_305, 22_935, 27_007, 30_109, 30_420, 33_409,
    34_949, 40_283, 40_493, 40_549, 47_282, 49_146, 50_257, 50_359, 50_360, 50_361
]
lowerCamelCase__        =		[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1_350, 1_853, 1_982, 2_460, 2_627,
    3_246, 3_253, 3_268, 3_536, 3_846, 3_961, 4_183, 4_667, 6_585, 6_647,
    7_273, 9_061, 9_383, 10_428, 10_929, 11_938, 12_033, 12_331, 12_562, 13_793,
    14_157, 14_635, 15_265, 15_618, 16_553, 16_604, 18_362, 18_956, 20_075, 21_675,
    22_520, 26_130, 26_161, 26_435, 28_279, 29_464, 31_650, 32_302, 32_470, 36_865,
    42_863, 47_425, 49_870, 50_254, 50_258, 50_360, 50_361, 50_362
]




class 			A__	(     _lowerCamelCase):
		A_						:	Tuple           =     'whisper'
		A_						:	int           =     ['past_key_values']
		A_						:	List[str]           =     {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}

		def __init__(				self	,		_SCREAMING_SNAKE_CASE=5_18_65	,		_SCREAMING_SNAKE_CASE=80	,		_SCREAMING_SNAKE_CASE=6	,		_SCREAMING_SNAKE_CASE=4	,		_SCREAMING_SNAKE_CASE=6	,		_SCREAMING_SNAKE_CASE=4	,		_SCREAMING_SNAKE_CASE=15_36	,		_SCREAMING_SNAKE_CASE=15_36	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=5_02_57	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE=True	,		_SCREAMING_SNAKE_CASE="gelu"	,		_SCREAMING_SNAKE_CASE=2_56	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=0.02	,		_SCREAMING_SNAKE_CASE=False	,		_SCREAMING_SNAKE_CASE=15_00	,		_SCREAMING_SNAKE_CASE=4_48	,		_SCREAMING_SNAKE_CASE=5_02_56	,		_SCREAMING_SNAKE_CASE=5_02_56	,		_SCREAMING_SNAKE_CASE=5_02_56	,		_SCREAMING_SNAKE_CASE=None	,		_SCREAMING_SNAKE_CASE=[2_20, 5_02_56]	,		_SCREAMING_SNAKE_CASE=False	,		_SCREAMING_SNAKE_CASE=2_56	,		_SCREAMING_SNAKE_CASE=False	,		_SCREAMING_SNAKE_CASE=0.05	,		_SCREAMING_SNAKE_CASE=10	,		_SCREAMING_SNAKE_CASE=2	,		_SCREAMING_SNAKE_CASE=0.0	,		_SCREAMING_SNAKE_CASE=10	,		_SCREAMING_SNAKE_CASE=0	,		_SCREAMING_SNAKE_CASE=7	,		**_SCREAMING_SNAKE_CASE	,		):
			__lowerCAmelCase      :						str						      =				vocab_size
			__lowerCAmelCase      :						Dict						      =				num_mel_bins
			__lowerCAmelCase      :						List[str]						      =				d_model
			__lowerCAmelCase      :						List[Any]						      =				encoder_layers
			__lowerCAmelCase      :						Optional[int]						      =				encoder_attention_heads
			__lowerCAmelCase      :						Dict						      =				decoder_layers
			__lowerCAmelCase      :						Optional[Any]						      =				decoder_attention_heads
			__lowerCAmelCase      :						str						      =				decoder_ffn_dim
			__lowerCAmelCase      :						Dict						      =				encoder_ffn_dim
			__lowerCAmelCase      :						List[Any]						      =				dropout
			__lowerCAmelCase      :						Union[str, Any]						      =				attention_dropout
			__lowerCAmelCase      :						int						      =				activation_dropout
			__lowerCAmelCase      :						Dict						      =				activation_function
			__lowerCAmelCase      :						str						      =				init_std
			__lowerCAmelCase      :						str						      =				encoder_layerdrop
			__lowerCAmelCase      :						Dict						      =				decoder_layerdrop
			__lowerCAmelCase      :						Optional[Any]						      =				use_cache
			__lowerCAmelCase      :						str						      =				encoder_layers
			__lowerCAmelCase      :						List[str]						      =				scale_embedding  # scale factor will be sqrt(d_model) if True
			__lowerCAmelCase      :						Union[str, Any]						      =				max_source_positions
			__lowerCAmelCase      :						List[str]						      =				max_target_positions

			# Audio Classification-specific parameters. Feel free to ignore for other classes.
			__lowerCAmelCase      :						int						      =				classifier_proj_size
			__lowerCAmelCase      :						List[Any]						      =				use_weighted_layer_sum

			# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
			__lowerCAmelCase      :						int						      =				apply_spec_augment
			__lowerCAmelCase      :						str						      =				mask_time_prob
			__lowerCAmelCase      :						Dict						      =				mask_time_length
			__lowerCAmelCase      :						Union[str, Any]						      =				mask_time_min_masks
			__lowerCAmelCase      :						int						      =				mask_feature_prob
			__lowerCAmelCase      :						List[Any]						      =				mask_feature_length
			__lowerCAmelCase      :						Any						      =				mask_feature_min_masks

			__lowerCAmelCase      :						Dict						      =				median_filter_width

			super().__init__(
			    pad_token_id=_SCREAMING_SNAKE_CASE	,		bos_token_id=_SCREAMING_SNAKE_CASE	,		eos_token_id=_SCREAMING_SNAKE_CASE	,		is_encoder_decoder=_SCREAMING_SNAKE_CASE	,		decoder_start_token_id=_SCREAMING_SNAKE_CASE	,		suppress_tokens=_SCREAMING_SNAKE_CASE	,		begin_suppress_tokens=_SCREAMING_SNAKE_CASE	,		**_SCREAMING_SNAKE_CASE	,		)




class 			A__	(     _lowerCamelCase):

		@property
		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[str]						      =				OrderedDict(
			    [
			        ('input_features', {0: 'batch', 1: 'feature_size', 2: 'encoder_sequence'}),
			    ]			)
			if self.use_past:
				__lowerCAmelCase      :						Union[str, Any]						      =				{0: 'batch'}
			else:
				__lowerCAmelCase      :						Optional[int]						      =				{0: 'batch', 1: 'decoder_sequence'}

			if self.use_past:
				self.fill_with_past_key_values_(_SCREAMING_SNAKE_CASE	,		direction='inputs'			)

			return common_inputs

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE = -1	,		_SCREAMING_SNAKE_CASE = -1	,		_SCREAMING_SNAKE_CASE = False	,		_SCREAMING_SNAKE_CASE = None	,		_SCREAMING_SNAKE_CASE = 2_20_50	,		_SCREAMING_SNAKE_CASE = 5.0	,		_SCREAMING_SNAKE_CASE = 2_20	,		):
			__lowerCAmelCase      :						int						      =				OrderedDict()
			__lowerCAmelCase      :						int						      =				OnnxConfig.generate_dummy_inputs(
			    self	,		preprocessor=preprocessor.feature_extractor	,		batch_size=_SCREAMING_SNAKE_CASE	,		framework=_SCREAMING_SNAKE_CASE	,		sampling_rate=_SCREAMING_SNAKE_CASE	,		time_duration=_SCREAMING_SNAKE_CASE	,		frequency=_SCREAMING_SNAKE_CASE	,		)
			__lowerCAmelCase      :						List[Any]						      =				encoder_inputs['input_features'].shape[2]
			__lowerCAmelCase      :						str						      =				encoder_sequence_length // 2 if self.use_past else seq_length

			__lowerCAmelCase      :						Dict						      =				super().generate_dummy_inputs(
			    preprocessor.tokenizer	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Any						      =				encoder_inputs.pop('input_features'			)
			__lowerCAmelCase      :						Dict						      =				decoder_inputs.pop('decoder_input_ids'			)

			if "past_key_values" in decoder_inputs:
				__lowerCAmelCase      :						int						      =				decoder_inputs.pop('past_key_values'			)

			return dummy_inputs







		@property
		def 							__lowerCamelCase							(				self			):
			return 1E-3

"""simple docstring"""







import gc
import unittest

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

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference




class 			A__	(     _lowerCamelCase	,					unittest.TestCase):
		A_						:	Optional[int]           =     ShapEPipeline
		A_						:	str           =     ['prompt']
		A_						:	Any           =     ['prompt']
		A_						:	List[Any]           =     [
		    'num_images_per_prompt',
		    'num_inference_steps',
		    'generator',
		    'latents',
		    'guidance_scale',
		    'frame_size',
		    'output_type',
		    'return_dict',
		]
		A_						:	Optional[int]           =     False

		@property
		def 							__lowerCamelCase							(				self			):
			return 32

		@property
		def 							__lowerCamelCase							(				self			):
			return 32

		@property
		def 							__lowerCamelCase							(				self			):
			return self.time_input_dim * 4

		@property
		def 							__lowerCamelCase							(				self			):
			return 8

		@property
		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Tuple						      =				CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'			)
			return tokenizer

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)
			__lowerCAmelCase      :						str						      =				CLIPTextConfig(
			    bos_token_id=0	,		eos_token_id=2	,		hidden_size=self.text_embedder_hidden_size	,		projection_dim=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 CLIPTextModelWithProjection(_SCREAMING_SNAKE_CASE			)

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

			__lowerCAmelCase      :						Optional[Any]						      =				{
			    'num_attention_heads': 2,
			    'attention_head_dim': 16,
			    'embedding_dim': self.time_input_dim,
			    'num_embeddings': 32,
			    'embedding_proj_dim': self.text_embedder_hidden_size,
			    'time_embed_dim': self.time_embed_dim,
			    'num_layers': 1,
			    'clip_embed_dim': self.time_input_dim * 2,
			    'additional_embeddings': 0,
			    'time_embed_act_fn': 'gelu',
			    'norm_in_type': 'layer',
			    'encoder_hid_proj_type': None,
			    'added_emb_type': None,
			}

			__lowerCAmelCase      :						int						      =				PriorTransformer(**_SCREAMING_SNAKE_CASE			)
			return model

		@property
		def 							__lowerCamelCase							(				self			):
			torch.manual_seed(0			)

			__lowerCAmelCase      :						Dict						      =				{
			    'param_shapes': (
			        (self.renderer_dim, 93),
			        (self.renderer_dim, 8),
			        (self.renderer_dim, 8),
			        (self.renderer_dim, 8),
			    ),
			    'd_latent': self.time_input_dim,
			    'd_hidden': self.renderer_dim,
			    'n_output': 12,
			    'background': (
			        0.1,
			        0.1,
			        0.1,
			    ),
			}
			__lowerCAmelCase      :						Union[str, Any]						      =				ShapERenderer(**_SCREAMING_SNAKE_CASE			)
			return model

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_prior
			__lowerCAmelCase      :						str						      =				self.dummy_text_encoder
			__lowerCAmelCase      :						List[Any]						      =				self.dummy_tokenizer
			__lowerCAmelCase      :						str						      =				self.dummy_renderer

			__lowerCAmelCase      :						List[Any]						      =				HeunDiscreteScheduler(
			    beta_schedule='exp'	,		num_train_timesteps=10_24	,		prediction_type='sample'	,		use_karras_sigmas=_SCREAMING_SNAKE_CASE	,		clip_sample=_SCREAMING_SNAKE_CASE	,		clip_sample_range=1.0	,		)
			__lowerCAmelCase      :						int						      =				{
			    'prior': prior,
			    'text_encoder': text_encoder,
			    'tokenizer': tokenizer,
			    'renderer': renderer,
			    'scheduler': scheduler,
			}

			return components

		def 							__lowerCamelCase							(				self	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE=0			):
			if str(_SCREAMING_SNAKE_CASE			).startswith('mps'			):
				__lowerCAmelCase      :						int						      =				torch.manual_seed(_SCREAMING_SNAKE_CASE			)
			else:
				__lowerCAmelCase      :						Dict						      =				torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Optional[Any]						      =				{
			    'prompt': 'horse',
			    'generator': generator,
			    'num_inference_steps': 1,
			    'frame_size': 32,
			    'output_type': 'np',
			}
			return inputs

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						Any						      =				'cpu'

			__lowerCAmelCase      :						int						      =				self.get_dummy_components()

			__lowerCAmelCase      :						Union[str, Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Union[str, Any]						      =				pipe.to(_SCREAMING_SNAKE_CASE			)

			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Optional[int]						      =				pipe(**self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)			)
			__lowerCAmelCase      :						Optional[Any]						      =				output.images[0]
			__lowerCAmelCase      :						Optional[int]						      =				image[0, -3:, -3:, -1]

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

			__lowerCAmelCase      :						str						      =				np.array(
			    [
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			        0.0003_9216,
			    ]			)

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

		def 							__lowerCamelCase							(				self			):
			# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
			self._test_inference_batch_consistent(batch_sizes=[1, 2]			)

		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						str						      =				torch_device == 'cpu'
			__lowerCAmelCase      :						str						      =				True

			self._test_inference_batch_single_identical(
			    batch_size=2	,		test_max_difference=_SCREAMING_SNAKE_CASE	,		relax_max_difference=_SCREAMING_SNAKE_CASE	,		)







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						str						      =				self.get_dummy_components()
			__lowerCAmelCase      :						List[Any]						      =				self.pipeline_class(**_SCREAMING_SNAKE_CASE			)
			__lowerCAmelCase      :						Tuple						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						int						      =				1
			__lowerCAmelCase      :						List[Any]						      =				2

			__lowerCAmelCase      :						int						      =				self.get_dummy_inputs(_SCREAMING_SNAKE_CASE			)

			for key in inputs.keys():
				if key in self.batch_params:
					__lowerCAmelCase      :						Dict						      =				batch_size * [inputs[key]]

			__lowerCAmelCase      :						Any						      =				pipe(**_SCREAMING_SNAKE_CASE	,		num_images_per_prompt=_SCREAMING_SNAKE_CASE			)[0]

			assert images.shape[0] == batch_size * num_images_per_prompt




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

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







		def 							__lowerCamelCase							(				self			):
			__lowerCAmelCase      :						List[Any]						      =				load_numpy(
			    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
			    '/shap_e/test_shap_e_np_out.npy'			)
			__lowerCAmelCase      :						Dict						      =				ShapEPipeline.from_pretrained('openai/shap-e'			)
			__lowerCAmelCase      :						int						      =				pipe.to(_SCREAMING_SNAKE_CASE			)
			pipe.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE			)

			__lowerCAmelCase      :						Any						      =				torch.Generator(device=_SCREAMING_SNAKE_CASE			).manual_seed(0			)

			__lowerCAmelCase      :						List[str]						      =				pipe(
			    'a shark'	,		generator=_SCREAMING_SNAKE_CASE	,		guidance_scale=15.0	,		num_inference_steps=64	,		frame_size=64	,		output_type='np'	,		).images[0]

			assert images.shape == (20, 64, 64, 3)

			assert_mean_pixel_difference(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE			)