# UnivNet

## Visão geral

O modelo UnivNet foi proposto em [UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation](https://huggingface.co/papers/2106.07889) por Won Jang, Dan Lim, Jaesam Yoon, Bongwan Kin e Juntae Kim. O modelo UnivNet é uma rede adversarial generativa (GAN) treinada para sintetizar formas de onda de fala de alta fidelidade. O modelo UnivNet compartilhado no `transformers` é o *generator*, que mapeia um espectrograma log-mel de condicionamento e uma sequência de ruído opcional para uma forma de onda de fala (por exemplo, um vocoder). Apenas o generator é necessário para inferência. O *discriminator* usado para treinar o `generator` não está implementado.

O resumo do artigo é o seguinte:

*A maioria dos vocoderes neurais utiliza mel-espectrogramas com banda limitada para gerar formas de onda. Se recursos espectrais de banda completa forem usados como entrada, o vocoder poderá receber a maior quantidade possível de informações acústicas. No entanto, em alguns modelos que empregam mel-espectrogramas de banda completa, ocorre um problema de suavização excessiva, no qual são gerados espectrogramas sem nitidez. Para resolver esse problema, propomos o UnivNet, um vocoder neural que sintetiza formas de onda de alta fidelidade em tempo real. Inspirados em trabalhos na área de detecção de atividade de voz, adicionamos um discriminador de espectrograma multirresolução que emprega múltiplas magnitudes de espectrograma linear calculadas usando vários conjuntos de parâmetros. Usando mel-espectrogramas de banda completa como entrada, esperamos gerar sinais de alta resolução ao adicionar um discriminador que utiliza espectrogramas de múltiplas resoluções como entrada. Em uma avaliação em um conjunto de dados contendo informações sobre centenas de falantes, o UnivNet obteve os melhores resultados objetivos e subjetivos entre os modelos concorrentes, tanto para falantes vistos quanto não vistos. Esses resultados, incluindo a melhor pontuação subjetiva para conversão de texto em fala, demonstram o potencial para adaptação rápida a novos falantes sem a necessidade de treinamento do zero.*

Dicas:

- O argumento `noise_sequence` para [UnivNetModel.forward()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetModel.forward) deve ser ruído gaussiano padrão (como o obtido de `torch.randn`) com a forma `([batch_size], noise_length, model.config.model_in_channels)`, onde `noise_length` deve corresponder à dimensão de comprimento (dimensão 1) do argumento `input_features`. Se não for fornecido, ele será gerado aleatoriamente; um `torch.Generator` pode ser fornecido ao argumento `generator` para que a passagem direta possa ser reproduzida. (Observe que [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor) retornará ruído gerado por padrão, portanto, não deve ser necessário gerar `noise_sequence` manualmente.)
- O padding adicionado pelo [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor) pode ser removido da saída do [UnivNetModel](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetModel) por meio do método `UnivNetFeatureExtractor.batch_decode()`, conforme mostrado no exemplo de uso abaixo.
- Preencher o final de cada forma de onda com silêncio pode reduzir artefatos no fim da amostra de áudio gerada. Isso pode ser feito fornecendo `pad_end = True` para [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Veja [este problema](https://github.com/seungwonpark/melgan/issues/8) para mais detalhes.

Exemplo 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 foi contribuído por [dg845](https://huggingface.co/dg845). Pelo que sei, não há um lançamento oficial de código, mas uma implementação não oficial pode ser encontrada em [maum-ai/univnet](https://github.com/maum-ai/univnet) com checkpoints pré-treinados [aqui](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)
```

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

**Parâmetros:**

model_in_channels (`int`, *opcional*, padrão 64) : O número de canais de entrada para a rede residual UnivNet. Isso deve corresponder a `noise_sequence.shape[1]` e ao valor usado na classe [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor).

model_hidden_channels (`int`, *opcional*, padrão 32) : O número de canais ocultos de cada bloco residual na rede residual UnivNet.

num_mel_bins (`int`, *opcional*, padrão 100) : O número de bins de frequência no espectrograma log-mel de condicionamento. Isso deve corresponder ao valor usado na classe [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor).

resblock_kernel_sizes (`tuple[int]` ou `list[int]`, *opcional*, padrão `[3, 3, 3]`) : Uma tupla de inteiros que define os tamanhos dos kernels das camadas convolucionais 1D na rede residual do UnivNet. O comprimento de `resblock_kernel_sizes` define o número de blocos resnet e deve corresponder ao de `resblock_stride_sizes` e `resblock_dilation_sizes`.

resblock_stride_sizes (`tuple[int]` ou `list[int]`, *opcional*, padrão `[8, 8, 4]`) : Uma tupla de inteiros que define os tamanhos de passo das camadas convolucionais 1D na rede residual do UnivNet. O comprimento de `resblock_stride_sizes` deve corresponder ao de `resblock_kernel_sizes` e `resblock_dilation_sizes`.

resblock_dilation_sizes (`tuple[tuple[int]]` ou `list[list[int]]`, *opcional*, padrão `[[1, 3, 9, 27], [1, 3, 9, 27], [1, 3, 9, 27]]`) : Uma tupla aninhada de inteiros que define as taxas de dilatação das camadas de convolução 1D dilatada na rede residual do UnivNet. O comprimento de `resblock_dilation_sizes` deve corresponder ao de `resblock_kernel_sizes` e `resblock_stride_sizes`. O comprimento de cada lista aninhada em `resblock_dilation_sizes` define o número de camadas de convolução por bloco resnet.

kernel_predictor_num_blocks (`int`, *opcional*, padrão 3) : O número de blocos residuais na rede do preditor de kernels, que calcula o kernel e o viés para cada camada de convolução de variáveis de localização na rede residual UnivNet.

kernel_predictor_hidden_channels (`int`, *opcional*, padrão 64) : O número de canais ocultos para cada bloco residual na rede do preditor de kernel.

kernel_predictor_conv_size (`int`, *opcional*, padrão 3) : O tamanho do kernel de cada camada convolucional 1D na rede preditora de kernels.

kernel_predictor_dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout para cada bloco residual na rede do preditor de kernel.

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

leaky_relu_slope (`float`, *opcional*, padrão 0.2) : O ângulo da inclinação negativa usado pela ativação leaky ReLU.

Esta é a classe de configuração para armazenar a configuração de um UnivNetModel. Ela é usada para instanciar um modelo Univnet de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [dg845/univnet-dev](https://huggingface.co/dg845/univnet-dev)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

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

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

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 1) : A dimensão dos recursos das características extraídas.

sampling_rate (`int`, *opcional*, padrão 24000) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).

padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preencher ao aplicar a estratégia de preenchimento definida pelo argumento `padding` de [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__). Deve corresponder ao silêncio do áudio. O argumento `pad_end` de `__call__` também usará esse valor de preenchimento.

do_normalize (`bool`, *opcional*, padrão `False`) : Se deve realizar a normalização do Tacotron 2 na entrada. A normalização pode ajudar a melhorar significativamente o desempenho de alguns modelos.

num_mel_bins (`int`, *opcional*, padrão 100) : O número de bins de frequência mel nos recursos do espectrograma extraídos. Isso deve corresponder a `UnivNetModel.config.num_mel_bins`.

hop_length (`int`, *opcional*, padrão 256) : O número direto de amostras entre as janelas deslizantes. Também referido como "shift" em muitos artigos. Observe que isso é diferente de outros extratores de recursos de áudio, como [SpeechT5FeatureExtractor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), que recebem o `hop_length` em ms.

win_length (`int`, *opcional*, padrão 1024) : O número direto de amostras para cada janela deslizante. Observe que isso é diferente de outros extratores de recursos de áudio, como [SpeechT5FeatureExtractor](/docs/transformers/main/pt/model_doc/speecht5#transformers.SpeechT5FeatureExtractor), que recebem o `win_length` em ms.

win_function (`str`, *opcional*, padrão `"hann_window"`) : Nome da função de janela usada para janelamento, deve ser acessível via `torch.{win_function}`

filter_length (`int`, *opcional*, padrão 1024) : O número de componentes de FFT a serem usados. Se `None`, isso é determinado usando `transformers.audio_utils.optimal_fft_length`.

max_length_s (`int`, *opcional*, padrão 10) : O comprimento máximo de entrada do modelo, em segundos. Isso é usado para aplicar padding ao áudio.

fmin (`float`, *opcional*, padrão 0.0) : Frequência mel mínima em Hz.

fmax (`float`, *opcional*) : Frequência mel máxima em Hz. Se não for definida, o valor padrão é `sampling_rate / 2`.

mel_floor (`float`, *opcional*, padrão 1e-09) : Valor mínimo dos bancos de frequência mel. Observe que a forma como o [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor) utiliza `mel_floor` é diferente da utilizada em [transformers.audio_utils.spectrogram()](/docs/transformers/main/pt/internal/audio_utils#transformers.audio_utils.spectrogram).

center (`bool`, *opcional*, padrão `False`) : Se deve aplicar padding à forma de onda para que o quadro `t` esteja centralizado em torno do tempo `t * hop_length`. Se `False`, o quadro `t` começará no tempo `t * hop_length`.

compression_factor (`float`, *opcional*, padrão 1.0) : O fator de compressão multiplicativo para a compressão de faixa dinâmica durante a normalização espectral.

compression_clip_val (`float`, *opcional*, padrão 1e-05) : O valor de recorte aplicado à forma de onda antes da aplicação da compressão de faixa dinâmica durante a normalização espectral.

normalize_min (`float`, *opcional*, padrão -11.512925148010254) : O valor mínimo usado para a normalização linear no estilo Tacotron 2. O padrão é o valor original da implementação do Tacotron 2.

normalize_max (`float`, *opcional*, padrão 2.3143386840820312) : O valor máximo usado para a normalização linear no estilo Tacotron 2. O padrão é o valor original da implementação do Tacotron 2.

model_in_channels (`int`, *opcional*, padrão 64) : O número de canais de entrada do modelo [UnivNetModel](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetModel). Isso deve corresponder a `UnivNetModel.config.model_in_channels`.

pad_end_length (`int`, *opcional*, padrão 10) : Se estiver preenchendo o final de cada forma de onda, o número de quadros de espectrograma equivalentes em amostras a serem adicionados. O número de amostras adicionadas será `pad_end_length * hop_length`.

return_attention_mask (`bool`, *opcional*, padrão `True`) : Se [__call__()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) deve ou não retornar `attention_mask`.

Constrói um extrator de recursos UnivNet.

Esta classe extrai recursos de banco de filtros log-mel a partir de fala bruta usando a Transformada de Fourier de Tempo Curto (STFT). A implementação da STFT segue a do TacoTron 2 e do Hifi-GAN.

Este extrator de características herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos.

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

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

**Parâmetros:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : A sequência ou lote de sequências a serem preenchidas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. Deve ser áudio mono canal, não estéreo, ou seja, um único float por timestep.

sampling_rate (`int`, *opcional*) : A taxa de amostragem na qual a entrada `raw_speech` foi amostrada. É fortemente recomendável passar `sampling_rate` na chamada de forward para evitar erros silenciosos e permitir o pipeline de reconhecimento automático de fala.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `True`) : Selecione uma estratégia para aplicar `padding` às formas de onda de entrada `raw_speech` (de acordo com o lado de `padding` e o índice de `padding` do modelo) entre:  - `True` ou `'longest'`: Aplica `padding` até a sequência mais longa do lote (ou nenhum `padding` se apenas uma sequência for fornecida). - `'max_length'`: Aplica `padding` até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, se esse argumento não for fornecido. - `False` ou `'do_not_pad'` (padrão): Sem `padding` (ou seja, pode gerar um lote com sequências de comprimentos diferentes).  Se `pad_end = True`, esse `padding` ocorrerá antes que a estratégia de `padding` seja aplicada.

max_length (`int`, *opcional*) : Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).

truncation (`bool`, *opcional*, padrão `True`) : Ativa a truncagem para cortar sequências de entrada maiores que `max_length` para `max_length`.

pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta) ou em TPUs, que se beneficiam de ter comprimentos de sequência que sejam múltiplos de 128.

return_noise (`bool`, *opcional*, padrão `True`) : Se deve gerar e retornar uma forma de onda de ruído para uso em [UnivNetModel.forward()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetModel.forward).

generator (`numpy.random.Generator`, *opcional*, padrão `None`) : Um gerador de números aleatórios `numpy.random.Generator` opcional para usar ao gerar ruído.

pad_end (`bool`, *opcional*, padrão `False`) : Se deve adicionar silêncio ao final de cada forma de onda. Isso pode ajudar a reduzir artefatos no final da amostra de áudio gerada; veja https://github.com/seungwonpark/melgan/issues/8 para mais detalhes. Esse preenchimento será feito antes da estratégia de preenchimento especificada em `padding` ser aplicada.

pad_length (`int`, *opcional*, padrão `None`) : Se for aplicado padding no final de cada forma de onda, o comprimento do padding em quadros de espectrograma. Se não definido, este valor será `self.config.pad_end_length` por padrão.

do_normalize (`bool`, *opcional*) : Se deve realizar a normalização do Tacotron 2 na entrada. A normalização pode ajudar a melhorar significativamente o desempenho de alguns modelos. Se não for definido, o valor padrão será `self.config.do_normalize`.

return_attention_mask (`bool`, *opcional*) : Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do feature_extractor específico.  [O que são attention masks?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de uma lista de inteiros do Python. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.np.array` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do Numpy.

Método principal para criar recursos e preparar uma ou várias sequências para o modelo.

## UnivNetModel[[transformers.UnivNetModel]]

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

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

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

**Parâmetros:**

config ([UnivNetConfig](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo Univnet básico que produz estados ocultos brutos, sem nenhum cabeçalho específico no topo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

**Parâmetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor). Veja [UnivNetFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor.__call__) para detalhes (`processor_class` usa [UnivNetFeatureExtractor](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetFeatureExtractor) para processar áudios).

noise_sequence (`torch.Tensor`, *opcional*) : Tensor contendo uma sequência de ruído de ruído gaussiano padrão. Pode ser em lote (batched) e ter a forma `(batch_size, sequence_length, config.model_in_channels)`, ou sem lote (un-batched) e ter a forma (sequence_length, config.model_in_channels)`. Se não for fornecido, será gerado aleatoriamente.

padding_mask (`torch.BoolTensor`, *opcional*) : Máscara indicando quais partes de cada sequência são preenchidas (padded). Os valores da máscara são selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados** - 0 para tokens que **estão mascarados**  A máscara pode ser em lote (batched) e ter a forma `(batch_size, sequence_length)` ou sem lote (un-batched) e ter a forma `(sequence_length,)`.

generator (`torch.Generator`, *opcional*) : Um [gerador do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. return_dict: Se deve retornar uma subclasse de [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

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

Um `UnivNetModelOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([UnivNetConfig](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetConfig)) e das entradas.

O método forward do [UnivNetModel](/docs/transformers/main/pt/model_doc/univnet#transformers.UnivNetModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **formas de onda** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Formas de onda de áudio de saída 1D (mono-canal) em lote.
- **waveform_lengths** (`torch.Tensor` de forma `(batch_size,)`) -- O comprimento em amostras de cada forma de onda não preenchida em `waveforms`, em lote.

Exemplo:

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