Pesquisa de site

Pipeline de fala traduzida em tempo real com Whisper e Soprano

Um dos nossos sonhos para a tecnologia de Deep Learning, desde que realmente começou a se popularizar no início dos anos 2020, é a tradução em tempo real da fala. Inspirados por mídias de ficção científica como Star Trek, a promessa da tradução em tempo real da nossa fala sempre foi ao mesmo tempo empolgante e com um potencial de negócios incrível. Só pela questão da eficiência, essas capacidades de tradução têm o potencial de acelerar as interações comerciais ao extremo.

Bem, depois de acompanhar o desenvolvimento dos sistemas de TTS, LM de Tradução e ASR ao longo dos anos, finalmente é possível criar nosso próprio pipeline de tradução de fala em tempo real usando tecnologias de código aberto! Neste tutorial, vamos percorrer nosso pipeline de tradução mais rápido que a fala, criado usando Python. Este tutorial irá mostrar como usar os pipelines Whisper ASR, Hunyuan MT translation LLM e Soprano 80M TTS juntos, e concluir com uma demonstração de um aplicativo Gradio que combina os três modelos em um pipeline de fala traduzida em tempo real e funcional.

Principais Conclusões

  • A tradução de fala em tempo real de ponta a ponta agora é prática com código aberto: combinando o Whisper Large-v3 para ASR, Hunyuan MT para tradução e Soprano 80M para TTS, é possível construir um pipeline mais rápido que a fala que transcreve, traduz e fala o áudio em menos de um segundo para alguns segundos de entrada em GPUs modernas.
  • A eficiência do modelo é tão importante quanto a precisão: o forte ASR multilingue zero-shot 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 prontos para produção podem ser construídos com código mínimo de integração: uma aplicação Python relativamente pequena, envolta em uma interface Gradio, é suficiente para orquestrar ASR → tradução → TTS, demonstrando como a tradução de fala em tempo real se tornou acessível 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 efetivamente em uma ampla variedade de conjuntos de dados, idiomas 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 aprimorado, especialmente para o inglês. Ele oferece melhor tratamento de sotaques, ruído de fundo e terminologia técnica, resultando em 10 a 20% menos erros do que a versão v2, além de oferecer processamento mais rápido em diversas condições de áudio e em uma ampla variedade de idiomas, incluindo africâner, árabe, chinês, francês, alemão, hindi, japonês, espanhol, entre muitos outros (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

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

Para esta demonstração, estamos usando o modelo completo de 7B. Isso se deve em grande parte à potência do NVIDIA H200 com o qual estamos executando o modelo, mas o modelo de 1,8B pode ser facilmente substituído usando o trecho de código abaixo.

Soprano 1.1 80m

Finalmente, temos nosso modelo de TTS. Soprano é um modelo de texto para fala ultra-leve, rodando no dispositivo, desenvolvido para síntese de fala expressiva e de alta fidelidade em velocidade sem precedentes, entregando até 2000× geração em tempo real na GPU e 20× em tempo real na CPU com streaming sem perdas e latência ultra-baixa (<15 ms na GPU, <250 ms na CPU). Sua arquitetura compacta de 80 milhões de parâmetros usa menos de 1 GB de memória, enquanto suporta geração de comprimento infinito através de divisão automática de texto e produz áudio cristalino, altamente expressivo, em 32 kHz.

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

Agora que apresentamos os componentes principais do pipeline, vamos juntá-los. Para facilitar isso, criamos um repositório no Github onde você pode acessar este projeto, disponível aqui. O arquivo ReadMe descreve como usar a demo. Para começar, inicialize seu Droplet GPU usando as instruções descritas neste tutorial. Isso permitirá que você acesse seu Droplet GPU a partir do terminal da sua máquina local e, em seguida, use o recurso simples de navegador do VS Code/Cursor para acessar o aplicativo web demo do Gradio.

Em seguida, cole o seguinte código no terminal do seu Droplet com 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

Isso iniciará o aplicativo web. Por padrão, haverá tanto um link compartilhado quanto um link local.

Aqui está como a página de demonstração vai parecer. Para usá-la, envie um arquivo de áudio ou gravação usando o módulo Audio do Gradio. Em seguida, clique no botão Executar na parte inferior da aplicação para realizar a tradução. Dependendo do tamanho do seu envio, isso pode levar de menos de um segundo a 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 arquivo do aplicativo primeiro carrega nossos arquivos de modelo. Em seguida, ele usa funções auxiliares com uma função de orquestração central para transcrever o áudio de entrada, traduzir esse texto para o inglês e, em seguida, usar TTS para transformar o texto traduzido em fala em inglês! Por exemplo, tudo isso acontece em menos de um segundo para processar 5 segundos de áudio em um Droplet Gradient do Linux-Console.net com GPU NVIDIA H200.

Considerações Finais

Neste tutorial, demonstramos que agora é possível realizar tradução de fala em tempo real com modelos de aprendizado profundo em um pipeline. Esse avanço tem grande potencial para uma infinidade de casos de uso de tradução, incluindo negócios e entretenimento. Estamos ansiosos para ver as tecnologias de ASR, TTS e tradução de LM se desenvolverem ainda mais, para que possamos aprimorar ainda mais este pipeline. 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.