Hugging Face's logo

Transformers documentation

Granite Speech

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

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2025-05-13 et contribué à Hugging Face Transformers le 2025-04-11.

Granite Speech

Aperçu

Le modèle Granite Speech (article de blog) est un modèle de langage multimodal, composé d'un encodeur vocal, d'un projecteur vocal, d'un grand modèle de langage et d'adaptateur(s) LoRA. Vous trouverez ci-dessous plus de détails sur chaque composant de l'architecture du modèle actuel (Granite 3.2 Speech).

  1. Encodeur de parole : un encodeur Conformer entraîné avec la Classification Temporelle Connectiviste (CTC) sur des cibles au niveau des caractères sur des corpus ASR. L'encodeur utilise l'attention par blocs et la CTC auto-conditionnée à partir de la couche intermédiaire.

  2. Speech Projector : un transformeur de requête (q-former) agissant sur les sorties du dernier bloc encodeur. L'encodeur et le projecteur effectuent un sous-échantillonnage temporel des caractéristiques audio afin de les fusionner dans les embeddings multimodaux qui seront traités par le llm.

  3. Grand modèle de langage : le modèle Granite Speech s'appuie sur les LLM Granite, initialement présentés dans ce papier.

  4. Adaptateurs LoRA : le modèle Granite Speech contient un LoRA spécifique à la modalité, qui est activé lorsque des fonctionnalités audio sont fournies et désactivé dans le cas contraire.

Notez que la plupart des composants susmentionnés sont implémentés de manière générique afin de permettre la compatibilité et une intégration potentielle avec d'autres architectures de modèles dans transformers.

Ce modèle a été contribué par Alexander Brooks, Avihu Dekel et George Saon.

Conseils d'utilisation

  • Ce modèle intègre son propre adaptateur LoRA, qui sera automatiquement chargé et activé/désactivé au besoin lors des appels d'inférence. Pensez à installer PEFT pour vous assurer que le LoRA est correctement appliqué !
  • Le modèle s'attend à un audio avec un taux d'échantillonnage de 16 kHz. Le processeur rééchantillonne automatiquement si nécessaire.
  • L’adaptateur LoRA est activé automatiquement lorsque des caractéristiques audio sont présentes et désactivé pour les entrées textuelles uniquement, vous n’avez donc pas besoin de le gérer manuellement.

Exemple d'utilisation

Granite Speech est un modèle multimodal de transcription audio en texte capable de transcrire des fichiers audio et de répondre à des invites textuelles. Voici comment l’utiliser :

Transcription de base de la parole

from datasets import Audio, load_dataset

from transformers import GraniteSpeechForConditionalGeneration, GraniteSpeechProcessor


# Load model and processor
model = GraniteSpeechForConditionalGeneration.from_pretrained(
    "ibm-granite/granite-3.2-8b-speech",
    device_map="auto"
)
processor = GraniteSpeechProcessor.from_pretrained("ibm-granite/granite-3.2-8b-speech")

# Load audio from dataset (16kHz sampling rate required)
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))
audio = ds['audio'][0]['array']

# Process audio
inputs = processor(audio=audio, return_tensors="pt").to(model.device)

# Generate transcription
generated_ids = model.generate(**inputs, max_new_tokens=256)
transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(transcription)

Transcription de la parole avec modèle de chat

Pour le suivi d'instructions avec de l'audio, utilisez le modèle de chat avec l'audio directement dans le format de conversation :

from datasets import Audio, load_dataset

from transformers import GraniteSpeechForConditionalGeneration, GraniteSpeechProcessor


model = GraniteSpeechForConditionalGeneration.from_pretrained(
    "ibm-granite/granite-3.2-8b-speech",
    device_map="auto"
)
processor = GraniteSpeechProcessor.from_pretrained("ibm-granite/granite-3.2-8b-speech")

# Load audio from dataset
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))
audio = ds['audio'][0]

# Prepare conversation with audio and text
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "audio", "audio": audio},
            {"type": "text", "text": "Transcribe the following audio:"},
        ],
    }
]

# Apply chat template with audio - processor handles both tokenization and audio processing
inputs = processor.apply_chat_template(conversation, tokenize=True, return_tensors="pt").to(model.device)

# Generate transcription
generated_ids = model.generate(**inputs, max_new_tokens=512)
output_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(output_text)

Traitement par lots

Traiter efficacement plusieurs fichiers audio :

from datasets import Audio, load_dataset

from transformers import GraniteSpeechForConditionalGeneration, GraniteSpeechProcessor


model = GraniteSpeechForConditionalGeneration.from_pretrained(
    "ibm-granite/granite-3.2-8b-speech",
    device_map="auto"
)
processor = GraniteSpeechProcessor.from_pretrained("ibm-granite/granite-3.2-8b-speech")

# Load multiple audio samples from dataset
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))
audio_samples = [ds['audio'][i]['array'] for i in range(3)]

# Process batch
inputs = processor(audio=audio_samples, return_tensors="pt", padding=True).to(model.device)

# Generate for all inputs
generated_ids = model.generate(**inputs, max_new_tokens=256)
transcriptions = processor.batch_decode(generated_ids, skip_special_tokens=True)

for i, transcription in enumerate(transcriptions):
    print(f"Audio {i+1}: {transcription}")

GraniteSpeechConfig

classe transformers.GraniteSpeechConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneprojector_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_index: int = 49155initializer_range: float = 0.02has_lora_adapter: bool = Truedownsample_rate: int = 5window_size: int = 15tie_word_embeddings: bool = True )

Paramètres

  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • encoder_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de l'encodeur.
  • projector_config (Union[AutoConfig, dict], facultatif, par défaut Blip2QFormerConfig) — L’objet de configuration ou le dictionnaire du projecteur audio.
  • audio_token_index (int, facultatif, par défaut 49155) — L’index du jeton audio utilisé comme espace réservé pour l’audio d’entrée.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • has_lora_adapter (bool, facultatif, valeur par défaut True) — Indique si le modèle possède ou non un adaptateur lora qui ne doit être activé que lors du traitement des entrées audio.
  • downsample_rate (int, facultatif, valeur par défaut 5) — Taux de sous-échantillonnage pour l'extracteur de caractéristiques audio.
  • window_size (int, facultatif, valeur par défaut 15) — Taille de la fenêtre pour le projecteur de caractéristiques audio.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un GraniteSpeechModel. Elle est utilisée pour instancier un modèle Granite Speech 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 ibm-granite/granite-speech-3.3-2b

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 GraniteSpeechConfig, GraniteSpeechForConditionalGeneration

>>> # Initializing a GraniteSpeechConfig
>>> configuration = GraniteSpeechConfig()

>>> # Initializing a GraniteSpeechForConditionalGeneration (with random weights)
>>> model = GraniteSpeechForConditionalGeneration(configuration)

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

GraniteSpeechEncoderConfig

classe transformers.GraniteSpeechEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneinput_dim: int = 160num_layers: int = 10hidden_dim: int = 1024feedforward_mult: int = 4num_heads: int = 8dim_head: int | None = Noneoutput_dim: int = 42context_size: int = 200max_pos_emb: int = 512dropout: float | int = 0.1conv_kernel_size: int = 15conv_expansion_factor: int = 2 )

Paramètres

  • input_dim (int, facultatif, par défaut 160) — Dimensionnalité des caractéristiques acoustiques d'entrée (par exemple, nombre de canaux de la banque de filtres mel).
  • num_layers (int, facultatif, par défaut 10) — Nombre de couches cachées dans le décodeur Transformer.
  • hidden_dim (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • feedforward_mult (int, facultatif, valeur par défaut 4) — Multiplicateur pour les projections up/down dans les couches feedforward de l’encodeur ; Les projections auront une dimension intermédiaire de taille hidden_dim * feedforward_mult.
  • num_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • dim_head (int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
  • output_dim (int, facultatif, par défaut 42) — Dimension intermédiaire des projections feedforward du conformer à ajouter à la sortie de chaque autre bloc encodeur.
  • context_size (int, facultatif, valeur par défaut 200) — Taille du contexte à utiliser dans l'attention du conformer.
  • max_pos_emb (int, facultatif, valeur par défaut 512) — Nombre maximal d’embeddings de position à utiliser dans l’attention (encodage positionnel relatif de Shaw).
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • conv_kernel_size (int, facultatif, par défaut 15) — La taille du noyau de convolution.
  • conv_expansion_factor (int, facultatif, valeur par défaut 2) — Dimension intermédiaire à utiliser dans les convolutions conformer.

Ceci est la classe de configuration destinée à stocker la configuration d'un GraniteSpeechModel. Elle est utilisée pour instancier un modèle Granite Speech 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 ibm-granite/granite-speech-3.3-2b

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 GraniteSpeechEncoderConfig, GraniteSpeechCTCEncoder

>>> # Initializing a GraniteSpeechEncoderConfig
>>> configuration = GraniteSpeechEncoderConfig()

>>> # Initializing a GraniteSpeechCTCEncoder (with random weights)
>>> model = GraniteSpeechCTCEncoder(configuration)

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

GraniteSpeechProcessor

classe transformers.GraniteSpeechProcessor

< >

( audio_processortokenizeraudio_token = '<|audio|>'chat_template = None )

Paramètres

  • audio_processor ({audio_processor_class}) — Le processeur audio est une entrée obligatoire.
  • tokenizer (tokenizer_class) — Le tokenizer est une entrée obligatoire.
  • audio_token (str, facultatif, par défaut "<|audio|>") — Le jeton spécial utilisé pour représenter l’audio dans la séquence de texte. Ce jeton sert de marqueur qui sera remplacé par plusieurs jetons audio en fonction de la longueur réelle de l’audio. Le nombre de jetons audio insérés dépend des dimensions des caractéristiques audio extraites par le processeur audio.
  • chat_template (str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.

Construit un GraniteSpeechProcessor qui encapsule un processeur audio et un tokenizer en un seul processeur.

GraniteSpeechProcessor offre toutes les fonctionnalités de {audio_processor_class} et de tokenizer_class. Consultez ~{audio_processor_class} et ~tokenizer_class pour plus d’informations.

__call__

< >

( text: str | list[str] | list[list[str]]audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = Nonedevice: str = 'cpu'**kwargs: *<class 'transformers.models.granite_speech.processing_granite_speech.GraniteSpeechProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature

Paramètres

  • text (Union[str, list[str], list[list[str]]]) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissez is_split_into_words=True pour éviter toute ambiguïté avec les entrées en lot.
  • audio (Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • device (str, facultatif, par défaut cpu) — L’appareil sur lequel traiter les vidéos. S’il n’est pas défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
  • **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Retourne

~feature_extraction_utils.BatchFeature

  • data (dict, facultatif) — Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes call/pad (« input_values », « attention_mask », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
  • skip_tensor_conversion (list[str] ou set[str], facultatif) — Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même si tensor_type est spécifié.

GraniteSpeechFeatureExtractor

classe transformers.GraniteSpeechFeatureExtractor

< >

( sampling_rate: int = 16000n_fft: int = 512win_length: int = 400hop_length: int = 160n_mels: int = 80projector_window_size: int = 15projector_downsample_rate: int = 5padding_value: float = 0.0**kwargs )

GraniteSpeechModel

classe transformers.GraniteSpeechModel

< >

( config: GraniteSpeechConfig )

Paramètres

  • config (GraniteSpeechConfig) — 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 Granite Speech, qui se compose d'un encodeur audio, d'un projecteur et d'un modèle de langage, sans tête de modélisation du langage.

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

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

forward

< >

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

Paramètres

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

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

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

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de GraniteSpeechFeatureExtractor. Voir GraniteSpeechFeatureExtractor.__call__() pour plus de détails (GraniteSpeechProcessor utilise GraniteSpeechFeatureExtractor pour le traitement des audios).
  • input_features_mask (torch.Tensor, facultatif) — Masque à appliquer aux caractéristiques audio avant leur diffusion dans les embeddings de langage.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

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

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

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

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

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

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

GraniteSpeechModelOutputWithPast ou tuple(torch.Tensor)

Un GraniteSpeechModelOutputWithPast 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 (GraniteSpeechConfig) et des entrées.

La méthode forward du GraniteSpeechModel redéfinit la méthode spéciale __call__.

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

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

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

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

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

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

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

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

  • audio_hidden_states (torch.Tensor, facultatif) — États cachés audio projetés.

GraniteSpeechForConditionalGeneration

classe transformers.GraniteSpeechForConditionalGeneration

< >

( config: GraniteSpeechConfig )

Paramètres

  • config (GraniteSpeechConfig) — 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 Granite Speech, qui se compose d'un encodeur audio, d'un projecteur et d'un modèle de langage.

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → GraniteSpeechCausalLMOutputWithPast or tuple(torch.Tensor)

Paramètres

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

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

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

  • input_features (torch.Tensor de forme (batch_size, sequence_length, feature_dim), facultatif) — Les tenseurs correspondant aux caractéristiques audio d'entrée. Les caractéristiques audio peuvent être obtenues à l'aide de GraniteSpeechFeatureExtractor. Voir GraniteSpeechFeatureExtractor.__call__() pour plus de détails (GraniteSpeechProcessor utilise GraniteSpeechFeatureExtractor pour le traitement des audios).
  • input_features_mask (torch.Tensor, facultatif) — Masque à appliquer aux caractéristiques audio avant leur diffusion dans les embeddings de langage.
  • attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
    • 1 pour les jetons qui ne sont pas masqués,
    • 0 pour les jetons masqués.

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

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

    Qu'est-ce que les identifiants de position ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée par le modèle à une étape antérieure du décodage, lorsque use_cache=True ou config.use_cache=True.

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

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

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

  • inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer input_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices input_ids en vecteurs associés que la matrice de recherche d’intégration interne du modèle.
  • labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le 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 de input_ids). Les jetons dont l'indice est défini sur -100 sont 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 sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • logits_to_keep (Union[int, torch.Tensor], facultatif, valeur par défaut 0) — Si c'est un int, calcule les logits pour les logits_to_keep derniers jetons. Si 0, calcule les logits pour tous les input_ids (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un torch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

Retourne

GraniteSpeechCausalLMOutputWithPast ou tuple(torch.Tensor)

Un GraniteSpeechCausalLMOutputWithPast 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 (GraniteSpeechConfig) et des entrées.

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

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

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

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

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

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

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

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

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

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

  • audio_hidden_states (torch.Tensor, facultatif) — États cachés audio projetés.

Exemple :

>>> from transformers import AutoProcessor, GraniteSpeechForConditionalGeneration
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("ibm-granite/granite-speech-3.3-2b")
>>> model = GraniteSpeechForConditionalGeneration.from_pretrained("ibm-granite/granite-speech-3.3-2b")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...

get_audio_features

< >

( *args**kwargs )

Update on GitHub

←Gradium Phonon TTS GraniteSpeech5→