



"""simple docstring"""






from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


snake_case   					=				logging.get_logger(__name__)



class     UpperCAmelCase    (	__SCREAMING_SNAKE_CASE  ):
   A__		:	Any           =  ['''input_features''', '''attention_mask''']



   def __init__(       self    :	List[Any]							,       __lowerCamelCase    :	str=8_0							,       __lowerCamelCase    :	str=1_6_0_0_0							,       __lowerCamelCase    :	List[str]=8_0							,       __lowerCamelCase    :	Dict=0.0							,       __lowerCamelCase    :	int=True							,       __lowerCamelCase    :	Tuple=True							,       __lowerCamelCase    :	Tuple=True							,       **__lowerCamelCase    :	List[str]							,       ):



     """simple docstring"""
     super().__init__(feature_size=__lowerCamelCase							,       sampling_rate=__lowerCamelCase							,       padding_value=__lowerCamelCase							,       **__lowerCamelCase				)
     _snake_case   	=      num_mel_bins
     _snake_case   	=      do_ceptral_normalize
     _snake_case   	=      normalize_means
     _snake_case   	=      normalize_vars
     _snake_case   	=      True



   def    __UpperCAmelCase    (       self    :	Optional[int]							,       __lowerCamelCase    :	np.ndarray							,       ):



     """simple docstring"""
     _snake_case   	=      waveform * (2**1_5)  # Kaldi compliance: 16-bit signed integers
     _snake_case   	=      torch.from_numpy(__lowerCamelCase				).unsqueeze(0				)
     _snake_case   	=      ta_kaldi.fbank(__lowerCamelCase							,       num_mel_bins=self.num_mel_bins							,       sample_frequency=self.sampling_rate				)
     return features.numpy()



   @staticmethod
   def    __UpperCAmelCase    (       __lowerCamelCase    :	np.ndarray							,       __lowerCamelCase    :	int							,       __lowerCamelCase    :	Optional[bool] = True							,       __lowerCamelCase    :	Optional[bool] = True							,       __lowerCamelCase    :	float = 0.0							,       ):



     """simple docstring"""
     # make sure we normalize float32 arrays
     if normalize_means:
       _snake_case   	=      x[:input_length].mean(axis=0				)
       _snake_case   	=      np.subtract(__lowerCamelCase							,       __lowerCamelCase				)
     if normalize_vars:
       _snake_case   	=      x[:input_length].std(axis=0				)
       _snake_case   	=      np.divide(__lowerCamelCase							,       __lowerCamelCase				)

     if input_length < x.shape[0]:
       _snake_case   	=      padding_value

     # make sure array is in float32
     _snake_case   	=      x.astype(np.floataa				)

     return x



   def    __UpperCAmelCase    (       self    :	Tuple							,       __lowerCamelCase    :	List[np.ndarray]							,       __lowerCamelCase    :	Optional[np.ndarray] = None				):



     """simple docstring"""
     _snake_case   	=      attention_mask.sum(-1				) if attention_mask is not None else [x.shape[0] for x in input_features]
     return [
         self.utterance_cmvn(__lowerCamelCase							,       __lowerCamelCase							,       self.normalize_means							,       self.normalize_vars							,       self.padding_value				)
         for x, n in zip(__lowerCamelCase							,       __lowerCamelCase				)
     ]





   def __call__(       self    :	int							,       __lowerCamelCase    :	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]							,       __lowerCamelCase    :	Union[bool, str, PaddingStrategy] = False							,       __lowerCamelCase    :	Optional[int] = None							,       __lowerCamelCase    :	bool = False							,       __lowerCamelCase    :	Optional[int] = None							,       __lowerCamelCase    :	Optional[Union[str, TensorType]] = None							,       __lowerCamelCase    :	Optional[int] = None							,       __lowerCamelCase    :	Optional[bool] = None							,       **__lowerCamelCase    :	Dict							,       ):



     """simple docstring"""

     if sampling_rate is not None:
       if sampling_rate != self.sampling_rate:
         raise ValueError(
             f"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
             f""" {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with"""
             f""" {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.'''				)

     _snake_case   	=      isinstance(__lowerCamelCase							,       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}"""				)
     _snake_case   	=      is_batched_numpy or (
         isinstance(__lowerCamelCase							,       (list, tuple)				) and (isinstance(raw_speech[0]							,       (np.ndarray, tuple, list)				))
     )

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

     # always return batch
     if not is_batched:
       _snake_case   	=      [raw_speech]

     # extract fbank features
     _snake_case   	=      [self._extract_fbank_features(__lowerCamelCase				) for waveform in raw_speech]

     # convert into correct format for padding
     _snake_case   	=      BatchFeature({'''input_features''': features}				)

     _snake_case   	=      self.pad(
         __lowerCamelCase							,       padding=__lowerCamelCase							,       max_length=__lowerCamelCase							,       truncation=__lowerCamelCase							,       pad_to_multiple_of=__lowerCamelCase							,       return_attention_mask=__lowerCamelCase							,       **__lowerCamelCase							,       )

     # make sure list is in array format
     _snake_case   	=      padded_inputs.get('''input_features'''				)
     if isinstance(input_features[0]							,       __lowerCamelCase				):
       _snake_case   	=      [np.asarray(__lowerCamelCase							,       dtype=np.floataa				) for feature in input_features]

     _snake_case   	=      padded_inputs.get('''attention_mask'''				)
     if attention_mask is not None:
       _snake_case   	=      [np.asarray(__lowerCamelCase							,       dtype=np.intaa				) for array in attention_mask]

     # Utterance-level cepstral mean and variance normalization
     if self.do_ceptral_normalize:
       _snake_case   	=      (
           np.array(__lowerCamelCase							,       dtype=np.intaa				)
           if self._get_padding_strategies(__lowerCamelCase							,       max_length=__lowerCamelCase				) is not PaddingStrategy.DO_NOT_PAD
           else None
       )
       _snake_case   	=      self.normalize(
           padded_inputs['''input_features''']							,       attention_mask=__lowerCamelCase				)

     if return_tensors is not None:
       _snake_case   	=      padded_inputs.convert_to_tensors(__lowerCamelCase				)

     return padded_inputs






"""simple docstring"""






import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

__lowerCAmelCase       :			List[str]   	=[
    """cross_validation.py""",
    """gradient_accumulation.py""",
    """local_sgd.py""",
    """multi_process_metrics.py""",
    """memory.py""",
    """automatic_gradient_accumulation.py""",
    """fsdp_with_peak_mem_tracking.py""",
    """deepspeed_with_config_support.py""",
    """megatron_lm_gpt_pretraining.py""",
]





class 					_A		(			unittest.TestCase      ):

      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase = None						,			__lowerCAmelCase = None		):







            """simple docstring"""



            lowercase								=      None
            lowercase								=      os.path.abspath(os.path.join("""examples"""						,			"""by_feature"""		)		)
            lowercase								=      os.path.abspath("""examples"""		)
            for item in os.listdir(__lowerCAmelCase		):
                  if item not in EXCLUDE_EXAMPLES:
                        lowercase								=      os.path.join(__lowerCAmelCase						,			__lowerCAmelCase		)
                        if os.path.isfile(__lowerCAmelCase		) and ".py" in item_path:
                              with self.subTest(
                                  tested_script=__lowerCAmelCase						,			feature_script=__lowerCAmelCase						,			tested_section="""main()""" if parser_only else """training_function()"""						,			):
                                    lowercase								=      compare_against_test(
                                        os.path.join(__lowerCAmelCase						,			__lowerCAmelCase		)						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)
                                    lowercase								=      """\n""".join(__lowerCAmelCase		)
                                    if special_strings is not None:
                                          for string in special_strings:
                                                lowercase								=      diff.replace(__lowerCAmelCase						,			""""""		)
                                    self.assertEqual(__lowerCAmelCase						,			""""""		)

      def 							A__			(		self		):







            """simple docstring"""



            self.one_complete_example("""complete_nlp_example.py"""						,			__lowerCAmelCase		)
            self.one_complete_example("""complete_nlp_example.py"""						,			__lowerCAmelCase		)







      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      os.path.abspath(os.path.join("""examples"""						,			"""cv_example.py"""		)		)
            lowercase								=      [
                """ """ * 16 + """{\n\n""",
                """ """ * 20 + """\"accuracy\": eval_metric[\"accuracy\"],\n\n""",
                """ """ * 20 + """\"f1\": eval_metric[\"f1\"],\n\n""",
                """ """ * 20 + """\"train_loss\": total_loss.item() / len(train_dataloader),\n\n""",
                """ """ * 20 + """\"epoch\": epoch,\n\n""",
                """ """ * 16 + """},\n\n""",
                """ """ * 16 + """step=epoch,\n""",
                """ """ * 12,
                """ """ * 8 + """for step, batch in enumerate(active_dataloader):\n""",
            ]
            self.one_complete_example("""complete_cv_example.py"""						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)
            self.one_complete_example("""complete_cv_example.py"""						,			__lowerCAmelCase						,			__lowerCAmelCase						,			__lowerCAmelCase		)






@mock.patch.dict(os.environ    ,       {'TESTING_MOCKED_DATALOADERS': '1'}      )
class 					_A		(			lowerCAmelCase      ):
      snake_case__     :  Any				    =      False

      @classmethod
      def 							A__			(		cls		):







            """simple docstring"""



            super().setUpClass()
            lowercase								=      tempfile.mkdtemp()
            lowercase								=      os.path.join(cls._tmpdir						,			"""default_config.yml"""		)

            write_basic_config(save_location=cls.configPath		)
            lowercase								=      ["""accelerate""", """launch""", """--config_file""", cls.configPath]

      @classmethod
      def 							A__			(		cls		):







            """simple docstring"""



            super().tearDownClass()
            shutil.rmtree(cls._tmpdir		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps epoch\n        --output_dir {self.tmpdir}\n        '.split()
            run_command(self._launch_args + testargs		)
            self.assertTrue(os.path.exists(os.path.join(self.tmpdir						,			"""epoch_0"""		)		)		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      f'\n        examples/by_feature/checkpointing.py\n        --checkpointing_steps 1\n        --output_dir {self.tmpdir}\n        '.split()
            lowercase								=      run_command(self._launch_args + testargs		)
            self.assertTrue(os.path.exists(os.path.join(self.tmpdir						,			"""step_2"""		)		)		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir						,			"epoch_0"		)}\n        '.split()
            lowercase								=      run_command(self._launch_args + testargs						,			return_stdout=__lowerCAmelCase		)
            self.assertNotIn("""epoch 0:"""						,			__lowerCAmelCase		)
            self.assertIn("""epoch 1:"""						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      f'\n        examples/by_feature/checkpointing.py\n        --resume_from_checkpoint {os.path.join(self.tmpdir						,			"step_2"		)}\n        '.split()
            lowercase								=      run_command(self._launch_args + testargs						,			return_stdout=__lowerCAmelCase		)
            if torch.cuda.is_available():
                  lowercase								=      torch.cuda.device_count()
            else:
                  lowercase								=      1
            if num_processes > 1:
                  self.assertNotIn("""epoch 0:"""						,			__lowerCAmelCase		)
                  self.assertIn("""epoch 1:"""						,			__lowerCAmelCase		)
            else:
                  self.assertIn("""epoch 0:"""						,			__lowerCAmelCase		)
                  self.assertIn("""epoch 1:"""						,			__lowerCAmelCase		)

      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      """
        examples/by_feature/cross_validation.py
        --num_folds 2
        """.split()
            with mock.patch.dict(os.environ						,			{"""TESTING_MOCKED_DATALOADERS""": """0"""}		):
                  lowercase								=      run_command(self._launch_args + testargs						,			return_stdout=__lowerCAmelCase		)
                  lowercase								=      re.findall("""({.+})"""						,			__lowerCAmelCase		)
                  lowercase								=      [r for r in results if """accuracy""" in r][-1]
                  lowercase								=      ast.literal_eval(__lowerCAmelCase		)
                  self.assertGreaterEqual(results["""accuracy"""]						,			0.7_5		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ["""examples/by_feature/multi_process_metrics.py"""]
            run_command(self._launch_args + testargs		)

      @require_trackers
      @mock.patch.dict(os.environ						,			{"""WANDB_MODE""": """offline"""}		)
      def 							A__			(		self		):







            """simple docstring"""



            with tempfile.TemporaryDirectory() as tmpdir:
                  lowercase								=      f'\n            examples/by_feature/tracking.py\n            --with_tracking\n            --project_dir {tmpdir}\n            '.split()
                  run_command(self._launch_args + testargs		)
                  self.assertTrue(os.path.exists(os.path.join(__lowerCAmelCase						,			"""tracking"""		)		)		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ["""examples/by_feature/gradient_accumulation.py"""]
            run_command(self._launch_args + testargs		)







      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      ["""examples/by_feature/local_sgd.py"""]
            run_command(self._launch_args + testargs		)



