


"""simple docstring"""
# This model implementation is heavily inspired by https://github.com/haofanwang/ControlNet-for-Diffusers/

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()



class 			_UpperCAmelCase (							__snake_case,				__snake_case,				__snake_case,				unittest.TestCase				):






		'''simple docstring'''

		lowerCamelCase__				=StableDiffusionControlNetImgaImgPipeline
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
		lowerCamelCase__				=IMAGE_TO_IMAGE_IMAGE_PARAMS.union({'control_image'}				)
		lowerCamelCase__				=IMAGE_TO_IMAGE_IMAGE_PARAMS



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			torch.manual_seed(0					)
			__snake_case	:						List[Any]						=				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				,       )
			torch.manual_seed(0					)
			__snake_case	:						Optional[Any]						=				ControlNetModel(
			    block_out_channels=(32, 64)				,       layers_per_block=2				,       in_channels=4				,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,       cross_attention_dim=32				,       conditioning_embedding_out_channels=(16, 32)				,       )
			torch.manual_seed(0					)
			__snake_case	:						Any						=				DDIMScheduler(
			    beta_start=0.0_0085				,       beta_end=0.012				,       beta_schedule='''scaled_linear'''				,       clip_sample=a_				,       set_alpha_to_one=a_				,       )
			torch.manual_seed(0					)
			__snake_case	:						Any						=				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				,       )
			torch.manual_seed(0					)
			__snake_case	:						List[str]						=				CLIPTextConfig(
			    bos_token_id=0				,       eos_token_id=2				,       hidden_size=32				,       intermediate_size=37				,       layer_norm_eps=1E-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=10_00				,       )
			__snake_case	:						Any						=				CLIPTextModel(a_					)
			__snake_case	:						List[str]						=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

			__snake_case	:						Tuple						=				{
			    '''unet''': unet,
			    '''controlnet''': controlnet,
			    '''scheduler''': scheduler,
			    '''vae''': vae,
			    '''text_encoder''': text_encoder,
			    '''tokenizer''': tokenizer,
			    '''safety_checker''': None,
			    '''feature_extractor''': None,
			}
			return components



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_=0					):





			'''simple docstring'''

			if str(a_					).startswith('''mps'''					):
				__snake_case	:						int						=				torch.manual_seed(a_					)
			else:
				__snake_case	:						int						=				torch.Generator(device=a_					).manual_seed(a_					)

			__snake_case	:						List[str]						=				2
			__snake_case	:						List[str]						=				randn_tensor(
			    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,       generator=a_				,       device=torch.device(a_					)				,       )
			__snake_case	:						Any						=				floats_tensor(control_image.shape				,       rng=random.Random(a_					)					).to(a_					)
			__snake_case	:						str						=				image.cpu().permute(0				,       2				,       3				,       1					)[0]
			__snake_case	:						int						=				Image.fromarray(np.uinta(a_					)					).convert('''RGB'''					).resize((64, 64)					)
			__snake_case	:						Any						=				{
			    '''prompt''': '''A painting of a squirrel eating a burger''',
			    '''generator''': generator,
			    '''num_inference_steps''': 2,
			    '''guidance_scale''': 6.0,
			    '''output_type''': '''numpy''',
			    '''image''': image,
			    '''control_image''': control_image,
			}

			return inputs



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3					)



		@unittest.skipIf(
		    torch_device != '''cuda''' or not is_xformers_available()				,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''				,       )
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3					)



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self._test_inference_batch_single_identical(expected_max_diff=2E-3					)



class 			_UpperCAmelCase (							__snake_case,				__snake_case,				unittest.TestCase				):






		'''simple docstring'''

		lowerCamelCase__				=StableDiffusionControlNetImgaImgPipeline
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
		lowerCamelCase__				=frozenset([]				)  # TO_DO: add image_params once refactored VaeImageProcessor.preprocess



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			torch.manual_seed(0					)
			__snake_case	:						Optional[int]						=				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				,       )
			torch.manual_seed(0					)

			def init_weights(a_					):
				if isinstance(a_				,       torch.nn.Convad					):
					torch.nn.init.normal(m.weight					)
					m.bias.data.fill_(1.0					)

			__snake_case	:						Dict						=				ControlNetModel(
			    block_out_channels=(32, 64)				,       layers_per_block=2				,       in_channels=4				,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,       cross_attention_dim=32				,       conditioning_embedding_out_channels=(16, 32)				,       )
			controlneta.controlnet_down_blocks.apply(a_					)

			torch.manual_seed(0					)
			__snake_case	:						Any						=				ControlNetModel(
			    block_out_channels=(32, 64)				,       layers_per_block=2				,       in_channels=4				,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,       cross_attention_dim=32				,       conditioning_embedding_out_channels=(16, 32)				,       )
			controlneta.controlnet_down_blocks.apply(a_					)

			torch.manual_seed(0					)
			__snake_case	:						List[Any]						=				DDIMScheduler(
			    beta_start=0.0_0085				,       beta_end=0.012				,       beta_schedule='''scaled_linear'''				,       clip_sample=a_				,       set_alpha_to_one=a_				,       )
			torch.manual_seed(0					)
			__snake_case	:						Union[str, Any]						=				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				,       )
			torch.manual_seed(0					)
			__snake_case	:						Optional[Any]						=				CLIPTextConfig(
			    bos_token_id=0				,       eos_token_id=2				,       hidden_size=32				,       intermediate_size=37				,       layer_norm_eps=1E-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=10_00				,       )
			__snake_case	:						Dict						=				CLIPTextModel(a_					)
			__snake_case	:						List[str]						=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

			__snake_case	:						Any						=				MultiControlNetModel([controlneta, controlneta]					)

			__snake_case	:						Any						=				{
			    '''unet''': unet,
			    '''controlnet''': controlnet,
			    '''scheduler''': scheduler,
			    '''vae''': vae,
			    '''text_encoder''': text_encoder,
			    '''tokenizer''': tokenizer,
			    '''safety_checker''': None,
			    '''feature_extractor''': None,
			}
			return components



		def 				SCREAMING_SNAKE_CASE  (self				,       a_				,       a_=0					):





			'''simple docstring'''

			if str(a_					).startswith('''mps'''					):
				__snake_case	:						Dict						=				torch.manual_seed(a_					)
			else:
				__snake_case	:						Optional[int]						=				torch.Generator(device=a_					).manual_seed(a_					)

			__snake_case	:						Union[str, Any]						=				2

			__snake_case	:						Any						=				[
			    randn_tensor(
			        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,       generator=a_				,       device=torch.device(a_					)				,       ),
			    randn_tensor(
			        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,       generator=a_				,       device=torch.device(a_					)				,       ),
			]

			__snake_case	:						List[str]						=				floats_tensor(control_image[0].shape				,       rng=random.Random(a_					)					).to(a_					)
			__snake_case	:						Union[str, Any]						=				image.cpu().permute(0				,       2				,       3				,       1					)[0]
			__snake_case	:						Optional[Any]						=				Image.fromarray(np.uinta(a_					)					).convert('''RGB'''					).resize((64, 64)					)
			__snake_case	:						Any						=				{
			    '''prompt''': '''A painting of a squirrel eating a burger''',
			    '''generator''': generator,
			    '''num_inference_steps''': 2,
			    '''guidance_scale''': 6.0,
			    '''output_type''': '''numpy''',
			    '''image''': image,
			    '''control_image''': control_image,
			}

			return inputs



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						str						=				self.get_dummy_components()
			__snake_case	:						List[Any]						=				self.pipeline_class(**a_					)
			pipe.to(a_					)

			__snake_case	:						List[Any]						=				10.0
			__snake_case	:						List[str]						=				4

			__snake_case	:						Optional[Any]						=				self.get_dummy_inputs(a_					)
			__snake_case	:						int						=				steps
			__snake_case	:						Union[str, Any]						=				scale
			__snake_case	:						str						=				pipe(**a_					)[0]

			__snake_case	:						int						=				self.get_dummy_inputs(a_					)
			__snake_case	:						Tuple						=				steps
			__snake_case	:						Any						=				scale
			__snake_case	:						str						=				pipe(**a_				,       control_guidance_start=0.1				,       control_guidance_end=0.2					)[0]

			__snake_case	:						str						=				self.get_dummy_inputs(a_					)
			__snake_case	:						Union[str, Any]						=				steps
			__snake_case	:						Tuple						=				scale
			__snake_case	:						List[str]						=				pipe(**a_				,       control_guidance_start=[0.1, 0.3]				,       control_guidance_end=[0.2, 0.7]					)[0]

			__snake_case	:						int						=				self.get_dummy_inputs(a_					)
			__snake_case	:						Tuple						=				steps
			__snake_case	:						List[Any]						=				scale
			__snake_case	:						str						=				pipe(**a_				,       control_guidance_start=0.4				,       control_guidance_end=[0.5, 0.8]					)[0]

			# make sure that all outputs are different
			assert np.sum(np.abs(output_a - output_a					)					) > 1E-3
			assert np.sum(np.abs(output_a - output_a					)					) > 1E-3
			assert np.sum(np.abs(output_a - output_a					)					) > 1E-3



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			return self._test_attention_slicing_forward_pass(expected_max_diff=2E-3					)



		@unittest.skipIf(
		    torch_device != '''cuda''' or not is_xformers_available()				,       reason='''XFormers attention is only available with CUDA and `xformers` installed'''				,       )
		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3					)



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			self._test_inference_batch_single_identical(expected_max_diff=2E-3					)



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						str						=				self.get_dummy_components()
			__snake_case	:						Union[str, Any]						=				self.pipeline_class(**a_					)
			pipe.to(a_					)
			pipe.set_progress_bar_config(disable=a_					)
			with tempfile.TemporaryDirectory() as tmpdir:
				try:
					# save_pretrained is not implemented for Multi-ControlNet
					pipe.save_pretrained(a_					)
				except NotImplementedError:
					pass



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






		'''simple docstring'''

		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

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



		def 				SCREAMING_SNAKE_CASE  (self					):





			'''simple docstring'''

			__snake_case	:						Any						=				ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''					)

			__snake_case	:						Union[str, Any]						=				StableDiffusionControlNetImgaImgPipeline.from_pretrained(
			    '''runwayml/stable-diffusion-v1-5'''				,       safety_checker=a_				,       controlnet=a_					)
			pipe.enable_model_cpu_offload()
			pipe.set_progress_bar_config(disable=a_					)

			__snake_case	:						Any						=				torch.Generator(device='''cpu'''					).manual_seed(0					)
			__snake_case	:						List[Any]						=				'''evil space-punk bird'''
			__snake_case	:						Union[str, Any]						=				load_image(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''					).resize((5_12, 5_12)					)
			__snake_case	:						List[str]						=				load_image(
			    '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''					).resize((5_12, 5_12)					)

			__snake_case	:						Any						=				pipe(
			    a_				,       a_				,       control_image=a_				,       generator=a_				,       output_type='''np'''				,       num_inference_steps=50				,       strength=0.6				,       )

			__snake_case	:						List[str]						=				output.images[0]

			assert image.shape == (5_12, 5_12, 3)

			__snake_case	:						Union[str, Any]						=				load_numpy(
			    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/img2img.npy'''					)

			assert np.abs(expected_image - image					).max() < 9E-2













"""simple docstring"""





import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


_SCREAMING_SNAKE_CASE					:				Tuple					    =						random.Random()







def      lowerCamelCase__       (							_lowerCamelCase       :		List[Any]		,				_lowerCamelCase       :		List[Any]=1.0		,				_lowerCamelCase       :		Optional[int]=None		,				_lowerCamelCase       :		str=None )      ->				List[str]:
  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
class      a						(					unittest.TestCase		):






    def __init__(       self     :							Any       ,						__SCREAMING_SNAKE_CASE     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							Tuple=7       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=400       ,						__SCREAMING_SNAKE_CASE     :							int=2000       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=1       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=0.0       ,						__SCREAMING_SNAKE_CASE     :							Dict=16000       ,						__SCREAMING_SNAKE_CASE     :							Dict=True       ,						__SCREAMING_SNAKE_CASE     :							List[Any]=80       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=16       ,						__SCREAMING_SNAKE_CASE     :							int=64       ,						__SCREAMING_SNAKE_CASE     :							Tuple="hann_window"       ,						__SCREAMING_SNAKE_CASE     :							Dict=80       ,						__SCREAMING_SNAKE_CASE     :							List[str]=7600       ,						__SCREAMING_SNAKE_CASE     :							List[str]=1e-1_0       ,						__SCREAMING_SNAKE_CASE     :							Any=True       ,						)     ->		List[str]:
      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_         =						padding_value
      lowerCamelCase_         =						sampling_rate
      lowerCamelCase_         =						do_normalize
      lowerCamelCase_         =						num_mel_bins
      lowerCamelCase_         =						hop_length
      lowerCamelCase_         =						win_length
      lowerCamelCase_         =						win_function
      lowerCamelCase_         =						fmin
      lowerCamelCase_         =						fmax
      lowerCamelCase_         =						mel_floor
      lowerCamelCase_         =						return_attention_mask






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      return {
          "feature_size": self.feature_size,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "do_normalize": self.do_normalize,
          "num_mel_bins": self.num_mel_bins,
          "hop_length": self.hop_length,
          "win_length": self.win_length,
          "win_function": self.win_function,
          "fmin": self.fmin,
          "fmax": self.fmax,
          "mel_floor": self.mel_floor,
          "return_attention_mask": self.return_attention_mask,
      }






    def    UpperCamelCase       (       self     :							List[str]       ,						__SCREAMING_SNAKE_CASE     :							Tuple=False       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]=False					)     ->		str:
      def _flatten(__SCREAMING_SNAKE_CASE     :							Any					):
        return list(itertools.chain(*__SCREAMING_SNAKE_CASE					)					)

      if equal_length:
        lowerCamelCase_         =						floats_list((self.batch_size, self.max_seq_length)					)
      else:
        # make sure that inputs increase in size
        lowerCamelCase_         =						[
            _flatten(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(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]

      return speech_inputs






    def    UpperCamelCase       (       self     :							Optional[int]       ,						__SCREAMING_SNAKE_CASE     :							str=False       ,						__SCREAMING_SNAKE_CASE     :							Any=False					)     ->		int:
      if equal_length:
        lowerCamelCase_         =						[floats_list((self.max_seq_length, self.num_mel_bins)					) for _ in range(self.batch_size					)]
      else:
        # make sure that inputs increase in size
        lowerCamelCase_         =						[
            floats_list((x, self.num_mel_bins)					)
            for x in range(self.min_seq_length       ,						self.max_seq_length       ,						self.seq_length_diff					)
        ]

      if numpify:
        lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]

      return speech_inputs






@require_torch
class      a						(					__snake_case  ,      unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:     Any						= SpeechTaFeatureExtractor






    def    UpperCamelCase       (       self     :							Any					)     ->		Any:
      lowerCamelCase_         =						SpeechTaFeatureExtractionTester(self					)






    def    UpperCamelCase       (       self     :							Dict       ,						__SCREAMING_SNAKE_CASE     :							int					)     ->		List[Any]:
      self.assertTrue(np.all(np.mean(__SCREAMING_SNAKE_CASE       ,						axis=0					) < 1e-3					)					)
      self.assertTrue(np.all(np.abs(np.var(__SCREAMING_SNAKE_CASE       ,						axis=0					) - 1					) < 1e-3					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		int:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      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(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test not batched input
      lowerCamelCase_         =						feat_extract(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		Optional[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]
      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
        lowerCamelCase_         =						processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:800]					)
        self.assertTrue(input_values[0][800:].sum() < 1e-6					)
        self._check_zero_mean_unit_variance(input_values[1][:1000]					)
        self.assertTrue(input_values[0][1000:].sum() < 1e-6					)
        self._check_zero_mean_unit_variance(input_values[2][:1200]					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Dict:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						range(800       ,						1400       ,						200					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in lengths]

      lowerCamelCase_         =						['longest', 'max_length', 'do_not_pad']
      lowerCamelCase_         =						[None, 1600, None]

      for max_length, padding in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        lowerCamelCase_         =						feat_extract(__SCREAMING_SNAKE_CASE       ,						max_length=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE					)
        lowerCamelCase_         =						processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:800]					)
        self._check_zero_mean_unit_variance(input_values[1][:1000]					)
        self._check_zero_mean_unit_variance(input_values[2][:1200]					)






    def    UpperCamelCase       (       self     :							Tuple					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='max_length'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1]					)
      self._check_zero_mean_unit_variance(input_values[2]					)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=1000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1, :1000]					)
      self._check_zero_mean_unit_variance(input_values[2]					)

      # make sure that if max_length < longest -> then pad to max_length
      self.assertTrue(input_values.shape == (3, 1000)					)

      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in range(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						feat_extract(
          __SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						max_length=2000       ,						padding='longest'       ,						return_tensors='np'					)
      lowerCamelCase_         =						processed.input_values

      self._check_zero_mean_unit_variance(input_values[0, :800]					)
      self._check_zero_mean_unit_variance(input_values[1, :1000]					)
      self._check_zero_mean_unit_variance(input_values[2]					)

      # make sure that if max_length > longest -> then pad to longest
      self.assertTrue(input_values.shape == (3, 1200)					)






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
      lowerCamelCase_         =						np.random.rand(100					).astype(np.floataa					)
      lowerCamelCase_         =						np_speech_inputs.tolist()

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






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Tuple:
      # Tests that all call wrap to encode_plus and batch_encode_plus
      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(800       ,						1400       ,						200					)]
      lowerCamelCase_         =						[np.asarray(__SCREAMING_SNAKE_CASE					) for speech_input in speech_inputs]

      # Test feature size
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						padding=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      self.assertTrue(input_values.ndim == 3					)
      self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins					)

      # Test not batched input
      lowerCamelCase_         =						feature_extractor(speech_inputs[0]       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(np_speech_inputs[0]       ,						return_tensors='np'					).input_values
      self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test batched
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)

      # Test 2-D numpy arrays are batched.
      lowerCamelCase_         =						[floats_list((1, x)					)[0] for x in (800, 800, 800)]
      lowerCamelCase_         =						np.asarray(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					).input_values
      for enc_seq_a, enc_seq_a in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
        self.assertTrue(np.allclose(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-3					)					)






    def    UpperCamelCase       (       self     :							int					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      self.assertTrue(all(len(__SCREAMING_SNAKE_CASE					) == len(__SCREAMING_SNAKE_CASE					) for x, y in zip(__SCREAMING_SNAKE_CASE       ,						processed_features[input_name]					)					)					)

      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='np'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							Tuple					)     ->		Any:
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target(equal_length=__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}       ,						tensor_type='pt'					)

      lowerCamelCase_         =						processed_features[input_name]

      if len(batch_features_input.shape					) < 3:
        lowerCamelCase_         =						batch_features_input[:, :, None]

      self.assertTrue(
          batch_features_input.shape
          == (self.feat_extract_tester.batch_size, len(speech_inputs[0]					), self.feat_extract_tester.num_mel_bins)					)






    @require_torch
    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.feature_extraction_class(**self.feat_extract_dict					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)[input_name]
      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='pt'					)[input_name]

      self.assertTrue(abs(input_np.astype(np.floataa					).sum() - input_pt.numpy().astype(np.floataa					).sum()					) < 1e-2					)






    def    UpperCamelCase       (       self     :							Dict					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(__SCREAMING_SNAKE_CASE       ,						padding='longest'       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(list(processed.attention_mask.shape					)       ,						list(processed[input_name].shape[:2]					)					)
      self.assertListEqual(processed.attention_mask.sum(-1					).tolist()       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Optional[Any]					)     ->		Optional[int]:
      lowerCamelCase_         =						self.feat_extract_dict
      lowerCamelCase_         =						True
      lowerCamelCase_         =						self.feature_extraction_class(**__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						self.feat_extract_tester.prepare_inputs_for_target()
      lowerCamelCase_         =						[len(__SCREAMING_SNAKE_CASE					) for x in speech_inputs]
      lowerCamelCase_         =						feat_extract.model_input_names[0]

      lowerCamelCase_         =						BatchFeature({input_name: speech_inputs}					)
      lowerCamelCase_         =						min(__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						feat_extract.num_mel_bins  # hack!

      lowerCamelCase_         =						feat_extract.pad(
          __SCREAMING_SNAKE_CASE       ,						padding='max_length'       ,						max_length=__SCREAMING_SNAKE_CASE       ,						truncation=__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
      self.assertIn('attention_mask'       ,						__SCREAMING_SNAKE_CASE					)
      self.assertListEqual(
          list(processed_pad.attention_mask.shape					)       ,						[processed_pad[input_name].shape[0], max_length]					)
      self.assertListEqual(
          processed_pad.attention_mask[:, :max_length].sum(-1					).tolist()       ,						[max_length for x in speech_inputs]					)






    def    UpperCamelCase       (       self     :							Optional[Any]       ,						__SCREAMING_SNAKE_CASE     :							Optional[Any]					)     ->		List[str]:
      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(__SCREAMING_SNAKE_CASE					)					)[:num_samples]['audio']

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






    def    UpperCamelCase       (       self     :							str					)     ->		Dict:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
           3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
           2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
           4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
           7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
           4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 93680)					)
      self.assertTrue(torch.allclose(input_values[0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-6					)					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		Optional[int]:
      # fmt: off
      lowerCamelCase_         =						torch.tensor(
          [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
           -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
           -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
           -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]					)
      # fmt: on

      lowerCamelCase_         =						self._load_datasamples(1					)
      lowerCamelCase_         =						SpeechTaFeatureExtractor()
      lowerCamelCase_         =						feature_extractor(audio_target=__SCREAMING_SNAKE_CASE       ,						return_tensors='pt'					).input_values
      self.assertEquals(input_values.shape       ,						(1, 366, 80)					)
      self.assertTrue(torch.allclose(input_values[0, 0, :30]       ,						__SCREAMING_SNAKE_CASE       ,						atol=1e-4					)					)




