

from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)







@flax.struct.dataclass
class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : jnp.ndarray
  UpperCAmelCase__      : jnp.ndarray







class        a__       (   nn.Module       ):







  """simple docstring"""




  UpperCAmelCase__      : int
  UpperCAmelCase__      : Tuple[int]			       =(1_6, 3_2, 9_6, 2_5_6)
  UpperCAmelCase__      : jnp.dtype			       =jnp.floataa


  def  _lowercase      (			self    : int		)					->List[str]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[Any]       =   nn.Conv(
            self.block_out_channels[0]				,				kernel_size=(3, 3)				,				padding=((1, 1), (1, 1))				,				dtype=self.dtype				,				)

        SCREAMING_SNAKE_CASE :      Optional[Any]       =   []
        for i in range(len(self.block_out_channels		) - 1		):
              SCREAMING_SNAKE_CASE :      Dict       =   self.block_out_channels[i]
              SCREAMING_SNAKE_CASE :      List[Any]       =   self.block_out_channels[i + 1]
              SCREAMING_SNAKE_CASE :      Any       =   nn.Conv(
                  UpperCAmelCase__				,				kernel_size=(3, 3)				,				padding=((1, 1), (1, 1))				,				dtype=self.dtype				,				)
              blocks.append(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      List[str]       =   nn.Conv(
                  UpperCAmelCase__				,				kernel_size=(3, 3)				,				strides=(2, 2)				,				padding=((1, 1), (1, 1))				,				dtype=self.dtype				,				)
              blocks.append(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      List[str]       =   blocks

        SCREAMING_SNAKE_CASE :      str       =   nn.Conv(
            self.conditioning_embedding_channels				,				kernel_size=(3, 3)				,				padding=((1, 1), (1, 1))				,				kernel_init=nn.initializers.zeros_init()				,				bias_init=nn.initializers.zeros_init()				,				dtype=self.dtype				,				)




  def __call__(			self    : Tuple				,				UpperCAmelCase__    : Optional[int]		)					->Optional[int]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      str       =   self.conv_in(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      int       =   nn.silu(UpperCAmelCase__		)

        for block in self.blocks:
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   block(UpperCAmelCase__		)
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   nn.silu(UpperCAmelCase__		)

        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.conv_out(UpperCAmelCase__		)

        return embedding







@flax_register_to_config
class        a__       (   nn.Module	,			UpperCAmelCase	,			UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : int			       =3_2
  UpperCAmelCase__      : int			       =4
  UpperCAmelCase__      : Tuple[str]			       =(
      "CrossAttnDownBlock2D",
      "CrossAttnDownBlock2D",
      "CrossAttnDownBlock2D",
      "DownBlock2D",
  )
  UpperCAmelCase__      : Union[bool, Tuple[bool]]			       =False
  UpperCAmelCase__      : Tuple[int]			       =(3_2_0, 6_4_0, 1_2_8_0, 1_2_8_0)
  UpperCAmelCase__      : int			       =2
  UpperCAmelCase__      : Union[int, Tuple[int]]			       =8
  UpperCAmelCase__      : Optional[Union[int, Tuple[int]]]			       =None
  UpperCAmelCase__      : int			       =1_2_8_0
  UpperCAmelCase__      : float			       =0.0
  UpperCAmelCase__      : bool			       =False
  UpperCAmelCase__      : jnp.dtype			       =jnp.floataa
  UpperCAmelCase__      : bool			       =True
  UpperCAmelCase__      : int			       =0
  UpperCAmelCase__      : str			       ="rgb"
  UpperCAmelCase__      : Tuple[int]			       =(1_6, 3_2, 9_6, 2_5_6)


  def  _lowercase      (			self    : Union[str, Any]				,				UpperCAmelCase__    : jax.random.KeyArray		)					->FrozenDict:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Optional[Any]       =   (1, self.in_channels, self.sample_size, self.sample_size)
        SCREAMING_SNAKE_CASE :      List[str]       =   jnp.zeros(UpperCAmelCase__				,				dtype=jnp.floataa		)
        SCREAMING_SNAKE_CASE :      Dict       =   jnp.ones((1,)				,				dtype=jnp.intaa		)
        SCREAMING_SNAKE_CASE :      Dict       =   jnp.zeros((1, 1, self.cross_attention_dim)				,				dtype=jnp.floataa		)
        SCREAMING_SNAKE_CASE :      Dict       =   (1, 3, self.sample_size * 8, self.sample_size * 8)
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   jnp.zeros(UpperCAmelCase__				,				dtype=jnp.floataa		)

        SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      List[str]       =   jax.random.split(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Dict       =   {"""params""": params_rng, """dropout""": dropout_rng}

        return self.init(UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__		)["params"]


  def  _lowercase      (			self    : Optional[Any]		)					->str:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Dict       =   self.block_out_channels
        SCREAMING_SNAKE_CASE :      List[str]       =   block_out_channels[0] * 4

        # If `num_attention_heads` is not defined (which is the case for most models)
        # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
        # The reason for this behavior is to correct for incorrectly named variables that were introduced
        # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
        # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
        # which is why we correct for the naming here.
        SCREAMING_SNAKE_CASE :      Optional[int]       =   self.num_attention_heads or self.attention_head_dim

        # input
        SCREAMING_SNAKE_CASE :      List[str]       =   nn.Conv(
            block_out_channels[0]				,				kernel_size=(3, 3)				,				strides=(1, 1)				,				padding=((1, 1), (1, 1))				,				dtype=self.dtype				,				)

        # time
        SCREAMING_SNAKE_CASE :      Optional[int]       =   FlaxTimesteps(
            block_out_channels[0]				,				flip_sin_to_cos=self.flip_sin_to_cos				,				freq_shift=self.config.freq_shift		)
        SCREAMING_SNAKE_CASE :      int       =   FlaxTimestepEmbedding(UpperCAmelCase__				,				dtype=self.dtype		)

        SCREAMING_SNAKE_CASE :      str       =   FlaxControlNetConditioningEmbedding(
            conditioning_embedding_channels=block_out_channels[0]				,				block_out_channels=self.conditioning_embedding_out_channels				,				)

        SCREAMING_SNAKE_CASE :      List[Any]       =   self.only_cross_attention
        if isinstance(UpperCAmelCase__				,				UpperCAmelCase__		):
              SCREAMING_SNAKE_CASE :      Tuple       =   (only_cross_attention,) * len(self.down_block_types		)

        if isinstance(UpperCAmelCase__				,				UpperCAmelCase__		):
              SCREAMING_SNAKE_CASE :      str       =   (num_attention_heads,) * len(self.down_block_types		)

        # down
        SCREAMING_SNAKE_CASE :      Any       =   []
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   []

        SCREAMING_SNAKE_CASE :      Any       =   block_out_channels[0]

        SCREAMING_SNAKE_CASE :      List[str]       =   nn.Conv(
            UpperCAmelCase__				,				kernel_size=(1, 1)				,				padding="""VALID"""				,				kernel_init=nn.initializers.zeros_init()				,				bias_init=nn.initializers.zeros_init()				,				dtype=self.dtype				,				)
        controlnet_down_blocks.append(UpperCAmelCase__		)

        for i, down_block_type in enumerate(self.down_block_types		):
              SCREAMING_SNAKE_CASE :      str       =   output_channel
              SCREAMING_SNAKE_CASE :      str       =   block_out_channels[i]
              SCREAMING_SNAKE_CASE :      Tuple       =   i == len(UpperCAmelCase__		) - 1

              if down_block_type == "CrossAttnDownBlock2D":
                    SCREAMING_SNAKE_CASE :      Optional[Any]       =   FlaxCrossAttnDownBlockaD(
                        in_channels=UpperCAmelCase__				,				out_channels=UpperCAmelCase__				,				dropout=self.dropout				,				num_layers=self.layers_per_block				,				num_attention_heads=num_attention_heads[i]				,				add_downsample=not is_final_block				,				use_linear_projection=self.use_linear_projection				,				only_cross_attention=only_cross_attention[i]				,				dtype=self.dtype				,				)
              else:
                    SCREAMING_SNAKE_CASE :      int       =   FlaxDownBlockaD(
                        in_channels=UpperCAmelCase__				,				out_channels=UpperCAmelCase__				,				dropout=self.dropout				,				num_layers=self.layers_per_block				,				add_downsample=not is_final_block				,				dtype=self.dtype				,				)

              down_blocks.append(UpperCAmelCase__		)

              for _ in range(self.layers_per_block		):
                    SCREAMING_SNAKE_CASE :      Any       =   nn.Conv(
                        UpperCAmelCase__				,				kernel_size=(1, 1)				,				padding="""VALID"""				,				kernel_init=nn.initializers.zeros_init()				,				bias_init=nn.initializers.zeros_init()				,				dtype=self.dtype				,				)
                    controlnet_down_blocks.append(UpperCAmelCase__		)

              if not is_final_block:
                    SCREAMING_SNAKE_CASE :      Dict       =   nn.Conv(
                        UpperCAmelCase__				,				kernel_size=(1, 1)				,				padding="""VALID"""				,				kernel_init=nn.initializers.zeros_init()				,				bias_init=nn.initializers.zeros_init()				,				dtype=self.dtype				,				)
                    controlnet_down_blocks.append(UpperCAmelCase__		)

        SCREAMING_SNAKE_CASE :      Optional[int]       =   down_blocks
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   controlnet_down_blocks

        # mid
        SCREAMING_SNAKE_CASE :      List[str]       =   block_out_channels[-1]
        SCREAMING_SNAKE_CASE :      Tuple       =   FlaxUNetMidBlockaDCrossAttn(
            in_channels=UpperCAmelCase__				,				dropout=self.dropout				,				num_attention_heads=num_attention_heads[-1]				,				use_linear_projection=self.use_linear_projection				,				dtype=self.dtype				,				)

        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   nn.Conv(
            UpperCAmelCase__				,				kernel_size=(1, 1)				,				padding="""VALID"""				,				kernel_init=nn.initializers.zeros_init()				,				bias_init=nn.initializers.zeros_init()				,				dtype=self.dtype				,				)




  def __call__(			self    : Union[str, Any]				,				UpperCAmelCase__    : int				,				UpperCAmelCase__    : Optional[Any]				,				UpperCAmelCase__    : Tuple				,				UpperCAmelCase__    : Any				,				UpperCAmelCase__    : float = 1.0				,				UpperCAmelCase__    : bool = True				,				UpperCAmelCase__    : bool = False				,				)					->Union[FlaxControlNetOutput, Tuple]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.controlnet_conditioning_channel_order
        if channel_order == "bgr":
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   jnp.flip(UpperCAmelCase__				,				axis=1		)

        # 1. time
        if not isinstance(UpperCAmelCase__				,				jnp.ndarray		):
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   jnp.array([timesteps]				,				dtype=jnp.intaa		)
        elif isinstance(UpperCAmelCase__				,				jnp.ndarray		) and len(timesteps.shape		) == 0:
              SCREAMING_SNAKE_CASE :      Tuple       =   timesteps.astype(dtype=jnp.floataa		)
              SCREAMING_SNAKE_CASE :      int       =   jnp.expand_dims(UpperCAmelCase__				,				0		)

        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.time_proj(UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.time_embedding(UpperCAmelCase__		)

        # 2. pre-process
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   jnp.transpose(UpperCAmelCase__				,				(0, 2, 3, 1)		)
        SCREAMING_SNAKE_CASE :      Tuple       =   self.conv_in(UpperCAmelCase__		)

        SCREAMING_SNAKE_CASE :      List[str]       =   jnp.transpose(UpperCAmelCase__				,				(0, 2, 3, 1)		)
        SCREAMING_SNAKE_CASE :      Any       =   self.controlnet_cond_embedding(UpperCAmelCase__		)
        sample += controlnet_cond

        # 3. down
        SCREAMING_SNAKE_CASE :      int       =   (sample,)
        for down_block in self.down_blocks:
              if isinstance(UpperCAmelCase__				,				UpperCAmelCase__		):
                    SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      Optional[Any]       =   down_block(UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__				,				deterministic=not train		)
              else:
                    SCREAMING_SNAKE_CASE     ,	SCREAMING_SNAKE_CASE :      int       =   down_block(UpperCAmelCase__				,				UpperCAmelCase__				,				deterministic=not train		)
              down_block_res_samples += res_samples

        # 4. mid
        SCREAMING_SNAKE_CASE :      Tuple       =   self.mid_block(UpperCAmelCase__				,				UpperCAmelCase__				,				UpperCAmelCase__				,				deterministic=not train		)

        # 5. contronet blocks
        SCREAMING_SNAKE_CASE :      str       =   ()
        for down_block_res_sample, controlnet_block in zip(UpperCAmelCase__				,				self.controlnet_down_blocks		):
              SCREAMING_SNAKE_CASE :      Dict       =   controlnet_block(UpperCAmelCase__		)
              controlnet_down_block_res_samples += (down_block_res_sample,)

        SCREAMING_SNAKE_CASE :      Optional[Any]       =   controlnet_down_block_res_samples

        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   self.controlnet_mid_block(UpperCAmelCase__		)

        # 6. scaling
        SCREAMING_SNAKE_CASE :      List[Any]       =   [sample * conditioning_scale for sample in down_block_res_samples]
        mid_block_res_sample *= conditioning_scale

        if not return_dict:
              return (down_block_res_samples, mid_block_res_sample)

        return FlaxControlNetOutput(
            down_block_res_samples=UpperCAmelCase__				,				mid_block_res_sample=UpperCAmelCase__		)







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__ :     Tuple				    =    logging.get_logger(__name__)







class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : Optional[int]			       =["""input_features""", """attention_mask"""]


  def __init__(			self    : List[str]				,				UpperCAmelCase__    : Optional[Any]=8_0				,				UpperCAmelCase__    : List[str]=1_6_0_0_0				,				UpperCAmelCase__    : Optional[int]=8_0				,				UpperCAmelCase__    : List[str]=0.0				,				UpperCAmelCase__    : List[Any]=True				,				UpperCAmelCase__    : Tuple=True				,				UpperCAmelCase__    : Tuple=True				,				**UpperCAmelCase__    : Optional[int]				,				)					->Optional[int]:
        """simple docstring"""







        super().__init__(feature_size=UpperCAmelCase__				,				sampling_rate=UpperCAmelCase__				,				padding_value=UpperCAmelCase__				,				**UpperCAmelCase__		)
        SCREAMING_SNAKE_CASE :      Optional[int]       =   num_mel_bins
        SCREAMING_SNAKE_CASE :      Dict       =   do_ceptral_normalize
        SCREAMING_SNAKE_CASE :      Optional[int]       =   normalize_means
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   normalize_vars
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   True


  def  _lowercase      (			self    : Tuple				,				UpperCAmelCase__    : np.ndarray				,				)					->np.ndarray:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      List[str]       =   waveform * (2**1_5)  # Kaldi compliance: 16-bit signed integers
        SCREAMING_SNAKE_CASE :      Dict       =   torch.from_numpy(UpperCAmelCase__		).unsqueeze(0		)
        SCREAMING_SNAKE_CASE :      List[Any]       =   ta_kaldi.fbank(UpperCAmelCase__				,				num_mel_bins=self.num_mel_bins				,				sample_frequency=self.sampling_rate		)
        return features.numpy()


  @staticmethod
  def  _lowercase      (			UpperCAmelCase__    : np.ndarray				,				UpperCAmelCase__    : int				,				UpperCAmelCase__    : Optional[bool] = True				,				UpperCAmelCase__    : Optional[bool] = True				,				UpperCAmelCase__    : float = 0.0				,				)					->np.ndarray:
        """simple docstring"""







        if normalize_means:
              SCREAMING_SNAKE_CASE :      Tuple       =   x[:input_length].mean(axis=0		)
              SCREAMING_SNAKE_CASE :      List[Any]       =   np.subtract(UpperCAmelCase__				,				UpperCAmelCase__		)
        if normalize_vars:
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   x[:input_length].std(axis=0		)
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.divide(UpperCAmelCase__				,				UpperCAmelCase__		)

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

        # make sure array is in float32
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   x.astype(np.floataa		)

        return x


  def  _lowercase      (			self    : List[str]				,				UpperCAmelCase__    : List[np.ndarray]				,				UpperCAmelCase__    : Optional[np.ndarray] = None		)					->List[np.ndarray]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      str       =   attention_mask.sum(-1		) if attention_mask is not None else [x.shape[0] for x in input_features]
        return [
            self.utterance_cmvn(UpperCAmelCase__				,				UpperCAmelCase__				,				self.normalize_means				,				self.normalize_vars				,				self.padding_value		)
            for x, n in zip(UpperCAmelCase__				,				UpperCAmelCase__		)
        ]




  def __call__(			self    : str				,				UpperCAmelCase__    : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,				UpperCAmelCase__    : Union[bool, str, PaddingStrategy] = False				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : bool = False				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : Optional[Union[str, TensorType]] = None				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : Optional[bool] = None				,				**UpperCAmelCase__    : Optional[int]				,				)					->BatchFeature:
        """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."""		)

        SCREAMING_SNAKE_CASE :      Tuple       =   isinstance(UpperCAmelCase__				,				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}"		)
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   is_batched_numpy or (
            isinstance(UpperCAmelCase__				,				(list, tuple)		) and (isinstance(raw_speech[0]				,				(np.ndarray, tuple, list)		))
        )

        if is_batched:
              SCREAMING_SNAKE_CASE :      Dict       =   [np.asarray(UpperCAmelCase__				,				dtype=np.floataa		) for speech in raw_speech]
        elif not is_batched and not isinstance(UpperCAmelCase__				,				np.ndarray		):
              SCREAMING_SNAKE_CASE :      Any       =   np.asarray(UpperCAmelCase__				,				dtype=np.floataa		)
        elif isinstance(UpperCAmelCase__				,				np.ndarray		) and raw_speech.dtype is np.dtype(np.floataa		):
              SCREAMING_SNAKE_CASE :      Tuple       =   raw_speech.astype(np.floataa		)

        # always return batch
        if not is_batched:
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   [raw_speech]

        # extract fbank features
        SCREAMING_SNAKE_CASE :      Tuple       =   [self._extract_fbank_features(UpperCAmelCase__		) for waveform in raw_speech]

        # convert into correct format for padding
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   BatchFeature({"""input_features""": features}		)

        SCREAMING_SNAKE_CASE :      str       =   self.pad(
            UpperCAmelCase__				,				padding=UpperCAmelCase__				,				max_length=UpperCAmelCase__				,				truncation=UpperCAmelCase__				,				pad_to_multiple_of=UpperCAmelCase__				,				return_attention_mask=UpperCAmelCase__				,				**UpperCAmelCase__				,				)

        # make sure list is in array format
        SCREAMING_SNAKE_CASE :      Dict       =   padded_inputs.get("""input_features"""		)
        if isinstance(input_features[0]				,				UpperCAmelCase__		):
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   [np.asarray(UpperCAmelCase__				,				dtype=np.floataa		) for feature in input_features]

        SCREAMING_SNAKE_CASE :      Dict       =   padded_inputs.get("""attention_mask"""		)
        if attention_mask is not None:
              SCREAMING_SNAKE_CASE :      int       =   [np.asarray(UpperCAmelCase__				,				dtype=np.intaa		) for array in attention_mask]

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

        if return_tensors is not None:
              SCREAMING_SNAKE_CASE :      Any       =   padded_inputs.convert_to_tensors(UpperCAmelCase__		)

        return padded_inputs




