# UnivNet

## Resumen

El modelo UnivNet se propuso en [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) de Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin y Juntae Kim. El modelo UnivNet es una red generativa adversaria (GAN) entrenada para sintetizar formas de onda de voz de alta fidelidad. El modelo UnivNet compartido en `transformers` es el *generator*, que mapea un espectrograma log-mel de condicionamiento y una secuencia de ruido opcional a una forma de onda de voz (p. ej., un vocoder). Solo se requiere el generator para la inferencia. El *discriminator* utilizado para entrenar el `generator` no está implementado.

El resumen del artículo es el siguiente:

*La mayoría de los vocoderes neuronales emplean mel-espectrogramas de banda limitada para generar formas de onda. Si se utilizan características espectrales de banda completa como entrada, se puede proporcionar al vocoder la mayor cantidad de información acústica posible. Sin embargo, en algunos modelos que emplean mel-espectrogramas de banda completa, se produce un problema de sobre-estabilización en el que se generan espectrogramas poco definidos. Para abordar este problema, proponemos UnivNet, un vocoder neuronal que sintetiza formas de onda de alta fidelidad en tiempo real. Inspirados en trabajos del campo de la detección de actividad de voz, añadimos un discriminador de espectrogramas de multi-resolución que emplea múltiples magnitudes de espectrogramas lineales calculadas utilizando diversos conjuntos de parámetros. Utilizando mel-espectrogramas de banda completa como entrada, esperamos generar señales de alta resolución añadiendo un discriminador que emplea espectrogramas de múltiples resoluciones como entrada. En una evaluación sobre un conjunto de datos que contiene información de cientos de hablantes, UnivNet obtuvo los mejores resultados objetivos y subjetivos entre los modelos competidores tanto para hablantes vistos como no vistos. Estos resultados, incluido el mejor puntaje subjetivo para la síntesis de voz a partir de texto, demuestran el potencial de una adaptación rápida a nuevos hablantes sin necesidad de entrenar desde cero.*

Consejos:

- El argumento `noise_sequence` de [UnivNetModel.forward()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetModel.forward) debe ser ruido gaussiano estándar (como el de `torch.randn`) con forma `([batch_size], noise_length, model.config.model_in_channels)`, donde `noise_length` debe coincidir con la dimensión de longitud (dimensión 1) del argumento `input_features`. Si no se proporciona, se generará aleatoriamente; se puede suministrar un `torch.Generator` al argumento `generator` para que la pasada hacia adelante sea reproducible. (Tenga en cuenta que [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor) devolverá ruido generado por defecto, por lo que no debería ser necesario generar `noise_sequence` manualmente.)
- El padding añadido por [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor) se puede eliminar de la salida de [UnivNetModel](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetModel) mediante el método `UnivNetFeatureExtractor.batch_decode()`, como se muestra en el ejemplo de uso a continuación.
- Rellenar el final de cada forma de onda con silencio puede reducir los artefactos al final de la muestra de audio generada. Esto se puede hacer proporcionando `pad_end = True` a [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Consulte [este problema](https://github.com/seungwonpark/melgan/issues/8) para obtener más detalles.

Ejemplo de uso:

```python
import torch
from datasets import Audio, load_dataset
from scipy.io.wavfile import write

from transformers import UnivNetFeatureExtractor, UnivNetModel

model_id_or_path = "dg845/univnet-dev"
model = UnivNetModel.from_pretrained(model_id_or_path, device_map="auto")
feature_extractor = UnivNetFeatureExtractor.from_pretrained(model_id_or_path)

ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
# Resample the audio to the model and feature extractor's sampling rate.
ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
# Pad the end of the converted waveforms to reduce artifacts at the end of the output audio samples.
inputs = feature_extractor(
    ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], pad_end=True, return_tensors="pt"
)

with torch.no_grad():
    audio = model(**inputs)

# Remove the extra padding at the end of the output.
audio = feature_extractor.batch_decode(**audio)[0]
# Convert to wav file
write("sample_audio.wav", feature_extractor.sampling_rate, audio)
```

Este modelo fue aportado por [dg845](https://huggingface.co/dg845). En lo que a mi conocimiento respecta, no existe una publicación oficial del código, pero se puede encontrar una implementación no oficial en [maum-ai/univnet](https://github.com/maum-ai/univnet) con puntos de control preentrenados [aquí](https://github.com/maum-ai/univnet#pre-trained-model).

## UnivNetConfig[[transformers.UnivNetConfig]]

#### transformers.UnivNetConfig[[transformers.UnivNetConfig]]

```python
transformers.UnivNetConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, model_in_channels: int = 64, model_hidden_channels: int = 32, num_mel_bins: int = 100, resblock_kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 3), resblock_stride_sizes: list[int] | tuple[int, ...] = (8, 8, 4), resblock_dilation_sizes: list | tuple = ((1, 3, 9, 27), (1, 3, 9, 27), (1, 3, 9, 27)), kernel_predictor_num_blocks: int = 3, kernel_predictor_hidden_channels: int = 64, kernel_predictor_conv_size: int = 3, kernel_predictor_dropout: float | int = 0.0, initializer_range: float = 0.01, leaky_relu_slope: float = 0.2)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/configuration_univnet.py#L24)

**Parámetros:**

model_in_channels (`int`, *opcional*, valor predeterminado 64) : El número de canales de entrada para la red residual UnivNet. Esto debe corresponder a `noise_sequence.shape[1]` y al valor utilizado en la clase [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor).

model_hidden_channels (`int`, *opcional*, valor predeterminado: 32) : El número de canales ocultos de cada bloque residual en la red residual UnivNet.

num_mel_bins (`int`, *opcional*, valor predeterminado 100) : El número de bandas de frecuencia en el espectrograma log-mel de condicionamiento. Este valor debe corresponder al utilizado en la clase [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor).

resblock_kernel_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[3, 3, 3]`) : Una tupla de enteros que define los tamaños de los núcleos de las capas convolucionales 1D en la red residual de UnivNet. La longitud de `resblock_kernel_sizes` define el número de bloques resnet y debe coincidir con la de `resblock_stride_sizes` y `resblock_dilation_sizes`.

resblock_stride_sizes (`tuple[int]` o `list[int]`, *opcional*, valor predeterminado `[8, 8, 4]`) : Una tupla de enteros que define los tamaños de paso de las capas de convolución 1D en la red residual de UnivNet. La longitud de `resblock_stride_sizes` debe coincidir con la de `resblock_kernel_sizes` y `resblock_dilation_sizes`.

resblock_dilation_sizes (`tuple[tuple[int]]` o `list[list[int]]`, *opcional*, valor predeterminado `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : Una tupla anidada de enteros que define las tasas de dilatación de las capas convolucionales 1D dilatadas en la red residual de UnivNet. La longitud de `resblock_dilation_sizes` debe coincidir con la de `resblock_kernel_sizes` y `resblock_stride_sizes`. La longitud de cada lista anidada en `resblock_dilation_sizes` define el número de capas convolucionales por bloque de resnet.

kernel_predictor_num_blocks (`int`, *opcional*, valor predeterminado 3) : El número de bloques residuales en la red del predictor de kernels, que calcula el kernel y el sesgo para cada capa de convolución de variables de ubicación en la red residual UnivNet.

kernel_predictor_hidden_channels (`int`, *opcional*, valor predeterminado: 64) : El número de canales ocultos para cada bloque residual en la red del predictor de kernel.

kernel_predictor_conv_size (`int`, *opcional*, valor predeterminado 3) : El tamaño del kernel de cada capa convolucional 1D en la red predictora de kernels.

kernel_predictor_dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout para cada bloque residual en la red del predictor de kernel.

initializer_range (`float`, *opcional*, valor predeterminado `0.01`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

leaky_relu_slope (`float`, *opcional*, valor predeterminado 0.2) : El ángulo de la pendiente negativa utilizado por la activación leaky ReLU.

Esta es la clase de configuración para almacenar la configuración de un UnivNetModel. Se utiliza para instanciar un modelo Univnet según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

```python
>>> from transformers import UnivNetModel, UnivNetConfig

>>> # Initializing a Tortoise TTS style configuration
>>> configuration = UnivNetConfig()

>>> # Initializing a model (with random weights) from the Tortoise TTS style configuration
>>> model = UnivNetModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## UnivNetFeatureExtractor[[transformers.UnivNetFeatureExtractor]]

#### transformers.UnivNetFeatureExtractor[[transformers.UnivNetFeatureExtractor]]

```python
transformers.UnivNetFeatureExtractor(feature_size: int = 1, sampling_rate: int = 24000, padding_value: float = 0.0, do_normalize: bool = False, num_mel_bins: int = 100, hop_length: int = 256, win_length: int = 1024, win_function: str = 'hann_window', filter_length: int | None = 1024, max_length_s: int = 10, fmin: float = 0.0, fmax: float | None = None, mel_floor: float = 1e-09, center: bool = False, compression_factor: float = 1.0, compression_clip_val: float = 1e-05, normalize_min: float = -11.512925148010254, normalize_max: float = 2.3143386840820312, model_in_channels: int = 64, pad_end_length: int = 10, return_attention_mask = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/feature_extraction_univnet.py#L29)

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 1) : La dimensión de las características de las características extraídas.

sampling_rate (`int`, *opcional*, valor predeterminado 24000) : La frecuencia de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).

padding_value (`float`, *opcional*, valor predeterminado 0.0) : El valor con el que se rellena al aplicar la estrategia de relleno definida por el argumento `padding` de [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Debe corresponder al silencio de audio. El argumento `pad_end` de `__call__` también utilizará este valor de relleno.

do_normalize (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe realizar la normalización de Tacotron 2 en la entrada. La normalización puede ayudar a mejorar significativamente el rendimiento de algunos modelos.

num_mel_bins (`int`, *opcional*, valor predeterminado 100) : El número de bandas de frecuencia mel en las características del espectrograma extraído. Debe coincidir con `UnivNetModel.config.num_mel_bins`.

hop_length (`int`, *opcional*, valor predeterminado 256) : El número directo de muestras entre las ventanas deslizantes. También se denomina "shift" en muchos artículos. Tenga en cuenta que esto difiere de otros extractores de características de audio, como [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), que toman `hop_length` en ms.

win_length (`int`, *opcional*, valor predeterminado 1024) : El número directo de muestras para cada ventana deslizante. Tenga en cuenta que esto es diferente de otros extractores de características de audio, como [SpeechT5FeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), que toman `win_length` en ms.

win_function (`str`, *opcional*, valor predeterminado `"hann_window"`) : Nombre de la función de ventana utilizada para la ventana, debe ser accesible mediante `torch.{win_function}`

filter_length (`int`, *opcional*, valor predeterminado 1024) : El número de componentes FFT a utilizar. Si es `None`, se determina mediante `transformers.audio_utils.optimal_fft_length`.

max_length_s (`int`, *opcional*, valor predeterminado: 10) : La longitud máxima de entrada del modelo en segundos. Se utiliza para rellenar el audio.

fmin (`float`, *opcional*, valor predeterminado 0.0) : Frecuencia mel mínima en Hz.

fmax (`float`, *opcional*) : Frecuencia mel máxima en Hz. Si no se establece, el valor predeterminado es `sampling_rate / 2`.

mel_floor (`float`, *opcional*, valor predeterminado 1e-09) : Valor mínimo de los bancos de frecuencias mel. Tenga en cuenta que la forma en que [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor) utiliza `mel_floor` es diferente a la de [transformers.audio_utils.spectrogram()](/docs/transformers/v5.23.0/es/internal/audio_utils#transformers.audio_utils.spectrogram).

center (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe rellenar la forma de onda para que el fotograma `t` esté centrado en el tiempo `t * hop_length`. Si es `False`, el fotograma `t` comenzará en el tiempo `t * hop_length`.

compression_factor (`float`, *opcional*, valor predeterminado 1.0) : Factor de compresión multiplicativo para la compresión del rango dinámico durante la normalización espectral.

compression_clip_val (`float`, *opcional*, valor predeterminado 1e-05) : El valor de recorte aplicado a la forma de onda antes de aplicar la compresión de rango dinámico durante la normalización espectral.

normalize_min (`float`, *opcional*, valor predeterminado -11.512925148010254) : El valor mínimo utilizado para la normalización lineal de estilo Tacotron 2. El valor predeterminado es el valor original de la implementación de Tacotron 2.

normalize_max (`float`, *opcional*, valor predeterminado 2.3143386840820312) : El valor máximo utilizado para la normalización lineal de estilo Tacotron 2. El valor predeterminado es el valor original de la implementación de Tacotron 2.

model_in_channels (`int`, *opcional*, valor predeterminado: 64) : El número de canales de entrada del modelo [UnivNetModel](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetModel). Debe coincidir con `UnivNetModel.config.model_in_channels`.

pad_end_length (`int`, *opcional*, valor predeterminado 10) : Si se rellena el final de cada forma de onda, es el número de muestras equivalentes a los fotogramas del espectrograma que se añadirán. El número de muestras añadidas será `pad_end_length * hop_length`.

return_attention_mask (`bool`, *opcional*, valor predeterminado `True`) : Indica si [__call__()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) debe devolver `attention_mask`.

Construye un extractor de características de UnivNet.

Esta clase extrae características de banco de filtros log-mel a partir de audio bruto utilizando la Transformada de Fourier de tiempo corto (STFT). La implementación de la STFT sigue la de TacoTron 2 y Hifi-GAN.

Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### __llamada__[[transformers.UnivNetFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_noise: bool = True, generator: numpy.random._generator.Generator | None = None, pad_end: bool = False, pad_length: int | None = None, do_normalize: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/feature_extraction_univnet.py#L286)

**Parámetros:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La secuencia o el lote de secuencias que se van a rellenar. Cada secuencia puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. Debe ser audio de un solo canal, no estéreo, es decir, un solo valor flotante por paso de tiempo.

sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada `raw_speech`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos y permitir el pipeline de reconocimiento automático de voz.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las formas de onda de entrada `raw_speech` (según el lado de relleno y el índice de relleno del modelo) entre:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona ese argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).  Si `pad_end = True`, ese relleno se aplicará antes de que se aplique la estrategia de `padding`.

max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba).

truncation (`bool`, *opcional*, valor predeterminado `True`) : Activa la truncación para recortar las secuencias de entrada más largas que `max_length` hasta `max_length`.

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta), o en TPUs, que se benefician de que las longitudes de secuencia sean un múltiplo de 128.

return_noise (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe generar y devolver una forma de onda de ruido para usar en [UnivNetModel.forward()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetModel.forward).

generator (`numpy.random.Generator`, *opcional*, valor predeterminado `None`) : Un generador de números aleatorios `numpy.random.Generator` opcional para utilizar al generar ruido.

pad_end (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe rellenar el final de cada forma de onda con silencio. Esto puede ayudar a reducir los artefactos al final de la muestra de audio generada; consulte https://github.com/seungwonpark/melgan/issues/8 para obtener más detalles. Este relleno se realizará antes de aplicar la estrategia de relleno especificada en `padding`.

pad_length (`int`, *opcional*, valor predeterminado `None`) : Si se rellena el final de cada forma de onda, la longitud del relleno en fotogramas del espectrograma. Si no se establece, este valor será `self.config.pad_end_length` por defecto.

do_normalize (`bool`, *opcional*) : Indica si se debe realizar la normalización de Tacotron 2 en la entrada. La normalización puede ayudar a mejorar significativamente el rendimiento de algunos modelos. Si no se establece, el valor predeterminado será `self.config.do_normalize`.

return_attention_mask (`bool`, *opcional*) : Indica si se debe devolver la máscara de atención. Si se deja en el valor predeterminado, se devolverá la máscara de atención según el valor predeterminado del feature_extractor específico.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.np.array` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

Método principal para extraer características y preparar una o varias secuencias para el modelo.

## UnivNetModel[[transformers.UnivNetModel]]

#### transformers.UnivNetModel[[transformers.UnivNetModel]]

```python
transformers.UnivNetModel(config: UnivNetConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/modeling_univnet.py#L425)

**Parámetros:**

config ([UnivNetConfig](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Univnet básico que emite estados ocultos sin ningún cabezal específico en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### forward[[transformers.UnivNetModel.forward]]

```python
forward(input_features: Tensor, noise_sequence: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.Tensor] = None, generator: typing.Optional[torch.Generator] = None, return_dict: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/univnet/modeling_univnet.py#L469)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor). Consulte [UnivNetFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) para más detalles (`processor_class` usa [UnivNetFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetFeatureExtractor) para procesar audios).

noise_sequence (`torch.Tensor`, *opcional*) : Tensor que contiene una secuencia de ruido de ruido gaussiano estándar. Puede estar agrupado y tener forma `(batch_size, sequence_length, config.model_in_channels)`, o no agrupado y tener forma (sequence_length, config.model_in_channels)`. Si no se proporciona, se generará aleatoriamente.

padding_mask (`torch.BoolTensor`, *opcional*) : Máscara que indica qué partes de cada secuencia están rellenas. Los valores de la máscara se seleccionan en `[0, 1]`:  - 1 para los tokens que **no están enmascarados** - 0 para los tokens que **están enmascarados**  La máscara puede estar agrupada y tener forma `(batch_size, sequence_length)` o no agrupada y tener forma `(sequence_length,)`.

generator (`torch.Generator`, *opcional*) : Un [generador de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. return_dict: Si se debe devolver una subclase de [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** `UnivNetModelOutput` o `tuple(torch.Tensor)`

Un `UnivNetModelOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([UnivNetConfig](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetConfig)) y las entradas.

El método forward de [UnivNetModel](/docs/transformers/v5.23.0/es/model_doc/univnet#transformers.UnivNetModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **formas de onda** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Formas de onda de audio de salida 1D (monocanal) por lotes.
- **waveform_lengths** (`torch.Tensor` de forma `(batch_size,)`) -- La longitud por lote, en muestras, de cada forma de onda sin relleno en `waveforms`.

Ejemplo:

```python
>>> from transformers import UnivNetFeatureExtractor, UnivNetModel
>>> from datasets import load_dataset, Audio

>>> model = UnivNetModel.from_pretrained("dg845/univnet-dev")
>>> feature_extractor = UnivNetFeatureExtractor.from_pretrained("dg845/univnet-dev")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> # Resample the audio to the feature extractor's sampling rate.
>>> ds = ds.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
>>> inputs = feature_extractor(
...     ds[0]["audio"]["array"], sampling_rate=ds[0]["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> audio = model(**inputs).waveforms
>>> list(audio.shape)
[1, 140288]
```

