Utilizza il riconoscimento vocale automatico (ASR) per generare la trascrizione di un podcast usando Granite 3.3 e watsonx.ai

Passaggio 2. Installa e importa le librerie pertinenti

Per questo tutorial abbiamo alcune dipendenze. Assicurati di importare i seguenti pacchetti e, se non sono installate, puoi risolvere il problema con una rapida installazione pip.

Se ricevi un errore "pip dependency resolver" relativo al pacchetto caikit-nlp, per ora puoi ignorarlom poiché il resto del notebook dovrebbe comunque funzionare normalmente.

# 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]

Passaggio 4: prepara il file audio del podcast per l'inferenza del modello

Dovremo apportare alcune modifiche al file audio del podcast prima di poterlo usare per l'inferenza del modello.

Per prima cosa, dobbiamo convertire il file M4A in un file WAV per poterlo utilizzare con il modello Granite Speech. Per effettuare questa conversione utilizzeremo la libreria moviepy. Possiamo usare la variabile di base che abbiamo definito in precedenza per creare il nuovo nome del file con estensione .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"

Successivamente, useremo torchaudiodio.load() per caricare il file audio come tensore ed estrarre la frequenza di campionamento.

Dovremo anche convertire la forma d'onda restituita dall'audio stereo al mono. Possiamo farlo prendendo la media dei canali audio stereo usando 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

A seguire, ricampioniamo la forma d'onda mono alla frequenza di campionamento del modello: 16 kHz. Per farlo, possiamo usare l'API di resampling di 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)

Infine, suddividiamo la forma d'onda ricampionata in blocchi di uguale dimensione per alimentarli nel modello e facilitare l'inferenza.

Useremo 'torch.split()' per suddividere l'onda completamente ricampionata in blocchi di 30 secondi e un campione di dimensione del blocco pari a 30 secondi * 16 kHz. Questo passaggio ci fornirà una lista di forme d'onda, dette 'chunks', ciascuna con 30 secondi di dati audio. Inseriremo ogni parte nel modello per l'inferenza.

# 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)

Passaggio 5: carica e istanzia il modello vocale Granite

Ora possiamo iniziare a istanziare il nostro modello vocale.

Per prima cosa imposteremo il nostro dispositivo torch sulla CPU. Se il dispositivo è impostato su GPU, è possibile che si verifichino errori di memoria esaurita durante l'esecuzione di questo notebook, ma la CPU dovrebbe funzionare bene sul tuo notebook watsonx.ai. Possiamo quindi configurare il nostro processore e tokenizzatore per il modello.

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

Se stai eseguendo il tuo notebook sulla piattaforma watsonx.ai, potresti anche dover eseguire il seguente codice per modificare manualmente adapter_config.json. Questo eviterà un errore durante il caricamento del modello.

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)

Ottimo, ora finalmente possiamo caricare il modello! Utilizzeremo AutoModelForSpeechSeq2Seq dalla libreria transformers e il metodo from_pretrained per caricare il modello.

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

Passaggio 6: crea un sistema ASR con il modello vocale Granite

Ora che abbiamo caricato il modello e preparato i dati audio, possiamo utilizzarlo per generare testo dal parlato.

Inizieremo creando un prompt per il modello per trascrivere i dati audio. Useremo tokenizer.apply_chat_template() per convertire il prompt in un formato che può essere inserito nel modello.

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
)

A seguire, possiamo impostare un elenco vuoto generated_texts per raccogliere il testo generato da ogni blocco di input audio.

Impostiamo un ciclo for per scorrere ogni blocco audio e passarlo al modello per la generazione. Qui, seguiremo anche l'avanzamento del ciclo utilizzando una barra di avanzamento tqdm.

Gli input del modello vengono creati tramite speech_granite_processor che abbiamo stabilito in precedenza. Il processore accetta text e chunk come input e restituisce una versione elaborata dei dati audio affinché il modello possa utilizzarli.

Gli output del modello vengono prodotti utilizzando il metodo generate del modello vocale. Da lì, usiamo il tokenizer per convertire gli output dei modelli in testo leggibile dall'uomo e memorizzare la trascrizione di ogni blocco nella nostra lista 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)

Poiché le trascrizioni dei chunk sono attualmente stringhe individuali in una lista, uniremo le stringhe con uno spazio intermedio per creare una trascrizione completa e coesa.

full_transcript = " ".join(generated_texts)

Passaggio 7: utilizza il modello di istruzione Granite per la sintesi

Ora che abbiamo una trascrizione completa, useremo lo stesso modello per riepilogarla. Possiamo accedere al modello Granite-3.3-8B-Instruct direttamente da Granite-speech-3.3-8b semplicemente chiamandolo con un prompt di testo che non contiene il token <|audio|>.

Configureremo un nuovo prompt per istruire questo modello a generare un riepilogo della trascrizione completa. Possiamo usare di nuovo tokenizer.apply_chat_template() per convertire il prompt per l'inferenza del modello.

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)

Utilizziamo di nuovo 'speech_granite_processor' per creare gli input del modello, ma questa volta non invieremo alcun file audio.

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

Riceveremo l'output da 'speech_granite.generate()' come tensor. Possiamo convertire questo output in testo utilizzando tokenizer.decode(). E infine, stampiamo il nostro riepilogo!

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)

Output:

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.