






"""simple docstring"""





from jiwer import compute_measures

import datasets


_SCREAMING_SNAKE_CASE					:				List[Any]					    =						'''\
@inproceedings{inproceedings,
    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},
    year = {2004},
    month = {01},
    pages = {},
    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}
}
'''

_SCREAMING_SNAKE_CASE					:				Optional[int]					    =						'''\
Word error rate (WER) is a common metric of the performance of an automatic speech recognition system.

The general difficulty of measuring performance lies in the fact that the recognized word sequence can have a different length from the reference word sequence (supposedly the correct one). The WER is derived from the Levenshtein distance, working at the word level instead of the phoneme level. The WER is a valuable tool for comparing different systems as well as for evaluating improvements within one system. This kind of measurement, however, provides no details on the nature of translation errors and further work is therefore required to identify the main source(s) of error and to focus any research effort.

This problem is solved by first aligning the recognized word sequence with the reference (spoken) word sequence using dynamic string alignment. Examination of this issue is seen through a theory called the power law that states the correlation between perplexity and word error rate.

Word error rate can then be computed as:

WER = (S + D + I) / N = (S + D + I) / (S + D + C)

where

S is the number of substitutions,
D is the number of deletions,
I is the number of insertions,
C is the number of correct words,
N is the number of words in the reference (N=S+D+C).

This value indicates the average number of errors per reference word. The lower the value, the better the
performance of the ASR system with a WER of 0 being a perfect score.
'''

_SCREAMING_SNAKE_CASE					:				Tuple					    =						'''
Compute WER score of transcribed segments against references.

Args:
    references: List of references for each speech input.
    predictions: List of transcriptions to score.
    concatenate_texts (bool, default=False): Whether to concatenate all input texts or compute WER iteratively.

Returns:
    (float): the word error rate

Examples:

    >>> predictions = ["this is the prediction", "there is an other sample"]
    >>> references = ["this is the reference", "there is another one"]
    >>> wer = datasets.load_metric("wer")
    >>> wer_score = wer.compute(predictions=predictions, references=references)
    >>> print(wer_score)
    0.5
'''






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,      _KWARGS_DESCRIPTION		)
class      a						(					datasets.Metric		):






    def    UpperCamelCase       (       self     :							Tuple					)     ->		Any:
      return datasets.MetricInfo(
          description=_DESCRIPTION       ,						citation=_CITATION       ,						inputs_description=_KWARGS_DESCRIPTION       ,						features=datasets.Features(
              {
                  'predictions': datasets.Value('string'       ,						id='sequence'					),
                  'references': datasets.Value('string'       ,						id='sequence'					),
              }					)       ,						codebase_urls=['https://github.com/jitsi/jiwer/']       ,						reference_urls=[
              'https://en.wikipedia.org/wiki/Word_error_rate',
          ]       ,						)






    def    UpperCamelCase       (       self     :							str       ,						__SCREAMING_SNAKE_CASE     :							Union[str, Any]=None       ,						__SCREAMING_SNAKE_CASE     :							Any=None       ,						__SCREAMING_SNAKE_CASE     :							Dict=False					)     ->		List[Any]:
      if concatenate_texts:
        return compute_measures(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)["wer"]
      else:
        lowerCamelCase_         =						0
        lowerCamelCase_         =						0
        for prediction, reference in zip(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					):
          lowerCamelCase_         =						compute_measures(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)
          incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
          total += measures["substitutions"] + measures["deletions"] + measures["hits"]
        return incorrect / total












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




