Nutzen Sie automatische Spracherkennung (ASR), um mit Granite 3.3 und watsonx.ai ein Podcast-Transkript zu erstellen.

Schritt 2. Installieren und importieren der relevanten Bibliotheken

Für dieses Tutorial gibt es einige Abhängigkeiten. Stellen Sie sicher, dass Sie die folgenden Pakete importieren; wenn diese nicht installiert sind, können Sie das Problem mit einer schnellen PIP-Installation beheben.Wenn Sie einen „pip dependency Resolver“-Fehler im Zusammenhang mit dem „caikit-nlp“-Paket erhalten, können Sie diesen vorerst ignorieren, da der Rest des Notebooks weiterhin normal laufen sollte.

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

Schritt 4: Die Podcast-Audiodatei für die Modellinferenz vorbereiten.

Wir müssen einige Änderungen an der Podcast-Audiodatei vornehmen, bevor wir sie für die Modellinferenz verwenden können.

Zuerst müssen wir die M4A-Datei in eine WAV-Datei konvertieren, um sie mit dem Granite Speech-Modell verwenden zu können. Für diese Konvertierung verwenden wir die moviepy-Bibliothek. Wir können die zuvor definierte Basisvariable verwenden, um den neuen Dateinamen mit der Endung .wav zu erstellen.

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

Als Nächstes verwenden wir torchaudiodio.load(), um die Audiodatei als Tensor zu laden und die Samplerate zu extrahieren.

Außerdem müssen wir die zurückgegebene Wellenform von Stereoton in Monoton umwandeln. Dies gelingt uns, indem wir mit „torch.mean()“ den Durchschnitt der Stereo-Tonkanäle bilden.

#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

Als nächstes müssen wir das Monosignal auf die Abtastrate des Modells (16 kHz) umrechnen. Dafür können wir die Resampling-API von Torchaudio verwenden.

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

Schließlich können wir die neu abgetastete Wellenform in Stücke gleicher Größe aufteilen, um sie ins Modell einzuspeisen und die Schlussfolgerung zu erleichtern.

Wir verwenden torch.split(), um die gesamte neu abgetastete Wellenform in Abschnitte von 30 Sekunden und eine Abschnittsgröße von 30 Sekunden * 16 kHz aufzuteilen. Dieser Schritt liefert uns eine Liste von Wellenformen, sogenannten „Chunks“, die jeweils 30 Sekunden Audiodaten enthalten. Wir werden jeden Teil in das Modell einspeisen, um daraus Rückschlüsse zu ziehen.

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

Schritt 5: Laden und Instanziieren des Granite-Sprachmodells

Jetzt können wir mit der Instanziierung unseres Sprachmodells beginnen.

Wir stellen zuerst unser Torch-Gerät auf CPU ein. Wenn das Gerät auf GPU eingestellt ist, kann es beim Ausführen dieses Notebooks zu Speichermangel-Fehlern kommen, die CPU sollte jedoch in Ihrem watsonx.ai Notebook einwandfrei funktionieren. Wir können dann unseren Prozessor und Tokenizer für das Modell einrichten.

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

Wenn Sie Ihr Notebook auf der watsonx.ai-Plattform betreiben, müssen Sie möglicherweise auch den folgenden Code ausführen, um die Datei adapter_config.json manuell zu bearbeiten. Dadurch wird ein Fehler beim Laden des Modells vermieden.

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)

Großartig! Jetzt können wir das Modell endlich laden! Wir verwenden AutoModelForSpeechSeq2Seq aus der transformers-Bibliothek und die Methode from_pretrained, um das Modell zu laden.

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

Schritt 6: Erstellen eines ASR-Systems mit dem Granite-Sprachmodell

Nachdem wir das Modell geladen und die Audiodaten vorbereitet haben, können wir es verwenden, um aus Sprache Text zu generieren.

Wir beginnen damit, einen Prompt für das Modell zu erstellen, um die Audiodaten zu transkribieren. Wir verwenden tokenizer.apply_chat_template(), um den Prompt in ein Format zu konvertieren, das dem Modell zugeführt werden kann.

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
)

Dann können wir eine leere Liste generated_texts einrichten, um den generierten Text aus jedem Audio-Eingabeabschnitt zu sammeln.

Wir richten eine „for“-Schleife ein, um jeden Audioabschnitt zu durchlaufen und ihn zur Generierung an das Modell zu übergeben. Hier werden wir den Fortschritt der Schleife auch mithilfe einer tqdm-Fortschrittsanzeige verfolgen.

Die Eingaben des Modells werden durch den zuvor eingerichteten speech_granite_processor erzeugt. Der Prozessor nimmt den „Text“ und das „Chunk“ als Eingabe und gibt eine verarbeitete Version der Audiodaten zurück, die das Modell verwenden kann.

Die Modellausgaben werden mithilfe der generate-Methode des Sprachmodells produziert. Von dort aus verwenden wir den Tokenizer, um die Ausgaben in für Menschen lesbaren Text umzuwandeln und die Transkription jedes Abschnitts in unserer Liste zusammenhängend zu speichern.

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)

Da die Block-Transkripte derzeit einzelne Zeichenfolgen in einer Liste sind, werden wir sie mit einem Leerzeichen dazwischen verbinden, um ein zusammenhängendes vollständiges Transkript zu erstellen.

full_transcript = " ".join(generated_texts)

Schritt 7: Das Granite-Instruct-Modell für die Zusammenfassung verwenden

Da wir nun ein vollständiges Transkript haben, verwenden wir dasselbe Modell, um es zusammenzufassen. Wir können direkt von Granite-speech-3.3-8b auf das Granite-3.3-8B-Instruct-Modell zugreifen, indem wir es einfach mit einem Textprompt aufrufen, die das Token <|audio|> nicht enthält.

Wir richten einen neuen Prompt ein, um dieses Modell anzuweisen, eine Zusammenfassung des vollständigen Transkripts zu erstellen. Wir können erneut tokenizer.apply_chat_template() verwenden., um den Prompt zur Modellinferenz zu konvertieren.

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)

Wir werden erneut speech_granite_processor verwenden, um unsere Eingaben zu erstellen, führen diesmal aber keine Audiodatei zu.

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

Wir werden die Ausgabe von speech_granite.generate() als Tensor erhalten. Wir können diese Ausgabe mithilfe von tokenizer.decode() in Text umwandeln. Und unsere Abschlusszusammenfassung ausgeben!

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)

Ausgabe:

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.