




import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

a_   		=     logging.getLogger()




def 					__SCREAMING_SNAKE_CASE   (  )       ->	str:

    """simple docstring"""


    __UpperCamelCase  		=						argparse.ArgumentParser()
    parser.add_argument('''-f'''      )
    __UpperCamelCase  		=						parser.parse_args()
    return args.f




def 					__SCREAMING_SNAKE_CASE   (  lowercase_      )       ->	str:

    """simple docstring"""


    __UpperCamelCase  		=						{}
    __UpperCamelCase  		=						os.path.join(lowercase_					,     '''all_results.json'''      )
    if os.path.exists(lowercase_      ):
        with open(lowercase_					,     '''r'''      ) as f:
            __UpperCamelCase  		=						json.load(lowercase_      )
    else:
        raise ValueError(F"can't find {path}"      )
    return results




def 					__SCREAMING_SNAKE_CASE   (  )       ->	Optional[int]:

    """simple docstring"""


    __UpperCamelCase  		=						torch.cuda.is_available() and torch_device == '''cuda'''
    return is_using_cuda and is_apex_available()


a_   		=     logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)


class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      @classmethod
      def       snake_case	(     cls					: Tuple				):
          # Write Accelerate config, will pick up on CPU, GPU, and multi-GPU
          __UpperCamelCase  		=						tempfile.mkdtemp()
          __UpperCamelCase  		=						os.path.join(cls.tmpdir ,       '''default_config.yml'''				)
          write_basic_config(save_location=cls.configPath				)
          __UpperCamelCase  		=						['''accelerate''', '''launch''', '''--config_file''', cls.configPath]







      @classmethod
      def       snake_case	(     cls					: Optional[Any]				):
          shutil.rmtree(cls.tmpdir				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: int				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          if is_cuda_and_apex_available():
              testargs.append('''--fp16'''				)

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_accuracy'''] ,       0.75				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''glue_no_trainer'''				)				)				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: str				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          if torch.cuda.device_count() > 1:
              # Skipping because there are not enough batches to train the model + would need a drop_last to work.
              return

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertLess(result['''perplexity'''] ,       100				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''clm_no_trainer'''				)				)				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: int				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertLess(result['''perplexity'''] ,       42				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''mlm_no_trainer'''				)				)				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: Dict				):
          # with so little data distributed training needs more epochs to get the score on par with 0/1 gpu
          __UpperCamelCase  		=						7 if get_gpu_count() > 1 else 2

          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_accuracy'''] ,       0.75				)
          self.assertLess(result['''train_loss'''] ,       0.5				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''ner_no_trainer'''				)				)				)







      @unittest.skip(reason='''Fix me @muellerzr'''				)
      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: Optional[int]				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          # Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
          self.assertGreaterEqual(result['''eval_f1'''] ,       28				)
          self.assertGreaterEqual(result['''eval_exact'''] ,       28				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''qa_no_trainer'''				)				)				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: Dict				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_accuracy'''] ,       0.8				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''swag_no_trainer'''				)				)				)







      @slow
      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: List[str]				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_rouge1'''] ,       10				)
          self.assertGreaterEqual(result['''eval_rouge2'''] ,       2				)
          self.assertGreaterEqual(result['''eval_rougeL'''] ,       7				)
          self.assertGreaterEqual(result['''eval_rougeLsum'''] ,       7				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''summarization_no_trainer'''				)				)				)







      @slow
      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: List[str]				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_bleu'''] ,       30				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''epoch_0'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''translation_no_trainer'''				)				)				)







      @slow
      def       snake_case	(     self					: List[str]				):
          __UpperCamelCase  		=						logging.StreamHandler(sys.stdout				)
          logger.addHandler(snake_case				)

          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        ".split()

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          self.assertGreaterEqual(result['''eval_overall_accuracy'''] ,       0.10				)







      @mock.patch.dict(os.environ ,       {'''WANDB_MODE''': '''offline'''}				)
      def       snake_case	(     self					: Tuple				):
          __UpperCamelCase  		=						self.get_auto_remove_tmp_dir()
          __UpperCamelCase  		=						F"\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        ".split()

          if is_cuda_and_apex_available():
              testargs.append('''--fp16'''				)

          run_command(self._launch_args + testargs				)
          __UpperCamelCase  		=						get_results(snake_case				)
          # The base model scores a 25%
          self.assertGreaterEqual(result['''eval_accuracy'''] ,       0.6				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''step_1'''				)				)				)
          self.assertTrue(os.path.exists(os.path.join(snake_case ,       '''image_classification_no_trainer'''				)				)				)












import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np
import torch

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


a_   		=     logging.get_logger(__name__)

class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      lowerCAmelCase__			: Dict    =					["input_features", "is_longer"]







      def __init__(     self					: Dict ,       snake_case					: int=64 ,       snake_case					: Dict=48000 ,       snake_case					: Tuple=480 ,       snake_case					: Optional[Any]=10 ,       snake_case					: Union[str, Any]=1024 ,       snake_case					: Union[str, Any]=0.0 ,       snake_case					: List[str]=False ,       snake_case					: float = 0 ,       snake_case					: float = 14000 ,       snake_case					: int = None ,       snake_case					: str = "fusion" ,       snake_case					: str = "repeatpad" ,       **snake_case					: int ,       ):
          super().__init__(
              feature_size=snake_case ,       sampling_rate=snake_case ,       padding_value=snake_case ,       return_attention_mask=snake_case ,       **snake_case ,       )
          __UpperCamelCase  		=						top_db
          __UpperCamelCase  		=						truncation
          __UpperCamelCase  		=						padding
          __UpperCamelCase  		=						fft_window_size
          __UpperCamelCase  		=						(fft_window_size >> 1) + 1
          __UpperCamelCase  		=						hop_length
          __UpperCamelCase  		=						max_length_s
          __UpperCamelCase  		=						max_length_s * sampling_rate
          __UpperCamelCase  		=						sampling_rate
          __UpperCamelCase  		=						frequency_min
          __UpperCamelCase  		=						frequency_max
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm=snake_case ,       mel_scale='''htk''' ,       )
          __UpperCamelCase  		=						mel_filter_bank(
              num_frequency_bins=self.nb_frequency_bins ,       num_mel_filters=snake_case ,       min_frequency=snake_case ,       max_frequency=snake_case ,       sampling_rate=snake_case ,       norm='''slaney''' ,       mel_scale='''slaney''' ,       )







      def       snake_case	(     self					: Union[str, Any]				):
          __UpperCamelCase  		=						copy.deepcopy(self.__dict__				)
          __UpperCamelCase  		=						self.__class__.__name__
          if "mel_filters" in output:
              del output["mel_filters"]
          if "mel_filters_slaney" in output:
              del output["mel_filters_slaney"]
          return output







      def       snake_case	(     self					: Tuple ,       snake_case					: np.array ,       snake_case					: Optional[np.array] = None				):
          __UpperCamelCase  		=						spectrogram(
              snake_case ,       window_function(self.fft_window_size ,       '''hann'''				) ,       frame_length=self.fft_window_size ,       hop_length=self.hop_length ,       power=2.0 ,       mel_filters=snake_case ,       log_mel='''dB''' ,       )
          return log_mel_spectrogram.T







      def       snake_case	(     self					: Optional[int] ,       snake_case					: Any ,       snake_case					: List[Any] ,       snake_case					: int				):
          __UpperCamelCase  		=						np.array_split(list(range(0 ,       total_frames - chunk_frames + 1				)				) ,       3				)
          if len(ranges[1]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          if len(ranges[2]				) == 0:
              # if the audio is too short, we just use the first chunk
              __UpperCamelCase  		=						[0]
          # randomly choose index for each part
          __UpperCamelCase  		=						np.random.choice(ranges[0]				)
          __UpperCamelCase  		=						np.random.choice(ranges[1]				)
          __UpperCamelCase  		=						np.random.choice(ranges[2]				)

          __UpperCamelCase  		=						mel[idx_front : idx_front + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_middle : idx_middle + chunk_frames, :]
          __UpperCamelCase  		=						mel[idx_back : idx_back + chunk_frames, :]

          __UpperCamelCase  		=						torch.tensor(mel[None, None, :]				)
          __UpperCamelCase  		=						torch.nn.functional.interpolate(
              snake_case ,       size=[chunk_frames, 64] ,       mode='''bilinear''' ,       align_corners=snake_case				)
          __UpperCamelCase  		=						mel_shrink[0][0].numpy()
          __UpperCamelCase  		=						np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back] ,       axis=0				)
          return mel_fusion







      def       snake_case	(     self					: Optional[Any] ,       snake_case					: np.array ,       snake_case					: Optional[int] ,       snake_case					: Tuple ,       snake_case					: str				):
          if waveform.shape[0] > max_length:
              if truncation == "rand_trunc":
                  __UpperCamelCase  		=						True
                  # random crop to max_length (for compatibility) -> this should be handled by self.pad
                  __UpperCamelCase  		=						len(snake_case				) - max_length
                  __UpperCamelCase  		=						np.random.randint(0 ,       overflow + 1				)
                  __UpperCamelCase  		=						waveform[idx : idx + max_length]
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]
              elif truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
                  __UpperCamelCase  		=						mel.shape[0]
                  if chunk_frames == total_frames:
                      # there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
                      # In this case, we just use the whole audio.
                      __UpperCamelCase  		=						np.stack([mel, mel, mel, mel] ,       axis=0				)
                      __UpperCamelCase  		=						False
                  else:
                      __UpperCamelCase  		=						self._random_mel_fusion(snake_case ,       snake_case ,       snake_case				)
                      __UpperCamelCase  		=						True
              else:
                  raise NotImplementedError(F"data_truncating {truncation} not implemented"				)

          else:
              __UpperCamelCase  		=						False
              # only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
              if waveform.shape[0] < max_length:
                  if padding == "repeat":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       n_repeat + 1				)				)[:max_length]
                  if padding == "repeatpad":
                      __UpperCamelCase  		=						int(max_length / len(snake_case				)				)
                      __UpperCamelCase  		=						np.stack(np.tile(snake_case ,       snake_case				)				)
                  __UpperCamelCase  		=						np.pad(snake_case ,       (0, max_length - waveform.shape[0]) ,       mode='''constant''' ,       constant_values=0				)

              if truncation == "fusion":
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters				)
                  __UpperCamelCase  		=						np.stack([input_mel, input_mel, input_mel, input_mel] ,       axis=0				)
              else:
                  __UpperCamelCase  		=						self._np_extract_fbank_features(snake_case ,       self.mel_filters_slaney				)[None, :]

          return input_mel, longer







      def __call__(     self					: List[str] ,       snake_case					: Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]] ,       snake_case					: str = None ,       snake_case					: Optional[str] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[int] = None ,       snake_case					: Optional[Union[str, TensorType]] = None ,       **snake_case					: Any ,       ):
          __UpperCamelCase  		=						truncation if truncation is not None else self.truncation
          __UpperCamelCase  		=						padding if padding else self.padding

          if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                  raise ValueError(
                      F"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
                      F" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
                      F" was sampled with {self.sampling_rate} and not {sampling_rate}."				)
          else:
              logger.warning(
                  '''It is strongly recommended to pass the `sampling_rate` argument to this function. '''
                  '''Failing to do so can result in silent errors that might be hard to debug.'''				)

          __UpperCamelCase  		=						isinstance(snake_case ,       np.ndarray				) and len(raw_speech.shape				) > 1
          if is_batched_numpy and len(raw_speech.shape				) > 2:
              raise ValueError(F"Only mono-channel audio is supported for input to {self}"				)
          __UpperCamelCase  		=						is_batched_numpy or (
              isinstance(snake_case ,       (list, tuple)				) and (isinstance(raw_speech[0] ,       (np.ndarray, tuple, list)				))
          )

          if is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for speech in raw_speech]
          elif not is_batched and not isinstance(snake_case ,       np.ndarray				):
              __UpperCamelCase  		=						np.asarray(snake_case ,       dtype=np.floataa				)
          elif isinstance(snake_case ,       np.ndarray				) and raw_speech.dtype is np.dtype(np.floataa				):
              __UpperCamelCase  		=						raw_speech.astype(np.floataa				)

          # always return batch
          if not is_batched:
              __UpperCamelCase  		=						[np.asarray(snake_case				)]

          # convert to mel spectrogram, truncate and pad if needed.
          __UpperCamelCase  		=						[
              self._get_input_mel(snake_case ,       max_length if max_length else self.nb_max_samples ,       snake_case ,       snake_case				)
              for waveform in raw_speech
          ]

          __UpperCamelCase  		=						[]
          __UpperCamelCase  		=						[]
          for mel, longer in padded_inputs:
              input_mel.append(snake_case				)
              is_longer.append(snake_case				)

          if truncation == "fusion" and sum(snake_case				) == 0:
              # if no audio is longer than 10s, then randomly select one audio to be longer
              __UpperCamelCase  		=						np.random.randint(0 ,       len(snake_case				)				)
              __UpperCamelCase  		=						True

          if isinstance(input_mel[0] ,       snake_case				):
              __UpperCamelCase  		=						[np.asarray(snake_case ,       dtype=np.floataa				) for feature in input_mel]

          # is_longer is a list of bool
          __UpperCamelCase  		=						[[longer] for longer in is_longer]

          __UpperCamelCase  		=						{'''input_features''': input_mel, '''is_longer''': is_longer}
          __UpperCamelCase  		=						BatchFeature(snake_case				)

          if return_tensors is not None:
              __UpperCamelCase  		=						input_features.convert_to_tensors(snake_case				)

          return input_features






