Rompa las barreras del idioma con Amazon Transcribe, Amazon Translate y Amazon Polly

Imagine un cirujano que realiza videollamadas con pacientes de todo el mundo sin necesidad de un traductor humano. ¿Qué pasaría si una nueva empresa pudiera expandir fácilmente su producto a través de las fronteras y hacia nuevos mercados geográficos al ofrecer soporte al cliente y ventas fluidos, precisos y multilingües, todo sin la necesidad de un traductor humano en vivo? ¿Qué sucede con su negocio cuando ya no está atado por el idioma?

Hoy en día es común tener reuniones virtuales con equipos y clientes internacionales que hablan muchos idiomas diferentes. Ya sean reuniones internas o externas, el significado a menudo se pierde en discusiones complejas y es posible que encuentre barreras idiomáticas que le impidan ser tan efectivo como podría ser.

En esta publicación, aprenderá a utilizar tres servicios de AWS completamente administrados (Amazon Transcribe, Traductor de Amazony Amazon Polly) para producir una solución de traductor de voz a voz casi en tiempo real que puede traducir rápidamente la entrada de voz en vivo de un orador de origen a un idioma de destino traducido, preciso y hablado, todo sin experiencia de aprendizaje automático (ML).

Resumen de la solución

Nuestro traductor consta de tres servicios AWS ML completamente administrados que trabajan juntos en un único script de Python mediante el uso de AWS SDK para Python (Boto3) para nuestra traducción de texto y partes de texto a voz, y un SDK de transmisión asincrónica para la transcripción de entrada de audio.

Amazon Transcribe: transmisión de voz a texto

El primer servicio que usa en nuestra pila es Amazon Transcribe, un servicio de voz a texto completamente administrado que toma el habla de entrada y la transcribe a texto. Amazon Transcribe tiene métodos de ingesta flexibles, por lotes o de transmisión, ya que acepta archivos de audio almacenados o transmisión de datos de audio. En esta publicación, utilizas el SDK de streaming asíncrono de Amazon Transcribe para Python, que utiliza el protocolo de transmisión HTTP/2 para transmitir audio en vivo y recibir transcripciones en vivo.

Cuando construimos este prototipo por primera vez, la ingestión de transmisión de Amazon Transcribe no admitía la detección automática de idioma, pero este ya no es el caso a partir de noviembre de 2021. Tanto la ingestión por lotes como la de transmisión ahora admiten la detección automática de idioma para todos idiomas admitidos. En esta publicación, mostramos cómo es posible una solución basada en parámetros a través de un diseño continuo sin parámetros en varios idiomas mediante el uso de la detección automática de idioma de transmisión. Después de que nuestro segmento de voz transcrito se devuelva como texto, envía una solicitud a Amazon Translate para traducir y devolver los resultados en nuestro Amazon Transcribe EventHandler método.

Amazon Translate: API de traducción totalmente administrada y de última generación

El siguiente en nuestra pila es Amazon Translate, un servicio de traducción automática neuronal que ofrece una traducción de idiomas rápida, de alta calidad, asequible y personalizable. A partir de junio de 2022, Amazon Translate admite la traducción en 75 idiomas, con nuevos pares de idiomas y mejoras constantemente. Amazon Translate utiliza modelos de aprendizaje profundo alojados en una arquitectura en la nube de AWS altamente escalable y resistente para entregar rápidamente traducciones precisas en tiempo real o por lotes, según su caso de uso. El uso de Amazon Translate es sencillo y no requiere la gestión de la arquitectura subyacente ni las habilidades de aprendizaje automático. Amazon Translate tiene varias características, como crear y usar un terminología personalizada para manejar el mapeo entre términos específicos de la industria. Para obtener más información sobre los límites del servicio de Amazon Translate, consulte Directrices y límites. Una vez que la aplicación recibe el texto traducido en nuestro idioma de destino, envía el texto traducido a Amazon Polly para la reproducción inmediata del audio traducido.

Amazon Polly: API de texto a voz completamente administrada

Finalmente, envía el texto traducido a Amazon Polly, un servicio de conversión de texto a voz totalmente administrado que puede enviar respuestas de clips de audio realistas para reproducción de transmisión inmediata o agruparlos y guardarlos en Servicio de almacenamiento simple de Amazon (Amazon S3) para su uso posterior. Puede controlar varios aspectos del habla, como la pronunciación, el volumen, el tono, la velocidad del habla y más usando estandarizados Lenguaje de marcado de síntesis de voz (SSML).

Puede sintetizar el habla para ciertos Amazon Polly voces neuronales usando el estilo Newscaster para que suenen como un presentador de noticias de TV o radio. También puede detectar cuándo se pronuncian palabras u oraciones específicas en el texto según los metadatos incluidos en la transmisión de audio. Esto permite al desarrollador sincronizar el resaltado gráfico y las animaciones, como los movimientos de los labios de un avatar, con el habla sintetizada.

Puede modificar la pronunciación de determinadas palabras, como nombres de empresas, acrónimos, palabras extranjeras o neologismos, por ejemplo, "P!nk", "ROTFL" o "C'est la vie" (cuando se habla en un idioma que no sea francés). voz), utilizando léxicos personalizados.

Descripción de la arquitectura

El siguiente diagrama ilustra la arquitectura de nuestra solución.

El flujo de trabajo es el siguiente:

1. El SDK de Python ingiere el audio.
2. Amazon Polly convierte la voz en texto, en 39 idiomas posibles.
3. Amazon Translate convierte los idiomas.
4. Amazon Live Transcribe convierte texto a voz.
5. El audio se emite a los altavoces.

Requisitos previos

Necesita una máquina host configurada con un micrófono, parlantes y una conexión a Internet confiable. Una computadora portátil moderna debería funcionar bien para esto porque no se necesita hardware adicional. A continuación, debe configurar la máquina con algunas herramientas de software.

Debe tener Python 3.7+ instalado para usar el SDK de transmisión asincrónica de Amazon Transcribe y para un módulo de Python llamado pyaudio, que utiliza para controlar el micrófono y los altavoces de la máquina. Este módulo depende de una biblioteca C llamada portaudio.h. Si encuentra problemas con pyaudio errores, sugerimos verificar su sistema operativo para ver si tiene el portaudio.h biblioteca instalada.

Para la autorización y autenticación de las llamadas de servicio, cree un Gestión de identidades y accesos de AWS (IAM) rol de servicio con permisos para llamar a los servicios de AWS necesarios. Al configurar el Interfaz de línea de comandos de AWS (AWS CLI) con este rol de servicio de IAM, puede ejecutar nuestro script en su máquina sin tener que pasar claves o contraseñas, porque las bibliotecas de AWS están escritas para usar las credenciales de usuario de la AWS CLI configuradas. Este es un método conveniente para la creación rápida de prototipos y garantiza que una identidad autorizada llame a nuestros servicios. Como siempre, siga el principio de privilegio mínimo cuando asigne políticas de IAM al crear un usuario o rol de IAM.

Para resumir, necesita los siguientes requisitos previos:

• Una máquina PC, Mac o Linux con micrófono, parlantes y conexión a Internet
• El portaudio.h Biblioteca C para su sistema operativo (brew, apt get, wget), que se necesita para que pyaudio funcione
• AWS CLI 2.0 con un usuario de IAM debidamente autorizado configurado mediante la ejecución de aws configure en la AWS CLI
• Python 3.7 +
• El SDK asincrónico de Python de Amazon Transcribe
• Las siguientes bibliotecas de Python:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementar la solución

Dependerá en gran medida del SDK de streaming asíncrono de Amazon Transcribe para Python como punto de partida y se basará en ese SDK específico. Después de experimentar con el SDK de streaming para Python, agrega micrófono de transmisión entrada usando pyaudio, una biblioteca de código abierto de Python comúnmente utilizada para manipular datos de audio. Luego, agrega llamadas Boto3 a Amazon Translate y Amazon Polly para nuestra funcionalidad de traducción y texto a voz. Finalmente, transmite el habla traducida a través de los parlantes de la computadora nuevamente con pyaudio. El módulo Python concurrent le brinda la capacidad de ejecutar código de bloqueo en su propio subproceso asíncrono para reproducir su discurso de Amazon Polly devuelto de manera fluida y sin bloqueo.

Importemos todos nuestros módulos necesarios, transcribamos clases de transmisión e instanciamos algunos globales:

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"

Primero, usa pyaudio para obtener la frecuencia de muestreo, el índice del dispositivo y el recuento de canales del dispositivo de entrada:

#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"]

Si esto no funciona, también puede recorrer e imprimir sus dispositivos como se muestra en el siguiente código, y luego usar el índice del dispositivo para recuperar la información del dispositivo con 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"]

Tu usas channel_count, sample_ratey dev_index como parámetros en un flujo de micrófono. En la función de devolución de llamada de esa secuencia, utiliza un asyncio devolución de llamada segura para subprocesos sin bloqueo para poner los bytes de entrada del flujo de micrófono en un asyncio cola de entrada. Tome nota de los objetos loop y input_queue creados con asyncio y cómo se usan en el siguiente código:

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

Ahora cuando la función del generador mic_stream() se llama, continuamente produce bytes de entrada siempre que haya datos de entrada de micrófono en la cola de entrada.

Ahora que sabe cómo obtener bytes de entrada del micrófono, veamos cómo escribir bytes de audio de salida de Amazon Polly en un flujo de salida de altavoz:

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

Ahora ampliemos lo que creaste en la publicación. SDK de streaming asíncrono de Amazon Transcribe para Python. En el siguiente código, crea un objeto ejecutor usando el ThreadPoolExecutor subclase con tres trabajadores concurrentes. Luego agrega una llamada de Amazon Translate en la transcripción devuelta finalizada en EventHandler y pasa ese texto traducido, el objeto ejecutor y nuestro aws_polly_tts() funcionar en un asyncio bucle con loop.run_in_executor(), que ejecuta nuestra función Amazon Polly (con texto de entrada traducido) de forma asincrónica al comienzo de la siguiente iteración del asyncio lazo.

#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, tenemos el loop_me() función. En él, usted define write_chunks(), que toma una transmisión de Amazon Transcribe como argumento y escribe asincrónicamente fragmentos de entrada de micrófono de transmisión en ella. entonces usas MyEventHandler() con el flujo de transcripción de salida como argumento y cree un objeto controlador. Entonces usas await con asyncio.gather() y pase write_chunks() y el controlador con el método handle_events() para manejar el futuro eventual de estas corrutinas. Por último, reúne todos los bucles de eventos y repite el loop_me() funcionar con run_until_complete(). Ver el siguiente 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()

Cuando el código anterior se ejecuta sin errores, puede hablar al micrófono y escuchar rápidamente su voz traducida al chino mandarín. La función de detección automática de idioma para Amazon Transcribe y Amazon Translate traduce cualquier idioma de entrada compatible al idioma de destino. Puede hablar durante bastante tiempo y, debido a la naturaleza sin bloqueo de las llamadas de función, todas sus entradas de voz se traducen y hablan, lo que hace de esta una excelente herramienta para traducir discursos en vivo.

Conclusión

Si bien esta publicación demostró cómo estas tres API de AWS totalmente administradas pueden funcionar juntas sin problemas, lo alentamos a pensar en cómo podría usar estos servicios de otras maneras para brindar soporte multilingüe para servicios o medios como subtítulos multilingües por una fracción del costo actual. . La medicina, los negocios e incluso las relaciones diplomáticas podrían beneficiarse de un servicio de traducción en constante mejora, de bajo costo y bajo mantenimiento.

Para obtener más información sobre la base de código de prueba de concepto para este caso de uso, consulte nuestro Github.

Acerca de los autores

Michael Tran es arquitecto de soluciones del equipo de ingeniería de Envision en Amazon Web Services. Brinda orientación técnica y ayuda a los clientes a acelerar su capacidad de innovar mostrando el arte de lo posible en AWS. Ha creado múltiples prototipos en torno a AI/ML e IoT para nuestros clientes. Puedes contactarme @Mike_Trann en Twitter.

cameron wilkes es arquitecto de creación de prototipos en el equipo de AWS Industry Accelerator. Mientras estuvo en el equipo, entregó varios prototipos basados ​​en ML a los clientes para demostrar el "Arte de lo posible" de ML en AWS. Le gusta la producción musical, los todoterrenos y el diseño.