Pipeline de fala traduzida em tempo real com Whisper e Soprano

Um dos nossos sonhos para a tecnologia de Aprendizagem Profunda, desde que começou a explodir no início dos anos 2020, é a tradução em tempo real da fala. Inspirados por media de ficção científica como Star Trek, a promessa de tradução em tempo real da nossa fala tem sido sempre emocionante e carregada de um incrível potencial de negócio. Só pelo facto de aumentar a eficiência, estas capacidades de tradução têm o potencial de acelerar as interações comerciais ao máximo.

Bem, depois de acompanhar o desenvolvimento dos sistemas de TTS, LM de Tradução e ASR ao longo dos anos, é finalmente possível criar a nossa própria pipeline de tradução de voz em tempo real usando tecnologias open-source! Neste tutorial, vamos percorrer a nossa pipeline de tradução mais rápida do que a fala, criada em Python. Este tutorial irá mostrar como usar em conjunto os pipelines Whisper ASR, Hunyuan MT LLM de tradução e Soprano 80M TTS, e concluirá com uma demonstração de uma aplicação Gradio que combina os três modelos numa pipeline de tradução de voz funcional e em tempo real.

Principais Conclusões

• A tradução de fala em tempo real de ponta a ponta é agora prática com código aberto: ao combinar o Whisper Large-v3 para ASR, o Hunyuan MT para tradução e o Soprano 80M para TTS, é possível criar um pipeline mais rápido do que a fala que transcreve, traduz e reproduz áudio em menos de um segundo para vários segundos de entrada em GPUs modernas.
• A eficiência do modelo é tão importante quanto a precisão: o ASR multilingue zero-shot poderoso do Whisper, a tradução de alta qualidade e escalável do Hunyuan MT (de 1,8B a 7B), e o TTS de latência ultrabaixa do Soprano mostram juntos como modelos eficientes e cuidadosamente escolhidos permitem desempenho em tempo real sem sistemas proprietários.
• Demos prontas para produção podem ser construídas com código mínimo de ligação: Uma aplicação Python relativamente pequena, envolvida numa interface Gradio, é suficiente para orquestrar ASR → tradução → TTS, demonstrando o quão acessível a tradução de voz em tempo real se tornou para desenvolvedores e empresas.

Whisper Large v3

Whisper é um modelo de reconhecimento automático de fala e tradução de fala de última geração, introduzido pela OpenAI no artigo Robust Speech Recognition via Large-Scale Weak Supervision por Alec Radford et al. Treinado com mais de cinco milhões de horas de áudio etiquetado, o Whisper apresenta um desempenho impressionante em zero-shot, generalizando eficazmente através de uma ampla variedade de conjuntos de dados, línguas e domínios do mundo real.

O Whisper Large-v3 suporta mais de 99 idiomas e introduz melhorias direcionadas em relação ao seu antecessor (Whisper Large v2), como um token dedicado ao cantonês e desempenho significativamente melhorado, especialmente para inglês. Oferece melhor tratamento de sotaques, ruído de fundo e terminologia técnica, apresentando 10–20% menos erros em relação à v2, além de proporcionar processamento mais rápido em diversas condições de áudio e numa ampla gama de idiomas, incluindo africâner, árabe, chinês, francês, alemão, hindi, japonês, espanhol e muitos mais (Fonte).

Com o Whisper Large v3 como a base de ASR, podemos captar com precisão a fala de quase qualquer fonte e transcrevê-la com exatidão em texto utilizável para o modelo de Texto-para-Fala.

Hunyuan MT

O Modelo de Tradução Hunyuan versão 1.5 consiste em dois modelos: o HY-MT1.5-1.8B com 1,8 mil milhões de parâmetros e o HY-MT1.5-7B com 7 mil milhões de parâmetros, ambos concebidos para suportar tradução bidirecional em 33 línguas, incorporando cinco variantes étnicas e dialetais. O HY-MT1.5-7B baseia-se no modelo campeão WMT25 da Tencent e está otimizado para tradução explicativa e cenários de línguas mistas, com capacidades adicionais como controlo de terminologia, tradução contextual e saída formatada. Apesar de ter menos de um terço dos parâmetros do modelo de 7B, o HY-MT1.5-1.8B oferece qualidade de tradução comparável com muito maior rapidez e, após quantização, pode ser implementado em dispositivos ponta a ponta para casos de uso de tradução em tempo real, tornando-o altamente versátil e amplamente aplicável.

Para esta demonstração, estamos a usar o modelo completo de 7B. Isto deve-se principalmente ao poder do NVIDIA H200 com o qual estamos a executar o modelo, mas o modelo de 1.8B pode ser facilmente substituído usando o segmento de código abaixo.

Soprano 1.1 80m

Finalmente, temos o nosso modelo de TTS. Soprano é um modelo de síntese de fala ultraleve, executado no dispositivo, desenvolvido para uma síntese de voz expressiva e de alta fidelidade a uma velocidade sem precedentes, oferecendo até 2000× geração em tempo real na GPU e 20× em tempo real na CPU, com transmissão sem perdas e latência ultrabaixa (<15 ms na GPU, <250 ms na CPU). A sua arquitetura compacta de 80 milhões de parâmetros usa menos de 1 GB de memória, suportando geração de comprimento infinito através de divisão automática de texto e produzindo áudio cristalino, altamente expressivo, a 32 kHz.

Demonstração: Tradução de Fala em Tempo Real

Agora que apresentámos os principais componentes do pipeline, vamos juntá-los todos. Para facilitar, criámos um repositório no Github onde poderá aceder a este projeto, disponível aqui. O ficheiro ReadMe explica como utilizar a demonstração. Para começar, inicie o seu Droplet com GPU seguindo as instruções descritas neste tutorial. Isto permitirá que aceda ao seu Droplet com GPU a partir da janela do terminal da sua máquina local e, em seguida, use a funcionalidade de navegador simples do VS Code/Cursor para aceder à aplicação web de demonstração Gradio.

De seguida, cole o seguinte código na janela do terminal do seu Droplet GPU:

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

Isto irá iniciar a aplicação web. Por padrão, haverá tanto um link partilhado como um link local.

Aqui está como ficará a página de demonstração. Para utilizá-la, envie um ficheiro de áudio ou gravação usando o módulo Audio Gradio. Em seguida, clique no botão Executar na parte inferior da aplicação para iniciar a tradução. Dependendo do tamanho do seu envio, isto pode levar desde menos de um segundo até alguns segundos.

Podemos ver o código abaixo:

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

Como podemos ver acima, o ficheiro da aplicação primeiro carrega os nossos ficheiros de modelo. Em seguida, utiliza funções auxiliares com uma função de orquestração central para transcrever o áudio de entrada, traduzir esse texto para inglês e depois usar TTS para transformar o texto traduzido em fala em inglês! Por exemplo, tudo isto acontece em menos de um segundo para funcionar com 5 segundos de áudio num Droplet Gradient da Linux-Console.net, equipado com uma GPU NVIDIA H200.

Considerações Finais

Neste tutorial, demonstrámos que é agora possível realizar tradução de fala em tempo real com modelos de deep learning componentes numa cadeia de processamento. Esta inovação tem um grande potencial para uma infinidade de casos de utilização de tradução, incluindo nos negócios e no entretenimento. Estamos ansiosos por ver as tecnologias de ASR, TTS e tradução de LM desenvolverem-se ainda mais para que possamos melhorar ainda mais esta cadeia de processamento. O nosso próximo objetivo é adicionar clonagem de voz ao processo!

Experimente esta demo do Gradient hoje!

Obrigado por aprender com a comunidade Linux-Console.net.