

"""simple docstring"""




import os
import time
import warnings
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional, Union

import torch
from filelock import FileLock
from torch.utils.data import Dataset

from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from ..processors.utils import InputFeatures


A_							:			Dict											= logging.get_logger(__name__)





@dataclass
class    lowerCamelCase						:
			lowerCamelCase__   :		str							=							field(metadata={'help': 'The name of the task to train on: ' + ', '.join(glue_processors.keys()			)}			)
			lowerCamelCase__   :		str							=							field(
			    metadata={'help': 'The input data dir. Should contain the .tsv files (or other data files) for the task.'}			)
			lowerCamelCase__   :		int							=							field(
			    default=1_2_8			,metadata={
			        'help': (
			            'The maximum total input sequence length after tokenization. Sequences longer '
			            'than this will be truncated, sequences shorter will be padded.'
			        )
			    }			,)
			lowerCamelCase__   :		bool							=							field(
			    default=A__			,metadata={'help': 'Overwrite the cached training and evaluation sets'}			)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      self.task_name.lower()





class    lowerCamelCase						(A__			):
			lowerCamelCase__   :		Dict							=							'train'
			lowerCamelCase__   :		Tuple							=							'dev'
			lowerCamelCase__   :		Any							=							'test'





class    lowerCamelCase						(A__			):
			lowerCamelCase__   :		GlueDataTrainingArguments
			lowerCamelCase__   :		str
			lowerCamelCase__   :		List[InputFeatures]

			def __init__(					self				:						Union[str, Any]    ,				__UpperCAmelCase				:						GlueDataTrainingArguments    ,				__UpperCAmelCase				:						PreTrainedTokenizerBase    ,				__UpperCAmelCase				:						Optional[int] = None    ,				__UpperCAmelCase				:						Union[str, Split] = Split.train    ,				__UpperCAmelCase				:						Optional[str] = None    ,				)   ->    str:
						warnings.warn(
						    """This dataset will be removed from the library soon, preprocessing should be handled with the 🤗 Datasets """
						    """library. You can have a look at this example script for pointers: """
						    """https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py"""    ,				__UpperCAmelCase    ,				)
						SCREAMING_SNAKE_CASE__								=      args
						SCREAMING_SNAKE_CASE__								=      glue_processors[args.task_name]()
						SCREAMING_SNAKE_CASE__								=      glue_output_modes[args.task_name]
						if isinstance(__UpperCAmelCase    ,				__UpperCAmelCase       ):
									try:
												SCREAMING_SNAKE_CASE__								=      Split[mode]
									except KeyError:
												raise KeyError("""mode is not a valid split name"""       )
        # Load data features from cache or dataset file
						SCREAMING_SNAKE_CASE__								=      os.path.join(
						    cache_dir if cache_dir is not None else args.data_dir    ,				F"""cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{args.task_name}"""    ,				)
						SCREAMING_SNAKE_CASE__								=      self.processor.get_labels()
						if args.task_name in ["mnli", "mnli-mm"] and tokenizer.__class__.__name__ in (
						    "RobertaTokenizer",
						    "RobertaTokenizerFast",
						    "XLMRobertaTokenizer",
						    "BartTokenizer",
						    "BartTokenizerFast",
						):
									# HACK(label indices are swapped in RoBERTa pretrained model)
									SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      label_list[2], label_list[1]
						SCREAMING_SNAKE_CASE__								=      label_list

						# Make sure only the first process in distributed training processes the dataset,
						# and the others will use the cache.
						SCREAMING_SNAKE_CASE__								=      cached_features_file + """.lock"""
						with FileLock(__UpperCAmelCase       ):
									if os.path.exists(__UpperCAmelCase       ) and not args.overwrite_cache:
												SCREAMING_SNAKE_CASE__								=      time.time()
												SCREAMING_SNAKE_CASE__								=      torch.load(__UpperCAmelCase       )
												logger.info(
												    F"""Loading features from cached file {cached_features_file} [took %.3f s]"""    ,				time.time() - start       )
									else:
												logger.info(F"""Creating features from dataset file at {args.data_dir}"""       )

												if mode == Split.dev:
															SCREAMING_SNAKE_CASE__								=      self.processor.get_dev_examples(args.data_dir       )
												elif mode == Split.test:
															SCREAMING_SNAKE_CASE__								=      self.processor.get_test_examples(args.data_dir       )
												else:
															SCREAMING_SNAKE_CASE__								=      self.processor.get_train_examples(args.data_dir       )
												if limit_length is not None:
															SCREAMING_SNAKE_CASE__								=      examples[:limit_length]
												SCREAMING_SNAKE_CASE__								=      glue_convert_examples_to_features(
												    __UpperCAmelCase    ,				__UpperCAmelCase    ,				max_length=args.max_seq_length    ,				label_list=__UpperCAmelCase    ,				output_mode=self.output_mode    ,				)
												SCREAMING_SNAKE_CASE__								=      time.time()
												torch.save(self.features    ,				__UpperCAmelCase       )
												# ^ This seems to take a lot of time so I want to investigate why and how we can improve.
												logger.info(
												    F"""Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]"""       )

			def __len__(					self				:						Tuple       )   ->    Optional[Any]:
						return len(self.features       )

			def __getitem__(					self				:						Tuple    ,				__UpperCAmelCase				:						Union[str, Any]       )   ->    InputFeatures:
						return self.features[i]





			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    str:
						return self.label_list





"""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


A_							:			List[str]											= random.Random()

def 	A       (     snake_case__		,				snake_case__=1.0		,				snake_case__=None		,				snake_case__=None    ):




			'''simple docstring'''


			if rng is None:
						SCREAMING_SNAKE_CASE__								=      global_rng

			SCREAMING_SNAKE_CASE__								=      []
			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    lowerCamelCase						(unittest.TestCase			):

			def __init__(					self				:						Tuple    ,				__UpperCAmelCase				:						int    ,				__UpperCAmelCase				:						List[str]=7    ,				__UpperCAmelCase				:						List[str]=4_0_0    ,				__UpperCAmelCase				:						Tuple=2_0_0_0    ,				__UpperCAmelCase				:						Any=1    ,				__UpperCAmelCase				:						str=0.0    ,				__UpperCAmelCase				:						int=1_6_0_0_0    ,				__UpperCAmelCase				:						str=True    ,				__UpperCAmelCase				:						List[str]=8_0    ,				__UpperCAmelCase				:						Dict=1_6    ,				__UpperCAmelCase				:						int=6_4    ,				__UpperCAmelCase				:						Any="hann_window"    ,				__UpperCAmelCase				:						Tuple=8_0    ,				__UpperCAmelCase				:						Tuple=7_6_0_0    ,				__UpperCAmelCase				:						List[Any]=1e-10    ,				__UpperCAmelCase				:						Tuple=True    ,				)   ->    int:
						SCREAMING_SNAKE_CASE__								=      parent
						SCREAMING_SNAKE_CASE__								=      batch_size
						SCREAMING_SNAKE_CASE__								=      min_seq_length
						SCREAMING_SNAKE_CASE__								=      max_seq_length
						SCREAMING_SNAKE_CASE__								=      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						SCREAMING_SNAKE_CASE__								=      feature_size
						SCREAMING_SNAKE_CASE__								=      padding_value
						SCREAMING_SNAKE_CASE__								=      sampling_rate
						SCREAMING_SNAKE_CASE__								=      do_normalize
						SCREAMING_SNAKE_CASE__								=      num_mel_bins
						SCREAMING_SNAKE_CASE__								=      hop_length
						SCREAMING_SNAKE_CASE__								=      win_length
						SCREAMING_SNAKE_CASE__								=      win_function
						SCREAMING_SNAKE_CASE__								=      fmin
						SCREAMING_SNAKE_CASE__								=      fmax
						SCREAMING_SNAKE_CASE__								=      mel_floor
						SCREAMING_SNAKE_CASE__								=      return_attention_mask

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    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 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						Dict=False    ,				__UpperCAmelCase				:						List[str]=False       )   ->    Optional[Any]:
						def _flatten(__UpperCAmelCase				:						List[Any]       ):
									return list(itertools.chain(*__UpperCAmelCase       )       )

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

						return speech_inputs





			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]    ,				__UpperCAmelCase				:						Union[str, Any]=False    ,				__UpperCAmelCase				:						Optional[int]=False       )   ->    str:
						if equal_length:
									SCREAMING_SNAKE_CASE__								=      [floats_list((self.max_seq_length, self.num_mel_bins)       ) for _ in range(self.batch_size       )]
						else:
									# make sure that inputs increase in size
									SCREAMING_SNAKE_CASE__								=      [
									    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:
									SCREAMING_SNAKE_CASE__								=      [np.asarray(__UpperCAmelCase       ) for x in speech_inputs]

						return speech_inputs





@require_torch
class    lowerCamelCase						(A__			,unittest.TestCase			):
			lowerCamelCase__   :		Any							=							SpeechTaFeatureExtractor

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Any:
						SCREAMING_SNAKE_CASE__								=      SpeechTaFeatureExtractionTester(self       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]    ,				__UpperCAmelCase				:						Any       )   ->    Tuple:
						self.assertTrue(np.all(np.mean(__UpperCAmelCase    ,				axis=0       ) < 1e-3       )       )
						self.assertTrue(np.all(np.abs(np.var(__UpperCAmelCase    ,				axis=0       ) - 1       ) < 1e-3       )       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]       )   ->    Optional[int]:
						# Tests that all call wrap to encode_plus and batch_encode_plus
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						# create three inputs of length 800, 1000, and 1200
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]
						SCREAMING_SNAKE_CASE__								=      [np.asarray(__UpperCAmelCase       ) for speech_input in speech_inputs]

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

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]

						SCREAMING_SNAKE_CASE__								=      ["""longest""", """max_length""", """do_not_pad"""]
						SCREAMING_SNAKE_CASE__								=      [None, 1_6_0_0, None]
						for max_length, padding in zip(__UpperCAmelCase    ,				__UpperCAmelCase       ):
									SCREAMING_SNAKE_CASE__								=      feat_extract(__UpperCAmelCase    ,				padding=__UpperCAmelCase    ,				max_length=__UpperCAmelCase    ,				return_tensors="""np"""       )
									SCREAMING_SNAKE_CASE__								=      processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:8_0_0]       )
									self.assertTrue(input_values[0][8_0_0:].sum() < 1e-6       )
									self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]       )
									self.assertTrue(input_values[0][1_0_0_0:].sum() < 1e-6       )
									self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]       )   ->    Optional[Any]:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						SCREAMING_SNAKE_CASE__								=      range(8_0_0    ,				1_4_0_0    ,				2_0_0       )
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in lengths]

						SCREAMING_SNAKE_CASE__								=      ["""longest""", """max_length""", """do_not_pad"""]
						SCREAMING_SNAKE_CASE__								=      [None, 1_6_0_0, None]

						for max_length, padding in zip(__UpperCAmelCase    ,				__UpperCAmelCase       ):
									SCREAMING_SNAKE_CASE__								=      feat_extract(__UpperCAmelCase    ,				max_length=__UpperCAmelCase    ,				padding=__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:8_0_0]       )
									self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]       )
									self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]
						SCREAMING_SNAKE_CASE__								=      feat_extract(
						    __UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				max_length=1_0_0_0    ,				padding="""max_length"""    ,				return_tensors="""np"""       )
						SCREAMING_SNAKE_CASE__								=      processed.input_values

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]
						SCREAMING_SNAKE_CASE__								=      feat_extract(
						    __UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				max_length=1_0_0_0    ,				padding="""longest"""    ,				return_tensors="""np"""       )
						SCREAMING_SNAKE_CASE__								=      processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_0_0]       )
						self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]       )
						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, 1_0_0_0)       )

						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]
						SCREAMING_SNAKE_CASE__								=      feat_extract(
						    __UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				max_length=2_0_0_0    ,				padding="""longest"""    ,				return_tensors="""np"""       )
						SCREAMING_SNAKE_CASE__								=      processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_0_0]       )
						self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]       )
						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, 1_2_0_0)       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Dict       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						SCREAMING_SNAKE_CASE__								=      np.random.rand(1_0_0       ).astype(np.floataa       )
						SCREAMING_SNAKE_CASE__								=      np_speech_inputs.tolist()

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]       )   ->    str:
						# Tests that all call wrap to encode_plus and batch_encode_plus
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
						# create three inputs of length 800, 1000, and 1200
						SCREAMING_SNAKE_CASE__								=      [floats_list((1, x)       )[0] for x in range(8_0_0    ,				1_4_0_0    ,				2_0_0       )]
						SCREAMING_SNAKE_CASE__								=      [np.asarray(__UpperCAmelCase       ) for speech_input in speech_inputs]

						# Test feature size
						SCREAMING_SNAKE_CASE__								=      feature_extractor(audio_target=__UpperCAmelCase    ,				padding=__UpperCAmelCase    ,				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
						SCREAMING_SNAKE_CASE__								=      feature_extractor(speech_inputs[0]    ,				return_tensors="""np"""       ).input_values
						SCREAMING_SNAKE_CASE__								=      feature_extractor(np_speech_inputs[0]    ,				return_tensors="""np"""       ).input_values
						self.assertTrue(np.allclose(__UpperCAmelCase    ,				__UpperCAmelCase    ,				atol=1e-3       )       )

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

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Dict       )   ->    Any:
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_dict       )
						SCREAMING_SNAKE_CASE__								=      feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}       )

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

						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target(equal_length=__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}    ,				tensor_type="""np"""       )

						SCREAMING_SNAKE_CASE__								=      processed_features[input_name]

						if len(batch_features_input.shape       ) < 3:
									SCREAMING_SNAKE_CASE__								=      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 					SCREAMING_SNAKE_CASE				(					self				:						Dict       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target(equal_length=__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_dict       )
						SCREAMING_SNAKE_CASE__								=      feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}    ,				tensor_type="""pt"""       )

						SCREAMING_SNAKE_CASE__								=      processed_features[input_name]

						if len(batch_features_input.shape       ) < 3:
									SCREAMING_SNAKE_CASE__								=      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 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**self.feat_extract_dict       )
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__								=      feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}       )

						SCREAMING_SNAKE_CASE__								=      feat_extract.num_mel_bins  # hack!

						SCREAMING_SNAKE_CASE__								=      feat_extract.pad(__UpperCAmelCase    ,				padding="""longest"""    ,				return_tensors="""np"""       )[input_name]
						SCREAMING_SNAKE_CASE__								=      feat_extract.pad(__UpperCAmelCase    ,				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 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_dict
						SCREAMING_SNAKE_CASE__								=      True
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__								=      [len(__UpperCAmelCase       ) for x in speech_inputs]
						SCREAMING_SNAKE_CASE__								=      feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}       )

						SCREAMING_SNAKE_CASE__								=      feat_extract.num_mel_bins  # hack!

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_dict
						SCREAMING_SNAKE_CASE__								=      True
						SCREAMING_SNAKE_CASE__								=      self.feature_extraction_class(**__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      self.feat_extract_tester.prepare_inputs_for_target()
						SCREAMING_SNAKE_CASE__								=      [len(__UpperCAmelCase       ) for x in speech_inputs]
						SCREAMING_SNAKE_CASE__								=      feat_extract.model_input_names[0]

						SCREAMING_SNAKE_CASE__								=      BatchFeature({input_name: speech_inputs}       )
						SCREAMING_SNAKE_CASE__								=      min(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      feat_extract.num_mel_bins  # hack!

						SCREAMING_SNAKE_CASE__								=      feat_extract.pad(
						    __UpperCAmelCase    ,				padding="""max_length"""    ,				max_length=__UpperCAmelCase    ,				truncation=__UpperCAmelCase    ,				return_tensors="""np"""       )
						self.assertIn("""attention_mask"""    ,				__UpperCAmelCase       )
						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 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]    ,				__UpperCAmelCase				:						int       )   ->    str:
						from datasets import load_dataset

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

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

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    Any:
						# fmt: off
						SCREAMING_SNAKE_CASE__								=      torch.tensor(
						    [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
						     3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
						     2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
						     4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
						     7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
						     4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]       )
						# fmt: on

						SCREAMING_SNAKE_CASE__								=      self._load_datasamples(1       )
						SCREAMING_SNAKE_CASE__								=      SpeechTaFeatureExtractor()
						SCREAMING_SNAKE_CASE__								=      feature_extractor(__UpperCAmelCase    ,				return_tensors="""pt"""       ).input_values
						self.assertEquals(input_values.shape    ,				(1, 9_3_6_8_0)       )
						self.assertTrue(torch.allclose(input_values[0, :3_0]    ,				__UpperCAmelCase    ,				atol=1e-6       )       )





			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Union[str, Any]:
						# fmt: off
						SCREAMING_SNAKE_CASE__								=      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

						SCREAMING_SNAKE_CASE__								=      self._load_datasamples(1       )
						SCREAMING_SNAKE_CASE__								=      SpeechTaFeatureExtractor()
						SCREAMING_SNAKE_CASE__								=      feature_extractor(audio_target=__UpperCAmelCase    ,				return_tensors="""pt"""       ).input_values
						self.assertEquals(input_values.shape    ,				(1, 3_6_6, 8_0)       )
						self.assertTrue(torch.allclose(input_values[0, 0, :3_0]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )


