# Moshi

## Visão geral

O modelo Moshi foi proposto em [Moshi: a speech-text foundation model for real-time dialogue](https://huggingface.co/papers/2410.00037) 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](/docs/transformers/main/pt/model_doc/musicgen#transformers.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. Tokens de texto geralmente têm dimensão `(batch_size, sequence_length)`, mas 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](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiForCausalLM). Trata-se estritamente de um LLM de texto clássico, que utiliza uma arquitetura semelhante à de [~GemmaForCausalLM](/docs/transformers/main/pt/model_doc/gemma#transformers.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](/docs/transformers/main/pt/model_doc/mimi#transformers.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](/docs/transformers/main/pt/model_doc/encodec#transformers.EncodecModel) tem no [~MusicgenModel](/docs/transformers/main/pt/model_doc/musicgen#transformers.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](https://github.com/kyutai-labs/moshi) 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()](/docs/transformers/main/pt/model_doc/moshi#transformers.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()](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiForConditionalGeneration.generate) então alimenta a si mesmo, de forma auto-regressiva, 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**.

```python
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()](/docs/transformers/main/pt/model_doc/moshi#transformers.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.

3. 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 de `text logits` e o `temporal context` para gerar codebooks de áudio de forma auto-regressiva.

Este modelo foi contribuído por [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe).

O código original pode ser encontrado [aqui](https://github.com/kyutai-labs/moshi).

## MoshiConfig[[transformers.MoshiConfig]]

#### transformers.MoshiConfig[[transformers.MoshiConfig]]

```python
transformers.MoshiConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, hidden_size: int = 4096, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int | None = None, audio_vocab_size: int | None = None, max_position_embeddings: int = 3000, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, hidden_act: str = 'silu', head_dim: int | None = None, initializer_range: float = 0.02, use_cache: bool = True, sliding_window: int = 3000, attention_dropout: float | int = 0.0, ffn_dim: int = 22528, rms_norm_eps: float = 1e-08, num_codebooks: int = 8, tie_word_embeddings: bool = False, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, audio_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, depth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/configuration_moshi.py#L93)

**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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). 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 usado.

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`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (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.

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) : Dimensionalidade 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 (padding) 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](https://huggingface.co/kmhf/hf-moshika)

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

Exemplo:

```python
>>> from transformers import (
...     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[[transformers.MoshiConfig.from_audio_encoder_config]]

```python
from_audio_encoder_config(audio_encoder_config: PreTrainedConfig, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/configuration_moshi.py#L199)

**Retorna:** [MoshiConfig](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiConfig)

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

Instancie um [MoshiConfig](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiConfig) (ou uma classe derivada) a partir de uma configuração de codificador de áudio.

## MoshiDepthConfig[[transformers.MoshiDepthConfig]]

#### transformers.MoshiDepthConfig[[transformers.MoshiDepthConfig]]

```python
transformers.MoshiDepthConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, hidden_size: int = 1024, input_size: int = 4096, num_hidden_layers: int = 6, num_attention_heads: int = 16, num_key_value_heads: int | None = None, audio_vocab_size: int = 2048, max_position_embeddings: int = 9, hidden_act: str = 'silu', head_dim: int | None = None, initializer_range: float = 0.02, use_cache: bool = True, sliding_window: int = 8, attention_dropout: float | int = 0.0, ffn_dim: int = 5632, rms_norm_eps: float = 1e-08, num_codebooks: int = 8, tie_word_embeddings: bool = False, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/configuration_moshi.py#L26)

**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) : Dimensionalidade 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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). 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 da sequência com o qual este modelo pode ser usado.

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`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (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.

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) : Dimensionalidade 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 (padding) 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](https://huggingface.co/kmhf/hf-moshika)

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

Exemplo:

```python
>>> from transformers import (
...     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[[transformers.MoshiModel]]

#### transformers.MoshiModel[[transformers.MoshiModel]]

```python
transformers.MoshiModel(config: MoshiConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L735)

**Parâmetros:**

config ([MoshiConfig](/docs/transformers/main/pt/model_doc/moshi#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

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

#### forward[[transformers.MoshiModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L754)

**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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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?](../glossary#attention-mask)

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?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

**Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiConfig)) e das entradas.

O método forward do [MoshiModel](/docs/transformers/main/pt/model_doc/moshi#transformers.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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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) com a 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 a 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 nas cabeças de autoatenção.

## MoshiForCausalLM[[transformers.MoshiForCausalLM]]

#### transformers.MoshiForCausalLM[[transformers.MoshiForCausalLM]]

```python
transformers.MoshiForCausalLM(config: MoshiConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L807)

**Parâmetros:**

config ([MoshiConfig](/docs/transformers/main/pt/model_doc/moshi#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

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

#### forward[[transformers.MoshiForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L820)

**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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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?](../glossary#attention-mask)

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?](../glossary#position-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 de `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 calcular a 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](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiConfig)) e das entradas.

O método forward de [MoshiForCausalLM](/docs/transformers/main/pt/model_doc/moshi#transformers.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 hidden-states 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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 nas cabeças de autoatenção.

Exemplo:

```python
>>> 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[[transformers.MoshiForConditionalGeneration]]

#### transformers.MoshiForConditionalGeneration[[transformers.MoshiForConditionalGeneration]]

```python
transformers.MoshiForConditionalGeneration(config: MoshiConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L884)

**Parâmetros:**

config ([MoshiConfig](/docs/transformers/main/pt/model_doc/moshi#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

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

#### forward[[transformers.MoshiForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, user_input_values: typing.Optional[torch.Tensor] = None, user_audio_codes: typing.Optional[torch.Tensor] = None, moshi_input_values: typing.Optional[torch.Tensor] = None, moshi_audio_codes: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, text_labels: typing.Optional[torch.LongTensor] = None, audio_labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L911)

**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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

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 da 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?](../glossary#attention-mask)

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_values` and represents the audio "tokens" of `user_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_values` and represents the audio "tokens" of `moshi_input_values` once passed through the audio encoder.

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 os últimos `inputs_embeds` precisam ser inseridos (veja `past_key_values`). Isso é útil se você quiser 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. 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 de `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](/docs/transformers/main/pt/model_doc/moshi#transformers.MoshiConfig)) e das entradas.

O método forward de [MoshiForConditionalGeneration](/docs/transformers/main/pt/model_doc/moshi#transformers.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 hidden-states 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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  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` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma 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` (uma para cada camada) de 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 nas cabeças 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:
```python
>>> 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[[transformers.MoshiForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, user_input_values: typing.Optional[torch.Tensor] = None, user_audio_codes: typing.Optional[torch.Tensor] = None, moshi_input_values: typing.Optional[torch.Tensor] = None, moshi_audio_codes: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, return_audio_waveforms: bool | None = True, return_audio_codes: bool | None = None, concat_unconditional_inputs: bool | None = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L1203)

**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_values` and represents the audio "tokens" of `user_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_values` and represents the audio "tokens" of `moshi_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 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` uma vez passados 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]`, *optional*) : Remaining dictionary of keyword arguments that are passed to the `generate` method. Refers to the original [`generate` docstrings](https://huggingface.co/docs/transformers/main/en/main_classes/text_generation#transformers.GenerationMixin.generate) for more information on how to use them. Note that keywords with a *depth_* prefix will be input for the `generate` method of the depth decoder. Otherwise, the latter will use its default generation config.

**Retorna:**

`MoshiConditionalGenerationGenerateOutput`

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

#### get_unconditional_inputs[[transformers.MoshiForConditionalGeneration.get_unconditional_inputs]]

```python
get_unconditional_inputs(num_samples = 1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/moshi/modeling_moshi.py#L1632)

**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, às custas de uma inferência mais demorada (já que mais tokens de áudio precisam ser gerados 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:
```python
>>> 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)
```