Transformers documentation
Canary
Ce modèle a été publié dans HF papers le 2025-09-17 et contribué à Hugging Face Transformers le 2026-08-31.
Canary
Aperçu
Canary-1B-v2 a été proposé dans Canary-1B-v2 & Parakeet-TDT-0.6B-v3: Efficient and High-Performance Models for Multilingual ASR and AST par Monica Sekoyan, Nithin Rao Koluguri, Nune Tadevosyan, Piotr Zelasko, Travis Bartley, Nikolay Karpov, Jagadeesh Balam et Boris Ginsburg.
L'abstract de l'article est le suivant :
Ce rapport présente Canary-1B-v2, un modèle multilingue rapide et robuste pour la reconnaissance automatique de la parole (ASR) et la traduction de la parole en texte (AST). Construit avec un encodeur FastConformer et un décodeur Transformer, il prend en charge 25 langues européennes. Le modèle a été entraîné sur 1,7 million d'heures de données au total, incluant Granary et NeMo ASR Set 3.0, avec de l'audio non vocal ajouté pour réduire les hallucinations pour l'ASR et l'AST. Nous décrivons son processus d'entraînement préliminaire et de fine-tuning en deux étapes avec équilibrage dynamique des données, ainsi que des expériences avec un encodeur nGPT. Les résultats montrent que nGPT s'adapte bien aux données massives, tandis que FastConformer excelle après le fine-tuning. Pour les horodatages, Canary-1B-v2 utilise le NeMo Forced Aligner (NFA) avec un modèle CTC auxiliaire, fournissant des horodatages fiables au niveau des segments pour l'ASR et l'AST. Les évaluations montrent que Canary-1B-v2 surpasse Whisper-large-v3 sur l'ASR en anglais tout en étant 10 fois plus rapide, et offre des performances compétitives en ASR et AST multilingues face à des modèles plus grands comme Seamless-M4T-v2-large et les systèmes basés sur des LLM. Nous publions également Parakeet-TDT-0.6B-v3, un successeur de v2, offrant l'ASR multilingue sur les mêmes 25 langues avec seulement 600 millions de paramètres.
Canary réutilise l’encodeur Fast Conformer de Parakeet (chargé via ParakeetEncoder / ParakeetEncoderConfig) et l’associe à un décodeur Transformer qui utilise des embeddings positionnels sinusoïdaux fixes, une attention croisée vers les sorties de l’encodeur et des embeddings d’entrée/sortie liés. La tâche est sélectionnée par un préfixe de prompt du décodeur construit par CanaryProcessor de la forme <|startofcontext|> <|startoftranscript|> <|emo:undefined|> <source_lang> <target_lang> <pnc|nopnc> <|noitn|> <|notimestamp|> <|nodiarize|>, où source_lang == target_lang sélectionne la transcription et, dans le cas contraire, la traduction.
L'implémentation originale peut être trouvée dans NVIDIA NeMo. Un point de contrôle de modèle est disponible à nvidia/canary-1b-v2.
Ce modèle a été contribué par Harshal Janjani.
Les horodatages au niveau des segments pour Canary-1B-v2 sont générés par l’outil externe NeMo Forced Aligner (NFA) avec un modèle CTC auxiliaire, et non par le décodeur, ils ne font donc pas partie de la sortie de
generate.
Utilisation
Transcription
La manière la plus simple de transcrire un audio est d’utiliser apply_transcription_request, qui construit le prompt du décodeur multitâche pour vous (c’est un wrapper de commodité pour apply_chat_template).
from datasets import load_dataset, Audio
from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
processor = AutoProcessor.from_pretrained("nvidia/canary-1b-v2")
model = AutoModelForSpeechSeq2Seq.from_pretrained("nvidia/canary-1b-v2", device_map="auto")
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
inputs = processor.apply_transcription_request(audio=ds[0]["audio"]["array"], source_language="en").to(model.device)
generated_ids = model.generate(**inputs, max_new_tokens=128)
print(processor.decode(generated_ids, skip_special_tokens=True)[0])Traduction
Définissez target_language sur une langue différente de source_language pour la traduction de la parole vers le texte.
...
inputs = processor.apply_transcription_request(
audio=ds[0]["audio"]["array"], source_language="en", target_language="de"
).to(model.device)
generated_ids = model.generate(**inputs, max_new_tokens=128)
print(processor.decode(generated_ids, skip_special_tokens=True)[0])Inférence par lots
Passez une liste d'audios et, éventuellement, une liste de source_language / target_language.
...
audios = [ds[0]["audio"]["array"], ds[1]["audio"]["array"]]
# single entries get broadcasted to list
inputs = processor.apply_transcription_request(
audio=audios, source_language="en", target_language=["en", "de"]
).to(model.device)
generated_ids = model.generate(**inputs, max_new_tokens=128)
for text in processor.decode(generated_ids, skip_special_tokens=True):
print(text)Torch compile
Pour la transcription autorégressive, torch.compile accélère les passages avant par jeton à l’intérieur de generate en fournissant un objet CompileConfig.
...
from transformers import CompileConfig
inputs = processor.apply_transcription_request(audio=ds[0]["audio"]["array"], source_language="en").to(model.device)
compile_config = CompileConfig()
# Warmup
for _ in range(3):
_ = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config)
# Apply model
generated_ids = model.generate(**inputs, max_new_tokens=128, cache_implementation="static", compile_config=compile_config)
print(processor.decode(generated_ids, skip_special_tokens=True)[0])Entraînement
Pass the target transcripts to apply_transcription_request with transcription, and the returned labels are used to compute the loss.
from datasets import Audio, load_dataset
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor
model_id = "nvidia/canary-1b-v2"
NUM_SAMPLES = 2
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_id, device_map="auto")
model.train()
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))
speech_samples = [el["array"] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]
inputs = processor.apply_transcription_request(speech_samples, source_language="en", transcription=text_samples)
inputs.to(model.device, dtype=model.dtype)
loss = model(**inputs).loss
print("Loss:", loss.item())
loss.backward()CanaryConfig
classe transformers.CanaryConfig
< 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 = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneuse_cache: bool = Truetie_word_embeddings: bool = Truepad_token_id: int | None = 2bos_token_id: int | None = 4eos_token_id: int | None = 3decoder_start_token_id: int | None = 7initializer_range: float = 0.02vocab_size: int = 16384 )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - encoder_config (
Union[dict, ParakeetEncoderConfig], facultatif) — L’objet de configuration ou le dictionnaire de l’encodeur FastConformer (ParakeetEncoderConfig). - decoder_config (
Union[dict, CanaryDecoderConfig], facultatif) — L’objet de configuration ou le dictionnaire du décodeur Transformer (CanaryDecoderConfig). - 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. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - pad_token_id (
int, facultatif, par défaut2) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut4) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
int, facultatif, par défaut3) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - decoder_start_token_id (
int, facultatif, valeur par défaut 7) — L’identifiant du jeton qui démarre le décodage (<|startofcontext|>, le premier jeton du prompt multitâche). - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - vocab_size (
int, facultatif, par défaut16384) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids.
Ceci est la classe de configuration destinée à stocker la configuration d'un CanaryModel. Elle est utilisée pour instancier un modèle Canary 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 nvidia/canary-1b-v2
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 CanaryForConditionalGeneration, CanaryConfig
>>> # Initializing a Canary configuration
>>> configuration = CanaryConfig()
>>> # Initializing a model from the configuration
>>> model = CanaryForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configCanaryDecoderConfig
classe transformers.CanaryDecoderConfig
< 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 = 16384hidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 8num_attention_heads: int = 8num_key_value_heads: int = 8hidden_act: str = 'relu'max_position_embeddings: int = 1024initializer_range: float = 0.02use_cache: bool = Truepad_token_id: int | None = 2bos_token_id: int | None = 4eos_token_id: int | None = 3attention_bias: bool = Trueattention_dropout: int | float | None = 0.0head_dim: int = 128 )
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éfaut16384) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut1024) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut4096) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut8) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif, valeur par défaut8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut seranum_attention_heads. - hidden_act (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - max_position_embeddings (
int, facultatif, par défaut1024) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - 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. - pad_token_id (
int, facultatif, par défaut2) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut4) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
int, facultatif, par défaut3) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire. - attention_bias (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser un biais dans les couches de projection des requêtes, des clés, des valeurs et de la sortie lors de l'auto-attention. - attention_dropout (
Union[int, float], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - head_dim (
int, facultatif, par défaut128) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
Ceci est la classe de configuration destinée à stocker la configuration d'un CanaryModel. Elle est utilisée pour instancier un modèle Canary 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 nvidia/canary-1b-v2
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.
>>> from transformers import CanaryDecoderModel, CanaryDecoderConfig
>>> # Initializing a CanaryDecoder canary_decoder-7b style configuration
>>> configuration = CanaryDecoderConfig()
>>> # Initializing a model from the canary_decoder-7b style configuration
>>> model = CanaryDecoderModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configCanaryProcessor
classe transformers.CanaryProcessor
< source >( feature_extractor = Nonetokenizer = Nonechat_template = None )
Paramètres
- feature_extractor (
ParakeetFeatureExtractor) — L'extracteur de caractéristiques est une entrée obligatoire. - tokenizer (
TokenizersBackend) — Le tokenizer est une entrée obligatoire. - chat_template (
str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.
Construit un CanaryProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
CanaryProcessor offre toutes les fonctionnalités de ParakeetFeatureExtractor et de TokenizersBackend. Consultez ~ParakeetFeatureExtractor et ~TokenizersBackend pour plus d’informations.
apply_transcription_request
< source >( audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], list[typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']]]]source_language: str | list[str] = 'en'target_language: str | list[str] | None = Nonepunctuation: bool = Truetranscription: str | list[str] | None = Nonetokenize: bool = True**kwargs: *<class 'transformers.models.canary.processing_canary.CanaryProcessorKwargs'> ) → BatchFeature or list[str]
Paramètres
- audio (
AudioInputoulist[AudioInput]) — Audio à transcrire ou traduire. Peut être une chaîne de caractères URL, un chemin local, un tableau numpy ou une liste de ces éléments. - source_language (
stroulist[str], facultatif, par défaut"en") — La langue de la parole d'entrée. Accepte les codes ISO (par ex."en","de","fr") ou les noms complets (par ex."English","German","French"). - target_language (
stroulist[str], facultatif) — La langue du texte de sortie. Accepte les codes ISO ou les noms complets. Par défaut,source_language(transcription) ; définissez-le sur une autre langue pour la traduction de la parole vers le texte. - punctuation (
bool, facultatif, par défautTrue) — Indique s'il faut demander la ponctuation et la majuscule en début de phrase dans la sortie. - transcription (
strorlist[str], optional) — Target transcript(s) (or translations) for training, one per audio. When given, each transcript is written as the assistant turn andlabelsare returned (seeoutput_labelsin__call__()). - tokenize (
bool, facultatif, par défautTrue) — Indique s'il faut tokeniser les prompts et traiter l'audio. SiFalse, l'audio n'est pas chargé et les prompts sont renvoyés sous forme de chaînes avec des placeholders audio non développés. Les passer avec l'audio au processeur,processor(text=prompts, audio=audio), produit les mêmes sorties quetokenize=True. - **kwargs —
Arguments supplémentaires transmis à apply_chat_template().
Les arguments du processeur (par exemple
text_kwargs,audio_kwargs, …) doivent être passés sous la formeprocessor_kwargs={...}.
Retourne
BatchFeature ou list[str]
Une invite par audio lorsque tokenize=False, sinon le processeur renvoie des données prêtes à être transmises à CanaryForConditionalGeneration.generate(), ou à CanaryForConditionalGeneration.forward() pour calculer la perte lorsque transcription est fourni.
Préparez les entrées pour la transcription ou la traduction sans écrire manuellement le modèle de discussion, que ce soit pour l'inférence ou, lorsque transcription est fourni, pour l'entraînement.
CanaryModel
classe transformers.CanaryModel
< source >( config: CanaryConfig )
Paramètres
- config (CanaryConfig) — 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 Canary brut (encodeur FastConformer + décodeur Transformer) produisant des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< 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.EncoderDecoderCache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.Tensor)
Paramètres
- input_features (
torch.Tensorde forme(batch_size, audio_length)) — Valeurs flottantes de la forme d’onde brute de la parole. La forme d’onde brute de la parole 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, le AutoFeatureExtractor doit être utilisé pour le bourrage et la conversion en un tenseur de typetorch.Tensor. - 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 AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur. - encoder_outputs (
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.EncoderDecoderCache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en 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, target_sequence_length)) — Indices des positions des jetons de chaque séquence d’entrée dans les embeddings de position. Utilisés pour calculer les embeddings de position jusqu’àconfig.decoder_config.max_position_embeddings - 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 (CanaryConfig) et des entrées.
La méthode forward du CanaryModel 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, CanaryModel
>>> from datasets import load_dataset
>>> model = CanaryModel.from_pretrained("UsefulSensors/canary-tiny")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("UsefulSensors/canary-tiny")
>>> 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, 288]CanaryForConditionalGeneration
classe transformers.CanaryForConditionalGeneration
< source >( config: CanaryConfig )
Paramètres
- config (CanaryConfig) — 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 Canary avec une tête de modélisation de langage. Peut être utilisé pour la reconnaissance automatique de la parole multilingue et la traduction de la parole en texte.
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.EncoderDecoderCache | None = Nonedecoder_inputs_embeds: tuple[torch.Tensor] | None = Nonedecoder_position_ids: tuple[torch.LongTensor] | None = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)
Paramètres
- input_features (
torch.Tensorde forme(batch_size, audio_length)) — Valeurs flottantes de la forme d’onde brute de la parole. La forme d’onde brute de la parole 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, le AutoFeatureExtractor doit être utilisé pour le bourrage et la conversion en un tenseur de typetorch.Tensor. - 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 AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur. - encoder_outputs (
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.EncoderDecoderCache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en 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, target_sequence_length)) — Indices des positions des jetons de chaque séquence d’entrée dans les embeddings de position. Utilisés pour calculer les embeddings de position jusqu’àconfig.decoder_config.max_position_embeddings - 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). - 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].
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 (CanaryConfig) et des entrées.
La méthode forward de CanaryForConditionalGeneration 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, CanaryForConditionalGeneration
>>> from datasets import load_dataset
>>> processor = AutoProcessor.from_pretrained("UsefulSensors/canary-tiny")
>>> model = CanaryForConditionalGeneration.from_pretrained("UsefulSensors/canary-tiny")
>>> 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(input_features, max_new_tokens=100)
>>> 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.'