# UnivNet

## Aperçu

Le modèle UnivNet a été proposé dans [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) par Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin et Juntae Kim. Le modèle UnivNet est un réseau antagoniste génératif (GAN) entraîné à synthétiser des formes d’onde vocales haute fidélité. Le modèle UnivNet partagé dans `transformers` est le *generator*, qui associe un spectrogramme log-mel de conditionnement et une séquence de bruit facultative à une forme d’onde vocale (par exemple, un vocoder). Seul le generator est requis pour l’inférence. Le *discriminator* utilisé pour entraîner le `generator` n’est pas implémenté.

L'abstract de l'article est le suivant :

*La plupart des vocodeurs neuronaux utilisent des mélospectrogrammes à bande limitée pour générer des formes d’onde. Si des caractéristiques spectrales pleine bande sont utilisées en entrée, le vocodeur peut recevoir le maximum d’informations acoustiques possible. Cependant, dans certains modèles utilisant des mélospectrogrammes pleine bande, un problème de lissage excessif se produit, entraînant la génération de spectrogrammes peu nets. Pour remédier à ce problème, nous proposons UnivNet, un vocodeur neuronal qui synthétise des formes d’onde haute fidélité en temps réel. Inspirés par des travaux dans le domaine de la détection d’activité vocale, nous avons ajouté un discriminateur de spectrogrammes multi-résolution qui utilise plusieurs amplitudes de spectrogrammes linéaires calculées à l’aide de divers ensembles de paramètres. En utilisant des mélospectrogrammes pleine bande en entrée, nous nous attendons à générer des signaux haute résolution en ajoutant un discriminateur qui utilise des spectrogrammes de plusieurs résolutions en entrée. Lors d’une évaluation sur un jeu de données contenant des informations sur des centaines de locuteurs, UnivNet a obtenu les meilleurs résultats objectifs et subjectifs parmi les modèles concurrents, tant pour les locuteurs vus que non vus. Ces résultats, y compris le meilleur score subjectif pour la synthèse vocale, démontrent le potentiel d’une adaptation rapide à de nouveaux locuteurs sans avoir besoin d’un entraînement à partir de zéro.*

Astuces :

- L'argument `noise_sequence` de [UnivNetModel.forward()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetModel.forward) doit être un bruit gaussien standard (tel que produit par `torch.randn`) de forme `([batch_size], noise_length, model.config.model_in_channels)`, où `noise_length` doit correspondre à la dimension de longueur (dimension 1) de l'argument `input_features`. S'il n'est pas fourni, il sera généré aléatoirement ; un `torch.Generator` peut être fourni à l'argument `generator` afin que le passage avant puisse être reproduit. (Notez que [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor) renvoie du bruit généré par défaut, il ne devrait donc pas être nécessaire de générer `noise_sequence` manuellement.)
- Le padding ajouté par [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor) peut être retiré de la sortie de [UnivNetModel](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetModel) à l’aide de la méthode `UnivNetFeatureExtractor.batch_decode()`, comme le montre l’exemple d’utilisation ci-dessous.
- L'ajout de silence à la fin de chaque forme d'onde peut réduire les artefacts en fin d'échantillon audio généré. Il est possible de le faire en transmettant `pad_end = True` à [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Consultez [ce problème](https://github.com/seungwonpark/melgan/issues/8) pour plus de détails.

Exemple d'utilisation :

```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)
```

Ce modèle a été contribué par [dg845](https://huggingface.co/dg845). À ma connaissance, il n’existe pas de publication officielle du code, mais une implémentation non officielle est disponible sur [maum-ai/univnet](https://github.com/maum-ai/univnet), avec des points de contrôle pré-entraînés [ici](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)
```

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

**Paramètres :**

model_in_channels (`int`, *facultatif*, valeur par défaut 64) : Le nombre de canaux d'entrée pour le réseau résiduel UnivNet. Cette valeur doit correspondre à `noise_sequence.shape[1]` et à la valeur utilisée dans la classe [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor).

model_hidden_channels (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de canaux cachés de chaque bloc résiduel dans le réseau résiduel UnivNet.

num_mel_bins (`int`, *facultatif*, valeur par défaut 100) : Le nombre de bandes de fréquence dans le spectrogramme log-mel de conditionnement. Cette valeur doit correspondre à celle utilisée dans la classe [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor).

resblock_kernel_sizes (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[3, 3, 3]`) : Un tuple d'entiers définissant les tailles de noyau des couches de convolution 1D dans le réseau résiduel UnivNet. La longueur de `resblock_kernel_sizes` définit le nombre de blocs resnet et doit correspondre à celle de `resblock_stride_sizes` et `resblock_dilation_sizes`.

resblock_stride_sizes (`tuple[int]` ou `list[int]`, *facultatif*, valeur par défaut `[8, 8, 4]`) : Un tuple d'entiers définissant les tailles de pas des couches de convolution 1D dans le réseau résiduel UnivNet. La longueur de `resblock_stride_sizes` doit correspondre à celle de `resblock_kernel_sizes` et de `resblock_dilation_sizes`.

resblock_dilation_sizes (`tuple[tuple[int]]` ou `list[list[int]]`, *facultatif*, par défaut `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : Un tuple imbriqué d'entiers définissant les taux de dilatation des couches de convolution 1D dilatées dans le réseau résiduel UnivNet. La longueur de `resblock_dilation_sizes` doit correspondre à celle de `resblock_kernel_sizes` et de `resblock_stride_sizes`. La longueur de chaque liste imbriquée dans `resblock_dilation_sizes` définit le nombre de couches de convolution par bloc resnet.

kernel_predictor_num_blocks (`int`, *facultatif*, valeur par défaut 3) : Le nombre de blocs résiduels dans le réseau du prédicteur de noyaux, qui calcule le noyau et le biais pour chaque couche de convolution à variables de position dans le réseau résiduel UnivNet.

kernel_predictor_hidden_channels (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de canaux cachés pour chaque bloc résiduel du réseau prédicteur de noyau.

kernel_predictor_conv_size (`int`, *facultatif*, valeur par défaut : 3) : La taille du noyau de chaque couche de convolution 1D dans le réseau prédicteur de noyaux.

kernel_predictor_dropout (`float`, *facultatif*, valeur par défaut 0.0) : La probabilité de dropout pour chaque bloc résiduel du réseau prédicteur de noyau.

initializer_range (`float`, *facultatif*, valeur par défaut `0.01`) : L'écart-type de truncated_normal_initializer pour l'initialisation de toutes les matrices de poids.

leaky_relu_slope (`float`, *facultatif*, par défaut 0.2) : L'angle de la pente négative utilisé par l'activation leaky ReLU.

Ceci est la classe de configuration destinée à stocker la configuration d'un UnivNetModel. Elle est utilisée pour instancier un modèle Univnet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```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)
```

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

**Paramètres :**

feature_size (`int`, *facultatif*, valeur par défaut : 1) : La dimension des caractéristiques des fonctionnalités extraites.

sampling_rate (`int`, *facultatif*, valeur par défaut : 24000) : Fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : La valeur utilisée pour le bourrage lors de l’application de la stratégie de bourrage définie par l’argument `padding` de [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Elle doit correspondre au silence audio. L’argument `pad_end` de `__call__` utilisera également cette valeur de bourrage.

do_normalize (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer la normalisation Tacotron 2 sur l'entrée. La normalisation peut contribuer à améliorer considérablement les performances de certains modèles.

num_mel_bins (`int`, *facultatif*, valeur par défaut 100) : Le nombre de bandes de fréquences mel dans les caractéristiques du spectrogramme extrait. Cette valeur doit correspondre à `UnivNetModel.config.num_mel_bins`.

hop_length (`int`, *facultatif*, valeur par défaut 256) : Nombre direct d'échantillons entre les fenêtres glissantes. Ce paramètre est également appelé « shift » dans de nombreux articles. Notez que cela diffère d'autres extracteurs de caractéristiques audio, tels que [SpeechT5FeatureExtractor](/docs/transformers/main/fr/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), qui prennent `hop_length` en millisecondes.

win_length (`int`, *facultatif*, valeur par défaut : 1024) : Le nombre direct d'échantillons pour chaque fenêtre glissante. Notez que cela diffère d'autres extracteurs de caractéristiques audio tels que [SpeechT5FeatureExtractor](/docs/transformers/main/fr/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), qui prennent `win_length` en millisecondes.

win_function (`str`, *facultatif*, valeur par défaut `"hann_window"`) : Nom de la fonction de fenêtre utilisée pour le fenêtrage, doit être accessible via `torch.{win_function}`

filter_length (`int`, *facultatif*, valeur par défaut 1024) : Le nombre de composantes FFT à utiliser. Si `None`, cette valeur est déterminée à l'aide de `transformers.audio_utils.optimal_fft_length`.

max_length_s (`int`, *facultatif*, valeur par défaut 10) : La longueur d'entrée maximale du modèle, en secondes. Cette valeur est utilisée pour effectuer le bourrage de l'audio.

fmin (`float`, *facultatif*, valeur par défaut 0.0) : Fréquence mel minimale en Hz.

fmax (`float`, *facultatif*) : Fréquence mel maximale en Hz. Si non définie, la valeur par défaut est `sampling_rate / 2`.

mel_floor (`float`, *facultatif*, valeur par défaut 1e-09) : Valeur minimale des banques de fréquences mel. Notez que la manière dont [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor) utilise `mel_floor` diffère de celle de [transformers.audio_utils.spectrogram()](/docs/transformers/main/fr/internal/audio_utils#transformers.audio_utils.spectrogram).

center (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter des zéros (padding) à la forme d'onde afin que la trame `t` soit centrée sur le temps `t * hop_length`. Si `False`, la trame `t` commence au temps `t * hop_length`.

compression_factor (`float`, *facultatif*, valeur par défaut 1.0) : Facteur de compression multiplicatif pour la compression de la plage dynamique lors de la normalisation spectrale.

compression_clip_val (`float`, *facultatif*, valeur par défaut 1e-05) : La valeur de clip appliquée à la forme d'onde avant l'application de la compression de plage dynamique lors de la normalisation spectrale.

normalize_min (`float`, *facultatif*, valeur par défaut : -11.512925148010254) : La valeur minimale utilisée pour la normalisation linéaire de type Tacotron 2. La valeur par défaut est la valeur originale de l'implémentation Tacotron 2.

normalize_max (`float`, *facultatif*, valeur par défaut 2.3143386840820312) : La valeur maximale utilisée pour la normalisation linéaire de type Tacotron 2. La valeur par défaut est la valeur originale de l'implémentation Tacotron 2.

model_in_channels (`int`, *facultatif*, valeur par défaut : 64) : Le nombre de canaux d'entrée du modèle [UnivNetModel](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetModel). Cette valeur doit correspondre à `UnivNetModel.config.model_in_channels`.

pad_end_length (`int`, *facultatif*, valeur par défaut 10) : Lors de l'ajout d'un padding à la fin de chaque forme d'onde, nombre d'échantillons correspondant au nombre de trames de spectrogramme à ajouter. Le nombre d'échantillons ajoutés sera `pad_end_length * hop_length`.

return_attention_mask (`bool`, *facultatif*, valeur par défaut `True`) : Indique si [__call__()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) doit retourner `attention_mask`.

Construit un extracteur de caractéristiques UnivNet.

Cette classe extrait les caractéristiques de la banque de filtres log-mel à partir de la parole brute en utilisant la transformée de Fourier à court terme (STFT). L’implémentation de la STFT suit celle de TacoTron 2 et Hifi-GAN.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/main/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

#### __appel__[[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)
```

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

**Paramètres :**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La séquence ou le lot de séquences à rembourrer. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Doit être un audio mono, pas stéréo, c'est-à-dire un seul flottant par pas de temps.

sampling_rate (`int`, *facultatif*) : Le taux d'échantillonnage auquel l'entrée `raw_speech` a été échantillonnée. Il est fortement recommandé de passer `sampling_rate` lors de l'appel forward afin d'éviter les erreurs silencieuses et de permettre le pipeline de reconnaissance automatique de la parole.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `True`) : Sélectionne une stratégie pour mettre en bourrage les formes d'onde d'entrée `raw_speech` (selon le côté de bourrage et l'indice de bourrage du modèle) parmi :  - `True` ou `'longest'` : Met en bourrage jusqu'à la séquence la plus longue du lot (ou sans bourrage si une seule séquence est fournie). - `'max_length'` : Met en bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Pas de bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).  Si `pad_end = True`, ce bourrage sera effectué avant que la stratégie de `padding` ne soit appliquée.

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

truncation (`bool`, *facultatif*, valeur par défaut `True`) : Active la troncature pour couper les séquences d'entrée plus longues que `max_length` à `max_length`.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdie jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta), ou sur les TPU qui bénéficient de longueurs de séquence multiples de 128.

return_noise (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut générer et retourner une forme d'onde de bruit à utiliser dans [UnivNetModel.forward()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetModel.forward).

generator (`numpy.random.Generator`, *facultatif*, par défaut `None`) : Un générateur de nombres aléatoires `numpy.random.Generator` facultatif à utiliser lors de la génération du bruit.

pad_end (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ajouter du silence à la fin de chaque forme d'onde. Cela peut aider à réduire les artefacts en fin d'échantillon audio généré ; voir https://github.com/seungwonpark/melgan/issues/8 pour plus de détails. Ce bourrage sera effectué avant l'application de la stratégie de bourrage spécifiée dans `padding`.

pad_length (`int`, *facultatif*, valeur par défaut `None`) : Si un bourrage est appliqué à la fin de chaque forme d'onde, la longueur du bourrage en trames de spectrogramme. Si non défini, la valeur par défaut est `self.config.pad_end_length`.

do_normalize (`bool`, *facultatif*) : Indique s'il faut effectuer la normalisation Tacotron 2 sur l'entrée. La normalisation peut contribuer à améliorer significativement les performances de certains modèles. Si non défini, la valeur par défaut est `self.config.do_normalize`.

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du feature_extractor spécifique. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.np.array` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

Méthode principale pour vectoriser et préparer une ou plusieurs séquences pour le modèle.

## UnivNetModel[[transformers.UnivNetModel]]

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

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

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

**Paramètres :**

config ([UnivNetConfig](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Univnet brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### 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)
```

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

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor). Voir [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) pour plus de détails (`processor_class` utilise [UnivNetFeatureExtractor](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetFeatureExtractor) pour le traitement des audios).

noise_sequence (`torch.Tensor`, *facultatif*) : Tensor contenant une séquence de bruit de bruit gaussien standard. Peut être groupé (batched) et de forme `(batch_size, sequence_length, config.model_in_channels)`, ou non groupé et de forme (sequence_length, config.model_in_channels)`. S'il n'est pas fourni, il sera généré aléatoirement.

padding_mask (`torch.BoolTensor`, *facultatif*) : Masque indiquant quelles parties de chaque séquence sont remplies (padding). Les valeurs du masque sont choisies dans `[0, 1]` :  - 1 pour les jetons qui ne sont **pas masqués** - 0 pour les jetons qui sont **masqués**  Le masque peut être en lot (batched) et de forme `(batch_size, sequence_length)` ou sans lot (un-batched) et de forme `(sequence_length,)`.

generator (`torch.Generator`, *facultatif*) : Un [générateur torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe. return_dict : Indique s'il faut retourner une sous-classe de [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple.

**Retourne :** `UnivNetModelOutput` ou `tuple(torch.Tensor)`

Un `UnivNetModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([UnivNetConfig](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetConfig)) et les entrées.

La méthode forward du modèle [UnivNetModel](/docs/transformers/main/fr/model_doc/univnet#transformers.UnivNetModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **formes d’onde** (`torch.Tensor` de forme `(batch_size, sequence_length)`) -- Formes d’onde audio de sortie 1D (mono-canal) par lot.
- **waveform_lengths** (`torch.Tensor` de forme `(batch_size,)`) -- La longueur en échantillons de chaque forme d'onde non rembourrée du lot dans `waveforms`.

Exemple :

```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]
```