Ultrapasse as barreiras linguísticas com o Amazon Transcribe, Amazon Translate e Amazon Polly

Imagine um cirurgião fazendo videochamadas com pacientes em todo o mundo sem a necessidade de um tradutor humano. E se uma startup nova pudesse facilmente expandir seu produto além-fronteiras e em novos mercados geográficos, oferecendo suporte ao cliente e vendas fluidos, precisos e multilíngues, tudo sem a necessidade de um tradutor humano ao vivo? O que acontece com o seu negócio quando você não está mais preso ao idioma?

Hoje é comum ter reuniões virtuais com equipes e clientes internacionais que falam muitos idiomas diferentes. Sejam reuniões internas ou externas, o significado geralmente se perde em discussões complexas e você pode encontrar barreiras linguísticas que o impedem de ser tão eficaz quanto poderia ser.

Neste post, você aprenderá a usar três serviços totalmente gerenciados da AWS (Amazon Transcribe, Amazon Tradutor e Amazon Polly) para produzir uma solução de tradutor de fala em tempo quase real que pode traduzir rapidamente a entrada de voz ao vivo de um locutor de origem em um idioma de destino falado, preciso e traduzido, tudo com zero experiência de aprendizado de máquina (ML).

Visão geral da solução

Nosso tradutor consiste em três serviços AWS ML totalmente gerenciados trabalhando juntos em um único script Python usando o SDK da AWS para Python (Boto3) para nossa tradução de texto e partes de conversão de texto em fala, e um SDK de streaming assíncrono para transcrição de entrada de áudio.

Amazon Transcribe: streaming de fala para texto

O primeiro serviço que você usa em nossa pilha é o Amazon Transcribe, um serviço de fala para texto totalmente gerenciado que recebe a fala de entrada e a transcreve em texto. O Amazon Transcribe tem métodos de ingestão flexíveis, em lote ou streaming, porque aceita arquivos de áudio armazenados ou dados de áudio em streaming. Neste post, você usa o SDK de streaming assíncrono do Amazon Transcribe para Python, que usa o protocolo de streaming HTTP/2 para transmitir áudio ao vivo e receber transcrições ao vivo.

Quando criamos esse protótipo, a ingestão de streaming do Amazon Transcribe não era compatível com a detecção automática de idioma, mas isso não é mais o caso em novembro de 2021. A ingestão de lote e streaming agora oferece suporte à detecção automática de idioma para todos idiomas suportados. Neste post, mostramos como é possível uma solução baseada em parâmetros, através de um design sem parâmetros multilíngue e sem interrupções, por meio do uso da detecção automática de idioma de streaming. Depois que nosso segmento de fala transcrito é retornado como texto, você envia uma solicitação ao Amazon Translate para traduzir e retornar os resultados em nosso Amazon Transcribe EventHandler método.

Amazon Translate: API de tradução de última geração e totalmente gerenciada

O próximo em nossa pilha é o Amazon Translate, um serviço de tradução automática neural que oferece tradução de idiomas rápida, de alta qualidade, acessível e personalizável. A partir de junho de 2022, o Amazon Translate oferece suporte à tradução em 75 idiomas, com novos pares de idiomas e melhorias sendo feitas constantemente. O Amazon Translate usa modelos de aprendizado profundo hospedados em uma arquitetura de Nuvem AWS altamente escalável e resiliente para fornecer traduções precisas rapidamente em tempo real ou em lote, dependendo do seu caso de uso. O uso do Amazon Translate é simples e não requer gerenciamento de arquitetura subjacente ou habilidades de ML. O Amazon Translate tem vários recursos, como criar e usar um terminologia customizada para lidar com o mapeamento entre termos específicos do setor. Para obter mais informações sobre os limites de serviço do Amazon Translate, consulte Diretrizes e limites. Depois que o aplicativo recebe o texto traduzido em nosso idioma de destino, ele envia o texto traduzido ao Amazon Polly para reprodução imediata do áudio traduzido.

Amazon Polly: API de conversão de texto em voz totalmente gerenciada

Por fim, você envia o texto traduzido para o Amazon Polly, um serviço de conversão de texto em fala totalmente gerenciado que pode enviar de volta respostas de clipe de áudio realistas para reprodução de streaming imediata ou em lote e salvo em Serviço de armazenamento simples da Amazon (Amazon S3) para uso posterior. Você pode controlar vários aspectos da fala, como pronúncia, volume, tom, velocidade de fala e muito mais usando Linguagem de marcação de síntese de fala (SSML).

Você pode sintetizar a fala para determinados Amazon Polly Vozes neurais usando o estilo Newscaster para fazê-los soar como um locutor de TV ou rádio. Você também pode detectar quando palavras ou frases específicas no texto estão sendo faladas com base nos metadados incluídos no fluxo de áudio. Isso permite que o desenvolvedor sincronize destaques gráficos e animações, como os movimentos dos lábios de um avatar, com a fala sintetizada.

Você pode modificar a pronúncia de palavras específicas, como nomes de empresas, acrônimos, palavras estrangeiras ou neologismos, por exemplo, "P!nk", "ROTFL" ou "C'est la vie" (quando falado em um idioma não francês). voz), usando léxicos personalizados.

Visão geral da arquitetura

O diagrama a seguir ilustra nossa arquitetura de solução.

O fluxo de trabalho é o seguinte:

1. O áudio é ingerido pelo SDK do Python.
2. O Amazon Polly converte a fala em texto, em 39 idiomas possíveis.
3. O Amazon Translate converte os idiomas.
4. O Amazon Live Transcribe converte texto em fala.
5. O áudio é enviado para os alto-falantes.

Pré-requisitos

Você precisa de uma máquina host configurada com microfone, alto-falantes e conexão confiável à Internet. Um laptop moderno deve funcionar bem para isso, porque nenhum hardware adicional é necessário. Em seguida, você precisa configurar a máquina com algumas ferramentas de software.

Você deve ter o Python 3.7+ instalado para usar o SDK de streaming assíncrono do Amazon Transcribe e para um módulo Python chamado pyaudio, que você usa para controlar o microfone e os alto-falantes do equipamento. Este módulo depende de uma biblioteca C chamada portaudio.h. Se você encontrar problemas com pyaudio erros, sugerimos verificar seu sistema operacional para ver se você tem o portaudio.h biblioteca instalada.

Para autorização e autenticação de chamadas de serviço, você cria um Gerenciamento de acesso e identidade da AWS (IAM) função de serviço com permissões para chamar os serviços necessários da AWS. Ao configurar o Interface de linha de comando da AWS (AWS CLI) com essa função de serviço do IAM, você pode executar nosso script em sua máquina sem precisar passar chaves ou senhas, pois as bibliotecas da AWS são gravadas para usar as credenciais do usuário da AWS CLI configurada. Este é um método conveniente para prototipagem rápida e garante que nossos serviços sejam chamados por uma identidade autorizada. Como sempre, siga o princípio de privilégio mínimo ao atribuir políticas do IAM ao criar um usuário ou função do IAM.

Para resumir, você precisa dos seguintes pré-requisitos:

• Uma máquina PC, Mac ou Linux com microfone, alto-falantes e conexão com a Internet
• A portaudio.h Biblioteca C para o seu sistema operacional (brew, apt get, wget), que é necessária para que o pyaudio funcione
• AWS CLI 2.0 com usuário do IAM devidamente autorizado configurado executando aws configure na AWS CLI
• Python 3.7 +
• O SDK Python do Amazon Transcribe assíncrono
• As seguintes bibliotecas Python:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementar a solução

Você dependerá muito do SDK de streaming assíncrono do Amazon Transcribe para Python como ponto de partida e criará com base nesse SDK específico. Depois de experimentar o SDK de streaming para Python, você adiciona microfone de transmissão entrada usando pyaudio, uma biblioteca de código aberto Python comumente usada para manipular dados de áudio. Em seguida, você adiciona chamadas Boto3 ao Amazon Translate e Amazon Polly para nossa tradução e funcionalidade de conversão de texto em fala. Finalmente, você transmite a fala traduzida pelos alto-falantes do computador novamente com pyaudio. O módulo Python concurrent oferece a capacidade de executar código de bloqueio em seu próprio thread assíncrono para reproduzir sua fala retornada do Amazon Polly de maneira contínua e sem bloqueio.

Vamos importar todos os nossos módulos necessários, transcrever classes de streaming e instanciar alguns globais:

import boto3
 import asyncio
 import pyaudio
 import concurrent
 from amazon_transcribe.client import TranscribeStreamingClient
 from amazon_transcribe.handlers import TranscriptResultStreamHandler
 from amazon_transcribe.model import TranscriptEvent


 polly = boto3.client('polly', region_name = 'us-west-2')
 translate = boto3.client(service_name='translate', region_name='us-west-2', use_ssl=True)
 pa = pyaudio.PyAudio()

 #for mic stream, 1024 should work fine
 default_frames = 1024

 #current params are set up for English to Mandarin, modify to your liking
 params['source_language'] = "en"
 params['target_language'] = "zh"
 params['lang_code_for_polly'] = "cmn-CN"
 params['voice_id'] = "Zhiyu"
 params['lang_code_for_transcribe'] = "en-US"

Primeiro, você usa pyaudio para obter a taxa de amostragem do dispositivo de entrada, o índice do dispositivo e a contagem de canais:

#try grabbing the default input device and see if we get lucky
 default_indput_device = pa.get_default_input_device_info()

 # verify this is your microphone device 
 print(default_input_device)

 #if correct then set it as your input device and define some globals
 input_device = default_input_device

 input_channel_count = input_device["maxInputChannels"]
 input_sample_rate = input_device["defaultSampleRate"]
 input_dev_index = input_device["index"]

Se isso não estiver funcionando, você também pode percorrer e imprimir seus dispositivos conforme mostrado no código a seguir e, em seguida, usar o índice do dispositivo para recuperar as informações do dispositivo com pyaudio:

print ("Available devices:n")
 for i in range(0, pa.get_device_count()):
     info = pa.get_device_info_by_index(i)
     print (str(info["index"])  + ": t %s n t %s n" % (info["name"], p.get_host_api_info_by_index(info["hostApi"])["name"]))

 # select the correct index from the above returned list of devices, for example zero
 dev_index = 0 
 input_device = pa.get_device_info_by_index(dev_index)

 #set globals for microphone stream
 input_channel_count = input_device["maxInputChannels"]
 input_sample_rate = input_device["defaultSampleRate"]
 input_dev_index = input_device["index"]

Você usa channel_count, sample_rate e dev_index como parâmetros em um fluxo de microfone. Na função de retorno de chamada desse fluxo, você usa um asyncio retorno de chamada thread-safe sem bloqueio para colocar os bytes de entrada do fluxo de microfone em um asyncio fila de entrada. Observe os objetos loop e input_queue criados com asyncio e como eles são usados ​​no código a seguir:

async def mic_stream():
     # This function wraps the raw input stream from the microphone forwarding
     # the blocks to an asyncio.Queue.
     
     loop = asyncio.get_event_loop()
     input_queue = asyncio.Queue()
     
     def callback(indata, frame_count, time_info, status):
         loop.call_soon_threadsafe(input_queue.put_nowait, indata)
         return (indata, pyaudio.paContinue)
         
     # Be sure to use the correct parameters for the audio stream that matches
     # the audio formats described for the source language you'll be using:
     # https://docs.aws.amazon.com/transcribe/latest/dg/streaming.html
     
     print(input_device)
     
     #Open stream
     stream = pa.open(format = pyaudio.paInt16,
                 channels = input_channel_count,
                 rate = int(input_sample_rate),
                 input = True,
                 frames_per_buffer = default_frames,
                 input_device_index = input_dev_index,
                 stream_callback=callback)
     # Initiate the audio stream and asynchronously yield the audio chunks
     # as they become available.
     stream.start_stream()
     print("started stream")
     while True:
         indata = await input_queue.get()
         yield indata

Agora, quando a função geradora mic_stream() é chamado, ele continuamente produz bytes de entrada enquanto houver dados de entrada de microfone na fila de entrada.

Agora que você sabe como obter bytes de entrada do microfone, vamos ver como gravar bytes de áudio de saída do Amazon Polly em um fluxo de saída de alto-falante:

#text will come from MyEventsHandler
 def aws_polly_tts(text):

     response = polly.synthesize_speech(
         Engine = 'standard',
         LanguageCode = params['lang_code_for_polly'],
         Text=text,
         VoiceId = params['voice_id'],
         OutputFormat = "pcm",
     )
     output_bytes = response['AudioStream']
     
     #play to the speakers
     write_to_speaker_stream(output_bytes)
     
 #how to write audio bytes to speakers

 def write_to_speaker_stream(output_bytes):
     """Consumes bytes in chunks to produce the response's output'"""
     print("Streaming started...")
     chunk_len = 1024
     channels = 1
     sample_rate = 16000
     
     if output_bytes:
         polly_stream = pa.open(
                     format = pyaudio.paInt16,
                     channels = channels,
                     rate = sample_rate,
                     output = True,
                     )
         #this is a blocking call - will sort this out with concurrent later
         while True:
             data = output_bytes.read(chunk_len)
             polly_stream.write(data)
             
         #If there's no more data to read, stop streaming
             if not data:
                 output_bytes.close()
                 polly_stream.stop_stream()
                 polly_stream.close()
                 break
         print("Streaming completed.")
     else:
         print("Nothing to stream.")

Agora vamos expandir o que você construiu no post SDK de streaming assíncrono do Amazon Transcribe para Python. No código a seguir, você cria um objeto executor usando o ThreadPoolExecutor subclasse com três trabalhadores com concorrente. Em seguida, você adiciona uma chamada do Amazon Translate na transcrição retornada finalizada no EventHandler e passa esse texto traduzido, o objeto executor e nosso aws_polly_tts() funcionar em um asyncio loop com loop.run_in_executor(), que executa nossa função Amazon Polly (com texto de entrada traduzido) de forma assíncrona no início da próxima iteração do asyncio loop.

#use concurrent package to create an executor object with 3 workers ie threads
 executor = concurrent.futures.ThreadPoolExecutor(max_workers=3)

 class MyEventHandler(TranscriptResultStreamHandler):
     async def handle_transcript_event(self, transcript_event: TranscriptEvent):

         #If the transcription is finalized, send it to translate
 
         results = transcript_event.transcript.results
         if len(results) > 0:
             if len(results[0].alternatives) > 0:
                 transcript = results[0].alternatives[0].transcript
                 print("transcript:", transcript)

                 print(results[0].channel_id)
                 if hasattr(results[0], "is_partial") and results[0].is_partial == False:
                     
                     #translate only 1 channel. the other channel is a duplicate
                     if results[0].channel_id == "ch_0":
                         trans_result = translate.translate_text(
                             Text = transcript,
                             SourceLanguageCode = params['source_language'],
                             TargetLanguageCode = params['target_language']
                         )
                         print("translated text:" + trans_result.get("TranslatedText"))
                         text = trans_result.get("TranslatedText")

                         #we run aws_polly_tts with a non-blocking executor at every loop iteration
                         await loop.run_in_executor(executor, aws_polly_tts, text)  

Finalmente, temos o loop_me() função. Nele você define write_chunks(), que usa um stream do Amazon Transcribe como argumento e grava de forma assíncrona pedaços de entrada de microfone de streaming nele. Você então usa MyEventHandler() com o fluxo de transcrição de saída como seu argumento e crie um objeto manipulador. Então você usa await com asyncio.gather() e passe o write_chunks() e o manipulador com o método handle_events() para lidar com os eventuais futuros dessas corrotinas. Por fim, você reúne todos os loops de eventos e faz um loop no loop_me() funcionar com run_until_complete(). Veja o seguinte código:

async def loop_me():
 # Setup up our client with our chosen AWS region

     client = TranscribeStreamingClient(region="us-west-2")
     stream = await client.start_stream_transcription(
         language_code=params['lang_code_for_transcribe'],
         media_sample_rate_hz=int(device_info["defaultSampleRate"]),
         number_of_channels = 2,
         enable_channel_identification=True,
         media_encoding="pcm",
     )
     recorded_frames = []
     async def write_chunks(stream):
         
         # This connects the raw audio chunks generator coming from the microphone
         # and passes them along to the transcription stream.
         print("getting mic stream")
         async for chunk in mic_stream():
             t.tic()
             recorded_frames.append(chunk)
             await stream.input_stream.send_audio_event(audio_chunk=chunk)
             t.toc("chunks passed to transcribe: ")
         await stream.input_stream.end_stream()

     handler = MyEventHandler(stream.output_stream)
     await asyncio.gather(write_chunks(stream), handler.handle_events())

 #write a proper while loop here
 loop = asyncio.get_event_loop()
 loop.run_until_complete(loop_me())
 loop.close()

Quando o código anterior é executado em conjunto sem erros, você pode falar no microfone e ouvir rapidamente sua voz traduzida para o chinês mandarim. O recurso de detecção automática de idioma do Amazon Transcribe e do Amazon Translate traduz qualquer idioma de entrada compatível para o idioma de destino. Você pode falar por algum tempo e, devido à natureza não bloqueante das chamadas de função, toda a sua entrada de fala é traduzida e falada, tornando-a uma excelente ferramenta para traduzir discursos ao vivo.

Conclusão

Embora esta postagem tenha demonstrado como essas três APIs totalmente gerenciadas da AWS podem funcionar perfeitamente juntas, recomendamos que você pense em como usar esses serviços de outras maneiras para fornecer suporte multilíngue para serviços ou mídia, como legendas multilíngues por uma fração do custo atual . Medicina, negócios e até mesmo relações diplomáticas podem se beneficiar de um serviço de tradução cada vez melhor, de baixo custo e baixa manutenção.

Para obter mais informações sobre a base de código de prova de conceito para este caso de uso, confira nosso Github.

Sobre os autores

Michael Tran é Arquiteto de Soluções com a equipe de Engenharia Envision na Amazon Web Services. Ele fornece orientação técnica e ajuda os clientes a acelerar sua capacidade de inovar mostrando a arte do possível na AWS. Ele construiu vários protótipos em torno de IA/ML e IoT para nossos clientes. Você pode entrar em contato comigo @Mike_Trann no Twitter.

Cameron Wilkes é arquiteto de prototipagem na equipe do AWS Industry Accelerator. Enquanto estava na equipe, ele entregou vários protótipos baseados em ML aos clientes para demonstrar a “Arte do Possível” do ML na AWS. Ele gosta de produção musical, off-road e design.