Franchissez les barrières linguistiques avec Amazon Transcribe, Amazon Translate et Amazon Polly

Imaginez un chirurgien prenant des appels vidéo avec des patients du monde entier sans avoir besoin d'un traducteur humain. Et si une start-up naissante pouvait facilement étendre son produit au-delà des frontières et sur de nouveaux marchés géographiques en offrant un support client et des ventes fluides, précis et multilingues, le tout sans avoir besoin d'un traducteur humain en direct ? Qu'arrive-t-il à votre entreprise lorsque vous n'êtes plus limité par la langue ?

Il est courant aujourd'hui d'avoir des réunions virtuelles avec des équipes et des clients internationaux qui parlent de nombreuses langues différentes. Qu'il s'agisse de réunions internes ou externes, le sens se perd souvent dans des discussions complexes et vous pouvez rencontrer des barrières linguistiques qui vous empêchent d'être aussi efficace que possible.

Dans cet article, vous apprendrez à utiliser trois services AWS entièrement gérés (Amazon Transcribe, Amazon Traduireet Amazon Polly) pour produire une solution de traduction parole-parole en temps quasi réel capable de traduire rapidement l'entrée vocale en direct d'un locuteur source dans une langue cible parlée, précise et traduite, le tout sans aucune expérience d'apprentissage automatique (ML).

Présentation de la solution

Notre traducteur se compose de trois services AWS ML entièrement gérés fonctionnant ensemble dans un seul script Python en utilisant le AWS SDK pour Python (Boto3) pour nos parties de traduction de texte et de synthèse vocale, et un SDK de streaming asynchrone pour la transcription de l'entrée audio.

Amazon Transcribe : Diffusion de la parole en texte

Le premier service que vous utilisez dans notre pile est Amazon Transcribe, un service de synthèse vocale entièrement géré qui prend la parole en entrée et la transcrit en texte. Amazon Transcribe propose des méthodes d'ingestion flexibles, par lots ou en streaming, car il accepte soit les fichiers audio stockés, soit les données audio en streaming. Dans cet article, vous utilisez le Amazon Transcribe streaming SDK asynchrone pour Python, qui utilise le protocole de diffusion HTTP/2 pour diffuser de l'audio en direct et recevoir des transcriptions en direct.

Lorsque nous avons construit ce prototype pour la première fois, l'ingestion de streaming Amazon Transcribe ne prenait pas en charge la détection automatique de la langue, mais ce n'est plus le cas depuis novembre 2021. L'ingestion par lots et par streaming prend désormais en charge la détection automatique de la langue pour tous. langues prises en charge. Dans cet article, nous montrons comment une solution basée sur des paramètres via une conception multilingue transparente sans paramètres est possible grâce à l'utilisation de la détection automatique de la langue en streaming. Une fois que notre segment vocal transcrit est renvoyé sous forme de texte, vous envoyez une demande à Amazon Translate pour traduire et renvoyer les résultats dans notre Amazon Transcribe EventHandler méthode.

Amazon Translate : API de traduction de pointe entièrement gérée

Le suivant dans notre pile est Amazon Translate, un service de traduction automatique neuronale qui fournit une traduction linguistique rapide, de haute qualité, abordable et personnalisable. Depuis juin 2022, Amazon Translate prend en charge la traduction dans 75 langues, avec de nouvelles paires de langues et des améliorations constamment apportées. Amazon Translate utilise des modèles d'apprentissage en profondeur hébergés sur une architecture AWS Cloud hautement évolutive et résiliente pour fournir rapidement des traductions précises en temps réel ou par lots, selon votre cas d'utilisation. L'utilisation d'Amazon Translate est simple et ne nécessite aucune gestion de l'architecture sous-jacente ou des compétences ML. Amazon Translate possède plusieurs fonctionnalités, telles que la création et l'utilisation d'un terminologie personnalisée pour gérer le mappage entre les termes spécifiques à l'industrie. Pour plus d'informations sur les limites du service Amazon Translate, consultez Lignes directrices et limites. Une fois que l'application a reçu le texte traduit dans notre langue cible, elle envoie le texte traduit à Amazon Polly pour une lecture audio traduite immédiate.

Amazon Polly : API de synthèse vocale entièrement gérée

Enfin, vous envoyez le texte traduit à Amazon Polly, un service de synthèse vocale entièrement géré qui peut soit renvoyer des réponses de clips audio réalistes pour une lecture en streaming immédiate, soit être regroupées et enregistrées dans Service de stockage simple Amazon (Amazon S3) pour une utilisation ultérieure. Vous pouvez contrôler divers aspects de la parole tels que la prononciation, le volume, la tonalité, le débit de parole, etc., à l'aide de Langage de balisage de synthèse vocale (SSML).

Vous pouvez synthétiser la parole pour certains Amazon Polly Voix neuronales en utilisant le style Newscaster pour les faire ressembler à un présentateur de télévision ou de radio. Vous pouvez également détecter le moment où des mots ou des phrases spécifiques dans le texte sont prononcés en fonction des métadonnées incluses dans le flux audio. Cela permet au développeur de synchroniser la mise en évidence graphique et les animations, telles que les mouvements des lèvres d'un avatar, avec la parole synthétisée.

Vous pouvez modifier la prononciation de mots particuliers, tels que des noms d'entreprise, des acronymes, des mots étrangers ou des néologismes, par exemple « P!nk », « ROTFL » ou « C'est la vie » (lorsqu'ils sont prononcés dans une langue autre que le français). voix), en utilisant des lexiques personnalisés.

Aperçu de l'architecture

Le diagramme suivant illustre notre architecture de solution.

Le flux de travail est le suivant :

1. L'audio est ingéré par le SDK Python.
2. Amazon Polly convertit le discours en texte, dans 39 langues possibles.
3. Amazon Translate convertit les langues.
4. Amazon Live Transcribe convertit le texte en parole.
5. Le son est émis vers les haut-parleurs.

Pré-requis

Vous avez besoin d'une machine hôte configurée avec un microphone, des haut-parleurs et une connexion Internet fiable. Un ordinateur portable moderne devrait fonctionner correctement car aucun matériel supplémentaire n'est nécessaire. Ensuite, vous devez configurer la machine avec certains outils logiciels.

Vous devez avoir Python 3.7+ installé pour utiliser le SDK de streaming Amazon Transcribe asynchrone et pour un module Python appelé pyaudio, que vous utilisez pour contrôler le microphone et les haut-parleurs de l'appareil. Ce module dépend d'une bibliothèque C appelée portaudio.h. Si vous rencontrez des problèmes avec pyaudio erreurs, nous vous suggérons de vérifier votre système d'exploitation pour voir si vous avez le portaudio.h bibliothèque installée.

Pour l'autorisation et l'authentification des appels de service, vous créez un Gestion des identités et des accès AWS (IAM) rôle de service avec des autorisations pour appeler les services AWS nécessaires. En configurant le Interface de ligne de commande AWS (AWS CLI) avec ce rôle de service IAM, vous pouvez exécuter notre script sur votre machine sans avoir à transmettre de clés ou de mots de passe, car les bibliothèques AWS sont écrites pour utiliser les informations d'identification configurées de l'utilisateur de l'AWS CLI. Il s'agit d'une méthode pratique pour le prototypage rapide et garantit que nos services sont appelés par une identité autorisée. Comme toujours, suivez le principe du moindre privilège lors de l'attribution de stratégies IAM lors de la création d'un utilisateur ou d'un rôle IAM.

Pour résumer, vous avez besoin des prérequis suivants :

• Une machine PC, Mac ou Linux avec microphone, haut-parleurs et connexion Internet
• Les portaudio.h Bibliothèque C pour votre système d'exploitation (brew, apt get, wget), nécessaire au fonctionnement de pyaudio
• AWS CLI 2.0 avec un utilisateur IAM correctement autorisé configuré en exécutant aws configure dans l'AWS CLI
• Python 3.7 +
• Le kit SDK Python Amazon Transcribe asynchrone
• Les bibliothèques Python suivantes :
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Mettre en œuvre la solution

Vous comptez beaucoup sur le SDK de streaming asynchrone Amazon Transcribe pour Python comme point de départ et allez vous appuyer sur ce SDK spécifique. Après avoir testé le SDK de streaming pour Python, vous ajoutez microphone en streaming entrée en utilisant pyaudio, une bibliothèque open source Python couramment utilisée pour manipuler des données audio. Ensuite, vous ajoutez les appels Boto3 à Amazon Translate et Amazon Polly pour notre fonctionnalité de traduction et de synthèse vocale. Enfin, vous diffusez à nouveau la parole traduite via les haut-parleurs de l'ordinateur avec pyaudio. Le module Python concurrent vous donne la possibilité d'exécuter du code de blocage dans son propre thread asynchrone pour lire votre discours Amazon Polly retourné de manière transparente et non bloquante.

Importons tous nos modules nécessaires, transcrivons les classes de streaming et instancions quelques globals :

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"

Tout d'abord, vous utilisez pyaudio pour obtenir le taux d'échantillonnage, l'indice de périphérique et le nombre de canaux du périphérique d'entrée :

#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 cela ne fonctionne pas, vous pouvez également parcourir et imprimer vos appareils comme indiqué dans le code suivant, puis utiliser l'index de l'appareil pour récupérer les informations sur l'appareil avec 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"]

Vous visitez la fonctionnalité channel_count, sample_rateet dev_index comme paramètres dans un flux micro. Dans la fonction de rappel de ce flux, vous utilisez un asyncio rappel thread-safe non bloquant pour mettre les octets d'entrée du flux micro dans un asyncio file d'attente d'entrée. Prenez note des objets loop et input_queue créés avec asyncio et comment ils sont utilisés dans le code suivant :

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

Maintenant, lorsque la fonction de générateur mic_stream() est appelé, il produit continuellement des octets d'entrée tant qu'il y a des données d'entrée de microphone dans la file d'attente d'entrée.

Maintenant que vous savez comment obtenir les octets d'entrée du microphone, voyons comment écrire les octets audio de sortie d'Amazon Polly dans un flux de sortie de haut-parleur :

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

Maintenant, développons ce que vous avez construit dans le post Amazon Transcribe Streaming SDK asynchrone pour Python. Dans le code suivant, vous créez un objet exécuteur à l'aide de la ThreadPoolExecutor sous-classe avec trois travailleurs avec simultané. Vous ajoutez ensuite un appel Amazon Translate sur la transcription renvoyée finalisée dans EventHandler et transmettez ce texte traduit, l'objet exécuteur et notre aws_polly_tts() fonctionner dans un asyncio boucle avec loop.run_in_executor(), qui exécute notre fonction Amazon Polly (avec le texte d'entrée traduit) de manière asynchrone au début de la prochaine itération du asyncio boucle.

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

Enfin, nous avons le loop_me() fonction. Vous y définissez write_chunks(), qui prend un flux Amazon Transcribe comme argument et y écrit de manière asynchrone des morceaux d'entrée de micro en streaming. Vous utilisez ensuite MyEventHandler() avec le flux de transcription de sortie comme argument et créez un objet gestionnaire. Ensuite, vous utilisez attendre avec asyncio.gather() et passez le write_chunks () et le gestionnaire avec la méthode handle_events () pour gérer les futurs éventuels de ces coroutines. Enfin, vous rassemblez toutes les boucles d'événements et bouclez le loop_me() fonctionner avec run_until_complete(). Voir le code suivant:

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

Lorsque le code précédent est exécuté sans erreur, vous pouvez parler dans le microphone et entendre rapidement votre voix traduite en chinois mandarin. La fonction de détection automatique de la langue pour Amazon Transcribe et Amazon Translate traduit toute langue d'entrée prise en charge dans la langue cible. Vous pouvez parler pendant un certain temps et en raison de la nature non bloquante des appels de fonction, toutes vos entrées vocales sont traduites et prononcées, ce qui en fait un excellent outil pour traduire des discours en direct.

Conclusion

Bien que cet article ait démontré comment ces trois API AWS entièrement gérées peuvent fonctionner ensemble de manière transparente, nous vous encourageons à réfléchir à la manière dont vous pourriez utiliser ces services d'autres manières pour fournir une prise en charge multilingue pour des services ou des médias tels que le sous-titrage multilingue pour une fraction du coût actuel. . La médecine, les affaires et même les relations diplomatiques pourraient toutes bénéficier d'un service de traduction en constante amélioration, à faible coût et nécessitant peu d'entretien.

Pour plus d'informations sur la base de code de preuve de concept pour ce cas d'utilisation, consultez notre Github.

À propos des auteurs

Michael Tran est un architecte de solutions avec l'équipe Envision Engineering chez Amazon Web Services. Il fournit des conseils techniques et aide les clients à accélérer leur capacité à innover en montrant l'art du possible sur AWS. Il a construit plusieurs prototypes autour de l'IA/ML et de l'IoT pour nos clients. Vous pouvez me contacter @Mike_Trann sur Twitter.

Cameron Wilkes est architecte de prototypage au sein de l'équipe AWS Industry Accelerator. Au sein de l'équipe, il a livré plusieurs prototypes basés sur ML à des clients pour démontrer « l'art du possible » de ML sur AWS. Il aime la production musicale, le tout-terrain et le design.