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.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2025-06-26.

Dia

FlashAttention SDPA

Aperçu

Dia est un modèle open source de texte vers parole (TTS) (1,6 milliard de paramètres) développé par Nari Labs. Il peut générer des dialogues très réalistes à partir de transcriptions, y compris des communications non verbales telles que le rire et la toux. De plus, le contrôle de l'émotion et du ton est également possible via le conditionnement audio (clonage de voix).

Architecture du modèle : Dia est un transformeur encodeur-décodeur basé sur l'architecture transformeur originale. Toutefois, il intègre également des fonctionnalités plus modernes telles que les incrustations positionnelles rotationnelles (RoPE). Pour sa partie texte (encodeur), un tokeniseur par octet est utilisé, tandis que pour la partie audio (décodeur), un modèle de codec pré-entraîné DAC est employé - DAC encode la parole en jetons de codebook discrets et les décode à nouveau en audio.

Conseils d'utilisation

Génération avec du texte

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")

Génération avec du texte et de l'audio (clonage de voix)

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")

Entraînement

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()

Ce modèle a été contribué par Jaeyong Sung, Arthur Zucker et Anton Vlasjuk. Le code d'origine peut être trouvé ici.

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 )

Paramètres

  • is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
  • encoder_config (Union[~models.dia.configuration_dia.DiaEncoderConfig, dict], facultatif) — L'objet de configuration ou le dictionnaire du backbone de l'encodeur.
  • decoder_config (Union[~models.dia.configuration_dia.DiaDecoderConfig, dict], facultatif) — L’objet de configuration ou le dictionnaire du backbone du décodeur.
  • norm_eps (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • pad_token_id (int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • bos_token_id (int, facultatif) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • delay_pattern (list[int], facultatif, par défaut [0, 8, 9, 10, 11, 12, 13, 14, 15]) — Le motif de délai pour le décodeur. La longueur de cette liste doit correspondre à decoder_config.num_channels.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.

Ceci est la classe de configuration destinée à stocker la configuration d'un DiaModel. Elle est utilisée pour instancier un modèle Dia en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nari-labs/Dia-1.6B

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

Par défaut, la configuration audio est utilisée, car il s’agit du décodeur dans ce cas, qui est généralement le backbone texte.

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 )

Paramètres

  • is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
  • max_position_embeddings (int, facultatif, par défaut 3072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • num_hidden_layers (int, facultatif, par défaut 18) — Nombre de couches cachées dans le décodeur Transformer.
  • hidden_size (int, facultatif, par défaut 2048) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 8192) — Dimension des représentations du MLP.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_key_value_heads (int, facultatif, valeur par défaut 4) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si num_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), si num_key_value_heads=1 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera num_attention_heads.
  • head_dim (int, facultatif, par défaut 128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
  • cross_num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche de cross-attention dans le décodeur du Transformer.
  • cross_head_dim (int, facultatif, valeur par défaut 128) — Dimension de la tête d'attention croisée.
  • cross_num_key_value_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes de clé et de valeur pour chaque couche d'attention croisée dans le décodeur du Transformer.
  • cross_hidden_size (int, facultatif, valeur par défaut 1024) — Dimension des couches d'attention croisée.
  • norm_eps (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • vocab_size (int, facultatif, par défaut 1028) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_act (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • num_channels (int, facultatif, par défaut 9) — Le nombre de canaux d'entrée.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • pad_token_id (int, facultatif, par défaut 1025) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 1024) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • bos_token_id (int, facultatif, par défaut 1026) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.

Ceci est la classe de configuration destinée à stocker la configuration d'un DiaModel. Elle est utilisée pour instancier un modèle Dia en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nari-labs/Dia-1.6B

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

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 )

Paramètres

  • max_position_embeddings (int, facultatif, par défaut 1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • num_hidden_layers (int, facultatif, par défaut 12) — Nombre de couches cachées dans le décodeur Transformer.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_key_value_heads (int, facultatif, valeur par défaut 16) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si num_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), si num_key_value_heads=1 le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut sera num_attention_heads.
  • head_dim (int, facultatif, par défaut 128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
  • intermediate_size (int, facultatif, par défaut 4096) — Dimension des représentations du MLP.
  • norm_eps (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • vocab_size (int, facultatif, par défaut 256) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • hidden_act (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • rope_parameters (dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.

Ceci est la classe de configuration destinée à stocker la configuration d'un DiaModel. Elle est utilisée pour instancier un modèle Dia en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de nari-labs/Dia-1.6B

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

DiaTokenizer

classe transformers.DiaTokenizer

< >

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

Paramètres

  • pad_token (str, facultatif, par défaut "<pad>") — Le jeton utilisé pour le bourrage, par exemple lors du regroupement de séquences de longueurs différentes.
  • unk_token (str, facultatif, par défaut "<pad>") — Le jeton inconnu. Un jeton qui n’est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.
  • max_length (int, facultatif, valeur par défaut 1024) — La longueur maximale des séquences lors de l’encodage. Les séquences plus longues que cette valeur seront tronquées.
  • offset (int, facultatif, par défaut 0) — Le décalage du tokeniseur.

Construit un tokenizer Dia. Dia utilise simplement l’encodage utf-8 des octets bruts, à l’exception des jetons spéciaux [S1] et [S2].

Ce tokenizer hérite de PreTrainedTokenizerFast, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__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

Paramètres

  • text (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_pair (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • text_pair_target (str, list[str], list[list[str]], facultatif) — La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir is_split_into_words=True (pour lever l’ambiguïté avec un lot de séquences).
  • tokenizer_kwargs (dict[str, Any], facultatif) — Kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité.
  • add_special_tokens (bool, facultatif, par défaut True) — Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacente PretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetons bos ou eos.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à une longueur maximale spécifiée avec l’argument max_length ou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni. Cela tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • 'only_first' : Tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.
    • 'only_second' : Tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronquera que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie.
    • False ou 'do_not_truncate' (par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou défini sur None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé.

  • stride (int, facultatif, valeur par défaut 0) — Si défini à un nombre avec max_length, les jetons en dépassement renvoyés lorsque return_overflowing_tokens=True contiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement.
  • is_split_into_words (bool, facultatif, par défaut False) — Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini à True, le tokeniseur suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et la tokenise. Cela est utile pour la NER ou la classification de tokens.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation de padding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta).
  • padding_side (str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • return_token_type_ids (bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton sont renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut return_outputs .

    Qu'est-ce que les identifiants de type de jeton ?

  • return_attention_mask (bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut return_outputs .

    Qu'est-ce que les masques d'attention ?

  • return_overflowing_tokens (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avec truncation_strategy = longest_first ou True, une erreur est levée au lieu de retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux.
  • return_offsets_mapping (bool, facultatif, par défaut False) — Indique s'il faut renvoyer (char_start, char_end) pour chaque jeton.

    Cela n’est disponible que sur les tokenizers rapides héritant de PreTrainedTokenizerFast ; si vous utilisez le tokenizer Python, cette méthode lève NotImplementedError.

  • return_length (bool, facultatif, par défaut False) — Indique s'il faut retourner les longueurs des entrées encodées.
  • verbose (bool, facultatif, par défaut True) — Indique s'il faut afficher plus d'informations et d'avertissements.
  • **kwargs — transmis à la méthode self.tokenize()

Retourne

BatchEncoding

Un BatchEncoding avec les champs suivants :

  • input_ids — Liste des identifiants de jetons à fournir à un modèle.

    Qu'est-ce que les identifiants d'entrée ?

  • token_type_ids — Liste des identifiants de type de jeton à fournir à un modèle (lorsque return_token_type_ids=True ou si “token_type_ids” est présent dans self.model_input_names).

    Qu'est-ce que les identifiants de type de jeton ?

  • attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque return_attention_mask=True ou si “attention_mask” est présent dans self.model_input_names).

    Qu'est-ce que les masques d'attention ?

  • overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).

  • num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une max_length est spécifiée et return_overflowing_tokens=True).

  • special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque add_special_tokens=True et return_special_tokens_mask=True).

  • length — La longueur des entrées (lorsque return_length=True)

Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences.

DiaFeatureExtractor

classe transformers.DiaFeatureExtractor

< >

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

Paramètres

  • feature_size (int, facultatif, par défaut 1) — La dimension des caractéristiques des fonctionnalités extraites. Utilisez 1 pour le mono, 2 pour le stéréo.
  • sampling_rate (int, facultatif, valeur par défaut 16000) — La fréquence d'échantillonnage à laquelle la forme d'onde audio doit être numérisée, exprimée en hertz (Hz).
  • padding_value (float, facultatif, par défaut 0.0) — La valeur utilisée pour le bourrage.
  • hop_length (int, facultatif, par défaut 512) — Longueur de chevauchement entre les fenêtres successives.

Construit un extracteur de fonctionnalités Dia.

Cet extracteur de fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__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 )

Paramètres

  • raw_audio (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La séquence ou le lot de séquences à traiter. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Le tableau numpy doit avoir la forme (num_samples,) pour un audio mono (feature_size = 1), ou (2, num_samples) pour un audio stéréo (feature_size = 2).
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : True) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, facultatif, par défaut False) — Active la troncature pour couper les séquences d’entrée plus longues que max_length à max_length.
  • max_length (int, facultatif) — Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).
  • return_tensors (str ou TensorType, facultatif, par défaut ‘pt’) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle l’entrée audio a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l’appel forward afin d’éviter les erreurs silencieuses.

Méthode principale pour vectoriser et préparer une ou plusieurs séquences pour le modèle.

DiaProcessor

classe transformers.DiaProcessor

< >

( feature_extractortokenizeraudio_tokenizer )

Paramètres

  • feature_extractor (DiaFeatureExtractor) — L'extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (DiaTokenizer) — Le tokenizer est une entrée obligatoire.
  • audio_tokenizer (DacModel) — Une instance de DacModel utilisée pour encoder/décoder l’audio à partir de/dans des codebooks. C’est une entrée obligatoire.

Construit un DiaProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

DiaProcessor offre toutes les fonctionnalités de DiaFeatureExtractor et de DiaTokenizer. Consultez ~DiaFeatureExtractor et ~DiaTokenizer pour plus d’informations.

__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'> )

Paramètres

  • text (Union[str, list[str]]) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissez is_split_into_words=True pour éviter toute ambiguïté avec les entrées en lot.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • output_labels (bool, facultatif, par défaut False) — Indique s'il faut retourner les étiquettes pour l'entraînement. Si True, le processeur génère les étiquettes à partir de la séquence d'entrée du décodeur en la décalant d'une position. Les étiquettes utilisent des valeurs spéciales : -100 pour les jetons à ignorer dans le calcul de la perte (jetons de bourrage et jetons BOS), et -101 pour les trames audio utilisées uniquement pour le modèle de base (lorsque depth_decoder_labels_ratio < 1.0). Ne peut pas être utilisé en même temps que generation=True.
  • bos_token_id (int, kwargs, facultatif, valeur par défaut 1026) — L'identifiant du jeton utilisé comme jeton de début de séquence pour les codebooks audio. Ce jeton est ajouté au début de chaque séquence audio lors de l'encodage.
  • eos_token_id (int, kwargs, facultatif, valeur par défaut 1024) — L'identifiant du jeton utilisé comme jeton de fin de séquence pour les codebooks audio. Ce jeton est ajouté aux séquences audio lors de l'entraînement (lorsque generation=False) pour marquer la fin de l'audio.
  • pad_token_id (int, kwargs, facultatif, valeur par défaut 1025) — L'identifiant du jeton utilisé pour l'ajustement des séquences de codebook audio. Ce jeton sert à combler les positions du motif de délai où aucun jeton audio valide n'existe.
  • delay_pattern (list[int], kwargs, facultatif, par défaut [0, 8, 9, 10, 11, 12, 13, 14, 15]) — Une liste de valeurs de délai (en trames) pour chaque canal de codebook. Le motif de délai crée des décalages temporels entre les différents canaux de codebook, permettant au modèle de capturer les dépendances entre les canaux. Chaque valeur représente le nombre de trames à retarder pour ce canal spécifique.
  • generation (bool, kwargs, facultatif, par défaut True) — Indique si le processeur est utilisé pour la génération (texte vers parole) ou pour l'entraînement. Si True, le processeur prépare les entrées pour le mode génération, où l'audio est généré à partir du texte. Si False, il prépare les entrées pour l'entraînement, où le texte et l'audio sont tous deux fournis.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

batch_decode

< >

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

Paramètres

  • decoder_input_ids (torch.Tensor) — La séquence de sortie complète du décodeur.
  • audio_prompt_len (int) — La longueur du préfixe audio (par exemple, lors de l'utilisation du clonage de voix).

Décode un lot de séquences de codebooks audio en leurs formes d’onde audio respectives via le audio_tokenizer. Voir decode() pour plus d’informations.

décoder

< >

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

Décode une seule séquence de codebooks audio en la forme d'onde audio correspondante via le audio_tokenizer. Consultez decode() et batch_decode() pour plus d'informations.

DiaModel

classe transformers.DiaModel

< >

( config: DiaConfig )

Paramètres

  • config (DiaConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle Dia brut, produisant des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

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)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • decoder_input_ids (torch.LongTensor de forme `(batch_size * num_codebooks, target_sequence_length) —
  • or (batch_size, target_sequence_length, num_codebooks)", 1 facultatif) —

    1. (batch_size * num_codebooks, target_sequence_length) : correspond au cas d'utilisation général où les codebooks d'entrée audio sont aplatis dans la dimension du lot. Cela correspond également aux logits audio aplatis utilisés pour calculer la perte.

    2. (batch_size, sequence_length, num_codebooks) : correspond à la forme utilisée en interne par Dia pour calculer les embeddings et les étapes suivantes de manière plus efficace.

    Si aucun decoder_input_ids n'est fourni, un tenseur de bos_token_id de forme (batch_size, 1, num_codebooks) sera créé. Les indices peuvent être obtenus à l'aide du DiaProcessor. Voir DiaProcessor.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

  • decoder_position_ids (torch.LongTensor de forme (batch_size, target_sequence_length)) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Utilisés pour calculer les embeddings de position jusqu'à config.decoder_config.max_position_embeddings.

    Qu'est-ce que les identifiants de position ?

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur.
  • encoder_outputs (Union[~modeling_outputs.BaseModelOutput, tuple], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • past_key_values (~cache_utils.EncoderDecoderCache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqModelOutput ou tuple(torch.Tensor)

Un Seq2SeqModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de DiaModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.

    Si past_key_values est utilisé, seule la dernière hidden-state des séquences de forme (batch_size, 1, hidden_size) est renvoyée.

  • past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

  • decoder_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.

  • decoder_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

  • encoder_last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.

  • encoder_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.

  • encoder_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

DiaForConditionalGeneration

classe transformers.DiaForConditionalGeneration

< >

( config: DiaConfig )

Paramètres

  • config (DiaConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle Dia, composé d'un encodeur de texte (octet) et d'un décodeur audio avec une tête de prédiction au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

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)

Paramètres

  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

    Qu'est-ce que les masques d'attention ?

  • decoder_input_ids (torch.LongTensor de forme `(batch_size * num_codebooks, target_sequence_length) —
  • or (batch_size, target_sequence_length, num_codebooks)", 1 facultatif) —

    1. (batch_size * num_codebooks, target_sequence_length) : correspond au cas d'utilisation général où les codebooks d'entrée audio sont aplatis dans la dimension du lot. Cela correspond également aux logits audio aplatis utilisés pour calculer la perte.

    2. (batch_size, sequence_length, num_codebooks) : correspond à la forme utilisée en interne par Dia pour calculer les embeddings et les étapes suivantes de manière plus efficace.

    Si aucun decoder_input_ids n'est fourni, un tenseur de bos_token_id de forme (batch_size, 1, num_codebooks) sera créé. Les indices peuvent être obtenus à l'aide du DiaProcessor. Voir DiaProcessor.call() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

  • decoder_position_ids (torch.LongTensor de forme (batch_size, target_sequence_length)) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Utilisés pour calculer les embeddings de position jusqu'à config.decoder_config.max_position_embeddings.

    Qu'est-ce que les identifiants de position ?

  • decoder_attention_mask (torch.LongTensor de forme (batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur.
  • encoder_outputs (Union[~modeling_outputs.BaseModelOutput, tuple], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • past_key_values (~cache_utils.EncoderDecoderCache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

    Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est fourni en entrée.

    Si past_key_values sont utilisés, l’utilisateur doit fournir uniquement les input_ids non traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme (batch_size, unprocessed_length) au lieu de tous les input_ids de forme (batch_size, sequence_length).

  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • labels (torch.LongTensor de forme (batch_size * num_codebooks,), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans [0, ..., config.decoder_config.vocab_size - 1] ou égaux à -100. Les jetons dont l'indice est défini à -100 sont ignorés (masqués).

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

Un Seq2SeqLMOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de DiaForConditionalGeneration surcharge la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage.

  • logits (torch.Tensor de forme (batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).

  • past_key_values (EncoderDecoderCache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.

    Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

  • decoder_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.

  • decoder_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

  • cross_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

  • encoder_last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.

  • encoder_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.

  • encoder_attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

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→