# Dia ## Visão geral [Dia](https://github.com/nari-labs/dia) é um modelo de texto para fala (TTS) de código aberto (1,6B de parâmetros) desenvolvido pela [Nari Labs](https://huggingface.co/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 embeddings posicionais 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](./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 ```python 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) ```python 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 ```python 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](https://huggingface.co/buttercrab), [Arthur Zucker](https://huggingface.co/ArthurZ) e [Anton Vlasjuk](https://huggingface.co/AntonV). O código original pode ser encontrado [aqui](https://github.com/nari-labs/dia/). ## DiaConfig[[transformers.DiaConfig]] #### transformers.DiaConfig[[transformers.DiaConfig]] ```python transformers.DiaConfig(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, 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, is_encoder_decoder: bool = True, encoder_config: transformers.models.dia.configuration_dia.DiaEncoderConfig | dict | None = None, decoder_config: transformers.models.dia.configuration_dia.DiaDecoderConfig | dict | None = None, norm_eps: float = 1e-05, pad_token_id: int | None = None, eos_token_id: int | list[int] | None = None, bos_token_id: int | None = None, delay_pattern: list[int] | None = None, initializer_range: float = 0.02, use_cache: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L87) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador 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 decoder. 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 (padding) 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`) : 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. 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](https://huggingface.co/nari-labs/Dia-1.6B) 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 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[[transformers.DiaConfig.get_text_config]] ```python get_text_config(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L159) Padronizando para a configuração de áudio, pois, neste caso, é o decodificador, que geralmente é o backbone de texto ## DiaDecoderConfig[[transformers.DiaDecoderConfig]] #### transformers.DiaDecoderConfig[[transformers.DiaDecoderConfig]] ```python transformers.DiaDecoderConfig(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, 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, is_encoder_decoder: bool = True, max_position_embeddings: int = 3072, num_hidden_layers: int = 18, hidden_size: int = 2048, intermediate_size: int = 8192, num_attention_heads: int = 16, num_key_value_heads: int = 4, head_dim: int = 128, cross_num_attention_heads: int = 16, cross_head_dim: int = 128, cross_num_key_value_heads: int = 16, cross_hidden_size: int = 1024, norm_eps: float = 1e-05, vocab_size: int = 1028, hidden_act: str = 'silu', num_channels: int = 9, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, initializer_range: float = 0.02, use_cache: bool = True, pad_token_id: int | None = 1025, eos_token_id: int | list[int] | None = 1024, bos_token_id: int | None = 1026) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L47) **Parâmetros:** is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador 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 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`. 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 atenção cruzada no decodificador do Transformer. cross_head_dim (`int`, *opcional*, padrão 128) : Dimensionalidade 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) : Dimensionalidade 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`) : 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. pad_token_id (`int`, *opcional*, padrão `1025`) : ID do token usado para preenchimento (padding) 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](https://huggingface.co/nari-labs/Dia-1.6B) 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. ## DiaEncoderConfig[[transformers.DiaEncoderConfig]] #### transformers.DiaEncoderConfig[[transformers.DiaEncoderConfig]] ```python transformers.DiaEncoderConfig(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, max_position_embeddings: int = 1024, num_hidden_layers: int = 12, hidden_size: int = 1024, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 128, intermediate_size: int = 4096, norm_eps: float = 1e-05, vocab_size: int = 256, hidden_act: str = 'silu', rope_parameters: dict | None = None, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/configuration_dia.py#L28) **Parâmetros:** max_position_embeddings (`int`, *opcional*, padrão `1024`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. 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 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`. 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](https://huggingface.co/nari-labs/Dia-1.6B) 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. ## DiaTokenizer[[transformers.DiaTokenizer]] #### transformers.DiaTokenizer[[transformers.DiaTokenizer]] ```python transformers.DiaTokenizer(pad_token: str | None = '', unk_token: str | None = '', max_length: int | None = 1024, offset: int = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/tokenization_dia.py#L23) **Parâmetros:** pad_token (`str`, *opcional*, padrão `""`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. unk_token (`str`, *opcional*, padrão `""`) : 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](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend), 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__[[transformers.DiaTokenizer.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_base.py#L2449) **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 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 (`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 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_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 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). 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 automaticamente tokens `bos` ou `eos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.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 padding 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](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.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 de entrada aceitável 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 um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o 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 de entrada aceitável para o 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 truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do 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`, será usado 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 até 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 truncada e excedente. 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 tokenizará. 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 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](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores em vez de 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 no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção 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?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite 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`) : Se deve ou não retornar informações da máscara de tokens especiais. return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica 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](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do 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](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) Um [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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?](../glossary#input-ids) - **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?](../glossary#token-type-ids) - **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?](../glossary#attention-mask) - **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[[transformers.DiaFeatureExtractor]] #### transformers.DiaFeatureExtractor[[transformers.DiaFeatureExtractor]] ```python transformers.DiaFeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, hop_length: int = 512, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/feature_extraction_dia.py#L26) **Parâmetros:** feature_size (`int`, *opcional*, padrão 1) : A dimensão dos recursos dos recursos extraídos. Use 1 para mono, 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 usado 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](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contém a maioria dos métodos principais. Os usuários devem consultar esta superclasse para obter mais informações sobre esses métodos. #### __call__[[transformers.DiaFeatureExtractor.__call__]] ```python __call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/feature_extraction_dia.py#L57) **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](/docs/transformers/main/pt/internal/file_utils#transformers.utils.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'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um 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 retornar 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](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*, padrão 'pt') : Se definido, retornará tensores em vez de 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 `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[[transformers.DiaProcessor]] #### transformers.DiaProcessor[[transformers.DiaProcessor]] ```python transformers.DiaProcessor(feature_extractor, tokenizer, audio_tokenizer) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L84) **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](/docs/transformers/main/pt/model_doc/dac#transformers.DacModel) usada para codificar/decodificar áudio para/de codebooks. É uma entrada obrigatória. Constrói um DiaProcessor que encapsula um extrator de recursos e um tokenizador em um único processador. [DiaProcessor](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor) oferece todas as funcionalidades de [DiaFeatureExtractor](/docs/transformers/main/pt/model_doc/dia#transformers.DiaFeatureExtractor) e [DiaTokenizer](/docs/transformers/main/pt/model_doc/dia#transformers.DiaTokenizer). Consulte [~DiaFeatureExtractor](/docs/transformers/main/pt/model_doc/dia#transformers.DiaFeatureExtractor) e [~DiaTokenizer](/docs/transformers/main/pt/model_doc/dia#transformers.DiaTokenizer) para mais informações. #### __call__[[transformers.DiaProcessor.__call__]] ```python __call__(text: str | list[str], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L144) **Parâmetros:** text (`Union[str, list[str]]`) : A sequência ou lote de sequências a serem codificadas. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, 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 deve retornar rótulos para o treinamento. Quando `True`, o processador gera 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 preenchimento 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 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. Este 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 padding de sequências de codebook de áudio. Este token é usado 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`, prepara as entradas para o treinamento, no qual tanto o texto quanto o áudio são fornecidos. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores 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](/docs/transformers/main/pt/main_classes/processors#transformers.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[[transformers.DiaProcessor.batch_decode]] ```python batch_decode(decoder_input_ids: torch.Tensor, audio_prompt_len: int | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L247) **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()](/docs/transformers/main/pt/model_doc/dac#transformers.DacModel.decode) para mais informações. #### decode[[transformers.DiaProcessor.decode]] ```python decode(decoder_input_ids: torch.Tensor, audio_prompt_len: int | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/processing_dia.py#L318) Decodifica uma única sequência de codebooks de áudio para a respectiva forma de onda de áudio por meio do `audio_tokenizer`. Consulte [decode()](/docs/transformers/main/pt/model_doc/dac#transformers.DacModel.decode) e [batch_decode()](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor.batch_decode) para mais informações. ## DiaModel[[transformers.DiaModel]] #### transformers.DiaModel[[transformers.DiaModel]] ```python transformers.DiaModel(config: DiaConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L640) **Parâmetros:** config ([DiaConfig](/docs/transformers/main/pt/model_doc/dia#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/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.DiaModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, use_cache: bool | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L648) **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.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?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size * num_codebooks, target_sequence_length) -- or (batch_size, target_sequence_length, num_codebooks)`, *optional*) : 1. (batch_size * num_codebooks, target_sequence_length): corresponds to the general use case where the audio input codebooks are flattened into the batch dimension. This also aligns with the flat- tened audio logits which are used to calculate the loss. 2. (batch_size, sequence_length, num_codebooks): corresponds to the internally used shape of Dia to calculate embeddings and subsequent steps more efficiently. If no `decoder_input_ids` are provided, it will create a tensor of `bos_token_id` with shape `(batch_size, 1, num_codebooks)`. Indices can be obtained using the [DiaProcessor](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor). See [DiaProcessor.__call__()](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor.__call__) for more details. [What are decoder input IDs?](../glossary#decoder-input-ids) 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 position IDs?](../glossary#position-ids) 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 estados ocultos na saída da última camada do codificador. Usado na atenção cruzada do decodificador. 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache de kv](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)`. 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:** [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqModelOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/dia#transformers.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 decoder 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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 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` (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 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` (uma 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` (uma para cada camada) de 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 encoder 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` (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 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` (uma para cada camada) de 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[[transformers.DiaForConditionalGeneration]] #### transformers.DiaForConditionalGeneration[[transformers.DiaForConditionalGeneration]] ```python transformers.DiaForConditionalGeneration(config: DiaConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L751) **Parâmetros:** config ([DiaConfig](/docs/transformers/main/pt/model_doc/dia#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/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.DiaForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_position_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.LongTensor] = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutput | tuple | None = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, use_cache: bool | None = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/modeling_dia.py#L770) **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.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?](../glossary#attention-mask) decoder_input_ids (`torch.LongTensor` de forma `(batch_size * num_codebooks, target_sequence_length) -- or (batch_size, target_sequence_length, num_codebooks)`, *optional*) : 1. (batch_size * num_codebooks, target_sequence_length): corresponds to the general use case where the audio input codebooks are flattened into the batch dimension. This also aligns with the flat- tened audio logits which are used to calculate the loss. 2. (batch_size, sequence_length, num_codebooks): corresponds to the internally used shape of Dia to calculate embeddings and subsequent steps more efficiently. If no `decoder_input_ids` are provided, it will create a tensor of `bos_token_id` with shape `(batch_size, 1, num_codebooks)`. Indices can be obtained using the [DiaProcessor](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor). See [DiaProcessor.__call__()](/docs/transformers/main/pt/model_doc/dia#transformers.DiaProcessor.__call__) for more details. [What are decoder input IDs?](../glossary#decoder-input-ids) 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 position IDs?](../glossary#position-ids) 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 estados ocultos na saída da última camada do codificador. Usado na atenção cruzada do decodificador. 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](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de cache de kv](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)`. 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 * num_codebooks,)`, *opcional*) : Rótulos para calcular a 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](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)` Um [Seq2SeqLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/dia#transformers.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`) -- É uma instância de [EncoderDecoderCache](/docs/transformers/main/pt/internal/generation_utils#transformers.EncoderDecoderCache). 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 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` (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 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` (uma 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` (uma para cada camada) de 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 encoder 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` (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 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` (uma para cada camada) de 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[[transformers.DiaForConditionalGeneration.generate]] ```python generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dia/generation_dia.py#L416)