Gunakan pengenalan suara otomatis (ASR) untuk menghasilkan transkrip podcast menggunakan Granite 3.3 dan watsonx.ai

Langkah 2. Instal dan impor pustaka yang relevan

Kami memiliki beberapa dependensi untuk tutorial ini. Pastikan untuk mengimpor yang berikut ini; jika tidak diinstal, Anda dapat menyelesaikan masalah ini dengan instalasi pip cepat.

Jika Anda menerima kesalahan "pip dependensi resolver" terkait dengan paket caikit-nlp, Anda dapat mengabaikannya untuk saat ini karena sisa notebook masih dapat berjalan secara normal.

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

Langkah 4: Siapkan file audio podcast untuk inferensi model

Kita perlu membuat beberapa modifikasi pada file audio podcast sebelum kita dapat menggunakannya untuk inferensi model.

Pertama, kita perlu mengonversi file M4A ke file WAV untuk menggunakannya dengan model Granite Speech. Kita akan menggunakan perpustakaan moviepy untuk melakukan konversi ini. Kita dapat menggunakan variabel dasar yang kita definisikan sebelumnya untuk membuat nama file baru dengan.wav ekstensi.

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

Selanjutnya, kita akan menggunakan torchaudiodio.load() untuk memuat file audio sebagai tensor dan mengekstrak laju sampel.

Kita juga perlu mengubah bentuk gelombang yang dikembalikan dari suara stereo menjadi suara mono. Kita dapat melakukan ini dengan mengambil rata-rata saluran suara stereo dengan menggunakan 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

Berikutnya, kita perlu mengambil sampel ulang bentuk gelombang mono ke laju sampel model: 16 khz. Kita dapat menggunakan API resampling torchaudio untuk mencapai ini.

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

Akhirnya, kita dapat membagi bentuk gelombang yang disampel ulang menjadi potongan-potongan dengan ukuran yang sama untuk dimasukkan ke dalam model agar inferensi lebih mudah.

Kita akan menggunakan torch.split ()untuk membagi bentuk gelombang yang disampel ulang penuh menjadi potongan-potongan 30 detik dan sampel ukuran potongan sama dengan 30 detik * 16 khz. Langkah ini akan memberi kita daftar bentuk gelombang, potongan, masing-masing dengan 30 detik data audio. Kami akan memasukkan setiap potongan ke dalam model untuk inferensi.

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

Langkah 5: Muat dan buat instans model ucapan Granite

Sekarang kita dapat mulai membuat instans model ucapan kita.

Pertama-tama kita akan mengatur perangkat obor kita ke CPU. Jika perangkat diatur ke GPU, Anda mungkin mengalami kesalahan kehabisan memori saat menjalankan notebook ini, tetapi CPU akan berfungsi dengan baik pada notebook watsonx.ai Anda. Kami kemudian dapat mengatur prosesor dan tokenizer kami untuk model tersebut.

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

Jika Anda menjalankan notebook Anda di platform watsonx.ai, Anda mungkin juga perlu menjalankan kode berikut untuk mengedit secara manual file adapter_config.json . Ini akan menghindari kesalahan saat memuat model.

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)

Bagus, sekarang kita akhirnya bisa memuat modelnya! Kita akan menggunakan AutoModelForSpeechSeq2seq dari pustaka transformers dan metode from_pretrained untuk memuat model.

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

Langkah 6: Buat sistem ASR dengan model ucapan Granite

Sekarang setelah model dimuat dan data audio disiapkan, kita dapat menggunakannya untuk menghasilkan teks dari ucapan.

Kita akan mulai dengan membuat prompt untuk model untuk mentranskripsikan data audio. Kita akan menggunakan tokenizer.apply_chat_template ()untuk mengubah prompt menjadi format yang dapat dimasukkan ke dalam model.

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
)

Kemudian, kita dapat mengatur daftar kosong generated_texts, untuk mengumpulkan teks yang dihasilkan dari setiap potongan input audio.

Kita menyiapkan loop for untuk mengulangi setiap potongan audio dan meneruskannya ke model untuk dibuat. Di sini, kita juga akan melacak kemajuan loop dengan menggunakan bilah kemajuan tqdm.

Input model dibuat melalui speech_granite_processor yang kita buat sebelumnya. Prosesor mengambil text dan chunk sebagai input dan mengembalikan versi data audio yang diproses untuk digunakan model.

Output model dihasilkan dengan menggunakan metode generate model ucapan. Dari sana, kita menggunakan tokenizer untuk mengubah output model menjadi teks yang dapat dibaca manusia dan menyimpan transkripsi setiap potongan ke dalam daftar generated_texts kita.

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)

Karena transkrip potongan saat ini merupakan string individu dalam daftar, kami akan menggabungkan string bersama dengan spasi di antaranya untuk membuat satu transkrip penuh yang kohesif.

full_transcript = " ".join(generated_texts)

Langkah 7: Gunakan model instruksi Granite untuk ringkasan

Sekarang kita memiliki transkrip lengkap, kita akan menggunakan model yang sama untuk meringkasnya. Kita dapat mengakses Granite-3.3-8B-Instruct model langsung dari Granite-Speech-3.3-8b hanya dengan memanggilnya dengan prompt teks yang tidak berisi token <|audio|>.

Kami akan menyiapkan prompt baru untuk menginstruksikan model ini untuk menghasilkan ringkasan transkrip lengkap. Kita dapat menggunakan tokenizer.apply_chat_template() lagi untuk mengonversi prompt untuk inferensi model.

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)

Kita akan gunakan speech_granite_processor lagi untuk membuat input model, tetapi kami tidak akan meneruskan file audio apa pun kali ini.

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

Kita akan menerima output dari speech_granite.generate ()sebagai tensor. Kita dapat mengonversi output ini menjadi teks dengan menggunakan tokenizer.decode (). Dan cetak ringkasan akhir!

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.