Hugging Face's logo

Transformers documentation

Mimi

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

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 18/09/2024.

FlashAttention SDPA

Mimi

Mimi é um modelo de codec de áudio neural com variantes pré-treinadas e quantizadas, projetado para representação e compressão eficientes de fala. O modelo opera a 1,1 kbps com uma taxa de quadro de 12 Hz e utiliza uma arquitetura de codificador-decodificador convolucional combinada com um quantizador vetorial residual de 16 livros de códigos. O Mimi gera fluxos duplos de tokens, ou seja, semânticos e acústicos, para equilibrar a riqueza linguística com a reconstrução de alta fidelidade. Os recursos principais incluem um codificador de streaming causal para uso de baixa latência, tokenização de caminho duplo para geração flexível em etapas posteriores e prontidão para integração com grandes modelos de fala, como o Moshi.

Você pode encontrar os checkpoints originais do Mimi na organização Kyutai.

Este modelo foi contribuído por ylacombe.

Clique nos modelos Mimi na barra lateral à direita para ver mais exemplos de como aplicar o Mimi.

O exemplo abaixo demonstra como codificar e decodificar áudio com a classe AutoModel.

AutoModel
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, MimiModel


librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

# load model and feature extractor
model = MimiModel.from_pretrained("kyutai/mimi", device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/mimi")

# load audio sample
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
audio_values = model.decode(encoder_outputs.audio_codes, inputs["padding_mask"])[0]
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values

MimiConfig

classe transformers.MimiConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Parâmetros

  • sampling_rate (int, opcional, padrão 24000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).
  • audio_channels (int, opcional, padrão 1) — Número de canais nos dados de áudio. 1 para mono ou 2 para estéreo.
  • hidden_size (int, opcional, padrão 512) — Dimensão das representações ocultas.
  • num_filters (int, opcional, padrão 64) — Número de núcleos de convolução da primeira camada de downsampling MimiConv1d.
  • num_residual_layers (int, opcional, padrão 1) — Número de camadas residuais.
  • upsampling_ratios (Sequence[int], opcional) — Proporções de tamanho e passo do kernel. O codificador usa proporções de downsampling em vez de proporções de upsampling, portanto, ele usará as proporções na ordem inversa em relação às especificadas aqui, que devem corresponder à ordem do decodificador. Se não especificado, o valor padrão será [8, 6, 5, 4]
  • kernel_size (int, opcional, padrão 7) — O tamanho do kernel de convolução.
  • last_kernel_size (int, opcional, padrão 3) — Tamanho do kernel para a última camada de convolução.
  • residual_kernel_size (int, opcional, padrão 3) — Tamanho do kernel para as camadas residuais.
  • dilation_growth_rate (int, opcional, padrão 2) — Quanto aumentar a dilatação em cada camada.
  • use_causal_conv (bool, opcional, padrão True) — Se deve usar convolução totalmente causal.
  • pad_mode (str, opcional, padrão "constant") — Modo de preenchimento para as convoluções.
  • compress (int, opcional, padrão 2) — Dimensão reduzida nos ramos residuais.
  • trim_right_ratio (float, opcional, padrão 1.0) — Proporção para o recorte na parte direita da convolução transposta sob a configuração use_causal_conv = True. Se for igual a 1.0, significa que todo o recorte é feito na parte direita.
  • codebook_size (int, opcional, padrão 2048) — O número de codebooks paralelos usados pelo modelo.
  • codebook_dim (int, opcional, padrão 256) — Dimensão de cada vetor de incorporação do codebook.
  • num_quantizers (int, opcional, padrão 32) — Número de canais de quantizador, ou codebooks, no quantizador.
  • use_conv_shortcut (bool, opcional, padrão False) — Se deve usar uma camada de convolução como conexão de ‘skip’ no bloco MimiResnetBlock. Se False, uma função identidade será usada, resultando em uma conexão residual genérica.
  • vector_quantization_hidden_dimension (int, opcional, padrão 256) — Dimensão da representação intermediária no espaço de quantização vetorial residual.
  • num_semantic_quantizers (int, opcional, padrão 1) — Número de canais de quantizador semântico, ou codebooks, no quantizador semântico. Deve ser menor que num_quantizers.
  • upsample_groups (int, opcional, padrão 512) — Se frame_rate!=encodec_frame_rate, indica o número de grupos usados na operação de upsampling para passar de uma taxa para outra.
  • num_hidden_layers (int, opcional, padrão 8) — Número de camadas ocultas no decodificador do Transformer.
  • intermediate_size (int, opcional, padrão 2048) — Dimensão das representações do MLP.
  • num_attention_heads (int, opcional, padrão 8) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional, padrão 8) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • head_dim (int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, padrão 8000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • use_cache (bool, opcional, padrão False) — Indica se o modelo deve ou não retornar as últimas chaves/valores de atenção (não utilizado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente de decodificador.
  • use_streaming (bool, opcional, padrão False) — Se deve usar o modo de streaming. Se True, o método de codificação do modelo retornará o cache de padding que pode ser usado em uma chamada subsequente ao método de codificação.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.
  • sliding_window (int, opcional, padrão 250) — Tamanho da janela de atenção deslizante. Se None, nenhuma janela deslizante é aplicada.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • layer_scale_initial_scale (float, opcional, padrão 0.01) — Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para grande. Defina 0 para desativar a escala da camada.
  • attention_bias (bool, opcional, padrão False) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • tie_word_embeddings (bool, opcional, padrão True) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.

Esta é a classe de configuração para armazenar a configuração de um MimiModel. Ela é usada para instanciar um modelo Mimi 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 kyutai/mimi

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 MimiModel, MimiConfig

>>> # Initializing a "kyutai/mimi" style configuration
>>> configuration = MimiConfig()

>>> # Initializing a model (with random weights) from the "kyutai/mimi" style configuration
>>> model = MimiModel(configuration)

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

MimiEncoderConfig

classe transformers.MimiEncoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Configuração da metade do codificador do Mimi (codificador SEANet, codificador transformer e downsampling). Ele compartilha todos os campos com MimiConfig (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do Mimi.

MimiDecoderConfig

classe transformers.MimiDecoderConfig

< >

( 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 = Nonesampling_rate: int = 24000audio_channels: int = 1hidden_size: int = 512num_filters: int = 64num_residual_layers: int = 1upsampling_ratios: list[int] | None = Nonekernel_size: int = 7last_kernel_size: int = 3residual_kernel_size: int = 3dilation_growth_rate: int = 2use_causal_conv: bool = Truepad_mode: str = 'constant'compress: int = 2trim_right_ratio: float = 1.0codebook_size: int = 2048codebook_dim: int = 256num_quantizers: int = 32use_conv_shortcut: bool = Falsevector_quantization_hidden_dimension: int = 256num_semantic_quantizers: int = 1upsample_groups: int = 512num_hidden_layers: int = 8intermediate_size: int = 2048num_attention_heads: int = 8num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'gelu'max_position_embeddings: int = 8000initializer_range: float = 0.02norm_eps: float = 1e-05use_cache: bool = Falseuse_streaming: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonesliding_window: int = 250attention_dropout: float | int = 0.0layer_scale_initial_scale: float = 0.01attention_bias: bool = Falsetie_word_embeddings: bool = True )

Configuração da metade decodificadora do Mimi (upsampling, transformer decodificador e decodificador SEANet). Ele compartilha todos os campos com MimiConfig (consulte sua documentação para os argumentos), portanto, pode ser carregado diretamente de um checkpoint completo do Mimi.

MimiModel

classe transformers.MimiModel

< >

( config: MimiConfig )

Parâmetros

  • config (MimiConfig) — 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 de codec de áudio neural Mimi.

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.

decode

< >

( audio_codes: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonedecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Decodifica os frames fornecidos em uma forma de onda de áudio de saída: os códigos são desquantizados nos latentes de MimiDecoderModel.forward().

encode

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonenum_quantizers: float | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Codifica a forma de onda de áudio de entrada em códigos discretos de forma (batch_size, num_quantizers, frames): os latentes de MimiEncoderModel.forward(), quantizados.

forward

< >

( input_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonenum_quantizers: int | None = Noneaudio_codes: typing.Optional[torch.Tensor] = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonedecoder_past_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiOutput or tuple(torch.FloatTensor)

Parâmetros

  • input_values (torch.FloatTensor de forma (batch_size, channels, sequence_length), opcional) — Entrada de áudio bruta convertida para Float.
  • padding_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Indica quais entradas devem ser ignoradas devido ao padding, em que os elementos são 1 para não mascarado ou 0 para mascarado.
  • num_quantizers (int, opcional) — Número de quantizadores (ou seja, codebooks) a serem usados. Por padrão, todos os quantizadores são utilizados.
  • audio_codes (torch.LongTensor de forma (batch_size, num_quantizers, codes_length), opcional) — Incorporações de códigos discretas calculadas usando model.encode.
  • encoder_past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador codificador. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior de decodificação, quando use_cache=True ou config.use_cache=True.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, o usuário pode opcionalmente inserir apenas os últimos audio_values ou `audio_codes (aqueles que não têm seus estados de chave passada fornecidos a este modelo).

  • decoder_past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador decodificador. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior de decodificação, quando use_cache=True ou config.use_cache=True.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, o usuário pode, opcionalmente, inserir apenas os últimos audio_values ou `audio_codes (aqueles que não têm seus estados de chave passada fornecidos a este modelo).

Retorna

MimiOutput ou tuple(torch.FloatTensor)

Um MimiOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (MimiConfig) e das entradas.

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

  • audio_codes (torch.LongTensor de forma (batch_size, num_quantizers, codes_length), opcional) — Embebidings de códigos discretos calculados usando model.encode.

  • audio_values (torch.FloatTensor de forma (batch_size, sequence_length), opcional) — Valores de áudio decodificados, obtidos usando a parte decodificadora do Mimi.

  • encoder_past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador codificador. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior de decodificação, quando use_cache=True ou config.use_cache=True.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, o usuário pode opcionalmente inserir apenas os últimos audio_values ou `audio_codes (aqueles que não têm seus estados de chave passada fornecidos a este modelo).

  • decoder_past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador decodificador. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior de decodificação, quando use_cache=True ou config.use_cache=True.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, o usuário pode opcionalmente inserir apenas os últimos audio_values ou `audio_codes (aqueles que não têm seus estados de chave passada fornecidos a este modelo).

Exemplos:

>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, MimiModel

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model_id = "kyutai/mimi"
>>> model = MimiModel.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> inputs = feature_extractor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values

MimiEncoderModel

classe transformers.MimiEncoderModel

< >

( config: MimiEncoderConfig )

Parâmetros

  • config (MimiEncoderConfig) — 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.

A metade codificadora do Mimi: codificador SEANet, transformador do codificador e redução de amostragem, do áudio para latentes contínuos.

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_values: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.mimi.modeling_mimi.MimiConv1dPaddingCache | None = Noneuse_streaming: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiEncoderModelOutput or tuple(torch.FloatTensor)

Parâmetros

  • input_values (torch.Tensor de forma (batch_size, channels, sequence_length)) — Valores em ponto flutuante da forma de onda de áudio de entrada.
  • padding_mask (torch.Tensor de forma (batch_size, channels, sequence_length), opcional) — Indica quais entradas devem ser ignoradas devido ao padding, em que os elementos são 1 para não mascarado ou 0 para mascarado.
  • past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador codificador, usados para acelerar a codificação em streaming.
  • padding_cache (MimiConv1dPaddingCache, opcional) — Cache de padding das convoluções causais, usado para codificação em streaming.
  • use_streaming (bool, opcional) — Se codificar em modo de streaming, retornando os caches para passar à próxima chamada.
  • Encodes a forma de onda de áudio de entrada em latentes contínuos de forma (batch_size, latent_dim, frames). —

Retorna

MimiEncoderModelOutput ou tuple(torch.FloatTensor)

Um MimiEncoderModelOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (MimiConfig) e das entradas.

O método forward do MimiEncoderModel sobrescreve 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.

  • latents (torch.FloatTensor de forma (batch_size, latent_dim, frames)) — Latentes contínuos do áudio, com um frame para cada config.frame_size amostras de áudio.
  • past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador codificador, retornados durante o streaming.
  • padding_cache (MimiConv1dPaddingCache, opcional) — Cache de padding para as convoluções causais de MimiConv1d, a fim de suportar streaming por meio do padding do cache.
  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True) — Estados ocultos do transformador codificador na saída de cada camada, além da sua entrada.
  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True) — Pesos de atenção de cada camada do transformador codificador.

MimiDecoderModel

classe transformers.MimiDecoderModel

< >

( config: MimiDecoderConfig )

Parâmetros

  • config (MimiDecoderConfig) — 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.

A metade decodificadora do Mimi: upsampling, transformer decodificador e decodificador SEANet, de latentes contínuos para áudio.

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

< >

( latents: Tensorpadding_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MimiDecoderOutput or tuple(torch.FloatTensor)

Parâmetros

  • latents (torch.FloatTensor de forma (batch_size, hidden_size, frames)) — Latentes contínuos para decodificar, conforme calculados por MimiModel.decode().
  • padding_mask (torch.Tensor de forma (batch_size, channels, sequence_length), opcional) — Indica quais entradas devem ser ignoradas devido ao padding, em que os elementos são 1 para não mascarado ou 0 para mascarado.
  • past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) do transformador decodificador, usados para acelerar a decodificação em streaming.
  • Decodes os quadros fornecidos em uma forma de onda de áudio de saída. Observe que a saída pode ser um pouco maior que a —
  • input. Nesse caso, quaisquer etapas extras no final podem ser removidas. —

Retorna

MimiDecoderOutput ou tuple(torch.FloatTensor)

Um MimiDecoderOutput ou uma tupla de torch.FloatTensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (MimiConfig) e das entradas.

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

  • audio_values (torch.FloatTensor de forma (batch_size, audio_channels, num_samples), opcional) — Valores de áudio decodificados, obtidos usando a parte decodificadora do Mimi.

  • decoder_past_key_values (Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados para acelerar a decodificação sequencial do transformador decodificador. Isso geralmente consiste nos past_key_values retornados pelo modelo em uma etapa anterior de decodificação, quando use_cache=True ou config.use_cache=True.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, o usuário pode, opcionalmente, inserir apenas os últimos audio_values ou `audio_codes (aqueles que não têm seus estados de chave passada fornecidos a este modelo).

  • hidden_states (tuple(torch.FloatTensor), opcional, retornado quando output_hidden_states=True) — Estados ocultos do transformador do decodificador na saída de cada camada, além da sua entrada.

  • attentions (tuple(torch.FloatTensor), opcional, retornado quando output_attentions=True) — Pesos de atenção de cada camada do transformador do decodificador.

Update on GitHub

←LASR MMS→