Utiliser la reconnaissance vocale automatique (ASR) pour générer la transcription d’un podcast avec Granite 3.3 et watsonx.ai

Étape 2. Installer et importer les bibliothèques nécessaires

Nous avons quelques dépendances pour ce tutoriel. Importez les paquets suivants ; s’ils ne sont pas installés, vous pouvez rapidement résoudre ce problème avec une installation pip.

Si vous recevez un message d’erreur « pip dependency resolver » lié au package « caikit-nlp », vous pouvez l’ignorer pour l’instant car le reste du notebook fonctionnera normalement.

# Install required packages
! pip install -q peft torchaudio soundfile pytubefix pytube moviepy tqdm https://github.com/huggingface/transformers/archive/main.zip

# Required imports
import json
import os

from pytubefix import YouTube
from tqdm import tqdm
from moviepy.audio.io.AudioFileClip import AudioFileClip

import torch
import torchaudio
from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
from huggingface_hub import hf_hub_download

url = "https://www.youtube.com/watch?v=90fUR1PQgt4" #latest episode 37 minutes

# Create a YouTube object
yt = YouTube(url)

# Download only the audio stream from the video
video = yt.streams.filter(only_audio=True).first()

# Save the audio to a file
out_file = video.download()

# Get the base name and extension of the downloaded audio
base = os.path.splitext(out_file)[0]

Étape 4 : Préparer le fichier audio du podcast pour l’inférence du modèle

Nous allons devoir apporter quelques modifications au fichier audio du podcast afin de pouvoir l’utiliser pour l’inférence du modèle.

Tout d’abord, nous devons convertir le fichier M4A en fichier WAV pour l’utiliser avec le modèle vocal Granite. Nous utiliserons la bibliothèque moviepy pour effectuer cette conversion. Nous pouvons utiliser la variable de base que nous avons définie précédemment pour créer le nouveau nom de fichier avec l’extension .wav.

# Load the M4A file
audio_clip = AudioFileClip(out_file)

# Write the audio to a WAV file
audio_clip.write_audiofile(base+".wav")

# Close the audio clip
audio_clip.close()

audio_path = base+".wav"

Ensuite, nous utiliserons « torchaudiodio.load() » pour charger le fichier audio en tant que tenseur et extraire le taux d’échantillonnage.

Il nous faudra également convertir la forme d’onde renvoyée de stéréo en mono. Pour ce faire, nous prenons la moyenne des canaux sonores stéréo grâce à « torch.mean() ».

#Resulting waveform and sample rate
waveform, sample_rate = torchaudio.load(audio_path, normalize=True)

# convert from stereo to mono
mono_waveform = torch.mean(waveform, dim=0, keepdim=True)

# confirm the waveform is mono
assert mono_waveform.shape[0] == 1 # mono

Ensuite, nous devons échantillonner la forme d’onde mono selon le taux d’échantillonnage du modèle : 16 kHz. Pour ce faire, nous pouvons utiliser l’API d’échantillonnage de torchaudio.

# Resample the mono waveform to the model's sample rate
resample_transform = torchaudio.transforms.Resample(orig_freq=sample_rate, new_freq=16000)
resampled_waveform = resample_transform(mono_waveform)

Enfin, nous divisons la forme d’onde échantillonnée en morceaux de taille égale à introduire dans le modèle pour faciliter l’inférence.

Nous utiliserons « torch.split () » pour diviser la forme d’onde échantillonnée en morceaux de 30 secondes et un échantillon de taille de morceau égale à 30 secondes * 16 kHz. Cette étape nous donnera une liste de formes d’onde, des « morceaux» dont chacun contient 30 secondes de données audio. Nous allons intégrer chaque morceau au modèle à des fins d’inférence.

# Define the desired chunk size
chunk_size_seconds = 30 
chunk_size_samples = chunk_size_seconds * 16000

# Split the waveform into chunks of equal size
chunks = torch.split(resampled_waveform, chunk_size_samples, dim=1)

Étape 5: Charger et instancier le modèle vocal Granite

Nous pouvons maintenant commencer à instancier notre modèle vocal.

Nous allons d’abord configurer notre appareil torch sur CPU. S’il est défini sur GPU, vous pourriez rencontrer des erreurs de mémoire insuffisante lors de l’exécution de ce notebook ; « CPU » devrait fonctionner correctement sur votre notebook watsonx.ai. Nous allons ensuite configurer notre processeur et tokeniseur pour le modèle.

device = 'cpu'
model_name = "ibm-granite/granite-speech-3.3-8b"
speech_granite_processor = AutoProcessor.from_pretrained(
    model_name, trust_remote_code=True)
tokenizer = speech_granite_processor.tokenizer

Si vous exécutez votre notebook sur la plateforme watsonx.ai, il faudra probablement exécuter le code suivant pour modifier manuellement le fichier « adapter_config.json ».   Cela évitera toute erreur lors du chargement du modèle.

adapter_config_file = hf_hub_download(model_name, 'adapter_config.json')

#load the existing config file and print it
with open(adapter_config_file, 'r') as file:
    data = json.load(file)

#remove key, value pairs in config file throwing error
keys_to_delete = ['layer_replication', 'loftq_config', 'megatron_config', 'megatron_core', 'use_dora', 'use_rslora']

for key in keys_to_delete:
    if key in data:
        del data[key]

# write the updated config file back to disk
with open(adapter_config_file, 'w') as file:
    json.dump(data, file, indent=4)

with open(adapter_config_file, 'r') as file:
    data = json.load(file)

Parfait, nous pouvons enfin charger le modèle ! Nous utiliserons «AutoModelForSpeechSeq2Seq » de la bibliothèque « transformers » et la méthode `« rom_pretrained » pour charger le modèle.

speech_granite = AutoModelForSpeechSeq2Seq.from_pretrained(model_name, trust_remote_code=True).to(device)

Étape 6 : Créer un système ASR avec le modèle vocal Granite

Maintenant que le modèle est chargé et que les données audio sont prêtes, nous pouvons générer un texte à partir du contenu vocal.

Nous allons commencer par créer un prompt pour que le modèle puisse transcrire les données audio. Nous utiliserons « tokenizer.apply_chat_template() » pour donner au prompt un format intégrable au modèle.

chat = [
    {
        "role": "system",
        "content": "Knowledge Cutoff Date: April 2025.\nToday's Date: April 16, 2025.\nYou are Granite, developed by IBM. You are a helpful AI assistant",
    },
    {
        "role": "user",
        "content": "<|audio|>can you transcribe the speech into a written format?",
    }
]

text = tokenizer.apply_chat_template(
    chat, tokenize=False, add_generation_prompt=True
)

Ensuite, nous allons configurer une liste vide « generated_texts » pour recueillir le texte généré à partir de chaque morceau d’entrée audio.

Nous avons mis en place une boucle « for » pour itérer sur chaque segment audio et le transmettre au modèle pour génération. Ici, nous allons également suivre la progression de la boucle en utilisant une barre de progression « tqdm ».

Les entrées du modèle sont créées avec « speech_granite_processor », que nous avons établi précédemment. Le processeur prend le « text » et « chunk » en entrée et renvoie une version traitée des données audio que le modèle peut utiliser.

Les sorties du modèle sont produites en utilisant la méthode « generate » du modèle vocal. Ensuite, nous utilisons le « tokenizer » pour convertir les sorties du modèle en texte lisible par l’humain et stocker la transcription de chaque morceau dans notre liste « generated_texts ».

generated_texts = []

for chunk in tqdm(chunks, desc="Generating transcript..."):

    model_inputs = speech_granite_processor(
        text,
        chunk,
        device=device, # Computation device; returned tensors are put on CPU
        return_tensors="pt",
    ).to(device)
    
    # Generate
    model_outputs = speech_granite.generate(
        **model_inputs,
        max_new_tokens=1000,
        num_beams=1,
        do_sample=False,
        min_length=1,
        top_p=1.0,
        repetition_penalty=1.0,
        length_penalty=1.0,
        temperature=1.0,
        bos_token_id=tokenizer.bos_token_id,
        eos_token_id=tokenizer.eos_token_id,
        pad_token_id=tokenizer.pad_token_id,)

    num_input_tokens = model_inputs["input_ids"].shape[-1]
    new_tokens = torch.unsqueeze(model_outputs[0, num_input_tokens:], dim=0)

    output_text = tokenizer.batch_decode(
        new_tokens, add_special_tokens=False, skip_special_tokens=True)[0]

    generated_texts.append(output_text)

Puisque les transcriptions sont actuellement des chaînes individuelles dans une liste, nous allons unir les chaînes avec un espace entre les deux pour former une transcription complète et cohérente.

full_transcript = " ".join(generated_texts)

Étape 7 : Utiliser le modèle d’instruction Granite pour la synthèse

Maintenant que nous avons une transcription complète, nous allons utiliser le même modèle pour la résumer. Nous pouvons accéder au modèle Granite-3.3-8B-Instruct directement à partir de Granite-speech-3.3-8b en l’appelant simplement avec un prompt textuel qui ne contient pas le token « <|audio|> ».

Nous allons créer un nouveau prompt pour demander à ce modèle de générer une synthèse de la transcription. Nous pouvons utiliser « tokenizer.apply_chat_template() » à nouveau pour convertir le prompt pour l’inférence du modèle.

conv = [{"role": "user", 
         "content": f"Compose a single, unified summary of the following transcript. Your response should only include the unified summary. Do not provide any further explanation. Transcript:{full_transcript}"}]

text = tokenizer.apply_chat_template(conv, tokenize=False, add_generation_prompt=True)

Nous allons utiliser à nouveau « speech_granite_processor » pour créer des entrées de modèle, mais cette fois, nous ne transmettrons aucun fichier audio.

model_inputs = speech_granite_processor(
    text,
    device=device, # Computation device; returned tensors are put on CPU
    return_tensors="pt",
).to(device)

Nous recevrons la sortie de « speech_granite.generate() » sous forme de tenseur. Nous pouvons convertir cette sortie en texte avec « tokenizer.decode() » et imprimer notre synthèse finale !

output = speech_granite.generate(
    **model_inputs,
    max_new_tokens= 2000, # concise summary
)

summary = tokenizer.decode(output[0, model_inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(summary)

Sortie :

In the 50th episode of Mixture of Experts, the panel discusses various AI-related topics. 

Kate Soule, Director of Technical Product Management at Granite, estimates that 90% of enterprise data is unstructured. 

Hilary Hunter, IBM Fellow and CTO of IBM Infrastructure, introduces IBM's new mainframe launch, IBM z, emphasizing its zero downtime and eight nines of reliability, crucial for global financial transactions. 

The conversation also touches on Meta's Llama 4 release, featuring three models: Scout (100 billion parameters), Maverick (200 billion parameters), and Behemoth (two trillion parameters). The panelists discuss the implications of these models, particularly the mixture of experts architecture, and its potential to become more community-driven. 

Shobhit Varshney Head of Data and AI for the Americas, shares insights on handling unstructured data in enterprises, advocating for bringing AI close to transaction data for low-latency, mission-critical applications. 

The episode concludes with a brief overview of Google Cloud Next, highlighting advancements in AI models, on-premises AI capabilities, and Google's focus on AI for media creation and agent-to-agent communication. 

The panel also references a Pew Research report on American perceptions of AI, noting discrepancies between experts' optimism and the general public's concerns about job impacts from AI.