Hugging Face's logo

Transformers documentation

CLVP

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

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2023-05-12 et ajouté à Hugging Face Transformers le 2023-11-10.

CLVP

Aperçu

Le modèle CLVP (Contrastive Language-Voice Pretrained Transformer) a été proposé dans Better speech synthesis through scaling par James Betker.

L'abstract de l'article est le suivant :

Ces dernières années, le domaine de la génération d’images a été révolutionné par l’application des transformeurs autorégressifs et des DDPM. Ces approches modélisent le processus de génération d’images comme un processus probabiliste par étapes et exploitent de grandes quantités de calcul et de données pour apprendre la distribution des images. Cette méthodologie d’amélioration des performances ne doit pas être limitée aux images. Cet article décrit une manière d’appliquer les avancées du domaine de la génération d’images à la synthèse vocale. Le résultat est TorToise, un système expressif de synthèse vocale multi-voix.

Ce modèle a été contribué par Susnato Dhar. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

  1. CLVP est une partie intégrante du modèle Tortoise TTS.
  2. CLVP peut être utilisé pour comparer différents candidats de parole générés avec le texte fourni, et les meilleurs jetons de parole sont transmis au modèle de diffusion.
  3. L'utilisation de la méthode ClvpModelForConditionalGeneration.generate() est fortement recommandée pour l'utilisation de tortoise.
  4. Notez que le modèle CLVP s'attend à ce que l'audio soit échantillonné à 22,05 kHz, contrairement à d'autres modèles audio qui s'attendent à 16 kHz.

Explication succincte

  • Le ClvpTokenizer tokenise l'entrée texte, et le ClvpFeatureExtractor extrait le log mel-spectrogramme de l'audio souhaité.
  • ClvpConditioningEncoder prend ces jetons de texte et ces représentations audio et les convertit en plongements conditionnés par le texte et l’audio.
  • Le ClvpForCausalLM utilise ces embeddings pour générer plusieurs candidats vocaux.
  • Chaque candidat vocal est transmis à l’encodeur vocal (ClvpEncoder) qui le convertit en une représentation vectorielle, et l’encodeur texte (ClvpEncoder) convertit les jetons de texte dans le même espace latent.
  • Enfin, nous comparons chaque vecteur de parole au vecteur de texte pour déterminer quel vecteur de parole est le plus similaire au vecteur de texte.
  • ClvpModelForConditionalGeneration.generate() regroupe toute la logique décrite ci-dessus dans une seule méthode.

Exemple :

import datasets

from transformers import ClvpModelForConditionalGeneration, ClvpProcessor


# Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
text = "This is an example text."

ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
sample = ds[0]["audio"]

# Define processor and model.
processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev", device_map="auto")

# Generate processor output and model output.
processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt").to(model.device)
generated_output = model.generate(**processor_output)

ClvpConfig

classe transformers.ClvpConfig

< >

( 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 = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonespeech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojection_dim: int = 768logit_scale_init_value: float = 2.6592initializer_factor: float = 1.0 )

Paramètres

  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • speech_config (dict, facultatif) — Dictionnaire des options de configuration utilisées pour initialiser l’encodeur vocal CLVP.
  • decoder_config (dict, facultatif) — Dictionnaire des options de configuration utilisées pour initialiser ClvpDecoderConfig.
  • projection_dim (int, facultatif, par défaut 768) — Dimension des couches de projection du texte et de la vision.
  • logit_scale_init_value (float, facultatif, par défaut 2.6592) — La valeur initiale du paramètre logit_scale.
  • initializer_factor (float, facultatif, par défaut 1.0) — Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

Ceci est la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp 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 susnato/clvp_dev

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 ClvpConfig, ClvpModelForConditionalGeneration

>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()

>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)

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

>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig

>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()

>>> config = ClvpConfig(config_text, config_speech, decoder_config)

ClvpEncoderConfig

classe transformers.ClvpEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 256hidden_size: int = 768intermediate_size: int = 1536projection_dim: int = 768num_hidden_layers: int = 20num_attention_heads: int = 12hidden_act: str = 'gelu'layer_norm_eps: float = 1e-05attention_dropout: float | int = 0.1dropout: float | int = 0.1use_rotary_embedding: bool = Trueuse_attention_bias: bool = Falsesummary_type: str = 'mean'initializer_factor: float = 1.0bos_token_id: int | None = 255eos_token_id: int | list[int] | None = 0pad_token_id: int | None = None )

Paramètres

  • 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_size (int, facultatif, par défaut 768) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, par défaut 1536) — Dimension des représentations du MLP.
  • projection_dim (int, facultatif, par défaut 768) — Dimension des couches de projection du texte et de la vision.
  • num_hidden_layers (int, facultatif, par défaut 20) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • use_rotary_embedding (bool, facultatif, par défaut True) — Indique s'il faut utiliser rotary_embedding ou non.
  • use_attention_bias (bool, facultatif, par défaut False) — Indique s'il faut utiliser un biais dans les couches Query, Key et Value lors de l'auto-attention.
  • summary_type (str, facultatif, par défaut "mean") — Stratégie à utiliser pour obtenir pooler_output à partir de last_hidden_state. "last", "first", "mean" et "cls_index" sont pris en charge.
  • initializer_factor (float, facultatif, par défaut 1.0) — Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).
  • bos_token_id (int, facultatif, par défaut 255) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 0) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • pad_token_id (int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

Ceci est la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp 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 susnato/clvp_dev

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 ClvpEncoderConfig, ClvpEncoder

>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()

>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)

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

ClvpDecoderConfig

classe transformers.ClvpDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 8194max_position_embeddings: int = 608max_text_tokens: int = 404hidden_size: int = 1024num_hidden_layers: int = 30num_attention_heads: int = 16n_inner: int | None = Nonenum_mel_attn_blocks: int = 6activation_function: str = 'gelu_new'resid_pdrop: float | int = 0.1embd_pdrop: float | int = 0.1attention_dropout: float | int = 0.1layer_norm_epsilon: float = 1e-05initializer_range: float = 0.02summary_type: str = 'cls_index'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1use_cache: bool = Truebos_token_id: int | None = 8192eos_token_id: int | list[int] | None = 8193pad_token_id: int | None = Nonefeature_size: int = 80use_attention_bias: bool = Trueinitializer_factor: float = 1.0decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248)add_cross_attention: bool = False )

Paramètres

  • vocab_size (int, facultatif, par défaut 8194) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
  • max_position_embeddings (int, facultatif, par défaut 608) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • max_text_tokens (int, facultatif, valeur par défaut 404) — La longueur de séquence maximale des jetons de texte avec laquelle ce modèle pourrait être utilisé. Similaire à n_positions dans GPT2Config.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • num_hidden_layers (int, facultatif, par défaut 30) — Nombre de couches cachées dans le décodeur Transformer.
  • 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.
  • n_inner (int, facultatif) — Dimension des couches feed-forward internes. None le définit à 4 fois hidden_size.
  • num_mel_attn_blocks (int, facultatif, valeur par défaut 6) — Indique le nombre de couches d'auto-attention dans ClvpConditioningEncoder.
  • activation_function (str, facultatif, par défaut gelu_new) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • resid_pdrop (Union[float, int], facultatif, valeur par défaut 0.1) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • embd_pdrop (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout pour les embeddings.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.1) — Le taux de dropout appliqué aux probabilités d'attention.
  • layer_norm_epsilon (float, facultatif, par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • 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.
  • summary_type (string, facultatif, par défaut "cls_index") — Argument utilisé lors de la résumation de séquence. Doit être l'une des options suivantes :
    • "last" : prend l’état caché du dernier jeton (comme XLNet).
    • "first" : prend l’état caché du premier jeton (comme BERT).
    • "mean" : Prendre la moyenne des états cachés de tous les jetons.
    • "cls_index" : Fournir un Tensor indiquant la position du jeton de classification (comme pour GPT/GPT-2).
    • "attn" : Non implémenté pour le moment, utilisez l'attention multi-têtes.
  • summary_use_proj (bool, facultatif, par défaut True) — Indique s'il faut ou non ajouter une projection après l'extraction du vecteur.
  • summary_activation (str, facultatif) — Passer "tanh" pour appliquer une activation tanh à la sortie ; toute autre valeur ne déclenchera aucune activation.
  • summary_proj_to_labels (bool, facultatif, par défaut True) — Indique si les sorties de la projection doivent avoir config.num_labels ou config.hidden_size classes.
  • summary_first_dropout (float, facultatif, valeur par défaut 0.1) — Le taux de dropout à utiliser après la projection et l'activation.
  • 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.
  • bos_token_id (int, facultatif, par défaut 8192) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 8193) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • pad_token_id (int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • feature_size (int, facultatif, valeur par défaut 80) — La dimension des caractéristiques des caractéristiques mel extraites. Cette valeur est utilisée dans ClvpConditioningEncoder.
  • use_attention_bias (bool, facultatif, par défaut True) — Indique s'il faut utiliser un biais dans les couches Query, Key et Value lors de l'auto-attention.
  • initializer_factor (float, facultatif, par défaut 1.0) — Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).
  • decoder_fixing_codes (list, facultatif, par défaut [83, 45, 45, 248]) — Ces valeurs sont utilisées dans la méthode fix_speech_decoder_output pour corriger les sorties générées par le décodeur.
  • add_cross_attention (bool, facultatif, valeur par défaut False) — Indique si des couches d'attention croisée doivent être ajoutées au modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un ClvpModelForConditionalGeneration. Elle est utilisée pour instancier un modèle Clvp 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 susnato/clvp_dev

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 ClvpDecoderConfig, ClvpDecoder

>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()

>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)

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

ClvpTokenizer

classe transformers.ClvpTokenizer

< >

( vocab_filemerges_fileerrors = 'replace'unk_token = '[UNK]'bos_token = '<|endoftext|>'eos_token = '[STOP]'pad_token = '[STOP]'add_prefix_space = False**kwargs )

Paramètres

  • vocab_file (str) — Chemin vers le fichier de vocabulaire.
  • merges_file (str) — Chemin vers le fichier de fusions.
  • errors (str, facultatif, par défaut "replace") — Paradigme à suivre lors du décodage des octets en UTF-8. Voir bytes.decode pour plus d'informations.
  • unk_token (str, facultatif, par défaut "[UNK]") — 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.
  • bos_token (str, facultatif, par défaut "<|endoftext|>") — Le jeton de début de séquence.
  • eos_token (str, facultatif, par défaut "[STOP]") — Le jeton de fin de séquence.
  • pad_token (str, facultatif, par défaut "[STOP]") — Le jeton de bourrage de la séquence.
  • add_prefix_space (bool, facultatif, par défaut False) — Indique s'il faut ajouter un espace initial à l'entrée. Cela permet de traiter le mot initial comme n'importe quel autre mot. (Le tokenizer CLVP détecte le début des mots par l'espace qui les précède).

Construit un tokenizer CLVP. Basé sur l'encodage par paires de bytes (Byte-Pair-Encoding) au niveau des octets.

Ce tokenizer a été entraîné à traiter les espaces comme des parties des jetons (un peu comme sentencepiece), de sorte qu'un mot sera

être encodé différemment selon qu'il se trouve au début de la phrase (sans espace) ou non :

>>> from transformers import ClvpTokenizer

>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]

>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]

Vous pouvez contourner ce comportement en passant add_prefix_space=True lors de l’instanciation de ce tokenizer ou lors de son appel sur un texte, mais comme le modèle n’a pas été pré-entraîné de cette manière, cela pourrait entraîner une baisse des performances.

Lorsqu'il est utilisé avec is_split_into_words=True, ce tokeniseur ajoute un espace avant chaque mot (y compris le premier).

Ce tokenizer hérite de PreTrainedTokenizer, 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.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None ) → tuple[str, ...]

Paramètres

  • save_directory (str) — Le répertoire dans lequel enregistrer le vocabulaire.
  • filename_prefix (str, facultatif) — Préfixe facultatif à ajouter au nom des fichiers enregistrés.

Retourne

tuple[str, ...]

Chemin des fichiers enregistrés, ou tuple vide si aucun fichier n'a été enregistré.

Implémentation par défaut pour les motifs courants de sauvegarde du vocabulaire. Enregistre self.encoder/self.vocab au format JSON, éventuellement avec self.bpe_ranks en tant que fusions. Retourne un tuple vide si aucun vocabulaire n'existe.

Écrasez cette méthode si votre tokenizer nécessite une logique de sauvegarde personnalisée (par exemple, des modèles SentencePiece, plusieurs fichiers de vocabulaire ou des formats de fichiers spéciaux).

ClvpFeatureExtractor

classe transformers.ClvpFeatureExtractor

< >

( feature_size = 80sampling_rate = 22050default_audio_length = 6hop_length = 256chunk_length = 30n_fft = 1024padding_value = 0.0mel_norms = Nonereturn_attention_mask = False**kwargs )

Paramètres

  • feature_size (int, facultatif, valeur par défaut 80) — La dimension des caractéristiques des fonctionnalités extraites.
  • sampling_rate (int, facultatif, valeur par défaut 22050) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • default_audio_length (int, facultatif, valeur par défaut 6) — La longueur par défaut de l'audio brut, en secondes. Si max_length n'est pas défini lors de l'appel de __call__, il est automatiquement défini à default_audio_length * self.sampling_rate.
  • hop_length (int, facultatif, par défaut 256) — Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence de Mel.
  • chunk_length (int, facultatif, valeur par défaut 30) — Nombre maximal de chunks de sampling_rate échantillons utilisés pour rognner et compléter les séquences audio plus longues ou plus courtes.
  • n_fft (int, facultatif, par défaut 1024) — Taille de la transformée de Fourier.
  • padding_value (float, facultatif, valeur par défaut 0.0) — Valeur de bourrage utilisée pour bourrer l'audio. Doit correspondre à des silences.
  • mel_norms (list de longueur feature_size, facultatif) — Si mel_norms est fourni, il sera utilisé pour normaliser les spectrogrammes log-mel le long de chaque filtre mel.
  • return_attention_mask (bool, facultatif, défaut sur False) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné.

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

Construit un extracteur de fonctionnalités CLVP.

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.

Cette classe extrait des caractéristiques de spectrogramme log-mel à partir de la parole brute à l'aide d'une implémentation numpy personnalisée de la Short Time Fourier Transform qui doit correspondre à l'équivalent torch.stft de pytorch.

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | None = Nonetruncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Truepadding: str | None = 'max_length'max_length: int | None = None**kwargs )

Paramètres

  • raw_speech (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La séquence ou le lot de séquences à compléter. 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. L’audio doit être en mono, pas en stéréo, c’est-à-dire un seul flottant par pas de temps.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle l’entrée raw_speech a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l’appel forward afin d’éviter les erreurs silencieuses et de permettre le pipeline de reconnaissance automatique de la parole.
  • truncation (bool, facultatif, par défaut True) — Active la troncature pour couper les séquences d’entrée plus longues que max_length à max_length.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie.

    Ceci est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul >= 7.5 (Volta), ou sur les TPU qui bénéficient d'avoir des longueurs de séquence qui sont un multiple de 128.

  • return_attention_mask (bool, facultatif, par défaut True) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné.

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

  • 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.
  • padding_value (float, facultatif, valeur par défaut 0.0) — La valeur utilisée pour remplir les valeurs / vecteurs de bourrage.
  • max_length (int, facultatif) — La longueur maximale des entrées.

ClvpFeatureExtractor est utilisé pour extraire diverses propriétés spécifiques à la voix, telles que le ton et la hauteur de la voix, la vitesse de parole, et même des défauts de parole comme un bégaiement ou une articulation approximative, à partir d’un échantillon de voix ou de raw_speech.

D'abord, le signal audio est complété ou tronqué de manière à obtenir une forme d'onde d'une durée de self.default_audio_length secondes, puis le spectrogramme log-mel est extrait de celle-ci.

ClvpProcessor

classe transformers.ClvpProcessor

< >

( feature_extractortokenizer )

Paramètres

  • feature_extractor (ClvpFeatureExtractor) — L'extracteur de caractéristiques est une entrée obligatoire.
  • tokenizer (ClvpTokenizer) — Le tokenizer est une entrée obligatoire.

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

ClvpProcessor offre toutes les fonctionnalités de ClvpFeatureExtractor et de ClvpTokenizer. Consultez ~ClvpFeatureExtractor et ~ClvpTokenizer pour plus d’informations.

__call__

< >

( *argstext = Noneaudio = None**kwargs )

Paramètres

  • text (`) -- The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set is_split_into_words=True` to avoid ambiguity with batched inputs.
  • audio (“) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. En cas de 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.
  • 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.

décoder

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

batch_decode

< >

( *args**kwargs )

Cette méthode transmet tous ses arguments à batch_decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.

ClvpModelForConditionalGeneration

classe transformers.ClvpModelForConditionalGeneration

< >

( config: ClvpConfig )

Paramètres

  • config (ClvpConfig) — 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 CLVP composite avec un encodeur de texte, un encodeur de parole et un modèle de décodeur de parole.

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] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonereturn_loss: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpOutput or tuple(torch.FloatTensor)

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 ?

  • input_features (torch.FloatTensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de ClvpFeatureExtractor. Voir ClvpFeatureExtractor.call() pour plus de détails (ClvpProcessor utilise ClvpFeatureExtractor pour le traitement des audios).
  • conditioning_encoder_inputs_embeds (torch.FloatTensor, facultatif) — inputs_embeds pour ClvpConditioningEncoder. Peut être utilisé à la place de input_ids.
  • text_encoder_inputs_embeds (torch.FloatTensor, facultatif) — inputs_embeds pour le modèle d'encodeur de texte, transmis à la place de input_ids.
  • 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 ?

  • return_loss (bool, facultatif) — Indique s'il faut renvoyer la perte contrastive.

Retourne

ClvpOutput ou tuple(torch.FloatTensor)

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

La méthode forward de ClvpModelForConditionalGeneration 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.FloatTensor de forme (1,), facultatif, renvoyé lorsque return_loss est True) — Perte contrastive pour la similarité parole-texte.
  • speech_ids (torch.LongTensor, facultatif) — speech_ids (ou candidats de parole) générés par le modèle ClvpForCausalLM.
  • logits_per_speech (torch.FloatTensor de forme (speech_batch_size, text_batch_size)) — Les scores de produit scalaire normalisé entre speech_embeds et text_embeds. Cela représente les scores de similarité entre le discours et le texte.
  • logits_per_text (torch.FloatTensor de forme (text_batch_size, speech_batch_size)) — Les scores de produit scalaire normalisé entre text_embeds et speech_embeds. Cela représente les scores de similarité texte-parole.
  • text_embeds (torch.FloatTensor de forme (batch_size, output_dim) — Les embeddings de texte obtenus en appliquant la couche de projection à la sortie agrégée du modèle encodeur de texte.
  • speech_embeds (torch.FloatTensor de forme (batch_size, output_dim) — Les embeddings de parole obtenus en appliquant la couche de projection à la sortie agrégée de l'encodeur de parole du modèle.
  • text_model_output (~modeling_outputs.BaseModelOutputWithPooling, facultatif) — La sortie agrégée de last_hidden_state du modèle encodeur de texte.
  • speech_model_output (~modeling_outputs.BaseModelOutputWithPooling, facultatif) — La sortie agrégée de last_hidden_state du modèle encodeur de la parole.
  • decoder_hidden_states (torch.FloatTensor, facultatif) — Les états cachés du modèle décodeur.
  • text_encoder_hidden_states (torch.FloatTensor, facultatif) — Les états cachés du modèle d’encodeur de texte.
  • speech_encoder_hidden_states (torch.FloatTensor, facultatif) — Les états cachés du modèle d'encodeur vocal.

Exemples :

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
...     input_ids=processor_output["input_ids"],
...     input_features=processor_output["input_features"],
...     return_dict=True,
... )

generate

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = Nonepad_to_max_mel_tokens: int | None = Noneoutput_hidden_states: bool | None = None**kwargs ) → ClvpOutput or tuple

Paramètres

  • input_ids (torch.FloatTensor de forme (batch_size, sequence_length), facultatif) — Tokens du texte d'entrée. Traités à partir du ClvpTokenizer.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de 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 ?

  • generation_config (~generation.GenerationConfig, facultatif) — La configuration de génération à utiliser comme paramétrage de base pour l’appel de génération. Les **kwargs transmis à generate qui correspondent aux attributs de generation_config les remplaceront. Si generation_config n’est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle generation_config.json, s’il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de GenerationConfig, dont la documentation doit être consultée pour paramétrer la génération.
  • pad_to_max_mel_tokens (int, facultatif) — Remplit les speech_ids générés jusqu'à la valeur spécifiée. Cela permet d'implémenter la même logique que dans le dépôt officiel, lien : https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 et de s'assurer que les logits sont identiques. Cela n'affecte pas la qualité de la génération, il est donc déconseillé de l'utiliser car il est moins efficace.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés des modèles de décodeur, d'encodeur de texte et d'encodeur vocal.

Retourne

ClvpOutput ou tuple

Un ClvpOutput (si return_dict_in_generate=True ou lorsque config.return_dict_in_generate=True) ou un tuple.

Méthode de génération pour ClvpModelForConditionalGeneration, cette méthode appelle la méthode generate de ClvpForCausalLM puis utilise les speech_ids générés pour traiter text_embeds et speech_embeds à l'aide de ClvpEncoder.

get_text_features

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonetext_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.FloatTensor)

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 ?

  • text_encoder_inputs_embeds (torch.FloatTensor, facultatif) — inputs_embeds pour le modèle d'encodeur de texte, transmis à la place de input_ids.
  • 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 ?

Retourne

ClvpEncoderOutput ou tuple(torch.FloatTensor)

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

Cette méthode peut être utilisée pour extraire text_embeds d'un texte. Les embeddings de texte obtenus en appliquant la couche de projection à la sortie agrégée du modèle d'encodeur de texte CLVP.

  • embeddings (torch.FloatTensor de forme (batch_size, output_dim), facultatif, renvoyé lorsque le modèle est initialisé avec with_projection=True) — Les embeddings obtenus en appliquant la couche de projection au pooler_output.

  • last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — L'état caché de la dernière couche du modèle.

  • pooler_output (torch.FloatTensor de forme (batch_size, hidden_size)) — Sortie agrégée de last_hidden_state.

  • hidden_states (tuple[torch.FloatTensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

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

Exemples :

>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text
>>> text = "This is an example text."

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])

get_speech_features

< >

( speech_ids: typing.Optional[torch.LongTensor] = Noneinput_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.FloatTensor] = Noneconditioning_encoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonegeneration_config: transformers.generation.configuration_utils.GenerationConfig | None = None**kwargs ) → torch.FloatTensor of shape (batch_size, output_dim)

Paramètres

  • speech_ids (torch.LongTensor de forme (batch_size, num_speech_ids), facultatif) — Tokens de parole. Le padding sera ignoré par défaut si vous en fournissez. Si speech_ids sont fournis, input_ids et input_features seront automatiquement ignorés.
  • input_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Tokens du texte d'entrée. Traités à partir du ClvpTokenizer. Si speech_ids n'est pas fourni, input_ids et input_features seront utilisés.
  • conditioning_encoder_inputs_embeds (torch.FloatTensor, facultatif) — inputs_embeds pour ClvpConditioningEncoder. Peut être utilisé à la place de input_ids.
  • attention_mask (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices de jetons de remplissage. 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 ?

  • generation_config (GenerationConfig, facultatif) — configuration de génération pour contrôler la génération de speech_ids si elles ne sont pas fournies.

Retourne

torch.FloatTensor de forme (batch_size, output_dim)

Les embeddings de parole obtenus en appliquant la couche de projection à la sortie agrégée du modèle CLVP Speech.

Cette méthode peut être utilisée pour extraire speech_embeds. Les embeddings vocaux sont obtenus en appliquant le modèle vocal sur speech_ids. Si speech_ids n'est pas présent mais que input_ids et input_features sont tous deux fournis, le modèle décodeur sera d'abord utilisé pour générer speech_ids, puis le modèle vocal sera appliqué.

Exemples :

>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
...     input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )

ClvpForCausalLM

classe transformers.ClvpForCausalLM

< >

( config: ClvpDecoderConfig )

Paramètres

  • config (ClvpDecoderConfig) — 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 de décodeur CLVP avec une tête de modélisation de langage 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] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

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 ?

  • past_key_values (~cache_utils.Cache, 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).

  • attention_mask (torch.FloatTensor 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 ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

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

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le modélisation du langage. Notez que les étiquettes sont décalées à l'intérieur du modèle, c'est-à-dire que vous pouvez définir labels = input_ids Les indices sont sélectionnés dans [-100, 0, ..., config.vocab_size] Toutes les étiquettes définies sur -100 sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans [0, ..., config.vocab_size]
  • 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

CausalLMOutputWithCrossAttentions ou tuple(torch.FloatTensor)

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

La méthode forward de ClvpForCausalLM 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.

  • loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).

  • logits (torch.FloatTensor 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).

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

    Poids des attentions 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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions croisées après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

  • past_key_values (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. 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'attention) qui peuvent être utilisés (voir l'entrée past_key_values) pour accélérer le décodage séquentiel.

ClvpModel

classe transformers.ClvpModel

< >

( config: ClvpDecoderConfig )

Paramètres

  • config (ClvpDecoderConfig) — 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 Clvp brut, qui produit 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.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

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.FloatTensor 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 ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

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

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, 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).

  • inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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

BaseModelOutputWithPastAndCrossAttentions ou tuple(torch.FloatTensor)

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

La méthode forward du ClvpModel 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.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche 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 (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. 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, le cas échéant, si config.is_encoder_decoder=True, 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.

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

    Poids des attentions 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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True et config.add_cross_attention=True sont passés ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (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.

ClvpEncoder

classe transformers.ClvpEncoder

< >

( config: ClvpEncoderConfig )

Paramètres

  • config — ClvpConfig

Encodeur Transformer composé de config.num_hidden_layers couches d'auto-attention. Chaque couche est une ClvpEncoderLayer.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ClvpEncoderOutput or tuple(torch.FloatTensor)

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 ?

  • inputs_embeds (torch.LongTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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 ?

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

Retourne

ClvpEncoderOutput ou tuple(torch.FloatTensor)

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

La méthode forward de ClvpEncoder 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.

  • embeddings (torch.FloatTensor de forme (batch_size, output_dim), facultatif, renvoyé lorsque le modèle est initialisé avec with_projection=True) — Les embeddings obtenus en appliquant la couche de projection au pooler_output.

  • last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — L'état caché de la dernière couche du modèle.

  • pooler_output (torch.FloatTensor de forme (batch_size, hidden_size)) — Sortie agrégée de last_hidden_state.

  • hidden_states (tuple[torch.FloatTensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

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

ClvpDecoder

classe transformers.ClvpDecoder

< >

( config: ClvpDecoderConfig )

Décodeur Transformer composé de config.num_hidden_layers couches. Chaque couche est une ClvpDecoderLayer

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

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.FloatTensor 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 ?

  • token_type_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans [0, 1]:
    • 0 correspond à un jeton sentence A,
    • 1 correspond à un jeton sentence B.

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

  • position_ids (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle [0, config.n_positions - 1].

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, 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).

  • inputs_embeds (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • 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

BaseModelOutputWithPastAndCrossAttentions ou tuple(torch.FloatTensor)

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

La méthode forward de ClvpDecoder 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.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche 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 (Cache, facultatif, renvoyé lorsque use_cache=True est passé ou lorsque config.use_cache=True) — Il s’agit d’une instance de Cache. 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, le cas échéant, si config.is_encoder_decoder=True, 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.

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

    Poids des attentions 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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True et config.add_cross_attention=True sont passés ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (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.

Update on GitHub

←CLIPSeg Code World Model (CWM)→