




import argparse
import json

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    VideoMAEConfig,
    VideoMAEForPreTraining,
    VideoMAEForVideoClassification,
    VideoMAEImageProcessor,
)






def  snake_case(    __magic_name__   )			->							int:





     '''simple docstring'''


     lowercase :       List[Any]       =			VideoMAEConfig()

     set_architecture_configs(__magic_name__			,		__magic_name__   )

     if "finetuned" not in model_name:
          lowercase :       Tuple       =			False

     if "finetuned" in model_name:
          lowercase :       List[str]       =			'''huggingface/label-files'''
          if "kinetics" in model_name:
               lowercase :       List[str]       =			4_00
               lowercase :       Optional[Any]       =			'''kinetics400-id2label.json'''
          elif "ssv2" in model_name:
               lowercase :       List[Any]       =			1_74
               lowercase :       Dict       =			'''something-something-v2-id2label.json'''
          else:
               raise ValueError('''Model name should either contain \'kinetics\' or \'ssv2\' in case it\'s fine-tuned.'''   )
          lowercase :       Dict       =			json.load(open(hf_hub_download(__magic_name__			,		__magic_name__			,		repo_type='''dataset'''   )			,		'''r'''   )   )
          lowercase :       Union[str, Any]       =			{int(__magic_name__   ): v for k, v in idalabel.items()}
          lowercase :       Optional[int]       =			idalabel
          lowercase :       Any       =			{v: k for k, v in idalabel.items()}

     return config






def  snake_case(    __magic_name__			,		__magic_name__   )			->							Tuple:





     '''simple docstring'''


     if "small" in model_name:
          lowercase :       List[str]       =			3_84
          lowercase :       Union[str, Any]       =			15_36
          lowercase :       List[str]       =			12
          lowercase :       Tuple       =			16
          lowercase :       List[Any]       =			12
          lowercase :       Optional[Any]       =			3
          lowercase :       Tuple       =			1_92
          lowercase :       str       =			7_68
     elif "large" in model_name:
          lowercase :       Tuple       =			10_24
          lowercase :       Any       =			40_96
          lowercase :       List[str]       =			24
          lowercase :       int       =			16
          lowercase :       Any       =			12
          lowercase :       str       =			8
          lowercase :       int       =			5_12
          lowercase :       List[str]       =			20_48
     elif "huge" in model_name:
          lowercase :       Any       =			12_80
          lowercase :       Any       =			51_20
          lowercase :       Dict       =			32
          lowercase :       Union[str, Any]       =			16
          lowercase :       Optional[Any]       =			12
          lowercase :       Tuple       =			8
          lowercase :       List[str]       =			6_40
          lowercase :       Union[str, Any]       =			25_60
     elif "base" not in model_name:
          raise ValueError('''Model name should include either "small", "base", "large", or "huge"'''   )






def  snake_case(    __magic_name__   )			->							Union[str, Any]:





     '''simple docstring'''


     if "encoder." in name:
          lowercase :       Any       =			name.replace('''encoder.'''			,		''''''   )
     if "cls_token" in name:
          lowercase :       str       =			name.replace('''cls_token'''			,		'''videomae.embeddings.cls_token'''   )
     if "decoder_pos_embed" in name:
          lowercase :       Dict       =			name.replace('''decoder_pos_embed'''			,		'''decoder.decoder_pos_embed'''   )
     if "pos_embed" in name and "decoder" not in name:
          lowercase :       str       =			name.replace('''pos_embed'''			,		'''videomae.embeddings.position_embeddings'''   )
     if "patch_embed.proj" in name:
          lowercase :       str       =			name.replace('''patch_embed.proj'''			,		'''videomae.embeddings.patch_embeddings.projection'''   )
     if "patch_embed.norm" in name:
          lowercase :       Any       =			name.replace('''patch_embed.norm'''			,		'''videomae.embeddings.norm'''   )
     if "decoder.blocks" in name:
          lowercase :       Dict       =			name.replace('''decoder.blocks'''			,		'''decoder.decoder_layers'''   )
     if "blocks" in name:
          lowercase :       Dict       =			name.replace('''blocks'''			,		'''videomae.encoder.layer'''   )
     if "attn.proj" in name:
          lowercase :       Union[str, Any]       =			name.replace('''attn.proj'''			,		'''attention.output.dense'''   )
     if "attn" in name and "bias" not in name:
          lowercase :       Union[str, Any]       =			name.replace('''attn'''			,		'''attention.self'''   )
     if "attn" in name:
          lowercase :       str       =			name.replace('''attn'''			,		'''attention.attention'''   )
     if "norm1" in name:
          lowercase :       List[Any]       =			name.replace('''norm1'''			,		'''layernorm_before'''   )
     if "norm2" in name:
          lowercase :       Optional[int]       =			name.replace('''norm2'''			,		'''layernorm_after'''   )
     if "mlp.fc1" in name:
          lowercase :       str       =			name.replace('''mlp.fc1'''			,		'''intermediate.dense'''   )
     if "mlp.fc2" in name:
          lowercase :       Dict       =			name.replace('''mlp.fc2'''			,		'''output.dense'''   )
     if "decoder_embed" in name:
          lowercase :       Tuple       =			name.replace('''decoder_embed'''			,		'''decoder.decoder_embed'''   )
     if "decoder_norm" in name:
          lowercase :       str       =			name.replace('''decoder_norm'''			,		'''decoder.decoder_norm'''   )
     if "decoder_pred" in name:
          lowercase :       List[str]       =			name.replace('''decoder_pred'''			,		'''decoder.decoder_pred'''   )
     if "norm.weight" in name and "decoder" not in name and "fc" not in name:
          lowercase :       Union[str, Any]       =			name.replace('''norm.weight'''			,		'''videomae.layernorm.weight'''   )
     if "norm.bias" in name and "decoder" not in name and "fc" not in name:
          lowercase :       List[Any]       =			name.replace('''norm.bias'''			,		'''videomae.layernorm.bias'''   )
     if "head" in name and "decoder" not in name:
          lowercase :       Tuple       =			name.replace('''head'''			,		'''classifier'''   )

     return name






def  snake_case(    __magic_name__			,		__magic_name__   )			->							Optional[Any]:





     '''simple docstring'''


     for key in orig_state_dict.copy().keys():
          lowercase :       int       =			orig_state_dict.pop(__magic_name__   )

          if key.startswith('''encoder.'''   ):
               lowercase :       Optional[int]       =			key.replace('''encoder.'''			,		''''''   )

          if "qkv" in key:
               lowercase :       List[Any]       =			key.split('''.'''   )
               if key.startswith('''decoder.blocks'''   ):
                    lowercase :       str       =			config.decoder_hidden_size
                    lowercase :       Any       =			int(key_split[2]   )
                    lowercase :       Optional[int]       =			'''decoder.decoder_layers.'''
                    if "weight" in key:
                         lowercase :       int       =			val[:dim, :]
                         lowercase :       Optional[Any]       =			val[dim : dim * 2, :]
                         lowercase :       Tuple       =			val[-dim:, :]
               else:
                    lowercase :       Union[str, Any]       =			config.hidden_size
                    lowercase :       List[Any]       =			int(key_split[1]   )
                    lowercase :       Union[str, Any]       =			'''videomae.encoder.layer.'''
                    if "weight" in key:
                         lowercase :       List[Any]       =			val[:dim, :]
                         lowercase :       List[str]       =			val[dim : dim * 2, :]
                         lowercase :       Dict       =			val[-dim:, :]
          else:
               lowercase :       Any       =			val

     return orig_state_dict






def  snake_case(    )			->							List[str]:





     '''simple docstring'''


     lowercase :       List[Any]       =			hf_hub_download(
         repo_id='''hf-internal-testing/spaghetti-video'''			,		filename='''eating_spaghetti.npy'''			,		repo_type='''dataset'''   )
     lowercase :       Dict       =			np.load(__magic_name__   )
     return list(__magic_name__   )






def  snake_case(    __magic_name__			,		__magic_name__			,		__magic_name__			,		__magic_name__   )			->							Optional[int]:





     '''simple docstring'''


     lowercase :       Any       =			get_videomae_config(__magic_name__   )

     if "finetuned" in model_name:
          lowercase :       Union[str, Any]       =			VideoMAEForVideoClassification(__magic_name__   )
     else:
          lowercase :       Any       =			VideoMAEForPreTraining(__magic_name__   )

     # download original checkpoint, hosted on Google Drive
     lowercase :       Optional[Any]       =			'''pytorch_model.bin'''
     gdown.cached_download(__magic_name__			,		__magic_name__			,		quiet=__magic_name__   )
     lowercase :       str       =			torch.load(__magic_name__			,		map_location='''cpu'''   )
     if "model" in files:
          lowercase :       Union[str, Any]       =			files['''model''']
     else:
          lowercase :       Optional[Any]       =			files['''module''']
     lowercase :       List[str]       =			convert_state_dict(__magic_name__			,		__magic_name__   )

     model.load_state_dict(__magic_name__   )
     model.eval()

     # verify model on basic input
     lowercase :       Any       =			VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]			,		image_std=[0.5, 0.5, 0.5]   )
     lowercase :       Optional[Any]       =			prepare_video()
     lowercase :       Dict       =			image_processor(__magic_name__			,		return_tensors='''pt'''   )

     if "finetuned" not in model_name:
          lowercase :       int       =			hf_hub_download(repo_id='''hf-internal-testing/bool-masked-pos'''			,		filename='''bool_masked_pos.pt'''   )
          lowercase :       Union[str, Any]       =			torch.load(__magic_name__   )

     lowercase :       Optional[int]       =			model(**__magic_name__   )
     lowercase :       Any       =			outputs.logits

     lowercase :       Tuple       =			[
         '''videomae-small-finetuned-kinetics''',
         '''videomae-small-finetuned-ssv2''',
         # Kinetics-400 checkpoints (short = pretrained only for 800 epochs instead of 1600)
         '''videomae-base-short''',
         '''videomae-base-short-finetuned-kinetics''',
         '''videomae-base''',
         '''videomae-base-finetuned-kinetics''',
         '''videomae-large''',
         '''videomae-large-finetuned-kinetics''',
         '''videomae-huge-finetuned-kinetics''',
         # Something-Something-v2 checkpoints (short = pretrained only for 800 epochs instead of 2400)
         '''videomae-base-short-ssv2''',
         '''videomae-base-short-finetuned-ssv2''',
         '''videomae-base-ssv2''',
         '''videomae-base-finetuned-ssv2''',
     ]

     # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
     if model_name == "videomae-small-finetuned-kinetics":
          lowercase :       Union[str, Any]       =			torch.Size([1, 4_00]   )
          lowercase :       List[Any]       =			torch.tensor([-0.9_2_9_1, -0.4_0_6_1, -0.9_3_0_7]   )
     elif model_name == "videomae-small-finetuned-ssv2":
          lowercase :       List[str]       =			torch.Size([1, 1_74]   )
          lowercase :       int       =			torch.tensor([0.2_6_7_1, -0.4_6_8_9, -0.8_2_3_5]   )
     elif model_name == "videomae-base":
          lowercase :       Dict       =			torch.Size([1, 14_08, 15_36]   )
          lowercase :       Union[str, Any]       =			torch.tensor([[0.7_7_3_9, 0.7_9_6_8, 0.7_0_8_9], [0.6_7_0_1, 0.7_4_8_7, 0.6_2_0_9], [0.4_2_8_7, 0.5_1_5_8, 0.4_7_7_3]]   )
     elif model_name == "videomae-base-short":
          lowercase :       int       =			torch.Size([1, 14_08, 15_36]   )
          lowercase :       int       =			torch.tensor([[0.7_9_9_4, 0.9_6_1_2, 0.8_5_0_8], [0.7_4_0_1, 0.8_9_5_8, 0.8_3_0_2], [0.5_8_6_2, 0.7_4_6_8, 0.7_3_2_5]]   )
          # we verified the loss both for normalized and unnormalized targets for this one
          lowercase :       str       =			torch.tensor([0.5_1_4_2]   ) if config.norm_pix_loss else torch.tensor([0.6_4_6_9]   )
     elif model_name == "videomae-large":
          lowercase :       str       =			torch.Size([1, 14_08, 15_36]   )
          lowercase :       Optional[Any]       =			torch.tensor([[0.7_1_4_9, 0.7_9_9_7, 0.6_9_6_6], [0.6_7_6_8, 0.7_8_6_9, 0.6_9_4_8], [0.5_1_3_9, 0.6_2_2_1, 0.5_6_0_5]]   )
     elif model_name == "videomae-large-finetuned-kinetics":
          lowercase :       Tuple       =			torch.Size([1, 4_00]   )
          lowercase :       Optional[int]       =			torch.tensor([0.0_7_7_1, 0.0_0_1_1, -0.3_6_2_5]   )
     elif model_name == "videomae-huge-finetuned-kinetics":
          lowercase :       Optional[int]       =			torch.Size([1, 4_00]   )
          lowercase :       List[Any]       =			torch.tensor([0.2_4_3_3, 0.1_6_3_2, -0.4_8_9_4]   )
     elif model_name == "videomae-base-short-finetuned-kinetics":
          lowercase :       Any       =			torch.Size([1, 4_00]   )
          lowercase :       List[str]       =			torch.tensor([0.6_5_8_8, 0.0_9_9_0, -0.2_4_9_3]   )
     elif model_name == "videomae-base-finetuned-kinetics":
          lowercase :       str       =			torch.Size([1, 4_00]   )
          lowercase :       int       =			torch.tensor([0.3_6_6_9, -0.0_6_8_8, -0.2_4_2_1]   )
     elif model_name == "videomae-base-short-ssv2":
          lowercase :       str       =			torch.Size([1, 14_08, 15_36]   )
          lowercase :       List[str]       =			torch.tensor([[0.4_7_1_2, 0.5_2_9_6, 0.5_7_8_6], [0.2_2_7_8, 0.2_7_2_9, 0.4_0_2_6], [0.0_3_5_2, 0.0_7_3_0, 0.2_5_0_6]]   )
     elif model_name == "videomae-base-short-finetuned-ssv2":
          lowercase :       Tuple       =			torch.Size([1, 1_74]   )
          lowercase :       int       =			torch.tensor([-0.0_5_3_7, -0.1_5_3_9, -0.3_2_6_6]   )
     elif model_name == "videomae-base-ssv2":
          lowercase :       Optional[int]       =			torch.Size([1, 14_08, 15_36]   )
          lowercase :       Any       =			torch.tensor([[0.8_1_3_1, 0.8_7_2_7, 0.8_5_4_6], [0.7_3_6_6, 0.9_3_7_7, 0.8_8_7_0], [0.5_9_3_5, 0.8_8_7_4, 0.8_5_6_4]]   )
     elif model_name == "videomae-base-finetuned-ssv2":
          lowercase :       Dict       =			torch.Size([1, 1_74]   )
          lowercase :       Optional[Any]       =			torch.tensor([0.1_9_6_1, -0.8_3_3_7, -0.6_3_8_9]   )
     else:
          raise ValueError(F"""Model name not supported. Should be one of {model_names}"""   )

     # verify logits
     assert logits.shape == expected_shape
     if "finetuned" in model_name:
          assert torch.allclose(logits[0, :3]			,		__magic_name__			,		atol=1e-4   )
     else:
          print('''Logits:'''			,		logits[0, :3, :3]   )
          assert torch.allclose(logits[0, :3, :3]			,		__magic_name__			,		atol=1e-4   )
     print('''Logits ok!'''   )

     # verify loss, if applicable
     if model_name == "videomae-base-short":
          lowercase :       Any       =			outputs.loss
          assert torch.allclose(__magic_name__			,		__magic_name__			,		atol=1e-4   )
          print('''Loss ok!'''   )

     if pytorch_dump_folder_path is not None:
          print(F"""Saving model and image processor to {pytorch_dump_folder_path}"""   )
          image_processor.save_pretrained(__magic_name__   )
          model.save_pretrained(__magic_name__   )

     if push_to_hub:
          print('''Pushing to the hub...'''   )
          model.push_to_hub(__magic_name__			,		organization='''nielsr'''   )


if __name__ == "__main__":
 lowerCAmelCase_						=			argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--checkpoint_url',
     default='https://drive.google.com/u/1/uc?id=1tEhLyskjb755TJ65ptsrafUG2llSwQE1&amp;export=download&amp;confirm=t&amp;uuid=aa3276eb-fb7e-482a-adec-dc7171df14c4',
     type=str,
     help=(
         'URL of the original PyTorch checkpoint (on Google Drive) you\'d like to convert. Should be a direct'
         ' download link.'
     ),
 )
 parser.add_argument(
     '--pytorch_dump_folder_path',
     default='/Users/nielsrogge/Documents/VideoMAE/Test',
     type=str,
     help='Path to the output PyTorch model directory.',
 )
 parser.add_argument('--model_name', default='videomae-base', type=str, help='Name of the model.')
 parser.add_argument(
     '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
 )

 lowerCAmelCase_						=			parser.parse_args()
 convert_videomae_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)





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

import numpy as np

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


lowerCAmelCase_						=			logging.get_logger(__name__)
class 						_A (  _lowerCamelCase				):
  _UpperCamelCase       :      str			=      ['''input_values''', '''attention_mask''']






  def __init__(  self		:     Optional[Any]				,						_A		:     int = 1				,						_A		:     int = 16_000				,						_A		:     float = 0.0				,						_A		:     bool = False				,						_A		:     int = 80				,						_A		:     int = 16				,						_A		:     int = 64				,						_A		:     str = "hann_window"				,						_A		:     float = 1.0				,						_A		:     float = 80				,						_A		:     float = 7_600				,						_A		:     float = 1E-10				,						_A		:     int = 2				,						_A		:     bool = True				,						**_A		:     int				,						)		->   Union[str, Any]:






       """simple docstring"""







       super().__init__(feature_size=_A				,						sampling_rate=_A				,						padding_value=_A				,						**_A				)
       lowercase :       str       =			do_normalize
       lowercase :       int       =			return_attention_mask

       lowercase :       Union[str, Any]       =			num_mel_bins
       lowercase :       Union[str, Any]       =			hop_length
       lowercase :       Dict       =			win_length
       lowercase :       Union[str, Any]       =			win_function
       lowercase :       int       =			frame_signal_scale
       lowercase :       Dict       =			fmin
       lowercase :       Optional[Any]       =			fmax
       lowercase :       str       =			mel_floor
       lowercase :       Dict       =			reduction_factor

       lowercase :       List[Any]       =			win_length * sampling_rate // 1_000
       lowercase :       Union[str, Any]       =			hop_length * sampling_rate // 1_000
       lowercase :       Optional[Any]       =			optimal_fft_length(self.sample_size				)
       lowercase :       Dict       =			(self.n_fft // 2) + 1

       lowercase :       Any       =			window_function(window_length=self.sample_size				,						name=self.win_function				,						periodic=_A				)

       lowercase :       Dict       =			mel_filter_bank(
           num_frequency_bins=self.n_freqs				,						num_mel_filters=self.num_mel_bins				,						min_frequency=self.fmin				,						max_frequency=self.fmax				,						sampling_rate=self.sampling_rate				,						norm='''slaney'''				,						mel_scale='''slaney'''				,						)

       if frame_signal_scale != 1.0:
            warnings.warn(
                '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)
       if reduction_factor != 2.0:
            warnings.warn(
                '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)






  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def  __a      (  _A		:     List[np.ndarray]				,						_A		:     List[np.ndarray]				,						_A		:     float = 0.0				)		->   List[np.ndarray]:






       """simple docstring"""







       if attention_mask is not None:
            lowercase :       Optional[int]       =			np.array(_A				,						np.intaa				)
            lowercase :       Dict       =			[]

            for vector, length in zip(_A				,						attention_mask.sum(-1				)				):
                 lowercase :       Dict       =			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7				)
                 if length < normed_slice.shape[0]:
                      lowercase :       List[str]       =			padding_value

                 normed_input_values.append(_A				)
       else:
            lowercase :       Dict       =			[(x - x.mean()) / np.sqrt(x.var() + 1E-7				) for x in input_values]

       return normed_input_values






  def  __a      (  self		:     Any				,						_A		:     np.ndarray				,						)		->   np.ndarray:






       """simple docstring"""







       lowercase :       Tuple       =			spectrogram(
           _A				,						window=self.window				,						frame_length=self.sample_size				,						hop_length=self.sample_stride				,						fft_length=self.n_fft				,						mel_filters=self.mel_filters				,						mel_floor=self.mel_floor				,						log_mel='''log10'''				,						)
       return log_mel_spec.T






  def __call__(  self		:     List[Any]				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						_A		:     Optional[int] = None				,						**_A		:     Tuple				,						)		->   BatchFeature:






       """simple docstring"""







       if audio is None and audio_target is None:
            raise ValueError('''You must provide either `audio` or `audio_target` values.'''				)

       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 audio 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.'''				)

       if audio is not None:
            lowercase :       Any       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)
       else:
            lowercase :       Any       =			None

       if audio_target is not None:
            lowercase :       Tuple       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)

            if inputs is None:
                 return inputs_target
            else:
                 lowercase :       Any       =			inputs_target['''input_values''']
                 lowercase :       Dict       =			inputs_target.get('''attention_mask'''				)
                 if decoder_attention_mask is not None:
                      lowercase :       Union[str, Any]       =			decoder_attention_mask

       return inputs






  def  __a      (  self		:     List[Any]				,						_A		:     Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,						_A		:     bool = False				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						**_A		:     Any				,						)		->   BatchFeature:






       """simple docstring"""







       lowercase :       Optional[int]       =			isinstance(_A				,						np.ndarray				) and len(speech.shape				) > 1
       if is_batched_numpy and len(speech.shape				) > 2:
            raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""				)
       lowercase :       int       =			is_batched_numpy or (
           isinstance(_A				,						(list, tuple)				) and (isinstance(speech[0]				,						(np.ndarray, tuple, list)				))
       )

       if is_batched:
            lowercase :       Optional[int]       =			[np.asarray(_A				,						dtype=np.floataa				) for speech in speech]
       elif not is_batched and not isinstance(_A				,						np.ndarray				):
            lowercase :       List[str]       =			np.asarray(_A				,						dtype=np.floataa				)
       elif isinstance(_A				,						np.ndarray				) and speech.dtype is np.dtype(np.floataa				):
            lowercase :       List[str]       =			speech.astype(np.floataa				)

       # always return batch
       if not is_batched:
            lowercase :       Union[str, Any]       =			[speech]

       # needed to make pad() work on spectrogram inputs
       lowercase :       Any       =			self.feature_size

       # convert into correct format for padding
       if is_target:
            lowercase :       int       =			[self._extract_mel_features(_A				) for waveform in speech]
            lowercase :       Any       =			BatchFeature({'''input_values''': features}				)
            lowercase :       Optional[Any]       =			self.num_mel_bins
       else:
            lowercase :       Optional[Any]       =			BatchFeature({'''input_values''': speech}				)

       lowercase :       Optional[int]       =			self.pad(
           _A				,						padding=_A				,						max_length=_A				,						truncation=_A				,						pad_to_multiple_of=_A				,						return_attention_mask=_A				,						**_A				,						)

       lowercase :       str       =			feature_size_hack

       # convert input values to correct format
       lowercase :       List[Any]       =			padded_inputs['''input_values''']
       if not isinstance(input_values[0]				,						np.ndarray				):
            lowercase :       List[str]       =			[np.asarray(_A				,						dtype=np.floataa				) for array in input_values]
       elif (
           not isinstance(_A				,						np.ndarray				)
           and isinstance(input_values[0]				,						np.ndarray				)
           and input_values[0].dtype is np.dtype(np.floataa				)
       ):
            lowercase :       List[str]       =			[array.astype(np.floataa				) for array in input_values]
       elif isinstance(_A				,						np.ndarray				) and input_values.dtype is np.dtype(np.floataa				):
            lowercase :       Optional[Any]       =			input_values.astype(np.floataa				)

       # convert attention_mask to correct format
       lowercase :       int       =			padded_inputs.get('''attention_mask'''				)
       if attention_mask is not None:
            lowercase :       Union[str, Any]       =			[np.asarray(_A				,						dtype=np.intaa				) for array in attention_mask]

       # zero-mean and unit-variance normalization
       if not is_target and self.do_normalize:
            lowercase :       Any       =			(
                attention_mask
                if self._get_padding_strategies(_A				,						max_length=_A				) is not PaddingStrategy.DO_NOT_PAD
                else None
            )
            lowercase :       Optional[int]       =			self.zero_mean_unit_var_norm(
                padded_inputs['''input_values''']				,						attention_mask=_A				,						padding_value=self.padding_value				)

       if return_tensors is not None:
            lowercase :       Tuple       =			padded_inputs.convert_to_tensors(_A				)

       return padded_inputs






  def  __a      (  self		:     Optional[Any]				)		->   Dict[str, Any]:






       """simple docstring"""







       lowercase :       Optional[Any]       =			super().to_dict()

       # Don't serialize these as they are derived from the other properties.
       lowercase :       Optional[int]       =			['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
       for name in names:
            if name in output:
                 del output[name]

       return output