Hugging Face's logo

Transformers documentation

Dia

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

and get access to the augmented documentation experience

to get started

Este modelo foi contribuído para o Hugging Face Transformers em 2025-06-26.

Dia

FlashAttention SDPA

Visão geral

Dia é um modelo de texto para fala (TTS) de código aberto (1,6B de parâmetros) desenvolvido pela Nari Labs. Ele pode gerar diálogos altamente realistas a partir de transcrições, incluindo comunicações não verbais, como risadas e tosses. Além disso, é possível controlar emoção e tom por meio de condicionamento por áudio (clonagem de voz).

Arquitetura do modelo: O Dia é um transformer encoder-decoder baseado na arquitetura original do transformer. No entanto, também inclui recursos mais modernos, como positional embeddings rotacionais (RoPE). Para a parte de texto (encoder), é utilizado um tokenizador de bytes, enquanto para a parte de áudio (decoder), é usado um modelo de codec pré-treinado DAC — o DAC codifica a fala em tokens discretos de codebook e os decodifica de volta para áudio.

Dicas de uso

Geração com Texto

from transformers import AutoProcessor, DiaForConditionalGeneration


model_checkpoint = "nari-labs/Dia-1.6B-0626"

text = ["[S1] Dia is an open weights text to dialogue model."]
model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto")
processor = AutoProcessor.from_pretrained(model_checkpoint)

inputs = processor(text=text, padding=True, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)  # corresponds to around ~2s

# save audio to a file
outputs = processor.batch_decode(outputs)
processor.save_audio(outputs, "example.wav")

Geração com Texto e Áudio (Clonagem de Voz)

from datasets import Audio, load_dataset

from transformers import AutoProcessor, DiaForConditionalGeneration


model_checkpoint = "nari-labs/Dia-1.6B-0626"

ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
ds = ds.cast_column("audio", Audio(sampling_rate=44100))
audio = ds[-1]["audio"]["array"]
# text is a transcript of the audio + additional text you want as new audio
text = ["[S1] I know. It's going to save me a lot of money, I hope. [S2] I sure hope so for you."]

processor = AutoProcessor.from_pretrained(model_checkpoint)
model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto")

inputs = processor(text=text, audio=audio, padding=True, return_tensors="pt").to(model.device)
prompt_len = processor.get_audio_prompt_len(inputs["decoder_attention_mask"])
outputs = model.generate(**inputs, max_new_tokens=256)  # corresponds to around ~2s

# retrieve actually generated audio and save to a file
outputs = processor.batch_decode(outputs, audio_prompt_len=prompt_len)
processor.save_audio(outputs, "example_with_audio.wav")

Treinamento

from datasets import Audio, load_dataset

from transformers import AutoProcessor, DiaForConditionalGeneration


model_checkpoint = "nari-labs/Dia-1.6B-0626"

ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
ds = ds.cast_column("audio", Audio(sampling_rate=44100))
audio = ds[-1]["audio"]["array"]
# text is a transcript of the audio
text = ["[S1] I know. It's going to save me a lot of money, I hope."]

model = DiaForConditionalGeneration.from_pretrained(model_checkpoint, device_map="auto")
processor = AutoProcessor.from_pretrained(model_checkpoint)

inputs = processor(
    text=text,
    audio=audio,
    generation=False,
    output_labels=True,
    padding=True,
    return_tensors="pt"
).to(model.device)

out = model(**inputs)
out.loss.backward()

Este modelo foi contribuído por Jaeyong Sung, Arthur Zucker e Anton Vlasjuk. O código original pode ser encontrado aqui.

DiaConfig

classe transformers.DiaConfig

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Trueencoder_config: transformers.models.dia.configuration_dia.DiaEncoderConfig | dict | None = Nonedecoder_config: transformers.models.dia.configuration_dia.DiaDecoderConfig | dict | None = Nonenorm_eps: float = 1e-05pad_token_id: int | None = Noneeos_token_id: int | list[int] | None = Nonebos_token_id: int | None = Nonedelay_pattern: list[int] | None = Noneinitializer_range: float = 0.02use_cache: bool = True )

Parâmetros

  • is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • encoder_config (Union[~models.dia.configuration_dia.DiaEncoderConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone do codificador.
  • decoder_config (Union[~models.dia.configuration_dia.DiaDecoderConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone do decodificador.
  • norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional) — ID do token usado para o fim do fluxo no vocabulário.
  • bos_token_id (int, opcional) — ID do token usado para o início do fluxo no vocabulário.
  • delay_pattern (list[int], opcional, padrão [0, 8, 9, 10, 11, 12, 13, 14, 15]) — O padrão de atraso para o decodificador. O comprimento desta lista deve corresponder a decoder_config.num_channels.
  • 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.

Esta é a classe de configuração para armazenar a configuração de um DiaModel. Ela é usada para instanciar um modelo Dia 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 nari-labs/Dia-1.6B

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 DiaConfig, DiaModel

>>> # Initializing a DiaConfig with default values
>>> configuration = DiaConfig()

>>> # Initializing a DiaModel (with random weights) from the configuration
>>> model = DiaModel(configuration)

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

get_text_config

< >

( *args**kwargs )

Padronizando para a configuração de áudio, pois, neste caso, o decodificador é normalmente o backbone de texto

DiaDecoderConfig

classe transformers.DiaDecoderConfig

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truemax_position_embeddings: int = 3072num_hidden_layers: int = 18hidden_size: int = 2048intermediate_size: int = 8192num_attention_heads: int = 16num_key_value_heads: int = 4head_dim: int = 128cross_num_attention_heads: int = 16cross_head_dim: int = 128cross_num_key_value_heads: int = 16cross_hidden_size: int = 1024norm_eps: float = 1e-05vocab_size: int = 1028hidden_act: str = 'silu'num_channels: int = 9rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneinitializer_range: float = 0.02use_cache: bool = Truepad_token_id: int | None = 1025eos_token_id: int | list[int] | None = 1024bos_token_id: int | None = 1026 )

Parâmetros

  • is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • max_position_embeddings (int, opcional, padrão 3072) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • num_hidden_layers (int, opcional, padrão 18) — Número de camadas ocultas no decodificador do Transformer.
  • hidden_size (int, opcional, padrão 2048) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 8192) — Dimensão das representações do MLP.
  • 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, padrão 4) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • head_dim (int, opcional, padrão 128) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • cross_num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de cross-attention no decodificador do Transformer.
  • cross_head_dim (int, opcional, padrão 128) — Dimensão da cabeça de atenção cruzada.
  • cross_num_key_value_heads (int, opcional, padrão 16) — Número de cabeças de chave e valor para cada camada de atenção cruzada no decodificador do Transformer.
  • cross_hidden_size (int, opcional, padrão 1024) — Dimensão das camadas de atenção cruzada.
  • norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • vocab_size (int, opcional, padrão 1028) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • 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.
  • num_channels (int, opcional, padrão 9) — O número de canais de entrada.
  • 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.
  • 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.
  • pad_token_id (int, opcional, padrão 1025) — ID do token usado para preenchimento no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional, padrão 1024) — ID do token usado para o fim do fluxo no vocabulário.
  • bos_token_id (int, opcional, padrão 1026) — ID do token usado para o início do fluxo no vocabulário.

Esta é a classe de configuração para armazenar a configuração de um DiaModel. Ela é usada para instanciar um modelo Dia 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 nari-labs/Dia-1.6B

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.

DiaEncoderConfig

classe transformers.DiaEncoderConfig

< >

( 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 = Nonemax_position_embeddings: int = 1024num_hidden_layers: int = 12hidden_size: int = 1024num_attention_heads: int = 16num_key_value_heads: int = 16head_dim: int = 128intermediate_size: int = 4096norm_eps: float = 1e-05vocab_size: int = 256hidden_act: str = 'silu'rope_parameters: dict | None = Noneinitializer_range: float = 0.02 )

Parâmetros

  • max_position_embeddings (int, opcional, padrão 1024) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • 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, padrão 16) — 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 key e value deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • head_dim (int, opcional, padrão 128) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • vocab_size (int, opcional, padrão 256) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • 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.
  • rope_parameters (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.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um DiaModel. Ela é usada para instanciar um modelo Dia 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 nari-labs/Dia-1.6B

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.

DiaTokenizer

classe transformers.DiaTokenizer

< >

( pad_token: str | None = '<pad>'unk_token: str | None = '<pad>'max_length: int | None = 1024offset: int = 0**kwargs )

Parâmetros

  • pad_token (str, opcional, padrão "<pad>") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
  • unk_token (str, opcional, padrão "<pad>") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
  • max_length (int, opcional, padrão 1024) — O comprimento máximo das sequências durante a codificação. Sequências mais longas que isso serão truncadas.
  • offset (int, opcional, padrão 0) — O deslocamento do tokenizer.

Construa um tokenizer Dia. O Dia simplesmente usa a codificação utf-8 de bytes brutos, exceto para os tokens especiais [S1] e [S2].

Este tokenizer herda de PreTrainedTokenizerFast, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

__call__

< >

( text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Nonetext_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = Noneadd_special_tokens: bool = Truepadding: bool | str | PaddingStrategy = Falsetruncation: bool | str | TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0is_split_into_words: bool = Falsepad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_offsets_mapping: bool = Falsereturn_length: bool = Falseverbose: bool = Truetokenizer_kwargs: dict[str, Any] | None = None**kwargs ) → BatchEncoding

Parâmetros

  • text (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_pair (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se as sequências forem fornecidas como lista de strings (pré-tokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_target (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a serem codificadas como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • text_pair_target (str, list[str], list[list[str]], opcional) — A sequência ou lote de sequências a ser codificada como textos de destino. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se as sequências forem fornecidas como lista de strings (pretokenizadas), você deve definir is_split_into_words=True (para eliminar a ambiguidade com um lote de sequências).
  • tokenizer_kwargs (dict[str, Any], opcional) — Kwargs adicionais para passar ao tokenizer. Eles serão mesclados com os parâmetros explícitos e outros kwargs, com os parâmetros explícitos tendo precedência.
  • add_special_tokens (bool, opcional, padrão True) — Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente PretrainedTokenizerBase.build_inputs_with_special_tokens, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokens bos ou eos automaticamente.
  • padding (bool, str ou PaddingStrategy, opcional, padrão é False) — Ativa e controla o padding. Aceita os seguintes valores:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
    • False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
  • truncation (bool, str ou TruncationStrategy, opcional, padrão é False) — Ativa e controla a truncagem. Aceita os seguintes valores:
    • True ou 'longest_first': Trunca para um comprimento máximo especificado com o argumento max_length ou para o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido.
    • 'only_first': Trunca para o comprimento máximo especificado com o argumento max_length ou para o comprimento máximo aceitável de entrada do modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.
    • 'only_second': Trunca para um comprimento máximo especificado com o argumento max_length ou para o comprimento máximo aceitável de entrada do modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido.
    • False ou 'do_not_truncate' (padrão): Sem truncamento (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada aceitável pelo modelo).
  • max_length (int, opcional) — Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento.

    Se não for definido ou for definido como None, isso usará o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

  • stride (int, opcional, padrão 0) — Se definido como um número junto com max_length, os tokens excedentes retornados quando return_overflowing_tokens=True conterão alguns tokens do final da sequência truncada retornada para fornecer alguma sobreposição entre as sequências truncadas e excedentes. O valor deste argumento define o número de tokens sobrepostos.
  • is_split_into_words (bool, opcional, padrão False) — Indica se a entrada já está pré-tokenizada (por exemplo, dividida em palavras). Se definido como True, o tokenizer assume que a entrada já foi dividida em palavras (por exemplo, separando por espaços em branco) e a tokeniza. Isso é útil para NER ou classificação de tokens.
  • pad_to_multiple_of (int, opcional) — Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que padding esteja ativado. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação >= 7.5 (Volta).
  • padding_side (str, opcional) — O lado em que o modelo deve ter o padding aplicado. Deve ser selecionado entre [‘right’, ‘left’]. O valor padrão é obtido do atributo de classe com o mesmo nome.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do Numpy.
  • return_token_type_ids (bool, opcional) — Se deve retornar os IDs de tipo de token. Se mantido o valor padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo return_outputs atributo.

    O que são IDs de tipo de token?

  • return_attention_mask (bool, opcional) — Se deve retornar a attention mask. Se mantido o valor padrão, a attention mask será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo return_outputs .

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

  • return_overflowing_tokens (bool, opcional, padrão False) — Indica se as sequências de tokens excedentes devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com truncation_strategy = longest_first ou True, um erro será lançado em vez de retornar os tokens excedentes.
  • return_special_tokens_mask (bool, opcional, padrão False) — Indica se a máscara de tokens especiais deve ser retornada.
  • return_offsets_mapping (bool, opcional, padrão é False) — Se deve ou não retornar (char_start, char_end) para cada token.

    Isso está disponível apenas em tokenizadores rápidos que herdam de PreTrainedTokenizerFast; se estiver usando o tokenizador em Python, este método lançará NotImplementedError.

  • return_length (bool, opcional, padrão False) — Indica se as comprimentos das entradas codificadas devem ser retornados.
  • verbose (bool, opcional, padrão True) — Se deve ou não exibir mais informações e avisos.
  • **kwargs — passados para o método self.tokenize()

Retorna

BatchEncoding

Um BatchEncoding com os seguintes campos:

  • input_ids — Lista de ids de tokens a serem fornecidos a um modelo.

    O que são IDs de entrada?

  • token_type_ids — Lista de ids de tipo de token a serem fornecidos a um modelo (quando return_token_type_ids=True ou se “token_type_ids” estiver em self.model_input_names).

    O que são IDs de tipo de token?

  • attention_mask — Lista de índices que especifica quais tokens devem ser considerados pelo modelo (quando return_attention_mask=True ou se “attention_mask” estiver em self.model_input_names).

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

  • overflowing_tokens — Lista de sequências de tokens excedentes (quando um max_length é especificado e return_overflowing_tokens=True).

  • num_truncated_tokens — Número de tokens truncados (quando um max_length é especificado e return_overflowing_tokens=True).

  • special_tokens_mask — Lista de 0s e 1s, em que 1 especifica tokens especiais adicionados e 0 especifica tokens regulares da sequência (quando add_special_tokens=True e return_special_tokens_mask=True).

  • length — O comprimento das entradas (quando return_length=True)

Método principal para tokenizar e preparar uma ou várias sequências ou um ou vários pares de sequências para o modelo.

DiaFeatureExtractor

classe transformers.DiaFeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 16000padding_value: float = 0.0hop_length: int = 512**kwargs )

Parâmetros

  • feature_size (int, opcional, padrão 1) — A dimensão dos recursos dos recursos extraídos. Use 1 para mono e 2 para estéreo.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).
  • padding_value (float, opcional, padrão 0.0) — O valor utilizado para preenchimento.
  • hop_length (int, opcional, padrão 512) — Comprimento de sobreposição entre janelas sucessivas.

Constrói um extrator de recursos Dia.

Este extrator de características herda de SequenceFeatureExtractor, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

__call__

< >

( raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy | None = Nonetruncation: bool | None = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None )

Parâmetros

  • raw_audio (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — A sequência ou lote de sequências a serem processadas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. O array numpy deve ter a forma (num_samples,) para áudio mono (feature_size = 1), ou (2, num_samples) para áudio estéreo (feature_size = 2).
  • padding (bool, str ou PaddingStrategy, opcional, padrão é True) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
    • False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
  • truncation (bool, opcional, padrão False) — Ativa a truncagem para cortar sequências de entrada com comprimento maior que max_length para max_length.
  • max_length (int, opcional) — Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).
  • return_tensors (str ou TensorType, opcional, padrão 'pt') — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do Numpy.
  • sampling_rate (int, opcional) — A taxa de amostragem na qual a entrada de audio foi amostrada. É fortemente recomendável passar sampling_rate na chamada de forward para evitar erros silenciosos.

Método principal para criar recursos e preparar uma ou várias sequências para o modelo.

DiaProcessor

classe transformers.DiaProcessor

< >

( feature_extractortokenizeraudio_tokenizer )

Parâmetros

  • feature_extractor (DiaFeatureExtractor) — O extrator de recursos é uma entrada obrigatória.
  • tokenizer (DiaTokenizer) — O tokenizer é uma entrada obrigatória.
  • audio_tokenizer (DacModel) — Uma instância de DacModel usada para codificar/decodificar áudio em/de codebooks. É uma entrada obrigatória.

Constrói um DiaProcessor que encapsula um extrator de recursos e um tokenizador em um único processador.

DiaProcessor oferece todas as funcionalidades de DiaFeatureExtractor e DiaTokenizer. Consulte ~DiaFeatureExtractor e ~DiaTokenizer para mais informações.

__call__

< >

( text: str | list[str]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Noneoutput_labels: bool | None = False**kwargs: *<class 'transformers.models.dia.processing_dia.DiaProcessorKwargs'> )

Parâmetros

  • text (Union[str, list[str]]) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], opcional) — O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio.
  • output_labels (bool, opcional, padrão False) — Indica se os rótulos devem ser retornados para o treinamento. Quando True, o processador gera os rótulos a partir da sequência de entrada do decodificador, deslocando-a em uma posição. Os rótulos utilizam valores especiais: -100 para tokens a serem ignorados no cálculo da perda (tokens de padding e BOS) e -101 para quadros de áudio usados apenas para o modelo de backbone (quando depth_decoder_labels_ratio < 1.0). Não pode ser usado em conjunto com generation=True.
  • bos_token_id (int, kwargs, opcional, padrão 1026) — O ID do token usado como token de início de sequência para os codebooks de áudio. Este token é adicionado ao início de cada sequência de áudio durante a codificação.
  • eos_token_id (int, kwargs, opcional, padrão 1024) — O ID do token usado como token de fim de sequência para os codebooks de áudio. Esse token é adicionado às sequências de áudio durante o treinamento (quando generation=False) para marcar o fim do áudio.
  • pad_token_id (int, kwargs, opcional, padrão 1025) — O ID do token usado para preenchimento de sequências de codebook de áudio. Este token é utilizado para preencher posições no padrão de atraso onde não existe um token de áudio válido.
  • delay_pattern (list[int], kwargs, opcional, padrão [0, 8, 9, 10, 11, 12, 13, 14, 15]) — Uma lista de valores de atraso (em frames) para cada canal de codebook. O padrão de atraso cria deslocamentos temporais entre os diferentes canais de codebook, permitindo que o modelo capture dependências entre os canais. Cada valor representa o número de frames para atrasar aquele canal específico.
  • generation (bool, kwargs, opcional, padrão True) — Indica se o processador está sendo usado para geração (texto para fala) ou para treinamento. Quando True, o processador prepara as entradas para o modo de geração, no qual o áudio é gerado a partir do texto. Quando False, ele prepara as entradas para o treinamento, no qual tanto o texto quanto o áudio são fornecidos.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

batch_decode

< >

( decoder_input_ids: torch.Tensoraudio_prompt_len: int | None = None**kwargs: *<class 'transformers.models.dia.processing_dia.DiaProcessorKwargs'> )

Parâmetros

  • decoder_input_ids (torch.Tensor) — A sequência de saída completa do decodificador.
  • audio_prompt_len (int) — O comprimento do prefixo de áudio (por exemplo, ao usar clonagem de voz).

Decodifica um lote de sequências de codebook de áudio para suas respectivas formas de onda de áudio por meio do audio_tokenizer. Consulte decode() para mais informações.

decode

< >

( decoder_input_ids: torch.Tensoraudio_prompt_len: int | None = None**kwargs: *<class 'transformers.models.dia.processing_dia.DiaProcessorKwargs'> )

Decodifica uma única sequência de codebooks de áudio para a respectiva forma de onda de áudio por meio do audio_tokenizer. Consulte decode() e batch_decode() para mais informações.

DiaModel

classe transformers.DiaModel

< >

( config: DiaConfig )

Parâmetros

  • config (DiaConfig) — 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 Dia puro, que gera os hidden-states brutos sem nenhum head 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.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqModelOutput 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.LongTensor 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?

  • decoder_input_ids (torch.LongTensor de forma `(batch_size * num_codebooks, target_sequence_length) —
  • or (batch_size, target_sequence_length, num_codebooks) opcional) —

    1. (batch_size * num_codebooks, target_sequence_length): corresponde ao caso de uso geral em que os codebooks de entrada de áudio são achatados na dimensão do lote. Isso também está alinhado com os logits de áudio achatados, que são usados para calcular a perda.

    2. (batch_size, sequence_length, num_codebooks): corresponde à forma utilizada internamente pelo Dia para calcular embeddings e as etapas subsequentes de forma mais eficiente.

    Se nenhum decoder_input_ids for fornecido, será criado um tensor de bos_token_id com a forma (batch_size, 1, num_codebooks). Os índices podem ser obtidos usando o DiaProcessor. Consulte DiaProcessor.call() para mais detalhes.

    O que são IDs de entrada do decodificador?

  • decoder_position_ids (torch.LongTensor de forma (batch_size, target_sequence_length)) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Usado para calcular os embeddings de posição até config.decoder_config.max_position_embeddings.

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

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro.
  • encoder_outputs (Union[~modeling_outputs.BaseModelOutput, tuple], opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • past_key_values (~cache_utils.EncoderDecoderCache, 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 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 é 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).

  • 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

Seq2SeqModelOutput ou tuple(torch.Tensor)

Um Seq2SeqModelOutput 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 (None) e das entradas.

O método forward do DiaModel sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • 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 decodificador 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 (EncoderDecoderCache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.

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

  • decoder_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 decodificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

  • encoder_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 codificador do modelo.

  • encoder_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 codificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

DiaForConditionalGeneration

classe transformers.DiaForConditionalGeneration

< >

( config: DiaConfig )

Parâmetros

  • config (DiaConfig) — 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 Dia, composto por um codificador de texto (byte) e um decodificador de áudio com uma cabeça de previsão 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.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_position_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs ) → Seq2SeqLMOutput 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.LongTensor 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?

  • decoder_input_ids (torch.LongTensor de forma `(batch_size * num_codebooks, target_sequence_length) —
  • or (batch_size, target_sequence_length, num_codebooks) opcional) —

    1. (batch_size * num_codebooks, target_sequence_length): corresponde ao caso de uso geral em que os codebooks de entrada de áudio são achatados na dimensão do lote. Isso também está alinhado com os logits de áudio achatados, que são usados para calcular a perda.

    2. (batch_size, sequence_length, num_codebooks): corresponde à forma utilizada internamente pelo Dia para calcular embeddings e as etapas subsequentes de forma mais eficiente.

    Se nenhum decoder_input_ids for fornecido, será criado um tensor de bos_token_id com a forma (batch_size, 1, num_codebooks). Os índices podem ser obtidos usando o DiaProcessor. Consulte DiaProcessor.call() para mais detalhes.

    O que são IDs de entrada do decodificador?

  • decoder_position_ids (torch.LongTensor de forma (batch_size, target_sequence_length)) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Usado para calcular os embeddings de posição até config.decoder_config.max_position_embeddings.

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

  • decoder_attention_mask (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Máscara para evitar a execução de atenção em determinados índices de tokens. Por padrão, uma máscara causal será usada, para garantir que o modelo só possa olhar para entradas anteriores a fim de prever o futuro.
  • encoder_outputs (Union[~modeling_outputs.BaseModelOutput, tuple], opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • past_key_values (~cache_utils.EncoderDecoderCache, 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 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 é 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).

  • 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 * num_codebooks,), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.decoder_config.vocab_size - 1] ou ser -100. Tokens com índices definidos como -100 são ignorados (mascarados).

Retorna

Seq2SeqLMOutput ou tuple(torch.Tensor)

Um Seq2SeqLMOutput 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 (None) e das entradas.

O método forward de DiaForConditionalGeneration sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem.

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

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

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

  • decoder_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 decodificador na saída de cada camada, além das saídas do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

  • encoder_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 codificador do modelo.

  • encoder_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 codificador na saída de cada camada, além das saídas do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

generate

< >

( inputs: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonelogits_processor: transformers.generation.logits_process.LogitsProcessorList | None = Nonestopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = Noneprefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = Nonesynced_gpus: bool | None = Noneassistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = Nonestreamer: typing.Optional[ForwardRef('BaseStreamer')] = Nonenegative_prompt_ids: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Nonecustom_generate: str | None = None**kwargs )

Update on GitHub

←dac EnCodec→