





import gc
import unittest

import numpy as np
import torch
from torch.backends.cuda import sdp_kernel

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)
from diffusers.utils import randn_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()






class 					__A    (    lowerCAmelCase			,				unittest.TestCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						ConsistencyModelPipeline
			lowerCAmelCase_							     =						UNCONDITIONAL_IMAGE_GENERATION_PARAMS
			lowerCAmelCase_							     =						UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS

			# Override required_optional_params to remove num_images_per_prompt
			lowerCAmelCase_							     =						frozenset(
			    [
			        """num_inference_steps""",
			        """generator""",
			        """latents""",
			        """output_type""",
			        """return_dict""",
			        """callback""",
			        """callback_steps""",
			    ] )





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained(
				    '''diffusers/consistency-models-test'''       ,  subfolder='''test_unet'''       ,  )
				return unet





			@property
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained(
				    '''diffusers/consistency-models-test'''       ,  subfolder='''test_unet_class_cond'''       ,  )
				return unet





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase=False							):



				'''simple docstring'''







				if class_cond:
					lowerCamelCase__								=		self.dummy_cond_unet
				else:
					lowerCamelCase__								=		self.dummy_uncond_unet

				# Default to CM multistep sampler
				lowerCamelCase__								=		CMStochasticIterativeScheduler(
				    num_train_timesteps=4_0       ,  sigma_min=0.002       ,  sigma_max=80.0       ,  )

				lowerCamelCase__								=		{
				    '''unet''': unet,
				    '''scheduler''': scheduler,
				}

				return components





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase=0							):



				'''simple docstring'''







				if str(__lowerCAmelCase							).startswith('''mps'''							):
					lowerCamelCase__								=		torch.manual_seed(__lowerCAmelCase							)
				else:
					lowerCamelCase__								=		torch.Generator(device=__lowerCAmelCase							).manual_seed(__lowerCAmelCase							)

				lowerCamelCase__								=		{
				    '''batch_size''': 1,
				    '''num_inference_steps''': None,
				    '''timesteps''': [2_2, 0],
				    '''generator''': generator,
				    '''output_type''': '''np''',
				}

				return inputs





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCamelCase__								=		self.get_dummy_components()
				lowerCamelCase__								=		ConsistencyModelPipeline(**__lowerCAmelCase							)
				lowerCamelCase__								=		pipe.to(__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_dummy_inputs(__lowerCAmelCase							)
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 3_2, 3_2, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]
				lowerCamelCase__								=		np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]							)

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





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCamelCase__								=		self.get_dummy_components(class_cond=__lowerCAmelCase							)
				lowerCamelCase__								=		ConsistencyModelPipeline(**__lowerCAmelCase							)
				lowerCamelCase__								=		pipe.to(__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_dummy_inputs(__lowerCAmelCase							)
				lowerCamelCase__								=		0
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 3_2, 3_2, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]
				lowerCamelCase__								=		np.array([0.3572, 0.6273, 0.4031, 0.3961, 0.4321, 0.5730, 0.5266, 0.4780, 0.5004]							)

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





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCamelCase__								=		self.get_dummy_components()
				lowerCamelCase__								=		ConsistencyModelPipeline(**__lowerCAmelCase							)
				lowerCamelCase__								=		pipe.to(__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_dummy_inputs(__lowerCAmelCase							)
				lowerCamelCase__								=		1
				lowerCamelCase__								=		None
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 3_2, 3_2, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]
				lowerCamelCase__								=		np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]							)

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





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
				lowerCamelCase__								=		self.get_dummy_components(class_cond=__lowerCAmelCase							)
				lowerCamelCase__								=		ConsistencyModelPipeline(**__lowerCAmelCase							)
				lowerCamelCase__								=		pipe.to(__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_dummy_inputs(__lowerCAmelCase							)
				lowerCamelCase__								=		1
				lowerCamelCase__								=		None
				lowerCamelCase__								=		0
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 3_2, 3_2, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]
				lowerCamelCase__								=		np.array([0.5004, 0.5004, 0.4994, 0.5008, 0.4976, 0.5018, 0.4990, 0.4982, 0.4987]							)

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






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

			'''simple docstring'''







			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







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





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase=0       ,  __lowerCAmelCase=False       ,  __lowerCAmelCase="cpu"       ,  __lowerCAmelCase=torch.floataa       ,  __lowerCAmelCase=(1, 3, 6_4, 6_4)							):



				'''simple docstring'''







				lowerCamelCase__								=		torch.manual_seed(__lowerCAmelCase							)

				lowerCamelCase__								=		{
				    '''num_inference_steps''': None,
				    '''timesteps''': [2_2, 0],
				    '''class_labels''': 0,
				    '''generator''': generator,
				    '''output_type''': '''np''',
				}

				if get_fixed_latents:
					lowerCamelCase__								=		self.get_fixed_latents(seed=__lowerCAmelCase       ,  device=__lowerCAmelCase       ,  dtype=__lowerCAmelCase       ,  shape=__lowerCAmelCase							)
					lowerCamelCase__								=		latents

				return inputs





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase=0       ,  __lowerCAmelCase="cpu"       ,  __lowerCAmelCase=torch.floataa       ,  __lowerCAmelCase=(1, 3, 6_4, 6_4)							):



				'''simple docstring'''







				if type(__lowerCAmelCase							) == str:
					lowerCamelCase__								=		torch.device(__lowerCAmelCase							)
				lowerCamelCase__								=		torch.Generator(device=__lowerCAmelCase							).manual_seed(__lowerCAmelCase							)
				lowerCamelCase__								=		randn_tensor(__lowerCAmelCase       ,  generator=__lowerCAmelCase       ,  device=__lowerCAmelCase       ,  dtype=__lowerCAmelCase							)
				return latents





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained('''diffusers/consistency_models'''       ,  subfolder='''diffusers_cd_imagenet64_l2'''							)
				lowerCamelCase__								=		CMStochasticIterativeScheduler(
				    num_train_timesteps=4_0       ,  sigma_min=0.002       ,  sigma_max=80.0       ,  )
				lowerCamelCase__								=		ConsistencyModelPipeline(unet=__lowerCAmelCase       ,  scheduler=__lowerCAmelCase							)
				pipe.to(torch_device=__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_inputs()
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 6_4, 6_4, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]

				lowerCamelCase__								=		np.array([0.0888, 0.0881, 0.0666, 0.0479, 0.0292, 0.0195, 0.0201, 0.0163, 0.0254]							)

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





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained('''diffusers/consistency_models'''       ,  subfolder='''diffusers_cd_imagenet64_l2'''							)
				lowerCamelCase__								=		CMStochasticIterativeScheduler(
				    num_train_timesteps=4_0       ,  sigma_min=0.002       ,  sigma_max=80.0       ,  )
				lowerCamelCase__								=		ConsistencyModelPipeline(unet=__lowerCAmelCase       ,  scheduler=__lowerCAmelCase							)
				pipe.to(torch_device=__lowerCAmelCase							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_inputs()
				lowerCamelCase__								=		1
				lowerCamelCase__								=		None
				lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 6_4, 6_4, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]

				lowerCamelCase__								=		np.array([0.0340, 0.0152, 0.0063, 0.0267, 0.0221, 0.0107, 0.0416, 0.0186, 0.0217]							)

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





			@require_torch_a
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained('''diffusers/consistency_models'''       ,  subfolder='''diffusers_cd_imagenet64_l2'''							)
				lowerCamelCase__								=		CMStochasticIterativeScheduler(
				    num_train_timesteps=4_0       ,  sigma_min=0.002       ,  sigma_max=80.0       ,  )
				lowerCamelCase__								=		ConsistencyModelPipeline(unet=__lowerCAmelCase       ,  scheduler=__lowerCAmelCase							)
				pipe.to(torch_device=__lowerCAmelCase       ,  torch_dtype=torch.floataa							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_inputs(get_fixed_latents=__lowerCAmelCase       ,  device=__lowerCAmelCase							)
				# Ensure usage of flash attention in torch 2.0
				with sdp_kernel(enable_flash=__lowerCAmelCase       ,  enable_math=__lowerCAmelCase       ,  enable_mem_efficient=__lowerCAmelCase							):
					lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 6_4, 6_4, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]

				lowerCamelCase__								=		np.array([0.1875, 0.1428, 0.1289, 0.2151, 0.2092, 0.1477, 0.1877, 0.1641, 0.1353]							)

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





			@require_torch_a
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		UNetaDModel.from_pretrained('''diffusers/consistency_models'''       ,  subfolder='''diffusers_cd_imagenet64_l2'''							)
				lowerCamelCase__								=		CMStochasticIterativeScheduler(
				    num_train_timesteps=4_0       ,  sigma_min=0.002       ,  sigma_max=80.0       ,  )
				lowerCamelCase__								=		ConsistencyModelPipeline(unet=__lowerCAmelCase       ,  scheduler=__lowerCAmelCase							)
				pipe.to(torch_device=__lowerCAmelCase       ,  torch_dtype=torch.floataa							)
				pipe.set_progress_bar_config(disable=__lowerCAmelCase							)

				lowerCamelCase__								=		self.get_inputs(get_fixed_latents=__lowerCAmelCase       ,  device=__lowerCAmelCase							)
				lowerCamelCase__								=		1
				lowerCamelCase__								=		None
				# Ensure usage of flash attention in torch 2.0
				with sdp_kernel(enable_flash=__lowerCAmelCase       ,  enable_math=__lowerCAmelCase       ,  enable_mem_efficient=__lowerCAmelCase							):
					lowerCamelCase__								=		pipe(**__lowerCAmelCase							).images
				assert image.shape == (1, 6_4, 6_4, 3)

				lowerCamelCase__								=		image[0, -3:, -3:, -1]

				lowerCamelCase__								=		np.array([0.1663, 0.1948, 0.2275, 0.1680, 0.1204, 0.1245, 0.1858, 0.1338, 0.2095]							)

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










import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
			from transformers import SpeechaTextFeatureExtractor

_a 						=      random.Random()





def lowerCAmelCase__(__snake_case       ,__snake_case=1.0       ,__snake_case=None       ,__snake_case=None							)				->      List[Any]:







	'''simple docstring'''







	if rng is None:
		lowerCamelCase__								=		global_rng

	lowerCamelCase__								=		[]
	for batch_idx in range(shape[0]							):
		values.append([]							)
		for _ in range(shape[1]							):
			values[-1].append(rng.random() * scale							)

	return values






@require_torch
@require_torchaudio
class 					__A    (    unittest.TestCase ):

			'''simple docstring'''







			def __init__(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase=7       ,  __lowerCAmelCase=4_0_0       ,  __lowerCAmelCase=2_0_0_0       ,  __lowerCAmelCase=2_4       ,  __lowerCAmelCase=2_4       ,  __lowerCAmelCase=0.0       ,  __lowerCAmelCase=1_6_0_0_0       ,  __lowerCAmelCase=True       ,  __lowerCAmelCase=True       ,  ):



				'''simple docstring'''







				lowerCamelCase__								=		parent
				lowerCamelCase__								=		batch_size
				lowerCamelCase__								=		min_seq_length
				lowerCamelCase__								=		max_seq_length
				lowerCamelCase__								=		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				lowerCamelCase__								=		feature_size
				lowerCamelCase__								=		num_mel_bins
				lowerCamelCase__								=		padding_value
				lowerCamelCase__								=		sampling_rate
				lowerCamelCase__								=		return_attention_mask
				lowerCamelCase__								=		do_normalize





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				return {
				    "feature_size": self.feature_size,
				    "num_mel_bins": self.num_mel_bins,
				    "padding_value": self.padding_value,
				    "sampling_rate": self.sampling_rate,
				    "return_attention_mask": self.return_attention_mask,
				    "do_normalize": self.do_normalize,
				}





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase=False       ,  __lowerCAmelCase=False							):



				'''simple docstring'''







				def _flatten(__lowerCAmelCase							):
					return list(itertools.chain(*__lowerCAmelCase							)							)

				if equal_length:
					lowerCamelCase__								=		[floats_list((self.max_seq_length, self.feature_size)							) for _ in range(self.batch_size							)]
				else:
					# make sure that inputs increase in size
					lowerCamelCase__								=		[
					    floats_list((x, self.feature_size)							)
					    for x in range(self.min_seq_length       ,  self.max_seq_length       ,  self.seq_length_diff							)
					]
				if numpify:
					lowerCamelCase__								=		[np.asarray(__lowerCAmelCase							) for x in speech_inputs]
				return speech_inputs






@require_torch
@require_torchaudio
class 					__A    (    lowerCAmelCase			,				unittest.TestCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						SpeechaTextFeatureExtractor if is_speech_available() else None





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		SpeechaTextFeatureExtractionTester(self							)





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				self.assertTrue(np.all(np.mean(__lowerCAmelCase       ,  axis=0							) < 1E-3							)							)
				self.assertTrue(np.all(np.abs(np.var(__lowerCAmelCase       ,  axis=0							) - 1							) < 1E-3							)							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				# create three inputs of length 800, 1000, and 1200
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		[np.asarray(__lowerCAmelCase							) for speech_input in speech_inputs]

				# Test feature size
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				self.assertTrue(input_features.ndim == 3							)
				self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size							)

				# Test not batched input
				lowerCamelCase__								=		feature_extractor(speech_inputs[0]       ,  return_tensors='''np'''							).input_features
				lowerCamelCase__								=		feature_extractor(np_speech_inputs[0]       ,  return_tensors='''np'''							).input_features
				self.assertTrue(np.allclose(__lowerCAmelCase       ,  __lowerCAmelCase       ,  atol=1E-3							)							)

				# Test batched
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				for enc_seq_a, enc_seq_a in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					self.assertTrue(np.allclose(__lowerCAmelCase       ,  __lowerCAmelCase       ,  atol=1E-3							)							)

				# Test 2-D numpy arrays are batched.
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
				lowerCamelCase__								=		np.asarray(__lowerCAmelCase							)
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''np'''							).input_features
				for enc_seq_a, enc_seq_a in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					self.assertTrue(np.allclose(__lowerCAmelCase       ,  __lowerCAmelCase       ,  atol=1E-3							)							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]

				lowerCamelCase__								=		['''longest''', '''max_length''', '''do_not_pad''']
				lowerCamelCase__								=		[None, 1_6, None]
				for max_length, padding in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		feature_extractor(
					    __lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  max_length=__lowerCAmelCase       ,  return_attention_mask=__lowerCAmelCase							)
					lowerCamelCase__								=		inputs.input_features
					lowerCamelCase__								=		inputs.attention_mask
					lowerCamelCase__								=		[np.sum(__lowerCAmelCase							) for x in attention_mask]

					self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]							)
					self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]							)
					self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]

				lowerCamelCase__								=		['''longest''', '''max_length''', '''do_not_pad''']
				lowerCamelCase__								=		[None, 1_6, None]
				for max_length, padding in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		feature_extractor(
					    __lowerCAmelCase       ,  max_length=__lowerCAmelCase       ,  padding=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase							)
					lowerCamelCase__								=		inputs.input_features
					lowerCamelCase__								=		inputs.attention_mask
					lowerCamelCase__								=		[np.sum(__lowerCAmelCase							) for x in attention_mask]

					self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]							)
					self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6							)
					self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]							)
					self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6							)
					self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''max_length'''       ,  max_length=4       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				lowerCamelCase__								=		inputs.input_features
				lowerCamelCase__								=		inputs.attention_mask
				lowerCamelCase__								=		np.sum(attention_mask == 1       ,  axis=1							)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]							)
				self._check_zero_mean_unit_variance(input_features[1]							)
				self._check_zero_mean_unit_variance(input_features[2]							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''longest'''       ,  max_length=4       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				lowerCamelCase__								=		inputs.input_features
				lowerCamelCase__								=		inputs.attention_mask
				lowerCamelCase__								=		np.sum(attention_mask == 1       ,  axis=1							)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]							)
				self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]							)
				self._check_zero_mean_unit_variance(input_features[2]							)

				# make sure that if max_length < longest -> then pad to max_length
				self.assertEqual(input_features.shape       ,  (3, 4, 2_4)							)

				lowerCamelCase__								=		[floats_list((1, x)							)[0] for x in range(8_0_0       ,  1_4_0_0       ,  2_0_0							)]
				lowerCamelCase__								=		feature_extractor(
				    __lowerCAmelCase       ,  padding='''longest'''       ,  max_length=1_6       ,  truncation=__lowerCAmelCase       ,  return_tensors='''np'''       ,  return_attention_mask=__lowerCAmelCase       ,  )
				lowerCamelCase__								=		inputs.input_features
				lowerCamelCase__								=		inputs.attention_mask
				lowerCamelCase__								=		np.sum(attention_mask == 1       ,  axis=1							)

				self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]							)
				self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]							)
				self._check_zero_mean_unit_variance(input_features[2]							)

				# make sure that if max_length < longest -> then pad to max_length
				self.assertEqual(input_features.shape       ,  (3, 6, 2_4)							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				import torch

				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		np.random.rand(1_0_0       ,  3_2							).astype(np.floataa							)
				lowerCamelCase__								=		np_speech_inputs.tolist()

				for inputs in [py_speech_inputs, np_speech_inputs]:
					lowerCamelCase__								=		feature_extractor.pad([{'''input_features''': inputs}]       ,  return_tensors='''np'''							)
					self.assertTrue(np_processed.input_features.dtype == np.floataa							)
					lowerCamelCase__								=		feature_extractor.pad([{'''input_features''': inputs}]       ,  return_tensors='''pt'''							)
					self.assertTrue(pt_processed.input_features.dtype == torch.floataa							)





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				from datasets import load_dataset

				lowerCamelCase__								=		load_dataset('''hf-internal-testing/librispeech_asr_dummy'''       ,  '''clean'''       ,  split='''validation'''							)
				# automatic decoding with librispeech
				lowerCamelCase__								=		ds.sort('''id'''							).select(range(__lowerCAmelCase							)							)[:num_samples]['''audio''']

				return [x["array"] for x in speech_samples]





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		np.array([
				    -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
				    -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
				    -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
				]							)
				# fmt: on

				lowerCamelCase__								=		self._load_datasamples(1							)
				lowerCamelCase__								=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
				lowerCamelCase__								=		feature_extractor(__lowerCAmelCase       ,  return_tensors='''pt'''							).input_features
				self.assertEquals(input_features.shape       ,  (1, 5_8_4, 2_4)							)
				self.assertTrue(np.allclose(input_features[0, 0, :3_0]       ,  __lowerCAmelCase       ,  atol=1E-4							)							)



