Hugging Face's logo

Transformers documentation

UnivNet

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 2021-06-15 e contribuído para o Hugging Face Transformers em 2023-11-22.

UnivNet

Visão geral

O modelo UnivNet foi proposto em UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation 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() 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), em que 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 retornará ruído gerado por padrão, portanto, não deve ser necessário gerar noise_sequence manualmente.)
  • O padding adicionado pelo UnivNetFeatureExtractor pode ser removido da saída do 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(). Veja este problema para mais detalhes.

Exemplo de uso:

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. Até onde eu saiba, não há um lançamento oficial de código, mas uma implementação não oficial pode ser encontrada em maum-ai/univnet com checkpoints pré-treinados aqui.

UnivNetConfig

classe transformers.UnivNetConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonemodel_in_channels: int = 64model_hidden_channels: int = 32num_mel_bins: int = 100resblock_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 = 3kernel_predictor_hidden_channels: int = 64kernel_predictor_conv_size: int = 3kernel_predictor_dropout: float | int = 0.0initializer_range: float = 0.01leaky_relu_slope: float = 0.2 )

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.
  • 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. Este valor deve corresponder ao valor usado na classe 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 de convolução 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 stride 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 convolucionais 1D dilataadas 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 convolucionais por bloco resnet.
  • kernel_predictor_num_blocks (int, opcional, padrão 3) — O número de blocos residuais na rede do preditor de kernel, 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 kernel predictor.
  • kernel_predictor_conv_size (int, opcional, padrão 3) — O tamanho do kernel de cada camada convolucional 1D na rede do preditor de kernel.
  • kernel_predictor_dropout (float, opcional, padrão 0.0) — A probabilidade de dropout para cada bloco residual na rede do kernel predictor.
  • 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 função de 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

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

classe transformers.UnivNetFeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 24000padding_value: float = 0.0do_normalize: bool = Falsenum_mel_bins: int = 100hop_length: int = 256win_length: int = 1024win_function: str = 'hann_window'filter_length: int | None = 1024max_length_s: int = 10fmin: float = 0.0fmax: float | None = Nonemel_floor: float = 1e-09center: bool = Falsecompression_factor: float = 1.0compression_clip_val: float = 1e-05normalize_min: float = -11.512925148010254normalize_max: float = 2.3143386840820312model_in_channels: int = 64pad_end_length: int = 10return_attention_mask = True**kwargs )

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 aplicar o preenchimento definido pelo argumento padding em 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 executar 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ído. 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 chamado de “shift” em muitos artigos. Observe que isso é diferente de outros extratores de recursos de áudio, como 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, que recebem 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, esse valor é determinado usando transformers.audio_utils.optimal_fft_length.
  • max_length_s (int, opcional, padrão 10) — O comprimento máximo da 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 utiliza mel_floor é diferente da utilizada em transformers.audio_utils.spectrogram().
  • center (bool, opcional, padrão False) — Indica se a forma de onda deve ser preenchida 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) — Fator de compressão multiplicativo para a compressão da 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. Deve corresponder a UnivNetModel.config.model_in_channels.
  • pad_end_length (int, opcional, padrão 10) — Ao aplicar padding no final de cada forma de onda, o número de amostras correspondentes a quadros de espectrograma 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() deve retornar attention_mask ou não.

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, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | None = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Truemax_length: int | None = Nonetruncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_noise: bool = Truegenerator: numpy.random._generator.Generator | None = Nonepad_end: bool = Falsepad_length: int | None = Nonedo_normalize: str | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = None )

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, 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, opcional, padrão é True) — Selecione uma estratégia para aplicar padding às formas de onda de raw_speech (de acordo com o lado de padding e o índice de padding do modelo) entre:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja 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 preenchimento ocorrerá antes de a estratégia padding ser 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 com comprimento maior 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 habilitar 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().
  • generator (numpy.random.Generator, opcional, padrão None) — Um gerador de números aleatórios numpy.random.Generator opcional a ser usado ao gerar ruído.
  • pad_end (bool, opcional, padrão False) — Indica se o final de cada forma de onda deve ser preenchido com silêncio. 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á realizado antes da estratégia de preenchimento especificada em padding.
  • pad_length (int, opcional, padrão None) — Ao aplicar padding no final de cada forma de onda, o comprimento do padding em quadros de espectrograma. Se não for definido, o valor padrão será self.config.pad_end_length.
  • do_normalize (bool, opcional) — Se deve executar 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 específico do feature_extractor.

    O que são máscaras de atenção?

  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors 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

classe transformers.UnivNetModel

< >

( config: UnivNetConfig )

Parâmetros

  • config (UnivNetConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método 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. 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 do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_features: Tensornoise_sequence: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.Tensor] = Nonegenerator: typing.Optional[torch.Generator] = Nonereturn_dict: bool | None = None**kwargs ) → UnivNetModelOutput or tuple(torch.Tensor)

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. Consulte UnivNetFeatureExtractor.call() para mais detalhes (processor_class usa UnivNetFeatureExtractor para processar os áudios).
  • noise_sequence (torch.Tensor, opcional) — Tensor contendo uma sequência de ruído de ruído gaussiano padrão. Pode ser em lote, com forma (batch_size, sequence_length, config.model_in_channels), ou sem lote, com forma (sequence_length, config.model_in_channels)`. Se não for fornecido, será gerado aleatoriamente.
  • padding_mask (torch.BoolTensor, opcional) — Máscara que indica quais partes de cada sequência são preenchidas (padding). 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, com forma (batch_size, sequence_length), ou sem lote, com forma (sequence_length,).

  • generator (torch.Generator, opcional) — Um gerador do torch para tornar a geração determinística. return_dict: Se deve retornar uma subclasse de ModelOutput em vez de uma tupla simples.
  • return_dict (bool, opcional) — Indica se deve retornar um 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) e das entradas.

O método forward do 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:

>>> 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]
Update on GitHub

←UniSpeech-SAT VibeVoice→