

import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


_a:     Dict							=      get_logger(__name__)


_a:     int							=      r"""\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n"""

class     __UpperCamelCase     :




	@add_start_docstrings(__lowerCAmelCase				)
	def __call__(		self						:    List[Any]		,						lowerCAmelCase						:    str		,						lowerCAmelCase						:    Union[str, Any]				):


		'''simple docstring'''







		raise NotImplementedError(
		    F"{self.__class__} is an abstract class. Only classes inheriting this class can be called."				)


class     __UpperCamelCase     :




	@add_start_docstrings(__lowerCAmelCase				)
	def __call__(		self						:    Dict		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    int				):


		'''simple docstring'''







		raise NotImplementedError(
		    F"{self.__class__} is an abstract class. Only classes inheriting this class can be called."				)


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	@add_start_docstrings(__lowerCAmelCase				)
	def __call__(		self						:    List[str]		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    Optional[Any]		,						**lowerCAmelCase						:    Optional[Any]				):


		'''simple docstring'''







		for processor in self:
			UpperCAmelCase_												=      inspect.signature(processor.__call__				).parameters
			if len(__lowerCAmelCase				) > 3:
				if not all(arg in kwargs for arg in list(function_args.keys()				)[2:]				):
					raise ValueError(
					    F"Make sure that all the required parameters: {list(function_args.keys()				)} for "
					    F"{processor.__class__} are passed to the logits processor."				)
				UpperCAmelCase_												=      processor(__lowerCAmelCase		,						__lowerCAmelCase		,						__lowerCAmelCase		,						**__lowerCAmelCase				)
			else:
				UpperCAmelCase_												=      processor(__lowerCAmelCase		,						__lowerCAmelCase		,						__lowerCAmelCase				)
		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Dict		,						lowerCAmelCase						:    Tuple				):


		'''simple docstring'''







		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or not (temperature > 0):
			raise ValueError(F"`temperature` has to be a strictly positive float, but is {temperature}"				)

		UpperCAmelCase_												=      temperature




	def __call__(		self						:    int		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Any				):


		'''simple docstring'''







		UpperCAmelCase_												=      scores / self.temperature
		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    int		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Union[str, Any] = -float("Inf"				)		,						lowerCAmelCase						:    List[Any] = 1				):


		'''simple docstring'''







		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or (top_p < 0 or top_p > 1.0):
			raise ValueError(F"`top_p` has to be a float > 0 and < 1, but is {top_p}"				)
		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or (min_tokens_to_keep < 1):
			raise ValueError(F"`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}"				)

		UpperCAmelCase_												=      top_p
		UpperCAmelCase_												=      filter_value
		UpperCAmelCase_												=      min_tokens_to_keep




	def __call__(		self						:    int		,						lowerCAmelCase						:    str		,						lowerCAmelCase						:    str		,						lowerCAmelCase						:    Dict				):


		'''simple docstring'''







		UpperCAmelCase_												=      lax.top_k(__lowerCAmelCase		,						scores.shape[-1]				)

		UpperCAmelCase_												=      jnp.full_like(__lowerCAmelCase		,						self.filter_value				)
		UpperCAmelCase_												=      jax.nn.softmax(__lowerCAmelCase		,						axis=-1				).cumsum(axis=-1				)
		UpperCAmelCase_												=      cumulative_probs < self.top_p

		# include the token that is higher than top_p as well
		UpperCAmelCase_												=      jnp.roll(__lowerCAmelCase		,						1				)
		score_mask |= score_mask.at[:, 0].set(__lowerCAmelCase				)

		# min tokens to keep
		UpperCAmelCase_												=      score_mask.at[:, : self.min_tokens_to_keep].set(__lowerCAmelCase				)

		UpperCAmelCase_												=      jnp.where(__lowerCAmelCase		,						__lowerCAmelCase		,						__lowerCAmelCase				)
		UpperCAmelCase_												=      jax.lax.sort_key_val(__lowerCAmelCase		,						__lowerCAmelCase				)[-1]

		return next_scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Union[str, Any]		,						lowerCAmelCase						:    str		,						lowerCAmelCase						:    int = -float("Inf"				)		,						lowerCAmelCase						:    Optional[int] = 1				):


		'''simple docstring'''







		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or top_k <= 0:
			raise ValueError(F"`top_k` has to be a strictly positive integer, but is {top_k}"				)

		UpperCAmelCase_												=      max(__lowerCAmelCase		,						__lowerCAmelCase				)
		UpperCAmelCase_												=      filter_value




	def __call__(		self						:    Optional[Any]		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Tuple		,						lowerCAmelCase						:    str				):


		'''simple docstring'''







		UpperCAmelCase_												=      scores.shape
		UpperCAmelCase_												=      jnp.full(batch_size * vocab_size		,						self.filter_value				)

		UpperCAmelCase_												=      min(self.top_k		,						scores.shape[-1]				)  # Safety check
		UpperCAmelCase_												=      lax.top_k(__lowerCAmelCase		,						__lowerCAmelCase				)
		UpperCAmelCase_												=      jnp.broadcast_to((jnp.arange(__lowerCAmelCase				) * vocab_size)[:, None]		,						(batch_size, topk)				).flatten()
		UpperCAmelCase_												=      topk_scores.flatten()
		UpperCAmelCase_												=      topk_indices.flatten() + shift

		UpperCAmelCase_												=      next_scores_flat.at[topk_indices_flat].set(__lowerCAmelCase				)
		UpperCAmelCase_												=      next_scores_flat.reshape(__lowerCAmelCase		,						__lowerCAmelCase				)
		return next_scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Dict		,						lowerCAmelCase						:    Optional[Any]				):


		'''simple docstring'''







		UpperCAmelCase_												=      bos_token_id




	def __call__(		self						:    List[Any]		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Optional[Any]				):


		'''simple docstring'''







		UpperCAmelCase_												=      jnp.full(scores.shape		,						-float("inf"				)				)

		UpperCAmelCase_												=      1 - jnp.bool_(cur_len - 1				)

		UpperCAmelCase_												=      jnp.where(__lowerCAmelCase		,						new_scores.at[:, self.bos_token_id].set(0				)		,						__lowerCAmelCase				)

		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Optional[Any]		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Dict				):


		'''simple docstring'''







		UpperCAmelCase_												=      max_length
		UpperCAmelCase_												=      eos_token_id




	def __call__(		self						:    Tuple		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    Union[str, Any]		,						lowerCAmelCase						:    int				):


		'''simple docstring'''







		UpperCAmelCase_												=      jnp.full(scores.shape		,						-float("inf"				)				)

		UpperCAmelCase_												=      1 - jnp.bool_(cur_len - self.max_length + 1				)

		UpperCAmelCase_												=      jnp.where(__lowerCAmelCase		,						new_scores.at[:, self.eos_token_id].set(0				)		,						__lowerCAmelCase				)

		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    List[str]		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    Any				):


		'''simple docstring'''







		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or min_length < 0:
			raise ValueError(F"`min_length` has to be a positive integer, but is {min_length}"				)

		if not isinstance(__lowerCAmelCase		,						__lowerCAmelCase				) or eos_token_id < 0:
			raise ValueError(F"`eos_token_id` has to be a positive integer, but is {eos_token_id}"				)

		UpperCAmelCase_												=      min_length
		UpperCAmelCase_												=      eos_token_id




	def __call__(		self						:    Any		,						lowerCAmelCase						:    Optional[Any]		,						lowerCAmelCase						:    List[str]		,						lowerCAmelCase						:    str				):


		'''simple docstring'''







		UpperCAmelCase_												=      1 - jnp.clip(cur_len - self.min_length		,						0		,						1				)

		UpperCAmelCase_												=      jnp.where(__lowerCAmelCase		,						scores.at[:, self.eos_token_id].set(-float("inf"				)				)		,						__lowerCAmelCase				)

		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Union[str, Any]		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Union[str, Any]				):


		'''simple docstring'''







		UpperCAmelCase_												=      list(__lowerCAmelCase				)
		UpperCAmelCase_												=      begin_index




	def __call__(		self						:    Optional[Any]		,						lowerCAmelCase						:    List[str]		,						lowerCAmelCase						:    int		,						lowerCAmelCase						:    Union[str, Any]				):


		'''simple docstring'''







		UpperCAmelCase_												=      1 - jnp.bool_(cur_len - self.begin_index				)

		UpperCAmelCase_												=      jnp.where(__lowerCAmelCase		,						scores.at[:, self.begin_suppress_tokens].set(-float("inf"				)				)		,						__lowerCAmelCase				)

		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Optional[Any]		,						lowerCAmelCase						:    Optional[Any]				):


		'''simple docstring'''







		UpperCAmelCase_												=      list(__lowerCAmelCase				)




	def __call__(		self						:    Dict		,						lowerCAmelCase						:    Union[str, Any]		,						lowerCAmelCase						:    List[Any]		,						lowerCAmelCase						:    List[str]				):


		'''simple docstring'''







		UpperCAmelCase_												=      scores.at[..., self.suppress_tokens].set(-float("inf"				)				)

		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    int		,						lowerCAmelCase						:    Tuple				):


		'''simple docstring'''







		UpperCAmelCase_												=      dict(__lowerCAmelCase				)
		# Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
		# index of the array corresponds to the index of the token to be forced, for XLA compatibility.
		# Indexes without forced tokens will have a negative value.
		UpperCAmelCase_												=      jnp.ones((max(force_token_map.keys()				) + 1)		,						dtype=jnp.intaa				) * -1
		for index, token in force_token_map.items():
			if token is not None:
				UpperCAmelCase_												=      force_token_array.at[index].set(__lowerCAmelCase				)
		UpperCAmelCase_												=      jnp.intaa(__lowerCAmelCase				)




	def __call__(		self						:    Any		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Dict				):


		'''simple docstring'''







		def _force_token(lowerCAmelCase						:    List[Any]				):
			UpperCAmelCase_												=      scores.shape[0]
			UpperCAmelCase_												=      self.force_token_array[generation_idx]

			UpperCAmelCase_												=      jnp.ones_like(__lowerCAmelCase		,						dtype=scores.dtype				) * -float("inf"				)
			UpperCAmelCase_												=      jnp.zeros((batch_size, 1)		,						dtype=scores.dtype				)
			UpperCAmelCase_												=      lax.dynamic_update_slice(__lowerCAmelCase		,						__lowerCAmelCase		,						(0, current_token)				)
			return new_scores

		UpperCAmelCase_												=      lax.cond(
		    cur_len >= self.force_token_array.shape[0]		,						lambda: scores		,						lambda: lax.cond(
		        self.force_token_array[cur_len] >= 0		,						lambda: _force_token(__lowerCAmelCase				)		,						lambda: scores		,						)		,						)
		return scores


class     __UpperCamelCase     (       SCREAMING_SNAKE_CASE__    ):




	def __init__(		self						:    Union[str, Any]		,						lowerCAmelCase						:    Any		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Tuple				):


		'''simple docstring'''







		UpperCAmelCase_												=      generate_config.eos_token_id
		UpperCAmelCase_												=      generate_config.no_timestamps_token_id
		UpperCAmelCase_												=      generate_config.no_timestamps_token_id + 1

		UpperCAmelCase_												=      decoder_input_length + 1

		if generate_config.is_multilingual:
			# room for language token and task token
			self.begin_index += 2
		if hasattr(__lowerCAmelCase		,						"max_initial_timestamp_index"				):
			UpperCAmelCase_												=      generate_config.max_initial_timestamp_index
		else:
			UpperCAmelCase_												=      model_config.vocab_size
		if self.max_initial_timestamp_index is None:
			UpperCAmelCase_												=      model_config.vocab_size




	def __call__(		self						:    int		,						lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    Optional[Any]		,						lowerCAmelCase						:    Tuple				):


		'''simple docstring'''







		UpperCAmelCase_												=      scores.at[:, self.no_timestamps_token_id].set(-float("inf"				)				)

		def handle_pairs(lowerCAmelCase						:    Union[str, Any]		,						lowerCAmelCase						:    Dict				):
			UpperCAmelCase_												=      jnp.where((cur_len - self.begin_index) >= 1		,						__lowerCAmelCase		,						__lowerCAmelCase				)
			UpperCAmelCase_												=      jnp.where(
			    input_ids_k[cur_len - 1] >= self.timestamp_begin		,						True and last_was_timestamp		,						__lowerCAmelCase		,						)

			UpperCAmelCase_												=      jnp.where((cur_len - self.begin_index) < 2		,						__lowerCAmelCase		,						__lowerCAmelCase				)
			UpperCAmelCase_												=      jnp.where(
			    input_ids_k[cur_len - 2] >= self.timestamp_begin		,						__lowerCAmelCase		,						__lowerCAmelCase		,						)

			return jnp.where(
			    __lowerCAmelCase		,						jnp.where(
			        penultimate_was_timestamp > 0		,						scores_k.at[self.timestamp_begin :].set(-float("inf"				)				)		,						scores_k.at[: self.eos_token_id].set(-float("inf"				)				)		,						)		,						__lowerCAmelCase		,						)

		UpperCAmelCase_												=      jax.vmap(__lowerCAmelCase				)(__lowerCAmelCase		,						__lowerCAmelCase				)

		UpperCAmelCase_												=      jnp.where(cur_len == self.begin_index		,						__lowerCAmelCase		,						__lowerCAmelCase				)
		UpperCAmelCase_												=      jnp.where(
		    self.max_initial_timestamp_index is not None		,						True and apply_max_initial_timestamp		,						__lowerCAmelCase		,						)

		UpperCAmelCase_												=      self.timestamp_begin + self.max_initial_timestamp_index

		UpperCAmelCase_												=      jnp.where(
		    __lowerCAmelCase		,						scores.at[:, last_allowed + 1 :].set(-float("inf"				)				)		,						__lowerCAmelCase		,						)

		# if sum of probability over timestamps is above any other token, sample timestamp
		UpperCAmelCase_												=      jax.nn.log_softmax(__lowerCAmelCase		,						axis=-1				)

		def handle_cumulative_probs(lowerCAmelCase						:    Dict		,						lowerCAmelCase						:    List[Any]				):
			UpperCAmelCase_												=      jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]		,						axis=-1				)
			UpperCAmelCase_												=      jnp.max(logprobs_k[: self.timestamp_begin]				)
			return jnp.where(
			    timestamp_logprob > max_text_token_logprob		,						scores_k.at[: self.timestamp_begin].set(-float("inf"				)				)		,						__lowerCAmelCase		,						)

		UpperCAmelCase_												=      jax.vmap(__lowerCAmelCase				)(__lowerCAmelCase		,						__lowerCAmelCase				)

		return scores







'''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


UpperCamelCase      					=logging.get_logger(__name__)




class      A     (   SCREAMING_SNAKE_CASE__    ):






 """simple docstring"""





 __a      :    List[Any]			  =    ['''input_features''', '''attention_mask''']
 def __init__(				self      ,  __lowerCAmelCase=80      ,  __lowerCAmelCase=1_60_00      ,  __lowerCAmelCase=80      ,  __lowerCAmelCase=0.0      ,  __lowerCAmelCase=True      ,  __lowerCAmelCase=True      ,  __lowerCAmelCase=True      ,  **__lowerCAmelCase      ,  ):
       super().__init__(feature_size=__lowerCAmelCase      ,  sampling_rate=__lowerCAmelCase      ,  padding_value=__lowerCAmelCase      ,  **__lowerCAmelCase			)
       UpperCamelCase_					: int            =				num_mel_bins
       UpperCamelCase_					: Union[str, Any]            =				do_ceptral_normalize
       UpperCamelCase_					: Any            =				normalize_means
       UpperCamelCase_					: int            =				normalize_vars
       UpperCamelCase_					: int            =				True
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  ):
       UpperCamelCase_					: Optional[Any]            =				waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
       UpperCamelCase_					: Optional[int]            =				torch.from_numpy(__lowerCAmelCase			).unsqueeze(0			)
       UpperCamelCase_					: Tuple            =				ta_kaldi.fbank(__lowerCAmelCase      ,  num_mel_bins=self.num_mel_bins      ,  sample_frequency=self.sampling_rate			)
       return features.numpy()
 @staticmethod
 def 	_UpperCAmelCase							(				__lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase = True      ,  __lowerCAmelCase = True      ,  __lowerCAmelCase = 0.0      ,  ):
       # make sure we normalize float32 arrays
       if normalize_means:
             UpperCamelCase_					: int            =				x[:input_length].mean(axis=0			)
             UpperCamelCase_					: str            =				np.subtract(__lowerCAmelCase      ,  __lowerCAmelCase			)
       if normalize_vars:
             UpperCamelCase_					: Optional[int]            =				x[:input_length].std(axis=0			)
             UpperCamelCase_					: Optional[Any]            =				np.divide(__lowerCAmelCase      ,  __lowerCAmelCase			)

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

       # make sure array is in float32
       UpperCamelCase_					: str            =				x.astype(np.floataa			)

       return x
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase = None			):
       UpperCamelCase_					: List[str]            =				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      ,  __lowerCAmelCase      ,  __lowerCAmelCase = False      ,  __lowerCAmelCase = None      ,  __lowerCAmelCase = False      ,  __lowerCAmelCase = None      ,  __lowerCAmelCase = None      ,  __lowerCAmelCase = None      ,  __lowerCAmelCase = None      ,  **__lowerCAmelCase      ,  ):

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

       UpperCamelCase_					: Optional[int]            =				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}"			)
       UpperCamelCase_					: List[str]            =				is_batched_numpy or (
           isinstance(__lowerCAmelCase      ,  (list, tuple)			) and (isinstance(raw_speech[0]      ,  (np.ndarray, tuple, list)			))
       )

       if is_batched:
             UpperCamelCase_					: str            =				[np.asarray(__lowerCAmelCase      ,  dtype=np.floataa			) for speech in raw_speech]
       elif not is_batched and not isinstance(__lowerCAmelCase      ,  np.ndarray			):
             UpperCamelCase_					: Optional[Any]            =				np.asarray(__lowerCAmelCase      ,  dtype=np.floataa			)
       elif isinstance(__lowerCAmelCase      ,  np.ndarray			) and raw_speech.dtype is np.dtype(np.floataa			):
             UpperCamelCase_					: int            =				raw_speech.astype(np.floataa			)

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

       # extract fbank features
       UpperCamelCase_					: Any            =				[self._extract_fbank_features(__lowerCAmelCase			) for waveform in raw_speech]

       # convert into correct format for padding
       UpperCamelCase_					: Tuple            =				BatchFeature({"""input_features""": features}			)

       UpperCamelCase_					: Tuple            =				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
       UpperCamelCase_					: str            =				padded_inputs.get("""input_features"""			)
       if isinstance(input_features[0]      ,  __lowerCAmelCase			):
             UpperCamelCase_					: Any            =				[np.asarray(__lowerCAmelCase      ,  dtype=np.floataa			) for feature in input_features]

       UpperCamelCase_					: Union[str, Any]            =				padded_inputs.get("""attention_mask"""			)
       if attention_mask is not None:
             UpperCamelCase_					: Union[str, Any]            =				[np.asarray(__lowerCAmelCase      ,  dtype=np.intaa			) for array in attention_mask]

       # Utterance-level cepstral mean and variance normalization
       if self.do_ceptral_normalize:
             UpperCamelCase_					: List[str]            =				(
                 np.array(__lowerCAmelCase      ,  dtype=np.intaa			)
                 if self._get_padding_strategies(__lowerCAmelCase      ,  max_length=__lowerCAmelCase			) is not PaddingStrategy.DO_NOT_PAD
                 else None
             )
             UpperCamelCase_					: Optional[int]            =				self.normalize(
                 padded_inputs["""input_features"""]      ,  attention_mask=__lowerCAmelCase			)

       if return_tensors is not None:
             UpperCamelCase_					: Optional[Any]            =				padded_inputs.convert_to_tensors(__lowerCAmelCase			)

       return padded_inputs






