Zoeken op website

Realtime vertaald spraakproces met Whisper en Soprano

Een van onze dromen voor Deep Learning-technologie, sinds het echt begon op te komen in het begin van de jaren 2020, is realtime vertaling van spraak. Geïnspireerd door sciencefictionmedia zoals Star Trek, is de belofte van realtime vertaling van onze spraak altijd zowel opwindend geweest als met ongelooflijk zakelijk potentieel. Alleen al omwille van efficiëntie, hebben dergelijke vertaalmogelijkheden het potentieel om zakelijke interacties tot het uiterste te versnellen.

Nou, na jarenlang het ontwikkelen van TTS-, vertaal-LM- en ASR-systemen in de gaten te hebben gehouden, is het eindelijk mogelijk om onze eigen realtime spraakvertalingspipeline te maken met open-source technologieën! In deze tutorial zullen we onze snellere-dan-spraak vertaalpipeline die met Python is gemaakt, stap voor stap doornemen. Deze tutorial laat zien hoe je de Whisper ASR, Hunyuan MT vertaal-LLM en Soprano 80M TTS pipelines samen gebruikt, en eindigt met een uitleg van een Gradio-applicatie die de drie modellen combineert tot een functionele, realtime vertaalde spraakpipeline.

Belangrijkste punten

  • End-to-end realtime spraakvertaling is nu praktisch met open source: Door Whisper Large-v3 voor ASR, Hunyuan MT voor vertaling en Soprano 80M voor TTS te combineren, is het mogelijk om een snellere-dan-spraak pipeline te bouwen die audio transcribeert, vertaalt en uitspreekt in minder dan een seconde voor meerdere seconden aan input op moderne GPU's.
  • De efficiëntie van modellen is net zo belangrijk als nauwkeurigheid: Whisper’s sterke meertalige zero-shot ASR, Hunyuan MT’s hoogwaardige en toch schaalbare vertaling (van 1,8B tot 7B), en Soprano’s ultrasnelle TTS laten samen zien hoe zorgvuldig gekozen, efficiënte modellen realtime prestaties mogelijk maken zonder propriëtaire systemen.
  • Productieklaar demomateriaal kan worden gebouwd met minimale verbindingscode: een relatief kleine Python-toepassing, verpakt in een Gradio-UI, is voldoende om ASR → vertaling → TTS te orkestreren, waarmee wordt aangetoond hoe toegankelijk real-time spraakvertaling is geworden voor zowel ontwikkelaars als bedrijven.

Whisper Large v3

Whisper is een geavanceerd automatisch spraakherkennings- en spraakvertalingsmodel dat door OpenAI is geïntroduceerd in het artikel Robust Speech Recognition via Large-Scale Weak Supervision door Alec Radford et al. Getraind op meer dan vijf miljoen uur gelabelde audio, toont Whisper sterke zero-shot prestaties en generaliseert het effectief over een breed scala aan datasets, talen en real-world domeinen.

Whisper Large-v3 ondersteunt meer dan 99 talen en introduceert gerichte verbeteringen ten opzichte van zijn voorganger (Whisper Large v2), zoals een speciale Cantonese token en aanzienlijk verbeterde prestaties, met name voor het Engels. Het biedt een betere verwerking van accenten, achtergrondgeluiden en technische terminologie, met 10–20% minder fouten dan v2, terwijl het ook snellere verwerking biedt in diverse audiocondities en een breed scala aan talen, waaronder Afrikaans, Arabisch, Chinees, Frans, Duits, Hindi, Japans, Spaans en nog veel meer (Bron).

Met Whisper Large v3 als de ASR-backbone kunnen we spraak van bijna elke bron nauwkeurig opnemen en deze correct omzetten naar bruikbare tekst voor het Text To Speech-model.

Hunyuan MT

Hunyuan-vertaalmodel versie 1.5 bestaat uit twee modellen: het 1,8 miljard-parameter HY-MT1.5-1.8B en het 7 miljard-parameter HY-MT1.5-7B, die beide zijn ontworpen om bidirectionele vertaling tussen 33 talen te ondersteunen en vijf etnische en dialectvarianten te verwerken. HY-MT1.5-7B is gebaseerd op Tencent’s WMT25-kampioensmodel en is geoptimaliseerd voor verklarende vertaling en scenario's met gemengde talen, met extra mogelijkheden zoals terminologiecontrole, contextuele vertaling en geformatteerde uitvoer. Ondanks dat het minder dan een derde van de parameters van het 7B-model heeft, levert HY-MT1.5-1.8B vergelijkbare vertaalkwaliteit met een veel hogere snelheid, en na kwantisatie kan het op edge-apparaten worden ingezet voor realtime vertaalscenario's, waardoor het zeer veelzijdig en breed toepasbaar is.

Voor deze demo gebruiken we het volledige 7B-model. Dit komt grotendeels door de kracht van de NVIDIA H200 waarmee we het model draaien, maar het 1.8B-model kan eenvoudig worden vervangen met het onderstaande codefragment.

Sopraan 1.1 80m

Eindelijk hebben we ons TTS-model. Soprano is een ultralicht, on-device tekst-naar-spraakmodel dat is ontwikkeld voor expressieve, hoge-fideliteit spraaksynthese met ongekende snelheid, met een generatie tot 2000× realtime op GPU en 20× realtime op CPU, met verliesloze streaming en ultra-lage latency (<15 ms op GPU, <250 ms op CPU). De compacte architectuur met 80 miljoen parameters gebruikt minder dan 1 GB geheugen en ondersteunt generatie van oneindige lengte door automatische tekstsplitsing, en produceert kristalheldere, zeer expressieve 32 kHz audio.

Demo: realtime spraakvertaling

Nu we de kerncomponenten van de pipeline hebben geïntroduceerd, laten we alles samenvoegen. Om dit te vergemakkelijken, hebben we een Github-repository gemaakt waar je toegang tot dit project kunt krijgen, te vinden hier. Het ReadMe-bestand beschrijft hoe je de demo kunt gebruiken. Om te beginnen, start je je GPU Droplet met de instructies zoals uiteengezet in deze tutorial. Dit stelt je in staat om toegang te krijgen tot je GPU Droplet vanaf het terminalvenster van je lokale machine, en vervolgens de eenvoudige browserfunctie van VS Code/Cursor te gebruiken om de demo Gradio-webapp te openen.

Plak vervolgens de volgende code in het terminalvenster van je GPU Droplet:

git clone https://github.com/Jameshskelton/realtime_speech_translation
cd realtime_speech_translation
python3 -m venv venv
source venv/bin/activate
pip3 install -r requirements.txt
python3 realtime_speech_translation.py

Dit zal de webapplicatie opstarten. Standaard is er zowel een gedeelde link als een lokale link.

Hier is hoe de demopagina eruit zal zien. Om het te gebruiken, dien je een audiobestand of opname in via de Audio Gradio-module. Klik daarna op de knop Uitvoeren onderaan de applicatie om de vertaling uit te voeren. Afhankelijk van de grootte van je inzending kan dit minder dan een seconde tot enkele seconden duren.

We kunnen de code hieronder zien:

# -----------------------------
# Imports
# -----------------------------

import os
import torch
import numpy as np
import gradio as gr

from transformers import (
    AutoModelForSpeechSeq2Seq,
    AutoProcessor,
    AutoModelForCausalLM,
    AutoTokenizer,
    pipeline,
)

from soprano import SopranoTTS
from scipy.io.wavfile import write
from pydub import AudioSegment


# -----------------------------
# Device and dtype configuration
# -----------------------------

device = "cuda:0" if torch.cuda.is_available() else "cpu"
torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32


# -----------------------------
# Whisper ASR setup
# -----------------------------

model_id = "openai/whisper-large-v3-turbo"

model = AutoModelForSpeechSeq2Seq.from_pretrained(
    model_id,
    torch_dtype=torch_dtype,
    low_cpu_mem_usage=True,
    use_safetensors=True,
)
model.to(device)

processor = AutoProcessor.from_pretrained(model_id)

pipe = pipeline(
    "automatic-speech-recognition",
    model=model,
    tokenizer=processor.tokenizer,
    feature_extractor=processor.feature_extractor,
    torch_dtype=torch_dtype,
    device=device,
    return_timestamps=True,
    chunk_length_s=5.0,
)


# -----------------------------
# Translation model setup
# -----------------------------

model_name_or_path = "tencent/HY-MT1.5-1.8B"

tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
model_tr = AutoModelForCausalLM.from_pretrained(
    model_name_or_path,
    device_map="auto",
)


# -----------------------------
# TTS setup
# -----------------------------

model_tts = SopranoTTS()


# -----------------------------
# Audio utilities
# -----------------------------

def convert_to_mono_pydub(input_file, output_file, output_format="wav"):
    """
    Converts a stereo or multi-channel audio file to mono using pydub.
    """
    audio = AudioSegment.from_file(input_file)
    mono_audio = audio.set_channels(1)
    mono_audio.export(output_file, format=output_format)
    print(f"Converted '{input_file}' to mono file '{output_file}'")


# -----------------------------
# ASR → Translation → TTS pipeline
# -----------------------------

def tts_translate(sample_audio):
    output_filename = "out1.wav"

    sample_rate, audio_array = sample_audio
    write(output_filename, sample_rate, audio_array)

    convert_to_mono_pydub("out1.wav", "out1.wav")

    result = pipe("out1.wav")

    messages = [
        {
            "role": "user",
            "content": (
                "Translate the following segment into English, "
                "without additional explanation.\n\n"
                f"{result['text']}"
            ),
        }
    ]

    tokenized_chat = tokenizer.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=False,
        return_tensors="pt",
    )

    outputs = model_tr.generate(
        tokenized_chat.to(model_tr.device),
        max_new_tokens=2048,
    )

    output_text = tokenizer.decode(outputs[0])

    innie = output_text.split("hy_place▁holder▁no▁8｜>")[1]
    clean_text = innie.split("<")[0]

    model_tts.infer(clean_text, "out.wav")

    return "out.wav", clean_text


# -----------------------------
# Gradio UI
# -----------------------------

with gr.Blocks() as demo:
    gr.Markdown("# Submit or record your audio for faster-than-speech translation!")

    with gr.Column():
        inp = gr.Audio(label="Input Audio to be Translated")

    with gr.Column():
        with gr.Row():
            out_audio = gr.Audio(label="Translated Audio")
        with gr.Row():
            out_text = gr.Textbox(label="Translated Text", lines=8)

    btn = gr.Button("Run")
    btn.click(fn=tts_translate, inputs=inp, outputs=[out_audio, out_text])

demo.launch(share = True)

Zoals we hierboven kunnen zien, laadt het applicatiebestand eerst onze modelfiles. Vervolgens maakt het gebruik van hulpfuncties met een kernorkestratiefunctie om de invoeraudio te transcriberen, die tekst naar het Engels te vertalen en daarna TTS te gebruiken om de vertaalde tekst om te zetten in Engelse spraak! Bijvoorbeeld, dit alles gebeurt in minder dan een seconde voor het verwerken van 5 seconden audio op een Linux-Console.net Gradient GPU Droplet aangedreven door een NVIDIA H200.

Afsluitende gedachten

In deze tutorial hebben we aangetoond dat het nu mogelijk is om realtime spraakvertaling te doen met componenten van deep learning-modellen in een pipeline. Deze doorbraak heeft groot potentieel voor een veelheid aan verschillende vertaaltoepassingen, waaronder in het bedrijfsleven en de entertainmentsector. We kijken ernaar uit om de ontwikkeling van ASR-, TTS- en LM-vertalingstechnologieën verder te volgen, zodat we deze pipeline nog verder kunnen verbeteren. Ons volgende doel is om spraakkloning aan het proces toe te voegen!

Probeer vandaag deze demo op Gradient!

Bedankt dat je samen met de Linux-Console.net-community hebt geleerd.