Transformers documentation
Whisper
Ce modèle a été publié dans HF papers le 2022-12-06 et contribué à Hugging Face Transformers le 2022-10-05.
Whisper
Whisper est un transformeur encodeur-décodeur (séquence-à-séquence) pré-entraîné sur 680 000 heures de données audio étiquetées. Ce volume de données de pré-entraînement permet d’obtenir des performances en zéro-shot sur des tâches audio en anglais et dans de nombreuses autres langues. Le décodeur permet à Whisper de mapper les représentations de la parole apprises par l’encodeur vers des sorties utiles, telles que du texte, sans fine-tuning supplémentaire. Whisper fonctionne directement, sans configuration particulière.
Vous pouvez trouver tous les points de contrôle originaux de Whisper dans la collection Whisper.
Cliquez sur les modèles Whisper dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Whisper à différentes tâches audio.
Définissez
use_kernels=Truedans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez Chargement des noyaux pour en savoir plus.
L'exemple ci-dessous montre comment transcrire automatiquement la parole en texte avec Pipeline ou la classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
task="automatic-speech-recognition",
model="openai/whisper-large-v3-turbo",
device=0
)
pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")# pip install datasets
from datasets import load_dataset
from transformers import AutoProcessor, WhisperForConditionalGeneration
processor = AutoProcessor.from_pretrained(
"openai/whisper-large-v3-turbo",
)
model = WhisperForConditionalGeneration.from_pretrained(
"openai/whisper-large-v3-turbo",
device_map="auto",
attn_implementation="sdpa"
)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
audio_sample = ds[0]["audio"]
input_features = processor(
audio_sample["array"],
sampling_rate=audio_sample["sampling_rate"],
return_tensors="pt"
).input_features
input_features = input_features.to(model.device, dtype=model.dtype)
predicted_ids = model.generate(input_features, cache_implementation="static")
transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
transcription[0]Notes
- Whisper s'appuie sur une fonction
generatepersonnalisée pour l'inférence, pensez à consulter la documentation ci-dessous. - Le WhisperProcessor permet de préparer l’audio et de décoder les identifiants prédits pour les reconvertir en texte.
WhisperConfig
classe transformers.WhisperConfig
< source >( 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 = Truevocab_size: int = 51865num_mel_bins: int = 80encoder_layers: int = 4encoder_attention_heads: int = 6decoder_layers: int = 4decoder_attention_heads: int = 6decoder_ffn_dim: int = 1536encoder_ffn_dim: int = 1536encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0decoder_start_token_id: int = 50257use_cache: bool = Trueactivation_function: str = 'gelu'd_model: int = 384dropout: float | int = 0.0attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02scale_embedding: bool = Falsemax_source_positions: int = 1500max_target_positions: int = 448pad_token_id: int | None = 50256bos_token_id: int | None = 50256eos_token_id: int | list[int] | None = 50256suppress_tokens: list | None = Nonebegin_suppress_tokens: list[int] | tuple[int, ...] | None = (220, 50256)use_weighted_layer_sum: bool = Falseclassifier_proj_size: int = 256apply_spec_augment: bool = Falsemask_time_prob: float | int = 0.05mask_time_length: int = 10mask_time_min_masks: int = 2mask_feature_prob: float | int = 0.0mask_feature_length: int = 10mask_feature_min_masks: int = 0median_filter_width: int = 7tie_word_embeddings: bool = True )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - vocab_size (
int, facultatif, par défaut51865) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - num_mel_bins (
int, facultatif, valeur par défaut80) — Nombre de caractéristiques mel utilisées par tranche d’entrée. Doit correspondre à la valeur utilisée dans la classeAutoFeatureExtractor. - encoder_layers (
int, facultatif, valeur par défaut4) — Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - encoder_attention_heads (
int, facultatif, valeur par défaut6) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer. - decoder_layers (
int, facultatif, valeur par défaut4) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - decoder_attention_heads (
int, facultatif, valeur par défaut6) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - decoder_ffn_dim (
int, facultatif, valeur par défaut1536) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur. - encoder_ffn_dim (
int, facultatif, valeur par défaut1536) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l'encodeur. - encoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.0) — Probabilité de LayerDrop pour l'encodeur. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - decoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.0) — Probabilité de LayerDrop pour le décodeur. Consultez l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - decoder_start_token_id (
int, facultatif, valeur par défaut50257) — Si un modèle encodeur-décodeur commence le décodage avec un jeton différent debos, l’identifiant de ce jeton. - use_cache (
bool, facultatif, valeur par défautTrue) — 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 siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - activation_function (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - d_model (
int, facultatif, par défaut384) — Taille des couches d'encodeur et de la couche pooler. - dropout (
Union[float, int], facultatif, par défaut0.0) — Le taux appliqué à toutes les couches de dropout. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - activation_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée. - init_std (
float, facultatif, valeur par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - scale_embedding (
bool, facultatif, par défautFalse) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model). - max_source_positions (
int, facultatif, valeur par défaut 1500) — La longueur de séquence maximale des caractéristiques de filtres log-mel avec laquelle ce modèle pourrait être utilisé. - max_target_positions (
int, facultatif, valeur par défaut : 448) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. Il est généralement recommandé de définir cette valeur sur un nombre élevé par précaution (par exemple, 512, 1024 ou 2048). - pad_token_id (
int, facultatif, valeur par défaut50256) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut50256) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut50256) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - suppress_tokens (
list[int], facultatif) — Une liste contenant les jetons non vocaux qui seront utilisés par le processeur de logits dans la fonctiongenerate. NON_SPEECH_TOKENS et NON_SPEECH_TOKENS_MULTI correspondent respectivement au modèleenglish-onlyet au modèlemultilingual. - begin_suppress_tokens (
list[int], facultatif, valeur par défaut[220,50256]) — Une liste contenant les jetons qui seront supprimés au début du processus d'échantillonnage. Initialisée avec le jeton pour" "(blank_token_id) et leeos_token_id - use_weighted_layer_sum (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser une moyenne pondérée des sorties des couches avec des poids appris. Ne concerne que l'utilisation d'une instance de WhisperForAudioClassification. - classifier_proj_size (
int, facultatif, par défaut 256) — Dimension de la projection avant le pooling par moyenne des jetons pour la classification. Ne concerne que l'utilisation d'une instance de WhisperForAudioClassification. - apply_spec_augment (
bool, facultatif, valeur par défautFalse) — Indique s'il faut appliquer l'augmentation de données SpecAugment aux sorties de l'encodeur de caractéristiques. Pour référence, voir SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition. - mask_time_prob (
float, facultatif, valeur par défaut 0.05) — Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe temporel qui seront masqués. La procédure de masquage génèremask_time_prob*len(time_axis)/mask_time_lengthmasques indépendants sur l'axe. Si l'on raisonne à partir de la probabilité que chaque vecteur de caractéristiques soit choisi comme début de la portée de vecteurs à masquer, mask_time_prob doit êtreprob_vector_start*mask_time_length. Notez que les chevauchements peuvent réduire le pourcentage réel de vecteurs masqués. Cela ne concerne que le cas oùapply_spec_augment == True. - mask_time_length (
int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe temporel. - mask_time_min_masks (
int, facultatif, valeur par défaut 2), — Le nombre minimal de masques de longueurmask_feature_lengthgénérés le long de l’axe temporel, à chaque étape temporelle, indépendamment demask_feature_prob. Ne concerne que le cas où ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” - mask_feature_prob (
float, facultatif, valeur par défaut 0.0) — Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe des caractéristiques qui seront masqués. La procédure de masquage génèremask_feature_prob*len(feature_axis)/mask_time_lengthmasques indépendants sur l'axe. Si l'on raisonne à partir de la probabilité que chaque vecteur de caractéristiques soit choisi comme début de la portée de vecteurs à masquer, mask_feature_prob doit êtreprob_vector_start*mask_feature_length. Notez que les chevauchements peuvent réduire le pourcentage réel de vecteurs masqués. Cela ne concerne que le cas oùapply_spec_augment is True. - mask_feature_prob (
Union[float, int], facultatif, valeur par défaut0.0) — Pourcentage (compris entre 0 et 1) de tous les vecteurs de caractéristiques le long de l'axe des caractéristiques qui seront masqués. La procédure de masquage génèremask_feature_prob*len(feature_axis)/mask_time_lengthmasques indépendants sur l'axe. Si l'on raisonne à partir de la probabilité que chaque vecteur de caractéristiques soit choisi comme début de la portée de vecteurs à masquer, mask_feature_prob doit êtreprob_vector_start*mask_feature_length. Notez que les chevauchements peuvent diminuer le pourcentage réel de vecteurs masqués. Cela n'est pertinent que siapply_spec_augmentestTrue. - mask_feature_length (
int, facultatif, valeur par défaut 10) — Longueur de la portée du vecteur le long de l'axe des caractéristiques. - mask_feature_min_masks (
int, facultatif, valeur par défaut 0) — Nombre minimal de masques de longueurmask_feature_lengthgénérés le long de l’axe des caractéristiques, à chaque étape, indépendamment demask_feature_prob. Ne concerne que le cas oùmask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks. - median_filter_width (
int, facultatif, valeur par défaut : 7) — Largeur du filtre médian utilisé pour lisser les sorties de l'attention croisée lors du calcul des horodatages des jetons. Doit être un nombre impair. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un WhisperModel. Elle est utilisée pour instancier un modèle Whisper en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de openai/whisper-tiny
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 WhisperConfig, WhisperModel
>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()
>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configWhisperTokenizer
classe transformers.WhisperTokenizer
< source >( vocab: str | dict[str, int] | None = Nonemerges = Nonenormalizer_file = Noneunk_token = '<|endoftext|>'bos_token = '<|endoftext|>'eos_token = '<|endoftext|>'add_prefix_space = Falselanguage = Nonetask = Nonepredict_timestamps = False**kwargs )
Paramètres
- vocab_file (
str, facultatif) — Chemin vers le fichier de vocabulaire. - merges_file (
str, facultatif) — Chemin vers le fichier de fusions. - normalizer_file (
str, facultatif) — Chemin du fichier normalizer_file. - tokenizer_file (
str, facultatif) — Chemin vers le fichier tokenizers (généralement avec l'extension .json) qui contient tout ce qui est nécessaire pour charger le tokenizer. - unk_token (
str, facultatif, par défaut"<|endoftext|>") — 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. Ledecoder_start_token_idest utilisé pour définir le premier jeton comme"<|startoftranscript|>"lors de la génération. - eos_token (
str, facultatif, par défaut"<|endoftext|>") — Le jeton de fin de séquence. - add_prefix_space (
bool, facultatif, valeur par défautFalse) — 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 Whisper détecte le début des mots par l'espace qui les précède). - language (
str, facultatif) — La langue du texte de transcription. Le jeton d’identifiant de langue correspondant est ajouté au début de la séquence pour les tâches de reconnaissance vocale multilingue et de traduction vocale, par exemple, pour l’espagnol, le jeton"<|es|>"est ajouté au début de la séquence. Cette option doit être utilisée uniquement pour l’ajustement fin multilingue. - task (
str, facultatif) — Identifiant de tâche à ajouter au début de la séquence (le cas échéant). À utiliser pour l'ajustement fin multilingue, avec"transcribe"pour la reconnaissance vocale et"translate"pour la traduction vocale. - predict_timestamps (
bool, facultatif, valeur par défautFalse) — Indique s'il faut omettre le jeton<|notimestamps|>au début de la séquence.
Construire un tokenizer Whisper « rapide » (basé sur la bibliothèque tokenizers de HuggingFace).
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.
set_prefix_tokens
< source >( language: str | None = Nonetask: str | None = Nonepredict_timestamps: bool | None = None )
Paramètres
- language (
str, facultatif, par défautNone) — La langue du texte de transcription. - task (
str, facultatif, par défautNone) — Identifiant de tâche à ajouter au début de la séquence (le cas échéant). - predict_timestamps (
bool, facultatif, valeur par défautNone) — Indique s'il faut omettre le jeton<|notimestamps|>au début de la séquence.
Remplace les jetons de préfixe ajoutés au début de la séquence d'étiquettes. Cette méthode peut être utilisée de manière autonome pour
mettre à jour les jetons de préfixe selon les besoins lors de l'ajustement fin. Exemple :
>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → list[int]
Paramètres
- token_ids_0 (
list[int]) — Liste d'identifiants. - token_ids_1 (
list[int], facultatif) — Deuxième liste d'identifiants facultative pour les paires de séquences. - already_has_special_tokens (
bool, facultatif, par défautFalse) — Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.
Retourne
list[int]
Une liste d'entiers dans l'intervalle [0, 1] : 1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupère les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide de la méthode prepare_for_model du tokeniseur.
batch_decode
< source >( sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensorskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
Paramètres
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Liste des identifiants d’entrée tokenisés. Peut être obtenue à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. SiNone, la valeur par défaut estself.clean_up_tokenization_spaces. - kwargs (arguments supplémentaires par mot-clé, facultatif) — Sera transmis à la méthode de décodage spécifique du modèle sous-jacent.
Retourne
list[str]
La liste des phrases décodées.
Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.
Cette méthode est fournie pour la compatibilité ascendante. La méthode decode gère désormais nativement les entrées par lots,
vous pouvez donc utiliser directement decode au lieu de batch_decode.
décoder
< source >( token_idsskip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = Noneoutput_offsets: bool = Falsetime_precision: float = 0.02decode_with_timestamps: bool = Falsenormalize: bool = Falsebasic_normalize: bool = Falseremove_diacritics: bool = False**kwargs ) → str
Paramètres
- token_ids (
Union[int, list[int], np.ndarray, torch.Tensor]) — Liste des identifiants d’entrée tokenisés. Peut être obtenue à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. Supprime les jetons précédents (avant l'invite) s'ils sont présents. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. Si la valeur estNone, la valeur par défaut estself.clean_up_tokenization_spaces(disponible danstokenizer_config). - output_offsets (
bool, facultatif, par défautFalse) — Indique s'il faut ou non afficher les décalages des jetons. Cette option ne doit être activée que si le modèle a prédit des horodatages. S'il existe des jetons précédents (avant l'invite) à décoder, ils n'apparaîtront dans le texte décodé que s'ils contiennent des jetons d'horodatage. - time_precision (
float, facultatif, valeur par défaut 0.02) — Le ratio temporel pour convertir un jeton en temps. - decode_with_timestamps (
bool, facultatif, valeur par défautFalse) — Indique s'il faut décoder en incluant les horodatages présents dans le texte brut. - normalize (
bool, facultatif, valeur par défautFalse) — Indique s'il faut ou non appliquer le normalisateur de texte anglais au texte décodé. N'est applicable que lorsque le texte cible est en anglais. Sinon, le normalisateur de texte de base doit être appliqué. - basic_normalize (
bool, facultatif, valeur par défautFalse) — Indique s'il faut ou non appliquer le normaliseur de texte Basic au texte décodé. Applicable au texte cible multilingue. - remove_diacritics (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les diacritiques lors de l'application du normaliseur de texte de base. La suppression des diacritiques peut détruire des informations dans le texte décodé ; il convient donc de l'utiliser avec prudence. - kwargs (arguments supplémentaires par mot-clé, facultatif) — Sera transmis à la méthode de décodage spécifique du modèle sous-jacent.
Retourne
str
La phrase décodée.
Convertit une séquence d'identifiants en chaîne de caractères, en utilisant le tokenizer et le vocabulaire, avec des options pour supprimer les jetons spéciaux et nettoyer les espaces de tokenization.
Similaire à l'exécution de self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids)).
Normaliser une chaîne de caractères donnée à l'aide de la classe BasicTextNormalizer, qui effectue des transformations courantes sur le texte multilingue.
Normaliser une chaîne de caractères donnée à l'aide de la classe EnglishTextNormalizer, qui effectue des transformations courantes sur le texte anglais.
WhisperFeatureExtractor
classe transformers.WhisperFeatureExtractor
< source >( feature_size = 80sampling_rate = 16000hop_length = 160chunk_length = 30n_fft = 400padding_value = 0.0dither = 0.0return_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 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz). - hop_length (
int, facultatif, par défaut 160) — Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel. - chunk_length (
int, facultatif, valeur par défaut 30) — Nombre maximal de chunks desampling_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 400) — 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. - dither (
float, optional, defaults to 0.0) — Adds dithering. In other words, adds a small Gaussian noise to each frame. E.g. use 0.0001 to add dithering with a normal distribution centered around 0.0 with standard deviation 0.0001 (assuming [-1,+1] range of raw_speech). The value 0.0 means no dithering. Dithering has similar effect asspectrogram(mel_floor=...). It reduces the high log_mel_fbank values for signals with hard-zero sections, when VAD cutoff is present in the signal.
Construit un extracteur de fonctionnalités Whisper.
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 les caractéristiques de la banque de filtres 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__
< source >( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Truepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'max_length'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'**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. - truncation (
bool, facultatif, par défautTrue) — Active la troncature pour couper les séquences d’entrée plus longues que max_length à max_length. - pad_to_multiple_of (
int, facultatif, valeur par défaut None) — 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_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets Numpynp.ndarray.
- 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 feature_extractor spécifique.Qu'est-ce que les masques d'attention ?
Pour les modèles Whisper,
attention_maskdoit toujours être transmis lors de l'inférence par lots, afin d'éviter des bugs subtils. - padding (
strou PaddingStrategy, facultatif, valeur par défaut :'max_length') — Active et contrôle le bourrage (padding). Accepte les valeurs suivantes : 'longest' : bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). 'max_length' (par défaut) : bourrage jusqu'à la longueur maximale spécifiée avec l'argument max_length, ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. 'do_not_pad' : aucun bourrage (c'est-à-dire qu'un lot de séquences de longueurs différentes peut être renvoyé).'longest': Rembourrage jusqu'à la séquence la plus longue du lot (ou aucun rembourrage si une seule séquence est fournie).'max_length'(par défaut) : Remplir jusqu'à une longueur maximale spécifiée avec l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.'do_not_pad': aucun padding (c.-à-d. peut produire un lot avec des séquences de longueurs différentes).
- 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é. - sampling_rate (
int, facultatif) — La fréquence d’échantillonnage à laquelle l’entréeraw_speecha été échantillonnée. Il est fortement recommandé de passersampling_ratelors de l’appel forward afin d’éviter les erreurs silencieuses et de permettre le pipeline de reconnaissance automatique de la parole. - do_normalize (
bool, facultatif, valeur par défautFalse) — Indique s'il faut normaliser l'entrée avec une moyenne nulle et une variance unitaire. La normalisation peut contribuer à améliorer considérablement les performances du modèle. - device (
str, facultatif, par défaut'cpu') — Spécifie l'appareil utilisé pour le calcul du spectrogramme log-mel des signaux audio dans la méthode_torch_extract_fbank_features. (par ex. « cpu », « cuda ») - **kwargs — Non pris en charge par WhisperFeatureExtractor.call() et ignoré.
Méthode principale pour extraire les caractéristiques d'une ou plusieurs séquences et les préparer pour le modèle. L'implémentation utilise PyTorch pour le calcul de la STFT si disponible, sinon une version plus lente basée sur NumPy.
WhisperProcessor
classe transformers.WhisperProcessor
< source >( feature_extractortokenizer )
Construit un WhisperProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
WhisperProcessor offre toutes les fonctionnalités de WhisperFeatureExtractor et de WhisperTokenizer. Consultez ~WhisperFeatureExtractor et ~WhisperTokenizer pour plus d'informations.
__call__
< source >( *args**kwargs )
Paramètres
- return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLikecache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'**kwargs )
Paramètres
- pretrained_model_name_or_path (
strouos.PathLike) — Cela peut être soit :- une chaîne de caractères, l'identifiant du modèle d'un feature_extractor pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co.
- un chemin vers un dossier contenant un fichier d’extracteur de caractéristiques enregistré à l’aide de la méthode
save_pretrained(), par exemple
./my_model_directory/. - un chemin vers un fichier JSON d’extracteur de caractéristiques enregistré fichier, par exemple
./my_model_directory/preprocessor_config.json.
- **kwargs —
Arguments supplémentaires passés à la fois à
from_pretrained() et à
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained.
Instanciez un processeur associé à un modèle pré-entraîné.
Cette méthode d’appel de classe invoque simplement la méthode from_pretrained() de l’extracteur de caractéristiques, la méthode de la classe ImageProcessingMixin du processeur d’images et la méthode
~tokenization_utils_base.PreTrainedTokenizer.from_pretraineddu tokeniseur. Veuillez consulter les docstrings des méthodes ci-dessus pour plus d’informations.
save_pretrained
< source >( save_directorypush_to_hub: bool = False**kwargs )
Paramètres
- save_directory (
strouos.PathLike) — Répertoire où le fichier JSON de l'extracteur de caractéristiques et les fichiers du tokenizer seront enregistrés (le répertoire sera créé s'il n'existe pas). - push_to_hub (
bool, facultatif, par défautFalse) — Indique s'il faut ou non pousser votre modèle sur le hub de modèles Hugging Face après l'avoir enregistré. Vous pouvez spécifier le dépôt auquel vous souhaitez pousser avecrepo_id(par défaut, il s'agit du nom desave_directorydans votre espace de noms). - kwargs (
dict[str, Any], facultatif) — Arguments supplémentaires passés à la méthode push_to_hub().
Enregistre les attributs de ce processeur (extracteur de caractéristiques, tokeniseur…) dans le répertoire spécifié afin qu’il puisse être rechargé à l’aide de la méthode from_pretrained().
Cette méthode de classe appelle simplement save_pretrained() et save_pretrained(). Veuillez consulter les docstrings des méthodes ci-dessus pour plus d'informations.
Cette méthode transmet tous ses arguments à batch_decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.
Cette méthode transmet tous ses arguments à decode() de PreTrainedTokenizer. Veuillez consulter la docstring de cette méthode pour plus d’informations.
WhisperModel
classe transformers.WhisperModel
< source >( config: WhisperConfig )
Paramètres
- config (WhisperConfig) — 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 Whisper 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
< source >( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqModelOutput or tuple(torch.Tensor)
Paramètres
- input_features (
torch.Tensorde 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 WhisperFeatureExtractor. Voir WhisperFeatureExtractor.call() pour plus de détails (WhisperProcessor utilise WhisperFeatureExtractor pour le traitement des audios). - attention_mask (
torch.LongTensorde 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.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de WhisperTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Whisper utilise decoder_start_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values).Les indices peuvent être obtenus à l’aide de WhisperTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
Whisper utilise
decoder_start_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que le dernierdecoder_input_ids(voirpast_key_values). - decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut.Si vous souhaitez modifier le comportement du padding, vous devez lire
modeling_whisper._prepare_decoder_attention_masket l’adapter à vos besoins. Consultez la figure 1 de l’article BART pour plus d’informations sur la stratégie par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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.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 lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'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_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon 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 lesinput_idsde forme(batch_size, sequence_length). - decoder_inputs_embeds (
tuple[torch.Tensor]de forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - decoder_position_ids (
torch.LongTensorde 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]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_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 (WhisperConfig) et des entrées.
La méthode forward de WhisperModel 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
Moduleplutô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.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Exemple :
>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperModel
>>> from datasets import load_dataset
>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]_mask_input_features
< source >( input_features: Tensorattention_mask: typing.Optional[torch.LongTensor] = None )
Les masques extraient les caractéristiques le long de l'axe temporel et/ou de l'axe des caractéristiques selon SpecAugment.
WhisperForConditionalGeneration
classe transformers.WhisperForConditionalGeneration
< source >( config: WhisperConfig )
Paramètres
- config (WhisperConfig) — 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 Whisper avec une tête de modélisation de langage. Peut être utilisé pour la reconnaissance automatique de la 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
< source >( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.Tensor)
Paramètres
- input_features (
torch.Tensorde 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 WhisperFeatureExtractor. Voir WhisperFeatureExtractor.call() pour plus de détails (WhisperProcessor utilise WhisperFeatureExtractor pour le traitement des audios). - attention_mask (
torch.LongTensorde 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.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l'aide de WhisperTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Whisper utilise decoder_start_token_id comme jeton de départ pour la génération de decoder_input_ids. Si past_key_values est utilisé, il est facultatif de n'entrer que les derniers decoder_input_ids (voir past_key_values).Les indices peuvent être obtenus à l’aide de WhisperTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
Quelles sont les identifiants d'entrée du décodeur ?
Whisper utilise
decoder_start_token_idcomme jeton de départ pour la génération dedecoder_input_ids. Sipast_key_valuesest utilisé, il est facultatif de n'entrer que le dernierdecoder_input_ids(voirpast_key_values). - decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut.Si vous souhaitez modifier le comportement du padding, vous devez lire
modeling_whisper._prepare_decoder_attention_masket l’adapter à vos besoins. Consultez la figure 1 de l’article BART pour plus d’informations sur la stratégie par défaut. - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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.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 lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'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_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon 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 lesinput_idsde forme(batch_size, sequence_length). - decoder_inputs_embeds (
tuple[torch.Tensor]de forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - decoder_position_ids (
torch.LongTensorde 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]. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation du langage. Les indices doivent être compris dans[0, ..., config.vocab_size]ou égaux à -100 (voir la docstring deinput_ids). Les jetons dont l’indice est défini sur-100sont ignorés (masqués) ; la perte n’est calculée que pour les jetons dont l’étiquette est comprise dans[0, ..., config.vocab_size].sequence_lengthdoit être inférieur ou égal àconfig.max_target_positions. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
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 (WhisperConfig) et des entrées.
La méthode forward de WhisperForConditionalGeneration 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage.logits (
torch.Tensorde 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Exemple :
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(inputs=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'generate
< source >( input_features: 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 = Falsereturn_timestamps: bool | None = Nonetask: str | None = Nonelanguage: str | list[str] | None = Noneis_multilingual: bool | None = Noneprompt_ids: typing.Optional[torch.Tensor] = Noneprompt_condition_type: str | None = Nonecondition_on_prev_tokens: bool | None = Nonetemperature: float | tuple[float, ...] | None = Nonecompression_ratio_threshold: float | None = Nonelogprob_threshold: float | None = Noneno_speech_threshold: float | None = Nonenum_segment_frames: int | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetime_precision: float = 0.02time_precision_features: float = 0.01return_token_timestamps: bool | None = Nonereturn_segments: bool = Falsereturn_dict_in_generate: bool | None = Noneforce_unique_generate_call: bool | None = Nonemonitor_progress: collections.abc.Callable[[torch.Tensor], None] | None = None**kwargs ) → ModelOutput or dict[str, Any] or torch.LongTensor
Paramètres
- input_features (
torch.Tensorde forme(batch_size, feature_size, sequence_length), facultatif) — Valeurs flottantes des caractéristiques log-mel extraites de la forme d’onde vocale brute. La forme d’onde vocale brute peut être obtenue en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_features, il convient d’utiliser AutoFeatureExtractor pour extraire les caractéristiques mel, appliquer le bourrage (padding) et convertir en un tenseur de typetorch.Tensor. Voir call() pour plus de détails. - generation_config (GenerationConfig, facultatif) —
La configuration de génération à utiliser comme paramétrisation de base pour l'appel de génération. Les
**kwargstransmis à generate qui correspondent aux attributs degeneration_configles remplaceront. Sigeneration_confign'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèlegeneration_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. - logits_processor (
LogitsProcessorList, facultatif) — Processeurs de logits personnalisés qui complètent les processeurs de logits par défaut construits à partir des arguments et de la configuration de génération. Si un processeur de logits est transmis qui a déjà été créé avec les arguments ou une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés. - stopping_criteria (
StoppingCriteriaList, facultatif) — Critères d’arrêt personnalisés qui complètent les critères d’arrêt par défaut construits à partir des arguments et d’une configuration de génération. Si un critère d’arrêt est transmis qui a déjà été créé à partir des arguments ou d’une configuration de génération, une erreur est levée. Cette fonctionnalité est destinée aux utilisateurs avancés. - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], list[int]], facultatif) — Si fourni, cette fonction contraint la recherche par faisceau aux jetons autorisés uniquement à chaque étape. Si non fourni, aucune contrainte n'est appliquée. Cette fonction prend 2 arguments : l'identifiant du lotbatch_idetinput_ids. Elle doit retourner une liste des jetons autorisés pour l'étape de génération suivante, conditionnée par l'identifiant du lotbatch_idet les jetons générés précédemmentinputs_ids. Cet argument est utile pour la génération contrainte conditionnée par le préfixe, comme décrit dans Autoregressive Entity Retrieval. - synced_gpus (
bool, facultatif, valeur par défautFalse) — Indique s'il faut continuer à exécuter la boucle while jusqu'à max_length (nécessaire pour éviter les blocages avecFullyShardedDataParallelet DeepSpeed ZeRO Stage 3). - return_timestamps (
bool, facultatif) — Indique s'il faut retourner les horodatages avec le texte. Cela active leWhisperTimestampsLogitsProcessor. Pour les audios de plus de 30 secondes, il est nécessaire de définirreturn_timestamps=True. - task (
str, facultatif) — Tâche à utiliser pour la génération, soit « translate » soit « transcribe ». - language (
strou liste destr, facultatif) — Jeton de langue à utiliser pour la génération, pouvant être au format<|en|>,enouenglish. Pour une génération par lots, une liste de jetons de langue peut être transmise. Vous pouvez trouver tous les jetons de langue possibles dans le dictionnairemodel.generation_config.lang_to_id. - is_multilingual (
bool, facultatif) — Indique si le modèle est multilingue ou non. - prompt_ids (
torch.Tensor, facultatif) — Tenseur de rang 1 d’identifiants de jetons, créé en transmettant du texte àget_prompt_ids(), qui est fourni en tant qu’invite à chaque fragment. Il peut être utilisé pour fournir ou « concevoir l’invite » d’un contexte de transcription, par exemple des vocabulaires personnalisés ou des noms propres, afin d’augmenter la probabilité que ces mots soient prédits correctement. Il ne peut pas être utilisé conjointement avecdecoder_start_token_id, car il écrase cette valeur. - prompt_condition_type (
str, facultatif) — Pertinent uniquement pour la transcription longue. Type de conditionnement deprompt_ids. « first-segment » signifie que seul le premier segment est conditionné parprompt_ids. « all-segments » signifie que chaque segment est conditionné parprompt_ids. Assurez-vous d’activercondition_on_prev_tokenspour « all-segments ». La valeur par défaut est « first-segment ». Pour la transcription à court terme, seul « first-segment » est possible. - condition_on_prev_tokens (
bool, facultatif) — Pertinent uniquement pour la transcription de longs formats. Indique s'il faut conditionner chaque segment sur le segment précédent. Comme le montre l'article Whisper, cela peut contribuer à améliorer les performances. - temperature (
floatou liste defloat, facultatif) — La température à utiliser pour la génération. Passer une valeurfloatunique etdo_sample=Trueactive la génération par échantillonnage. Pour la transcription de longs formats, le repli sur la température peut être activé en passant une liste de valeurs float telles que (0.0, 0.2, 0.4, 0.6, 0.8, 1.0). Comme indiqué dans l’article Whisper, cela peut aider à améliorer les performances. - compression_ratio_threshold (
float, facultatif) — Pertinent uniquement pour la transcription de longs formats. Si défini, le taux de compression zlib de chaque segment est calculé. Si le taux de compression d'un segment est supérieur àcompression_ratio_threshold, le repli sur la température est activé : le segment généré est supprimé et la génération est répétée en utilisant une température plus élevée. L'intuition derrière cette fonctionnalité est que les segments avec des taux de compression très élevés souffrent de nombreuses répétitions. Les répétitions indésirables peuvent être réduites en injectant plus d'aléatoire en augmentant la température. Sicompression_ratio_thresholdest défini, assurez-vous quetemperatureest une liste de valeurs. Une valeur courante pourcompression_ratio_thresholdest 1,35. Comme indiqué dans l'article Whisper, cela peut aider à améliorer les performances. - logprob_threshold (
float, facultatif) — Pertinent uniquement pour la transcription de longue durée. S'il est défini, la log-probabilité moyenne de chaque segment est calculée. Si la log-probabilité d'un segment donné est inférieure àlogprob_threshold, le repli sur la température est activé : le segment généré est supprimé et la génération est répétée avec une température plus élevée. L'intuition derrière cette fonctionnalité est que les segments de faible log-probabilité peuvent être améliorés en injectant plus d'aléatoire en augmentant la température. Silogprob_thresholdest défini, assurez-vous quetemperatureest une liste de valeurs. Une valeur courante pourlogprob_thresholdest -1.0. Comme indiqué dans l'article Whisper, cela peut aider à améliorer les performances. - no_speech_threshold (
float, facultatif) — Pertinent uniquement pour la transcription de longs formats. S'il est défini, le jeton « no-speech » combiné àlogprob_thresholdsert à déterminer si un segment ne contient que du silence. Dans ce cas, la transcription de ce segment est ignorée. Comme indiqué dans l'article sur Whisper, cela peut contribuer à améliorer les performances. - num_segment_frames (
int, facultatif) — Le nombre de frames dont est composé un segment unique. S'il n'est pas défini,num_segment_framesest par défaut égal au stride du modèle multiplié par la longueur d'entrée maximale. - attention_mask (
torch.Tensor, facultatif) —attention_maskdoit être transmis lors de la transcription de longs formats avec une taille de lot > 1. - time_precision (
int, facultatif, valeur par défaut 0.02) — Durée du jeton de sortie en secondes. Par ex. 0.02 signifie qu'un jeton généré représente en moyenne 20 ms. - time_precision_features (
int, facultatif, valeur par défaut 0.01) — La durée représentée par un cadre de fonction, en secondes. - return_token_timestamps (
bool, facultatif) — Indique s'il faut renvoyer des horodatages au niveau des jetons avec le texte. Cette option peut être utilisée avec ou sans l'optionreturn_timestamps. Pour obtenir des horodatages au niveau des mots, utilisez le tokenizer pour regrouper les jetons en mots. - return_segments (
bool, facultatif, valeur par défautFalse) — Indique s'il faut également renvoyer une liste de tous les segments. Notez que cette option ne peut être activée que lors d'une transcription de longue durée. - return_dict_in_generate (
bool, facultatif, valeur par défautFalse) — Indique s'il faut retourner un ModelOutput plutôt que simplement les jetons générés. Remarque : lors d'une transcription longue,return_dict_in_generatene peut être activé que sireturn_segmentsest défini sur True. Dans ce cas, les sorties de génération de chaque segment sont ajoutées à chaque segment. - force_unique_generate_call (
bool, facultatif) — Indique s'il faut forcer un appel unique à la méthode generate() de la GenerationMixin sous-jacente. Cela est utile pour le décodage assisté et les tests afin de garantir qu'un seul appel à generate() est effectué, ce qui permet ainsi de renvoyer les identifiants de jetons d'entrée du décodeur et les identifiants de jetons eos. - monitor_progress (
Callable[[torch.Tensor], None], facultatif) — Si fournie, cette fonction peut être appelée pour signaler l'avancement de la transcription audio. La fonction prend un argument tensorpde forme(n, 2), oùnest la taille du lot.p[i, 0]contient l'indice de la trame audio actuellement en cours de transcription pour l'élément de loti.p[i, 1]contient le nombre total de trames pour l'élément de loti. Aucune valeur de retour n'est attendue. - kwargs (
dict[str, Any], facultatif) — Paramétrage ad hoc degenerate_configet/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonctionforwarddu modèle. Si le modèle est un modèle encoder-décodeur, les kwargs spécifiques à l’encodeur ne doivent pas être préfixés et les kwargs spécifiques au décodeur doivent être préfixés par decoder_.
Retourne
ModelOutput ou dict[str, Any] ou torch.LongTensor
L'une des options suivantes :
- ModelOutput lorsque
return_dict_in_generate=Trueet (return_timestamps=Falseouforce_unique_generate_call=True), incluant les identifiants d'entrée du décodeur et l'identifiant de fin de séquence. dict[str, Any]lorsque (return_dict_in_generate=Trueetreturn_timestamps=True) oureturn_segments=Trueoureturn_token_timestamps=True.torch.LongTensordans tous les autres cas, à l'exception des identifiants d'entrée du décodeur et de l'identifiant de fin de séquence.
Les types ModelOutput possibles sont :
segments est une liste de listes (une liste par élément du lot) de segment.
Un segment est un dictionnaire avec les clés start, end, tokens, idxs et result.
start: horodatage de début du segment.end: l'horodatage de fin du segment.tokens: les jetons du segment, à l'exclusion des identifiants d'entrée du décodeur et de l'identifiant de fin de séquence.idxs: les indices de début (inclus) et de fin (exclus) destokensdu segment dans l’appel sous-jacent à generate() de GenerationMixin (présent dansresult).result: le résultat de l'appel sous-jacent à generate() de GenerationMixin.
Lorsque return_timestamps=True, return_dict_in_generate=True s’applique à chaque appel de la méthode generate() de la GenerationMixin sous-jacente, les sorties étant stockées dans result de chaque segment.
Transcrit ou traduit les caractéristiques d’entrée log-mel en une séquence d’identifiants de jetons générés de manière auto-régressive.
La plupart des paramètres de contrôle de la génération sont définis dans
generation_configqui, s'il n'est pas transmis, sera défini sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quelgeneration_configen transmettant les paramètres correspondants à generate(), par exemple.generate(inputs, num_beams=4, do_sample=True).Pour un aperçu des stratégies de génération et des exemples de code, consultez le guide suivant.
Exemple :
- Transcription longue : pour transcrire ou traduire des audios de plus de 30 secondes, traitez les fichiers audio sans troncature et transmettez toutes les caractéristiques mel d'un coup à generate. Il est nécessaire de définir
return_timestamps=True. En effet, la transcription longue utilise un algorithme séquentiel basé sur la prédiction des horodatages, avec des heuristiques telles que le seuil de ratio de compression, le seuil de probabilité logarithmique et le repli sur la température. Cet algorithme est décrit dans l'article original de Whisper, section 3.8. Long-form Transcription.
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()
>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]
>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)
>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs, return_timestamps=True)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."Le rappel monitor_progress peut être utilisé pour suivre la progression de la transcription :
>>> from tqdm import tqdm
>>> # prepare inputs like above
>>> # define a callback to monitor the progress of the transcription.
>>> with tqdm(desc="Progress") as pbar:
>>> def monitor_progress(p_batch):
>>> i = torch.argmax(p_batch[:, 1])
>>> p = p_batch[i].detach().cpu()
>>> pbar.total = int(p[1])
>>> pbar.n = int(p[0])
>>> pbar.update()
>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs, return_timestamps=True, monitor_progress=monitor_progress)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
Progress: 95%|█████████████████████████████████████████████████████████████████████████████████████████████████▎ | 8497/8901 [00:04<00:00, 2052.79it/s]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."- Transcription de courte durée: Si les caractéristiques d'entrée mel transmises sont inférieures ou égales à 30 secondes, deux possibilités s'offrent à vous :
return_timestamps=False: l'audio complet sera transcrit en un seul appel à generate() de GenerationMixin.return_timestamps=True: l’audio sera transcrit en utilisant la même logique que pour la transcription de longue durée.
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(inputs=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'WhisperForCausalLM
classe transformers.WhisperForCausalLM
< source >( config: WhisperConfig )
Paramètres
- config (WhisperConfig) — 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.
Décodeur Whisper avec une tête de modélisation de langage au sommet (couche linéaire dont les poids sont liés aux plongements d'entrée).
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: tuple[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → CausalLMOutputWithCrossAttentions or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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.
- attention_mask (
torch.Tensorde 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.
- encoder_outputs (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée si le modèle est configuré comme un décodeur. - 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 lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'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_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon 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 lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
CausalLMOutputWithCrossAttentions ou tuple(torch.Tensor)
Un CausalLMOutputWithCrossAttentions 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 (WhisperConfig) et des entrées.
La méthode forward de WhisperForCausalLM 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde 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.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(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.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.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.
Exemple :
>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")
>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
... sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)
>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'WhisperForAudioClassification
classe transformers.WhisperForAudioClassification
< source >( config: WhisperConfig )
Paramètres
- config (WhisperConfig) — 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.
Modèle d'encodeur Whisper avec une tête de classification de séquence au sommet (une couche linéaire sur la sortie agrégée) pour des tâches comme le SUPERB Keyword Spotting.
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
< source >( input_features: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)
Paramètres
- input_features (
torch.LongTensorde 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 WhisperFeatureExtractor. Voir WhisperFeatureExtractor.call() pour plus de détails (WhisperProcessor utilise WhisperFeatureExtractor pour le traitement des audios). - encoder_outputs (
tuple[tuple[torch.Tensor]], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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. - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée).
Retourne
SequenceClassifierOutput ou tuple(torch.Tensor)
Un SequenceClassifierOutput 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 (WhisperConfig) et des entrées.
La méthode forward de WhisperForAudioClassification 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1).logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax).hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(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.
Exemple :
>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))
>>> inputs = feature_extractor(
... sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features
>>> with torch.no_grad():
... logits = model(input_features).logits
>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'