Utilice el reconocimiento de voz (ASR) automático para generar una transcripción de un podcast con Granite 3.3 y watsonx.ai

Paso 2. Instale e importe bibliotecas relevantes

Tenemos algunas dependencias para este tutorial. Asegúrese de importar los siguientes y, si no están instalados, puede resolverlo con una instalación rápida de pip.

Si recibe un error de "resolución de dependencias de pip" relacionado con el paquete "caikit-nlp", puede ignorarlo por ahora, ya que el resto del notebook debería poder ejecutarse 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]

Paso 4: prepare el archivo de audio del pódcast para la inferencia de modelos

Tendremos que hacer un par de modificaciones en el archivo de audio del pódcast antes de poder utilizarlo para la inferencia de modelos.

Primero, necesitamos convertir el archivo M4A en un archivo WAV para usarlo con el modelo Granite Speech. Utilizaremos la biblioteca moviepy para realizar esta conversión. Podemos usar la variable base que definimos anteriormente para crear el nuevo nombre de archivo con la extensión .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"

A continuación, usaremos "torchaudiodio.load()" para cargar el archivo de audio como tensor y extraer la frecuencia de muestreo.

También tendremos que convertir la forma de onda devuelta del sonido estéreo al sonido mono. Podemos hacer esto tomando el promedio de los canales de sonido estéreo 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 continuación, necesitamos volver a muestrear la forma de onda mono a la frecuencia de muestreo del modelo: 16 kHz. Podemos usar la API de remuestreo de torchaudio para lograrlo.

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

Por último, podemos dividir la forma de onda remuestreada en trozos del mismo tamaño para introducirlos en el modelo y facilitar la inferencia.

Usaremos "torch.split()" para dividir la forma de onda remuestreada completa en fragmentos de 30 segundos y una muestra de tamaño de fragmento igual a 30 segundos * 16 khz. Este paso nos dará una lista de formas de onda, "fragmentos", cada una con 30 segundos de datos de audio. Introduciremos cada parte del modelo para su inferencia.

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

Paso 5: cargue e instancie el modelo de voz de Granite

Ahora podemos empezar a crear instancias de nuestro modelo de voz.

Primero configuraremos nuestro dispositivo torch en CPU. Si el dispositivo está configurado en GPU, es posible que se produzcan errores de falta de memoria al ejecutar este notebook, pero la CPU debería funcionar bien en su notebook watsonx.ai. A continuación, podemos configurar nuestro procesador y tokenizador para el modelo.

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 está ejecutando su notebook en la plataforma watsonx.ai, es posible que también deba ejecutar el siguiente código para editar manualmente el archivo "adapter_config.json". Esto evitará un error al cargar el modelo.

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)

Genial, ¡Ahora por fin podemos cargar el modelo! Usaremos "AutoModelForSpeechSeq2Seq" de la biblioteca "transformers" y el método "from_pretrained" para cargar el modelo.

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

Paso 6: cree un sistema ASR con el modelo de voz Granite

Ahora que tenemos el modelo cargado y los datos de audio preparados, podemos utilizarlo para generar texto a partir de la voz.

Empezaremos por crear una instrucción para que el modelo transcriba los datos de audio. Usaremos "tokenizer.apply_chat_template()" para convertir la instrucción en un formato que pueda introducirse en el modelo.

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
)

Luego, podemos crear una lista vacía "generated_texts" para recopilar el texto generado de cada parte de la entrada de audio.

Establecemos un bucle "for" para iterar por cada trozo de audio y pasarlo al modelo para su generación. Aquí, también realizaremos un seguimiento del progreso del bucle utilizando una barra de progreso "tqdm".

Las entradas del modelo se crean a través del "speech_granite_processor" que establecimos anteriormente. El procesador toma el "text" y el "chunk" como entrada y devuelve una versión procesada de los datos de audio para que la utilice el modelo.

Los outputs del modelo se producen utilizando el método "generar" del modelo de voz. A partir de ahí, utilizamos el "tokenizador" para convertir los resultados del modelo en texto legible por humanos y almacenar la transcripción de cada fragmento en nuestra 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)

Dado que las transcripciones de los fragmentos son actualmente cadenas individuales en una lista, uniremos las cadenas con un espacio entre ellas para crear una transcripción completa cohesiva.

full_transcript = " ".join(generated_texts)

Paso 7: utilice el modelo de instrucciones de Granite para el resumen

Ahora que tenemos una transcripción completa, utilizaremos el mismo modelo para resumirla. Podemos acceder al modelo Granite-3.3-8B-Instruct directamente desde Granite-speech-3.3-8b simplemente llamándolo con una instrucción que no contenga el token "<|audio|>".

Configuraremos una nueva instrucción para indicar a este modelo que genere un resumen de la transcripción completa. Podemos usar "tokenizer.apply_chat_template()" de nuevo para convertir la instrucción para la inferencia del modelo.

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)

Vamos a utilizar "speech_granite_processor" de nuevo para crear entradas de modelo, pero esta vez no pasaremos ningún archivo de audio.

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

Nosotros recibiremos el output de "speech_granite.generate()" como un tensor. Podemos convertir este output en texto con "tokenizer.decode()". ¡E imprima nuestro resumen final!

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.