Hugging Face's logo

Transformers documentation

Moshi

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 publicado no HF papers em 2024-09-17 e contribuído para o Hugging Face Transformers em 2024-10-16.

Moshi

FlashAttention SDPA

Visão geral

O modelo Moshi foi proposto em Moshi: a speech-text foundation model for real-time dialogue por Alexandre Défossez, Laurent Mazaré, Manu Orsini, Amélie Royer, Patrick Pérez, Hervé Jégou, Edouard Grave e Neil Zeghidour.

Moshi é um modelo de base para fala e texto que trata o diálogo falado como geração de fala para fala. Partindo de um backbone de modelo de linguagem de texto, o Moshi gera fala como tokens a partir do quantizador residual de um codec neural de áudio, enquanto modela separadamente a própria fala e a do usuário em streams paralelos. Isso permite a remoção de turnos de fala explícitos e a modelagem de dinâmicas conversacionais arbitrárias. O Moshi também prevê tokens de texto alinhados no tempo como um prefixo para os tokens de áudio. Esse método de “Inner Monologue” melhora significativamente a qualidade linguística da fala gerada e fornece reconhecimento de fala em streaming e texto para fala. Como resultado, o Moshi é o primeiro grande modelo de linguagem falado full-duplex em tempo real, com uma latência teórica de 160ms, 200ms na prática.

O resumo do artigo é o seguinte:

Apresentamos o Moshi, um modelo de base para fala e texto e um framework de diálogo oral full-duplex. Os sistemas atuais para diálogo oral dependem de pipelines de componentes independentes, a saber: detecção de atividade de voz, reconhecimento de fala, diálogo textual e text-to-speech. Tais frameworks não conseguem emular a experiência de conversas reais. Primeiro, sua complexidade induz uma latência de vários segundos entre as interações. Segundo, como o texto é a modalidade intermediária para o diálogo, informações não linguísticas que modificam o significado — como emoção ou sons não vocais — são perdidas na interação. Por fim, eles dependem de uma segmentação em turnos de fala, que não leva em conta a fala sobreposta, interrupções e interjeições. O Moshi resolve esses problemas independentes de forma integrada ao tratar o diálogo oral como geração de fala para fala. Partindo de um backbone de modelo de linguagem de texto, o Moshi gera fala como tokens a partir do quantizador residual de um codec de áudio neural, enquanto modela separadamente a própria fala e a do usuário em streams paralelos. Isso permite a remoção de turnos de fala explícitos e a modelagem de dinâmicas conversacionais arbitrárias. Além disso, estendemos a geração hierárquica de tokens semânticos para acústicos de trabalhos anteriores para primeiro prever tokens de texto alinhados no tempo como um prefixo para tokens de áudio. Não apenas esse método “Inner Monologue” melhora significativamente a qualidade linguística da fala gerada, mas também ilustramos como ele pode fornecer reconhecimento de fala em streaming e text-to-speech. Nosso modelo resultante é o primeiro large language model oral full-duplex em tempo real, com uma latência teórica de 160ms, 200ms na prática, e está disponível em github.com/kyutai-labs/moshi.

Moshi lida com 3 fluxos de informações:

  1. O áudio do usuário
  2. Áudio do Moshi
  3. Saída textual do Moshi

De forma semelhante ao ~MusicgenModel, o áudio é representado por codebooks de áudio, que podem ser interpretados como tokens. A principal diferença entre tokens de texto e codebooks de áudio é que os codebooks de áudio introduzem uma dimensão adicional de informação. Os tokens de texto geralmente têm dimensão (batch_size, sequence_length), mas os tokens de áudio têm dimensão (batch_size, num_codebooks, sequence_length).

O Moshi é composto por 3 componentes:

1. O decodificador principal (Helium no artigo)

Corresponde a MoshiForCausalLM. Trata-se estritamente de um LLM de texto clássico, que utiliza uma arquitetura semelhante à de ~GemmaForCausalLM. Em outras palavras, ele recebe tokens de texto, os embute, os passa pelo decodificador e por uma cabeça de linguagem, para obter logits de texto.

2. O decodificador de profundidade

Por si só, também é um LLM clássico, mas desta vez, em vez de gerar ao longo da dimensão do tempo, ele gera ao longo da dimensão do codebook.

Isso também significa que o comprimento do contexto é num_codebooks, portanto, ele não pode gerar mais do que num_codebooks.

Observe que cada timestamp - ou seja, cada codebook - possui seu próprio conjunto de Linear Layers e Embeddings.

3. MimiModel

É o codificador de áudio da Kyutai, que foi recentemente integrado ao transformers e é usado para “tokenizar” áudio. Ele tem o mesmo uso que o ~EncodecModel tem no ~MusicgenModel.

Dicas

Os checkpoints originais podem ser convertidos usando o script de conversão src/transformers/models/moshi/convert_moshi_transformers.py

Como usar o modelo

Esta implementação tem dois objetivos principais:

  1. testar rapidamente a geração de modelos simplificando a API original
  2. simplificar o treinamento. Um guia de treinamento será disponibilizado em breve, mas contribuições dos usuários são bem-vindas!

Ele foi projetado para uso intermediário. Recomendamos fortemente o uso da implementação original para inferir o modelo em streaming em tempo real.

1. Geração de modelo

Moshi é um modelo auto-regressivo de streaming com dois fluxos de áudio. Em outras palavras, um fluxo de áudio corresponde ao que o modelo disse/dirá e o outro fluxo de áudio corresponde ao que o usuário disse/dirá.

MoshiForConditionalGeneration.generate() portanto requer 3 entradas:

  1. input_ids - correspondente ao histórico de tokens do texto
  2. moshi_input_values ou moshi_audio_codes - correspondentes ao histórico de áudio do modelo
  3. user_input_values ou user_audio_codes - correspondentes ao histórico de áudio do usuário

Essas três entradas devem estar sincronizadas. Ou seja, seus comprimentos devem corresponder ao mesmo número de tokens.

Você pode usar dinamicamente as 3 entradas, dependendo do que deseja testar:

  1. Basta verificar a resposta do modelo a um prompt de usuário - nesse caso, input_ids pode ser preenchido com tokens de padding e user_input_values pode ser um tensor de zeros com a mesma forma do prompt do usuário.
  2. Teste um comportamento mais complexo - nesse caso, você deve ter cuidado com a forma como os tokens de entrada são sincronizados com os áudios.

O modelo original sincroniza texto com áudio, preenchendo o texto entre cada enunciado de token.

Para seguir o exemplo da imagem a seguir, "Hello, I'm Moshi" poderia ser transformado em "Hello,<pad><unk>I'm Moshi".

MoshiForConditionalGeneration.generate() então alimenta a si mesmo, de forma autoregressiva, seu próprio fluxo de áudio, mas, como não tem acesso ao fluxo de entrada do usuário ao usar transformers, ele assumirá que o usuário está produzindo áudio em branco.

import math

import torch
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, AutoTokenizer


librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/moshiko-pytorch-bf16")
tokenizer = AutoTokenizer.from_pretrained("kyutai/moshiko-pytorch-bf16")
dtype = torch.bfloat16

# prepare user input audio
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
user_input_values = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(device=device, dtype=dtype)

# prepare moshi input values - we suppose moshi didn't say anything while the user spoke
moshi_input_values = torch.zeros_like(user_input_values.input_values)

# prepare moshi input ids - we suppose moshi didn't say anything while the user spoke
num_tokens = math.ceil(moshi_input_values.shape[-1] * waveform_to_token_ratio)
input_ids = torch.ones((1, num_tokens), device=device, dtype=torch.int64) * tokenizer.encode("<pad>")[0]

# generate 25 new tokens (around 2s of audio)
output = model.generate(input_ids=input_ids, user_input_values=user_input_values.input_values, moshi_input_values=moshi_input_values, max_new_tokens=25)

text_tokens = output.sequences
audio_waveforms = output.audio_sequences

2. Treinamento do modelo

A maior parte do trabalho precisa ser feita durante a criação/pré-processamento dos dados, devido à necessidade de alinhar/sincronizar os fluxos.

Quando terminar, basta encaminhar text_labels e audio_labels para MoshiForConditionalGeneration.forward(), junto com as entradas habituais, para obter a perda do modelo.

Um guia de treinamento estará disponível em breve, mas contribuições dos usuários são bem-vindas!

Como o modelo processa as entradas / gera

  1. Os fluxos de entrada são incorporados e combinados em inputs_embeds.

  2. inputs_embeds é passado pelo decodificador principal, que o processa como um LLM normal faria.

  3. O decodificador principal produz text logits, mas também seu last hidden state, que é chamado de temporal context no artigo.

  4. O decodificador de profundidade alterna a dimensão na qual fazemos o encaminhamento / geração (codebooks em vez de tempo). Ele usa o token gerado a partir dos text logits e o temporal context para gerar codebooks de áudio de forma auto-regressiva.

Este modelo foi contribuído por Yoach Lacombe (ylacombe).

O código original pode ser encontrado aqui.

MoshiConfig

classe transformers.MoshiConfig

< >

( 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 = Nonevocab_size: int = 32000hidden_size: int = 4096num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int | None = Noneaudio_vocab_size: int | None = Nonemax_position_embeddings: int = 3000rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonehidden_act: str = 'silu'head_dim: int | None = Noneinitializer_range: float = 0.02use_cache: bool = Truesliding_window: int = 3000attention_dropout: float | int = 0.0ffn_dim: int = 22528rms_norm_eps: float = 1e-08num_codebooks: int = 8tie_word_embeddings: bool = Falsepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Noneaudio_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedepth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

Parâmetros

  • vocab_size (int, opcional, padrão 32000) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • hidden_size (int, opcional, padrão 4096) — Dimensão das representações ocultas.
  • num_hidden_layers (int, opcional, padrão 32) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 32) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — 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.
  • audio_vocab_size (int, opcional) — Tamanho do vocabulário da parte de áudio do modelo. Define o número de tokens diferentes que podem ser representados pelos audio_codes passados ao chamar os modelos Moshi.
  • max_position_embeddings (int, opcional, padrão 3000) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • 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.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • 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
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • sliding_window (int, opcional, padrão 3000) — 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.
  • ffn_dim (int, opcional, padrão 22528) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no bloco principal do decodificador. Deve ser par.
  • rms_norm_eps (float, opcional, padrão 1e-08) — O epsilon usado pelas camadas de normalização rms.
  • num_codebooks (int, opcional, padrão 8) — O número de codebooks paralelos usados pelo modelo.
  • tie_word_embeddings (bool, opcional, padrão False) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário.
  • audio_encoder_config (PreTrainedConfig | dict, opcional) — Configuração para o codificador de áudio.
  • depth_decoder_config (PreTrainedConfig | dict, opcional) — Configuração para o decodificador de profundidade.

Esta é a classe de configuração para armazenar a configuração de um MoshiModel. Ela é usada para instanciar um modelo Moshi 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 kmhf/hf-moshika

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 (
...     MoshiConfig,
...     MoshiForConditionalGeneration,
... )

>>> configuration = MoshiConfig()

>>> # Initializing a MoshiForConditionalGeneration (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiForConditionalGeneration(configuration)

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

>>> # Saving the model, including its configuration
>>> model.save_pretrained("kmhf/hf-moshika")

>>> # loading model and config from pretrained folder
>>> moshi_config = MoshiConfig.from_pretrained("kmhf/hf-moshika")
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika", config=moshi_config)

from_audio_encoder_config

< >

( audio_encoder_config: PreTrainedConfig**kwargs ) → MoshiConfig

Retorna

MoshiConfig

Uma instância de um objeto de configuração

Instancie um MoshiConfig (ou uma classe derivada) a partir de uma configuração de codificador de áudio.

MoshiDepthConfig

classe transformers.MoshiDepthConfig

< >

( 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 = Nonevocab_size: int = 32000hidden_size: int = 1024input_size: int = 4096num_hidden_layers: int = 6num_attention_heads: int = 16num_key_value_heads: int | None = Noneaudio_vocab_size: int = 2048max_position_embeddings: int = 9hidden_act: str = 'silu'head_dim: int | None = Noneinitializer_range: float = 0.02use_cache: bool = Truesliding_window: int = 8attention_dropout: float | int = 0.0ffn_dim: int = 5632rms_norm_eps: float = 1e-08num_codebooks: int = 8tie_word_embeddings: bool = Falsepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = None )

Parâmetros

  • vocab_size (int, opcional, padrão 32000) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • input_size (int, opcional, padrão 4096) — Dimensão dos estados ocultos de entrada. Usado para conectar o decodificador principal ao decodificador de profundidade.
  • num_hidden_layers (int, opcional, padrão 6) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional) — 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.
  • audio_vocab_size (int, opcional, padrão 2048) — Tamanho do vocabulário da parte de áudio do modelo. Define o número de tokens diferentes que podem ser representados pelos audio_codes passados ao chamar os modelos Moshi.
  • max_position_embeddings (int, opcional, padrão 9) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • 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
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • sliding_window (int, opcional, padrão 8) — 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.
  • ffn_dim (int, opcional, padrão 5632) — Dimensão da camada “intermediária” (frequentemente chamada de feed-forward) no bloco do decodificador de profundidade. Deve ser par.
  • rms_norm_eps (float, opcional, padrão 1e-08) — O epsilon usado pelas camadas de normalização rms.
  • num_codebooks (int, opcional, padrão 8) — O número de codebooks paralelos usados pelo modelo.
  • tie_word_embeddings (bool, opcional, padrão False) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um MoshiModel. Ela é usada para instanciar um modelo Moshi 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 kmhf/hf-moshika

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 (
...     MoshiDepthConfig,
...     MoshiDepthDecoder,
... )

>>> configuration = MoshiDepthConfig()

>>> # Initializing a MoshiDepthDecoder (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiDepthDecoder(configuration)

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

MoshiModel

classe transformers.MoshiModel

< >

( config: MoshiConfig )

Parâmetros

  • config (MoshiConfig) — 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 Moshi básico, que gera 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_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

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

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

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

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

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

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

BaseModelOutputWithPast ou tuple(torch.Tensor)

Um BaseModelOutputWithPast 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 (MoshiConfig) e das entradas.

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

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

MoshiForCausalLM

classe transformers.MoshiForCausalLM

< >

( config: MoshiConfig )

Parâmetros

  • config (MoshiConfig) — 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 decodificador Moshi com uma cabeça de modelagem de linguagem de texto no topo. Utilizável apenas para texto.

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_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoshiCausalLMOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

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

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

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

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

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

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].
  • logits_to_keep (Union[int, torch.Tensor], opcional, padrão 0) — Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_ids (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um torch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).

Retorna

MoshiCausalLMOutputWithPast ou tuple(torch.Tensor)

Um MoshiCausalLMOutputWithPast 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 (MoshiConfig) e das entradas.

O método forward de MoshiForCausalLM 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.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do modelo.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple[torch.Tensor, ...], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple[torch.Tensor, ...], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

>>> from transformers import AutoTokenizer, MoshiForCausalLM

>>> model = MoshiForCausalLM.from_pretrained("kmhf/hf-moshika")
>>> tokenizer = AutoTokenizer.from_pretrained("kmhf/hf-moshika")

>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"

MoshiForConditionalGeneration

classe transformers.MoshiForConditionalGeneration

< >

( config: MoshiConfig )

Parâmetros

  • config (MoshiConfig) — 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 Moshi original, com um codificador de áudio, um decodificador de profundidade Moshi e um decodificador Moshi, para conversão de fala em fala.

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_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.BoolTensor] = Noneuser_input_values: typing.Optional[torch.Tensor] = Noneuser_audio_codes: typing.Optional[torch.Tensor] = Nonemoshi_input_values: typing.Optional[torch.Tensor] = Nonemoshi_audio_codes: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonetext_labels: typing.Optional[torch.LongTensor] = Noneaudio_labels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → MoshiConditionalGenerationOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • attention_mask (torch.BoolTensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

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

  • user_input_values (torch.Tensor de forma `(batch_size, 1, audio_sequence_length), opcional) — As formas de onda de áudio usadas como prompt de áudio do usuário para a geração.
  • user_audio_codes (torch.Tensor of shape (batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio user prompt for the generation. Has priority over user_input_valuesand represents the audio "tokens" ofuser_input_values` once passed through the audio encoder.
  • moshi_input_values (torch.Tensor de forma `(batch_size, 1, audio_sequence_length), opcional) — As formas de onda de áudio usadas como prompt de áudio Moshi para a geração.
  • moshi_audio_codes (torch.Tensor of shape (batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio Moshi prompt for the generation. Has priority over moshi_input_valuesand represents the audio "tokens" ofmoshi_input_values` once passed through the audio encoder.
  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

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

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids você pode escolher passar diretamente uma representação incorporada. Se past_key_values for usado, opcionalmente apenas o último inputs_embeds precisa ser entrado (veja past_key_values). Isso é útil se você quiser mais controle sobre como converter input_ids índices em vetores associados do que a matriz de busca de incorporação interna do modelo.

    Se input_ids e inputs_embeds estiverem ambos não definidos, inputs_embeds assume o valor de inputs_embeds.

  • text_labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para modelagem de linguagem de texto. Observe que os rótulos são deslocados dentro do modelo, ou seja, você pode definir labels = input_ids Os índices são selecionados em [-100, 0, ..., config.vocab_size] Todos os rótulos definidos como -100 são ignorados (mascarados); a perda é calculada apenas para rótulos em [0, ..., config.vocab_size]
  • audio_labels (torch.LongTensor de forma (batch_size, num_codebooks, sequence_length), opcional) — Rótulos para modelagem de linguagem. Observe que os rótulos são deslocados dentro do modelo, ou seja, você pode definir labels = input_ids Os índices são selecionados em [-100, 0, ..., config.vocab_size] Todos os rótulos definidos como -100 são ignorados (mascarados); a perda é calculada apenas para rótulos em [0, ..., config.audio_vocab_size]
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

MoshiConditionalGenerationOutputWithPast ou tuple(torch.Tensor)

Um MoshiConditionalGenerationOutputWithPast 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 (MoshiConfig) e das entradas.

O método forward de MoshiForConditionalGeneration 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.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando text_labels é fornecido) — Perda de modelagem de linguagem de texto (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem de texto (pontuações para cada token do vocabulário antes do SoftMax).

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Sequência de estados ocultos na saída da última camada do modelo.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple[torch.Tensor, ...], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple[torch.Tensor, ...], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • depth_loss (torch.Tensor de forma (1,), opcional, retornado quando audio_labels é fornecido) — Perda de modelagem de linguagem de áudio (para previsão do próximo token).

  • audio_logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão das cabeças de modelagem de linguagem de áudio.

  • depth_past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — Chaves e valores passados do decodificador de profundidade.

  • depth_hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Estados ocultos do decodificador de profundidade

  • depth_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Pesos de Attenções do decodificador de profundidade após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplos:

>>> from transformers import MoshiForConditionalGeneration
>>> import torch

>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")
>>> inputs = moshi.get_unconditional_inputs()

>>> logits = model(**inputs, ).logits
>>> logits.shape  # (bsz, seq_len, text_vocab_size)
torch.Size([1, 1, 32000])

generate

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneuser_input_values: typing.Optional[torch.Tensor] = Noneuser_audio_codes: typing.Optional[torch.Tensor] = Nonemoshi_input_values: typing.Optional[torch.Tensor] = Nonemoshi_audio_codes: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonereturn_audio_waveforms: bool | None = Truereturn_audio_codes: bool | None = Noneconcat_unconditional_inputs: bool | None = True**kwargs )

Parâmetros

  • input_ids (torch.Tensor de forma `(batch_size, sequence_length), opcional) — A sequência usada como prompt de texto para a geração.
  • user_input_values (torch.Tensor de forma `(batch_size, 1, audio_sequence_length), opcional) — As formas de onda de áudio usadas como prompt de áudio do usuário para a geração.
  • user_audio_codes (torch.Tensor of shape (batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio user prompt for the generation. Has priority over user_input_valuesand represents the audio "tokens" ofuser_input_values` once passed through the audio encoder.
  • moshi_input_values (torch.Tensor de forma `(batch_size, 1, audio_sequence_length), opcional) — As formas de onda de áudio usadas como prompt de áudio Moshi para a geração.
  • moshi_audio_codes (torch.Tensor of shape (batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio Moshi prompt for the generation. Has priority over moshi_input_valuesand represents the audio "tokens" ofmoshi_input_values` once passed through the audio encoder.
  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids e as entradas de áudio, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter as entradas em vetores associados do que a matriz de busca de incorporação interna do modelo.
  • return_audio_waveforms (bool, opcional, padrão True) — Se False, não gera as formas de onda de áudio.
  • return_audio_codes (bool, opcional) — Se True, também retorna os códigos de áudio gerados, ou seja, os “tokens” intermediários de áudio que se transformam em audio_sequences após passarem pelo decodificador de áudio.
  • concat_unconditional_inputs (bool, opcional, padrão True) — Se False, não concatenará os tokens iniciais de áudio e texto.
  • kwargs (dict[str, Any], opcional) — Dicionário restante de argumentos de palavra-chave que são passados para o método generate. Consulte os docstrings originais de generate para obter mais informações sobre como usá-los. Observe que as palavras-chave com o prefixo depth_ serão usadas como entrada para o método generate do decodificador de profundidade. Caso contrário, este último usará sua configuração de geração padrão.

Gera sequências de ids de tokens de texto e ids de tokens de áudio.

get_unconditional_inputs

< >

( num_samples = 1 )

Parâmetros

  • num_samples (int, opcional) — Número de amostras de áudio a serem geradas incondicionalmente.
  • max_new_tokens (int, opcional) — Número de tokens a serem gerados para cada amostra. Mais tokens significam amostras de áudio mais longas, em detrimento de um tempo de inferência maior (pois é necessário gerar mais tokens de áudio por amostra).

Função auxiliar para obter entradas nulas para geração incondicional, permitindo que o modelo seja usado sem o extrator de recursos ou o tokenizador.

Exemplo:

>>> from transformers import MoshiForConditionalGeneration

>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")

>>> # get the unconditional (or 'null') inputs for the model
>>> unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
>>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)
Update on GitHub

←Moonshine Streaming MOSS-Transcribe-Diarize→