Hugging Face's logo

Transformers documentation

Mimi

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.Tensor)

Parâmetros

  • input_values (torch.Tensor 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.Tensor)

Um MimiOutput 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 (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.Tensor 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.Tensor)

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.Tensor)

Um MimiEncoderModelOutput 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 (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.Tensor 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.Tensor), 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.Tensor), opcional, retornado quando output_attentions=True) — Pesos de atenção de cada camada do transformador do 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.Tensor)

Parâmetros

  • latents (torch.Tensor 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.Tensor)

Um MimiDecoderOutput 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 (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.Tensor 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.Tensor), 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.Tensor), opcional, retornado quando output_attentions=True) — Pesos de atenção de cada camada do transformador do decodificador.

Update on GitHub

←LASR MMS→