Saluran paip pertuturan terjemahan Masa Nyata dengan Whisper dan Soprano

Salah satu impian kami untuk teknologi Pembelajaran Mendalam, sejak ia benar-benar mula berkembang pesat pada awal 2020-an, ialah terjemahan masa nyata bagi pertuturan. Dipengaruhi oleh media fiksyen sains seperti Star Trek, janji terjemahan masa nyata bagi pertuturan kita sentiasa menarik dan mempunyai potensi perniagaan yang luar biasa. Semata-mata demi kecekapan, kemampuan terjemahan seperti ini berpotensi mempercepatkan interaksi perniagaan hingga ke tahap maksimum.

Baiklah, selepas memerhatikan perkembangan sistem TTS, Translation LM, dan ASR selama bertahun-tahun, akhirnya adalah mungkin untuk membina saluran terjemahan suara masa nyata kita sendiri menggunakan teknologi sumber terbuka! Dalam tutorial ini, kami akan menelusuri saluran terjemahan yang lebih pantas daripada pertuturan yang dibina menggunakan Python. Tutorial ini akan menelusuri penggunaan Whisper ASR, Hunyuan MT translation LLM, dan Soprano 80M TTS secara bersama, dan diakhiri dengan panduan aplikasi Gradio yang menggabungkan ketiga-tiga model ini menjadi saluran terjemahan suara masa nyata yang berfungsi.

Kesimpulan Utama

• Terjemahan pertuturan masa nyata dari hujung ke hujung kini boleh dilakukan dengan sumber terbuka: Dengan menggabungkan Whisper Large-v3 untuk ASR, Hunyuan MT untuk terjemahan, dan Soprano 80M untuk TTS, adalah mungkin untuk membina saluran yang lebih pantas daripada pertuturan yang mentranskripsikan, menterjemah, dan membacakan audio dalam masa kurang daripada satu saat untuk beberapa saat input pada GPU moden.
• Kecekapan model adalah sama penting dengan ketepatan: ASR tanpa tembakan sifar pelbagai bahasa Whisper yang hebat, terjemahan berkualiti tinggi namun boleh diskala Hunyuan MT (dari 1.8B hingga 7B), dan TTS latensi sangat rendah Soprano bersama-sama menunjukkan bagaimana model yang dipilih dengan teliti dan cekap membolehkan prestasi masa nyata tanpa sistem proprietari.
• Demo yang sedia untuk pengeluaran boleh dibina dengan kod sambungan yang minimum: Sebuah aplikasi Python yang agak kecil, dibungkus dalam UI Gradio, sudah mencukupi untuk mengatur ASR → terjemahan → TTS, menunjukkan betapa mudahnya terjemahan pertuturan masa nyata untuk diakses oleh pembangun dan perniagaan.

Whisper Large v3

Whisper ialah model pengecaman ucapan automatik dan terjemahan ucapan terkini yang diperkenalkan oleh OpenAI dalam kertas kerja Robust Speech Recognition via Large-Scale Weak Supervision oleh Alec Radford et al. Latihan dijalankan pada lebih daripada lima juta jam audio berlabel, Whisper menunjukkan prestasi zero-shot yang hebat, mampu menggeneralisasi dengan berkesan merentasi pelbagai set data, bahasa, dan domain dunia sebenar.

Whisper Large-v3 menyokong lebih daripada 99 bahasa dan memperkenalkan penambahbaikan yang khusus berbanding pendahulunya (Whisper Large v2) seperti token Kantonis yang dikhaskan dan prestasi yang lebih baik, terutamanya untuk bahasa Inggeris. Ia menawarkan pengendalian yang lebih baik terhadap loghat, bunyi latar, dan terminologi teknikal, menghasilkan 10–20% kesilapan lebih sedikit berbanding v2 serta memberikan pemprosesan yang lebih pantas dalam pelbagai keadaan audio dan pelbagai bahasa termasuk Afrikaans, Arab, Cina, Perancis, Jerman, Hindi, Jepun, Sepanyol, dan banyak lagi (Sumber).

Dengan Whisper Large v3 sebagai tulang belakang ASR, kita dapat menerima ucapan dari hampir mana-mana sumber dengan tepat dan menyalinnya menjadi teks yang boleh digunakan untuk model Teks ke Ucapan.

Hunyuan MT

Model Terjemahan Hunyuan versi 1.5 terdiri daripada dua model: HY-MT1.5-1.8B dengan 1.8 bilion parameter dan HY-MT1.5-7B dengan 7 bilion parameter, kedua-duanya direka untuk menyokong terjemahan dwihala merentas 33 bahasa sambil menggabungkan lima varian etnik dan dialek. HY-MT1.5-7B dibangunkan berdasarkan model juara WMT25 Tencent dan dioptimumkan untuk terjemahan penjelasan dan senario bahasa campuran, dengan kemudahan tambahan seperti kawalan terminologi, terjemahan kontekstual, dan output berformat. Walaupun mempunyai kurang daripada sepertiga bilangan parameter model 7B, HY-MT1.5-1.8B memberikan kualiti terjemahan yang setara dengan kelajuan yang jauh lebih tinggi, dan selepas kuantisasi boleh digunakan pada peranti tepi untuk penggunaan terjemahan masa nyata, menjadikannya sangat serbaguna dan boleh diaplikasikan secara meluas.

Untuk demo ini, kami menggunakan model 7B penuh. Ini sebahagian besarnya disebabkan oleh kuasa NVIDIA H200 yang kami gunakan untuk menjalankan model itu, tetapi model 1.8B boleh digantikan dengan mudah menggunakan segmen kod di bawah.

Soprano 1.1 80m

Akhirnya, kami mempunyai model TTS kami. Soprano adalah model teks-ke-ucapan ultra-ringan yang beroperasi di peranti, dibina untuk sintesis ucapan yang ekspresif dan berkualiti tinggi dengan kelajuan yang belum pernah dicapai, menghasilkan sehingga 2000× generasi masa nyata pada GPU dan 20× masa nyata pada CPU dengan penstriman tanpa kehilangan dan kelewatan ultra-rendah (<15 ms pada GPU, <250 ms pada CPU). Seni bina 80M-parameter yang padat menggunakan kurang daripada 1 GB memori sambil menyokong generasi sepanjang tanpa batas melalui pemisahan teks automatik dan menghasilkan audio 32 kHz yang jelas seperti kristal dan sangat ekspresif.

Demo: Terjemahan Ucapan Masa Sebenar

Sekarang setelah kita telah memperkenalkan komponen utama rangkaian, mari kita gabungkan semuanya. Untuk memudahkan ini, kami telah mencipta sebuah repositori Github di mana anda boleh mengakses projek ini, yang boleh didapati di sini. Fail ReadMe menerangkan bagaimana untuk menggunakan demo tersebut. Untuk memulakan, lancarkan GPU Droplet anda menggunakan arahan yang diterangkan dalam tutorial ini. Ini akan membolehkan anda mengakses GPU Droplet anda dari tetingkap terminal mesin tempatan anda, dan kemudian menggunakan ciri penyemak imbas sederhana VS Code/Cursor untuk mengakses aplikasi web demo Gradio.

Seterusnya, tampal kod berikut ke dalam tetingkap 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 memulakan aplikasi web. Secara lalai, akan ada kedua-dua pautan dikongsi dan pautan tempatan.

Berikut ialah bagaimana halaman demo akan kelihatan. Untuk menggunakannya, hantar fail audio atau rakaman menggunakan modul Audio Gradio. Kemudian klik butang Jalankan di bahagian bawah aplikasi untuk menjalankan terjemahan. Bergantung pada saiz penghantaran anda, ini boleh mengambil masa kurang daripada satu saat hingga beberapa saat.

Kita boleh melihat kod di bawah:

# -----------------------------
# 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, fail aplikasi pertama sekali memuatkan fail model kita. Ia kemudian menggunakan fungsi pembantu bersama fungsi orkestrasi teras untuk menyalin audio input, menterjemah teks itu ke dalam bahasa Inggeris, dan kemudian menggunakan TTS untuk menukar teks yang diterjemahkan itu menjadi ucapan dalam bahasa Inggeris! Contohnya, semua ini berlaku dalam masa kurang dari satu saat untuk memproses 5 saat audio pada Linux-Console.net Gradient GPU Droplet yang dikuasakan oleh NVIDIA H200.

Pemikiran Penutup

Dalam tutorial ini, kami menunjukkan bahawa kini adalah mungkin untuk melakukan terjemahan ucapan masa nyata dengan model pembelajaran mendalam komponen dalam satu saluran. Penemuan ini mempunyai potensi besar untuk pelbagai kegunaan terjemahan, termasuk dalam perniagaan dan hiburan. Kami teruja untuk melihat teknologi ASR, TTS, dan Terjemahan LM berkembang dengan lebih lanjut supaya kami dapat menambah baik saluran ini lagi. Matlamat seterusnya kami adalah menambah peniruan suara ke dalam proses ini!

Cuba demo ini di Gradient hari ini!

Terima kasih kerana belajar bersama Komuniti Linux-Console.net.