






"""simple docstring"""



import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
						from transformers import LlamaTokenizerFast
except ImportError as e:
						warnings.warn(e)
						warnings.warn(
						    '''The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'''
						)
						A_    =							None
A_    =							{
    '''7B''': 1_1008,
    '''13B''': 1_3824,
    '''30B''': 1_7920,
    '''65B''': 2_2016,
    '''70B''': 2_8672,
}
A_    =							{
    '''7B''': 1,
    '''7Bf''': 1,
    '''13B''': 2,
    '''13Bf''': 2,
    '''30B''': 4,
    '''65B''': 8,
    '''70B''': 8,
    '''70Bf''': 8,
}




def      _lowerCAmelCase		(							UpperCAmelCase__       :					Any,						UpperCAmelCase__       :					List[Any]=1,						UpperCAmelCase__       :					Dict=2_5_6      )		->Optional[Any]:
						return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3      )      ) + multiple_of - 1) // multiple_of)




def      _lowerCAmelCase		(							UpperCAmelCase__       :					int      )		->Optional[Any]:
						with open(UpperCAmelCase__,						"""r"""      ) as f:
												return json.load(UpperCAmelCase__      )




def      _lowerCAmelCase		(							UpperCAmelCase__       :					Optional[int],						UpperCAmelCase__       :					int      )		->List[str]:
						with open(UpperCAmelCase__,						"""w"""      ) as f:
												json.dump(UpperCAmelCase__,						UpperCAmelCase__      )




def      _lowerCAmelCase		(							UpperCAmelCase__       :					Tuple,						UpperCAmelCase__       :					Dict,						UpperCAmelCase__       :					str,						UpperCAmelCase__       :					Optional[int]=True      )		->Optional[Any]:
						os.makedirs(UpperCAmelCase__,						exist_ok=UpperCAmelCase__      )
						A__						:  Tuple		  =  os.path.join(UpperCAmelCase__,						"""tmp"""      )
						os.makedirs(UpperCAmelCase__,						exist_ok=UpperCAmelCase__      )

						A__						:  Optional[Any]		  =  read_json(os.path.join(UpperCAmelCase__,						"""params.json"""      )      )
						A__						:  Optional[Any]		  =  NUM_SHARDS[model_size]
						A__						:  int		  =  params["""n_layers"""]
						A__						:  Tuple		  =  params["""n_heads"""]
						A__						:  List[Any]		  =  n_heads // num_shards
						A__						:  int		  =  params["""dim"""]
						A__						:  Optional[int]		  =  dim // n_heads
						A__						:  List[str]		  =  1_0000.0
						A__						:  Union[str, Any]		  =  1.0 / (base ** (torch.arange(0,						UpperCAmelCase__,						2      ).float() / dims_per_head))

						if "n_kv_heads" in params:
												A__						:  Dict		  =  params["""n_kv_heads"""]  # for GQA / MQA
												A__						:  Optional[Any]		  =  n_heads_per_shard // num_key_value_heads
												A__						:  str		  =  dim // num_key_value_heads
						else:  # compatibility with other checkpoints
												A__						:  List[Any]		  =  n_heads
												A__						:  Tuple		  =  n_heads_per_shard
												A__						:  List[str]		  =  dim

						# permute for sliced rotary
						def permute(UpperCAmelCase__       :					Tuple,						UpperCAmelCase__       :					Optional[Any]=n_heads,						UpperCAmelCase__       :					Any=dim,						UpperCAmelCase__       :					Dict=dim      ):
												return w.view(UpperCAmelCase__,						dima // n_heads // 2,						2,						UpperCAmelCase__      ).transpose(1,						2      ).reshape(UpperCAmelCase__,						UpperCAmelCase__      )

						print(f'Fetching all parameters from the checkpoint at {input_base_path}.'      )
						# Load weights
						if model_size == "7B":
												# Not sharded
												# (The sharded implementation would also work, but this is simpler.)
												A__						:  Any		  =  torch.load(os.path.join(UpperCAmelCase__,						"""consolidated.00.pth"""      ),						map_location="""cpu"""      )
						else:
												# Sharded
												A__						:  Union[str, Any]		  =  [
												    torch.load(os.path.join(UpperCAmelCase__,						f'consolidated.{i:02d}.pth'      ),						map_location="""cpu"""      )
												    for i in range(UpperCAmelCase__      )
												]
						A__						:  int		  =  0
						A__						:  Any		  =  {"""weight_map""": {}}
						for layer_i in range(UpperCAmelCase__      ):
												A__						:  Any		  =  f'pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'
												if model_size == "7B":
																		# Unsharded
																		A__						:  Optional[Any]		  =  {
																		    f'model.layers.{layer_i}.self_attn.q_proj.weight': permute(
																		        loaded[f'layers.{layer_i}.attention.wq.weight']      ),
																		    f'model.layers.{layer_i}.self_attn.k_proj.weight': permute(
																		        loaded[f'layers.{layer_i}.attention.wk.weight']      ),
																		    f'model.layers.{layer_i}.self_attn.v_proj.weight': loaded[f'layers.{layer_i}.attention.wv.weight'],
																		    f'model.layers.{layer_i}.self_attn.o_proj.weight': loaded[f'layers.{layer_i}.attention.wo.weight'],
																		    f'model.layers.{layer_i}.mlp.gate_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w1.weight'],
																		    f'model.layers.{layer_i}.mlp.down_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w2.weight'],
																		    f'model.layers.{layer_i}.mlp.up_proj.weight': loaded[f'layers.{layer_i}.feed_forward.w3.weight'],
																		    f'model.layers.{layer_i}.input_layernorm.weight': loaded[f'layers.{layer_i}.attention_norm.weight'],
																		    f'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[f'layers.{layer_i}.ffn_norm.weight'],
																		}
												else:
																		# Sharded
																		# Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
																		# the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
																		# redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

																		A__						:  Optional[Any]		  =  {
																		    f'model.layers.{layer_i}.input_layernorm.weight': loaded[0][
																		        f'layers.{layer_i}.attention_norm.weight'
																		    ].clone(),
																		    f'model.layers.{layer_i}.post_attention_layernorm.weight': loaded[0][
																		        f'layers.{layer_i}.ffn_norm.weight'
																		    ].clone(),
																		}
																		A__						:  Optional[Any]		  =  permute(
																		    torch.cat(
																		        [
																		            loaded[i][f'layers.{layer_i}.attention.wq.weight'].view(UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__      )
																		            for i in range(UpperCAmelCase__      )
																		        ],						dim=0,						).reshape(UpperCAmelCase__,						UpperCAmelCase__      )      )
																		A__						:  Tuple		  =  permute(
																		    torch.cat(
																		        [
																		            loaded[i][f'layers.{layer_i}.attention.wk.weight'].view(
																		                UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__      )
																		            for i in range(UpperCAmelCase__      )
																		        ],						dim=0,						).reshape(UpperCAmelCase__,						UpperCAmelCase__      ),						UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__,						)
																		A__						:  List[Any]		  =  torch.cat(
																		    [
																		        loaded[i][f'layers.{layer_i}.attention.wv.weight'].view(
																		            UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__      )
																		        for i in range(UpperCAmelCase__      )
																		    ],						dim=0,						).reshape(UpperCAmelCase__,						UpperCAmelCase__      )

																		A__						:  str		  =  torch.cat(
																		    [loaded[i][f'layers.{layer_i}.attention.wo.weight'] for i in range(UpperCAmelCase__      )],						dim=1      )
																		A__						:  Tuple		  =  torch.cat(
																		    [loaded[i][f'layers.{layer_i}.feed_forward.w1.weight'] for i in range(UpperCAmelCase__      )],						dim=0      )
																		A__						:  Optional[int]		  =  torch.cat(
																		    [loaded[i][f'layers.{layer_i}.feed_forward.w2.weight'] for i in range(UpperCAmelCase__      )],						dim=1      )
																		A__						:  List[Any]		  =  torch.cat(
																		    [loaded[i][f'layers.{layer_i}.feed_forward.w3.weight'] for i in range(UpperCAmelCase__      )],						dim=0      )

												A__						:  Union[str, Any]		  =  inv_freq
												for k, v in state_dict.items():
																		A__						:  List[Any]		  =  filename
																		param_count += v.numel()
												torch.save(UpperCAmelCase__,						os.path.join(UpperCAmelCase__,						UpperCAmelCase__      )      )

						A__						:  Union[str, Any]		  =  f'pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'
						if model_size == "7B":
												# Unsharded
												A__						:  List[Any]		  =  {
												    """model.embed_tokens.weight""": loaded["""tok_embeddings.weight"""],
												    """model.norm.weight""": loaded["""norm.weight"""],
												    """lm_head.weight""": loaded["""output.weight"""],
												}
						else:
												A__						:  str		  =  {
												    """model.norm.weight""": loaded[0]["""norm.weight"""],
												    """model.embed_tokens.weight""": torch.cat(
												        [loaded[i]["""tok_embeddings.weight"""] for i in range(UpperCAmelCase__      )],						dim=1      ),
												    """lm_head.weight""": torch.cat([loaded[i]["""output.weight"""] for i in range(UpperCAmelCase__      )],						dim=0      ),
												}

						for k, v in state_dict.items():
												A__						:  Optional[int]		  =  filename
												param_count += v.numel()
						torch.save(UpperCAmelCase__,						os.path.join(UpperCAmelCase__,						UpperCAmelCase__      )      )

						# Write configs
						A__						:  List[Any]		  =  {"""total_size""": param_count * 2}
						write_json(UpperCAmelCase__,						os.path.join(UpperCAmelCase__,						"""pytorch_model.bin.index.json"""      )      )
						A__						:  List[Any]		  =  params["""ffn_dim_multiplier"""] if """ffn_dim_multiplier""" in params else 1
						A__						:  Union[str, Any]		  =  params["""multiple_of"""] if """multiple_of""" in params else 2_5_6
						A__						:  List[Any]		  =  LlamaConfig(
						    hidden_size=UpperCAmelCase__,						intermediate_size=compute_intermediate_size(UpperCAmelCase__,						UpperCAmelCase__,						UpperCAmelCase__      ),						num_attention_heads=params["""n_heads"""],						num_hidden_layers=params["""n_layers"""],						rms_norm_eps=params["""norm_eps"""],						num_key_value_heads=UpperCAmelCase__,						)
						config.save_pretrained(UpperCAmelCase__      )

						# Make space so we can load the model properly now.
						del state_dict
						del loaded
						gc.collect()

						print("""Loading the checkpoint in a Llama model."""      )
						A__						:  int		  =  LlamaForCausalLM.from_pretrained(UpperCAmelCase__,						torch_dtype=torch.floataa,						low_cpu_mem_usage=UpperCAmelCase__      )
						# Avoid saving this as part of the config.
						del model.config._name_or_path

						print("""Saving in the Transformers format."""      )
						model.save_pretrained(UpperCAmelCase__,						safe_serialization=UpperCAmelCase__      )
						shutil.rmtree(UpperCAmelCase__      )




def      _lowerCAmelCase		(							UpperCAmelCase__       :					List[Any],						UpperCAmelCase__       :					Union[str, Any]      )		->List[Any]:
						# Initialize the tokenizer based on the `spm` model
						A__						:  Optional[int]		  =  LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
						print(f'Saving a {tokenizer_class.__name__} to {tokenizer_path}.'      )
						A__						:  int		  =  tokenizer_class(UpperCAmelCase__      )
						tokenizer.save_pretrained(UpperCAmelCase__      )




def      _lowerCAmelCase		(							)		->Optional[int]:
						A__						:  Optional[Any]		  =  argparse.ArgumentParser()
						parser.add_argument(
						    """--input_dir""",						help="""Location of LLaMA weights, which contains tokenizer.model and model folders""",						)
						parser.add_argument(
						    """--model_size""",						choices=["""7B""", """7Bf""", """13B""", """13Bf""", """30B""", """65B""", """70B""", """70Bf""", """tokenizer_only"""],						)
						parser.add_argument(
						    """--output_dir""",						help="""Location to write HF model and tokenizer""",						)
						parser.add_argument("""--safe_serialization""",						type=UpperCAmelCase__,						help="""Whether or not to save using `safetensors`."""      )
						A__						:  int		  =  parser.parse_args()
						if args.model_size != "tokenizer_only":
												write_model(
												    model_path=args.output_dir,						input_base_path=os.path.join(args.input_dir,						args.model_size      ),						model_size=args.model_size,						safe_serialization=args.safe_serialization,						)
						A__						:  List[Any]		  =  os.path.join(args.input_dir,						"""tokenizer.model"""      )
						write_tokenizer(args.output_dir,						UpperCAmelCase__      )


if __name__ == "__main__":
						main()














"""simple docstring"""



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


A_    =							logging.get_logger(__name__)






class 							__SCREAMING_SNAKE_CASE						(				UpperCamelCase		):
							snake_case_     =							['input_values', 'attention_mask']


							def __init__(			self      :						Union[str, Any]			,    snake_case      :						int = 1			,    snake_case      :						int = 1_6000			,    snake_case      :						float = 0.0			,    snake_case      :						bool = False			,    snake_case      :						int = 80			,    snake_case      :						int = 16			,    snake_case      :						int = 64			,    snake_case      :						str = "hann_window"			,    snake_case      :						float = 1.0			,    snake_case      :						float = 80			,    snake_case      :						float = 7600			,    snake_case      :						float = 1e-10			,    snake_case      :						int = 2			,    snake_case      :						bool = True			,    **snake_case      :						Dict			,    ):
													'''simple docstring'''





													super().__init__(feature_size=snake_case			,    sampling_rate=snake_case			,    padding_value=snake_case			,    **snake_case							)
													A__						:  Optional[int]		  =  do_normalize
													A__						:  List[Any]		  =  return_attention_mask

													A__						:  Tuple		  =  num_mel_bins
													A__						:  Optional[int]		  =  hop_length
													A__						:  List[str]		  =  win_length
													A__						:  List[Any]		  =  win_function
													A__						:  Tuple		  =  frame_signal_scale
													A__						:  Optional[Any]		  =  fmin
													A__						:  str		  =  fmax
													A__						:  str		  =  mel_floor
													A__						:  Dict		  =  reduction_factor

													A__						:  int		  =  win_length * sampling_rate // 1000
													A__						:  Optional[Any]		  =  hop_length * sampling_rate // 1000
													A__						:  Optional[int]		  =  optimal_fft_length(self.sample_size							)
													A__						:  List[Any]		  =  (self.n_fft // 2) + 1

													A__						:  str		  =  window_function(window_length=self.sample_size			,    name=self.win_function			,    periodic=snake_case							)

													A__						:  Optional[Any]		  =  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"""			,    snake_case			,    )
													if reduction_factor != 2.0:
																			warnings.warn(
																			    """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"""			,    snake_case			,    )


							@staticmethod
							# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
							def 						_UpperCamelCase       (			snake_case      :						List[np.ndarray]			,    snake_case      :						List[np.ndarray]			,    snake_case      :						float = 0.0							):
													'''simple docstring'''





													if attention_mask is not None:
																			A__						:  Tuple		  =  np.array(snake_case			,    np.intaa							)
																			A__						:  List[Any]		  =  []

																			for vector, length in zip(snake_case			,    attention_mask.sum(-1							)							):
																									A__						:  str		  =  (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7							)
																									if length < normed_slice.shape[0]:
																															A__						:  int		  =  padding_value

																									normed_input_values.append(snake_case							)
													else:
																			A__						:  List[Any]		  =  [(x - x.mean()) / np.sqrt(x.var() + 1e-7							) for x in input_values]

													return normed_input_values


							def 						_UpperCamelCase       (			self      :						Optional[int]			,    snake_case      :						np.ndarray			,    ):
													'''simple docstring'''





													A__						:  List[Any]		  =  spectrogram(
													    snake_case			,    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      :						str			,    snake_case      :						Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None			,    snake_case      :						Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None			,    snake_case      :						Union[bool, str, PaddingStrategy] = False			,    snake_case      :						Optional[int] = None			,    snake_case      :						bool = False			,    snake_case      :						Optional[int] = None			,    snake_case      :						Optional[bool] = None			,    snake_case      :						Optional[Union[str, TensorType]] = None			,    snake_case      :						Optional[int] = None			,    **snake_case      :						Union[str, Any]			,    ):
													'''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:
																			A__						:  Dict		  =  self._process_audio(
																			    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    **snake_case			,    )
													else:
																			A__						:  Dict		  =  None

													if audio_target is not None:
																			A__						:  Union[str, Any]		  =  self._process_audio(
																			    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    snake_case			,    **snake_case			,    )

																			if inputs is None:
																									return inputs_target
																			else:
																									A__						:  Union[str, Any]		  =  inputs_target["""input_values"""]
																									A__						:  str		  =  inputs_target.get("""attention_mask"""							)
																									if decoder_attention_mask is not None:
																															A__						:  List[str]		  =  decoder_attention_mask

													return inputs


							def 						_UpperCamelCase       (			self      :						str			,    snake_case      :						Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]			,    snake_case      :						bool = False			,    snake_case      :						Union[bool, str, PaddingStrategy] = False			,    snake_case      :						Optional[int] = None			,    snake_case      :						bool = False			,    snake_case      :						Optional[int] = None			,    snake_case      :						Optional[bool] = None			,    snake_case      :						Optional[Union[str, TensorType]] = None			,    **snake_case      :						Union[str, Any]			,    ):
													'''simple docstring'''





													A__						:  List[str]		  =  isinstance(snake_case			,    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}'							)
													A__						:  Tuple		  =  is_batched_numpy or (
													    isinstance(snake_case			,    (list, tuple)							) and (isinstance(speech[0]			,    (np.ndarray, tuple, list)							))
													)

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

													# always return batch
													if not is_batched:
																			A__						:  Optional[Any]		  =  [speech]

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

													# convert into correct format for padding
													if is_target:
																			A__						:  str		  =  [self._extract_mel_features(snake_case							) for waveform in speech]
																			A__						:  List[str]		  =  BatchFeature({"""input_values""": features}							)
																			A__						:  Dict		  =  self.num_mel_bins
													else:
																			A__						:  Tuple		  =  BatchFeature({"""input_values""": speech}							)

													A__						:  List[str]		  =  self.pad(
													    snake_case			,    padding=snake_case			,    max_length=snake_case			,    truncation=snake_case			,    pad_to_multiple_of=snake_case			,    return_attention_mask=snake_case			,    **snake_case			,    )

													A__						:  List[str]		  =  feature_size_hack

													# convert input values to correct format
													A__						:  str		  =  padded_inputs["""input_values"""]
													if not isinstance(input_values[0]			,    np.ndarray							):
																			A__						:  Tuple		  =  [np.asarray(snake_case			,    dtype=np.floataa							) for array in input_values]
													elif (
													    not isinstance(snake_case			,    np.ndarray							)
													    and isinstance(input_values[0]			,    np.ndarray							)
													    and input_values[0].dtype is np.dtype(np.floataa							)
													):
																			A__						:  Dict		  =  [array.astype(np.floataa							) for array in input_values]
													elif isinstance(snake_case			,    np.ndarray							) and input_values.dtype is np.dtype(np.floataa							):
																			A__						:  Any		  =  input_values.astype(np.floataa							)

													# convert attention_mask to correct format
													A__						:  List[Any]		  =  padded_inputs.get("""attention_mask"""							)
													if attention_mask is not None:
																			A__						:  Any		  =  [np.asarray(snake_case			,    dtype=np.intaa							) for array in attention_mask]

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

													if return_tensors is not None:
																			A__						:  Any		  =  padded_inputs.convert_to_tensors(snake_case							)

													return padded_inputs


							def 						_UpperCamelCase       (			self      :						Union[str, Any]							):
													'''simple docstring'''





													A__						:  List[str]		  =  super().to_dict()

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

													return output






