Pipa ucapan terjemahan waktu nyata dengan Whisper dan Soprano

Salah satu impian kami untuk teknologi Deep Learning, sejak benar-benar mulai berkembang pesat pada awal 2020-an, adalah terjemahan ucapan secara real-time. Terinspirasi oleh media fiksi ilmiah seperti Star Trek, janji terjemahan ucapan secara real-time selalu menarik dan memiliki potensi bisnis yang luar biasa. Hanya untuk efisiensi saja, kemampuan terjemahan seperti ini berpotensi mempercepat interaksi bisnis secara ekstrem.

Nah, setelah memantau perkembangan sistem TTS, Translation LM, dan ASR selama bertahun-tahun, akhirnya kini memungkinkan untuk membuat pipeline terjemahan ucapan waktu nyata kita sendiri menggunakan teknologi sumber terbuka! Dalam tutorial ini, kita akan menelusuri pipeline terjemahan yang lebih cepat dari kecepatan bicara yang dibuat menggunakan Python. Tutorial ini akan menjelaskan cara menggunakan Whisper ASR, Hunyuan MT translation LLM, dan pipeline Soprano 80M TTS secara bersamaan, dan ditutup dengan penjelasan aplikasi Gradio yang menggabungkan ketiga model tersebut menjadi sebuah pipeline terjemahan ucapan waktu nyata yang fungsional.

Poin Penting

• Terjemahan ucapan waktu-nyata dari awal hingga akhir kini praktis dengan sumber terbuka: Dengan menggabungkan Whisper Large-v3 untuk ASR, Hunyuan MT untuk terjemahan, dan Soprano 80M untuk TTS, memungkinkan untuk membangun jalur kerja yang lebih cepat dari kecepatan bicara yang menyalin, menerjemahkan, dan membacakan audio dalam waktu kurang dari satu detik untuk beberapa detik input pada GPU modern.
• Efisiensi model sama pentingnya dengan akurasi: ASR multilingual zero-shot yang kuat dari Whisper, terjemahan berkualitas tinggi dan dapat diskalakan dari Hunyuan MT (dari 1,8B hingga 7B), dan TTS ultra-latensi rendah dari Soprano secara bersama-sama menunjukkan bagaimana model yang dipilih dengan cermat dan efisien memungkinkan performa real-time tanpa sistem proprietary.
• Demo siap produksi dapat dibuat dengan kode tambahan minimal: Sebuah aplikasi Python yang relatif kecil, dibungkus dalam antarmuka Gradio, sudah cukup untuk mengatur ASR → terjemahan → TTS, menunjukkan betapa mudahnya penerjemahan suara real-time bagi pengembang dan bisnis saat ini.

Whisper Large v3

Whisper adalah model pengenalan suara otomatis dan terjemahan ucapan mutakhir yang diperkenalkan oleh OpenAI dalam makalah Robust Speech Recognition via Large-Scale Weak Supervision oleh Alec Radford et al. Dilatih pada lebih dari lima juta jam audio yang diberi label, Whisper menunjukkan kinerja zero-shot yang kuat, mampu menggeneralisasi secara efektif di berbagai kumpulan data, bahasa, dan domain dunia nyata.

Whisper Large-v3 mendukung lebih dari 99 bahasa dan menghadirkan peningkatan yang ditargetkan dibandingkan pendahulunya (Whisper Large v2) seperti token Kanton khusus dan peningkatan kinerja yang signifikan, terutama untuk bahasa Inggris. Model ini menawarkan penanganan aksen, kebisingan latar belakang, dan terminologi teknis yang lebih baik, menghasilkan 10–20% lebih sedikit kesalahan dibandingkan v2 sekaligus memberikan pemrosesan yang lebih cepat di berbagai kondisi audio dan berbagai bahasa termasuk Afrikaans, Arab, Tionghoa, Prancis, Jerman, Hindi, Jepang, Spanyol, dan masih banyak lagi (Sumber).

Dengan Whisper Large v3 sebagai kerangka ASR, kita dapat dengan akurat menangkap ucapan dari hampir semua sumber dan menyalinnya dengan tepat menjadi teks yang dapat digunakan untuk model Text To Speech.

Hunyuan MT

Model Terjemahan Hunyuan versi 1.5 terdiri dari dua model: HY-MT1.5-1.8B dengan 1,8 miliar parameter dan HY-MT1.5-7B dengan 7 miliar parameter, keduanya dirancang untuk mendukung terjemahan dua arah di 33 bahasa sekaligus menggabungkan lima varian etnis dan dialek. HY-MT1.5-7B dibangun berdasarkan model juara WMT25 milik Tencent dan dioptimalkan untuk terjemahan penjelasan serta skenario bahasa campuran, dengan kemampuan tambahan seperti kontrol terminologi, terjemahan kontekstual, dan output terformat. Meskipun memiliki kurang dari sepertiga jumlah parameter dari model 7B, HY-MT1.5-1.8B memberikan kualitas terjemahan yang sebanding dengan kecepatan jauh lebih tinggi, dan setelah proses kuantisasi dapat diterapkan pada perangkat edge untuk penggunaan terjemahan real-time, membuatnya sangat serbaguna dan mudah diterapkan secara luas.

Untuk demo ini, kami menggunakan model 7B lengkap. Hal ini sebagian besar disebabkan oleh kekuatan NVIDIA H200 yang kami gunakan untuk menjalankan model, tetapi model 1.8B dapat dengan mudah digantikan menggunakan potongan kode di bawah ini.

Soprano 1.1 80m

Akhirnya, kami memiliki model TTS kami. Soprano adalah model text-to-speech ultra-ringan yang berjalan di perangkat, dibangun untuk sintesis suara ekspresif dan berkualitas tinggi dengan kecepatan yang belum pernah ada sebelumnya, menghasilkan hingga 2000× kecepatan nyata di GPU dan 20× kecepatan nyata di CPU dengan streaming tanpa kehilangan kualitas dan latensi ultra-rendah (<15 ms di GPU, <250 ms di CPU). Arsitektur kompaknya yang memiliki 80 juta parameter menggunakan kurang dari 1 GB memori sambil mendukung generasi teks tak terbatas melalui pemisahan teks otomatis dan menghasilkan audio 32 kHz yang jernih dan sangat ekspresif.

Demo: Terjemahan Ucapan Real-time

Sekarang setelah kita memperkenalkan komponen inti dari pipeline, mari kita satukan semuanya. Untuk mempermudah hal ini, kami telah membuat repositori Github di mana Anda dapat mengakses proyek ini, yang dapat ditemukan di sini. File ReadMe menjelaskan cara menggunakan demo. Untuk memulai, jalankan GPU Droplet Anda menggunakan instruksi yang dijelaskan dalam tutorial ini. Ini akan memungkinkan Anda mengakses GPU Droplet dari jendela terminal mesin lokal Anda, dan kemudian menggunakan fitur browser sederhana VS Code/Cursor untuk mengakses aplikasi web demo Gradio.

Selanjutnya, tempelkan kode berikut ke jendela terminal GPU Droplet Anda:

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

Ini akan memulai aplikasi web. Secara default, akan ada tautan bersama dan tautan lokal.

Berikut adalah tampilan halaman demo. Untuk menggunakannya, kirimkan file audio atau rekaman menggunakan modul Audio Gradio. Kemudian klik tombol Jalankan di bagian bawah aplikasi untuk menjalankan terjemahan. Tergantung pada ukuran file yang Anda kirimkan, ini bisa memakan waktu kurang dari satu detik hingga beberapa detik.

Kita bisa melihat kodenya di bawah ini:

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

Seperti yang dapat kita lihat dari atas, file aplikasi pertama-tama memuat file model kita. Kemudian menggunakan fungsi pembantu dengan fungsi orkestrasi inti untuk menyalin audio input, menerjemahkan teks tersebut ke bahasa Inggris, dan kemudian menggunakan TTS untuk mengubah teks yang diterjemahkan menjadi ucapan dalam bahasa Inggris! Misalnya, semua ini terjadi dalam waktu kurang dari satu detik untuk memproses audio selama 5 detik pada Linux-Console.net Gradient GPU Droplet yang didukung oleh NVIDIA H200.

Pemikiran Penutup

Dalam tutorial ini, kami menunjukkan bahwa sekarang dimungkinkan melakukan terjemahan ucapan secara real-time dengan model pembelajaran mendalam komponen dalam sebuah pipeline. Terobosan ini memiliki potensi besar untuk berbagai macam kasus penggunaan terjemahan, termasuk dalam bisnis dan hiburan. Kami menantikan perkembangan lebih lanjut dari teknologi ASR, TTS, dan LM Translation supaya kami dapat meningkatkan pipeline ini lebih jauh. Tujuan kami berikutnya adalah menambahkan kloning suara ke dalam proses ini!

Coba demo ini di Gradient hari ini!

Terima kasih telah belajar bersama Komunitas Linux-Console.net.