Doorbreek taalbarrières met Amazon Transcribe, Amazon Translate en Amazon Polly

Stel je een chirurg voor die videogesprekken voert met patiënten over de hele wereld zonder dat er een menselijke vertaler nodig is. Wat als een jonge startup hun product gemakkelijk over de grenzen en naar nieuwe geografische markten zou kunnen uitbreiden door vloeiende, nauwkeurige, meertalige klantenondersteuning en verkoop te bieden, allemaal zonder de noodzaak van een levende menselijke vertaler? Wat gebeurt er met je bedrijf als je niet meer aan taal gebonden bent?

Tegenwoordig is het gebruikelijk om virtuele vergaderingen te houden met internationale teams en klanten die veel verschillende talen spreken. Of het nu interne of externe vergaderingen zijn, betekenis gaat vaak verloren in complexe discussies en u kunt tegen taalbarrières aanlopen waardoor u niet zo effectief bent als u zou kunnen zijn.

In dit bericht leert u hoe u drie volledig beheerde AWS-services kunt gebruiken (Amazon Transcribe, Amazon Vertalen en Amazon Polly) om een ​​bijna-realtime spraak-naar-spraak-vertaleroplossing te produceren die de live spraakinvoer van een bronspreker snel kan vertalen in een gesproken, nauwkeurige, vertaalde doeltaal, allemaal zonder ervaring met machine learning (ML).

Overzicht van de oplossing

Onze vertaler bestaat uit drie volledig beheerde AWS ML-services die samenwerken in een enkel Python-script met behulp van de AWS SDK voor Python (Boto3) voor onze tekstvertaling en tekst-naar-spraakgedeelten, en een asynchrone streaming SDK voor transcriptie van audio-invoer.

Amazon Transcribe: spraak naar tekst streamen

De eerste service die u in onze stapel gebruikt, is Amazon Transcribe, een volledig beheerde spraak-naar-tekstservice die spraakinvoer opneemt en deze naar tekst transcribeert. Amazon Transcribe heeft flexibele opnamemethoden, batch of streaming, omdat het zowel opgeslagen audiobestanden als streaming audiogegevens accepteert. In dit bericht gebruik je de asynchrone Amazon Transcribe streaming SDK voor Python, dat het HTTP/2-streamingprotocol gebruikt om live audio te streamen en live transcripties te ontvangen.

Toen we dit prototype voor het eerst bouwden, ondersteunde Amazon Transcribe-streamingopname geen automatische taaldetectie, maar dit is niet langer het geval vanaf november 2021. Zowel batch- als streamingopname ondersteunen nu automatische taaldetectie voor iedereen ondersteunde talen. In dit bericht laten we zien hoe een op parameters gebaseerde oplossing, hoewel een naadloos, meertalig, parameterloos ontwerp mogelijk is door het gebruik van automatische taaldetectie voor streaming. Nadat ons getranscribeerde spraaksegment als tekst is geretourneerd, stuurt u een verzoek naar Amazon Translate om de resultaten te vertalen en terug te sturen in onze Amazon Transcribe EventHandler methode.

Amazon Translate: ultramoderne, volledig beheerde vertaal-API

De volgende in onze stapel is Amazon Translate, een neurale machinevertaalservice die snelle, hoogwaardige, betaalbare en aanpasbare taalvertaling levert. Vanaf juni 2022 ondersteunt Amazon Translate vertalingen in 75 talen, waarbij voortdurend nieuwe taalparen en verbeteringen worden aangebracht. Amazon Translate maakt gebruik van deep learning-modellen die worden gehost op een zeer schaalbare en veerkrachtige AWS Cloud-architectuur om snel nauwkeurige vertalingen te leveren, in realtime of batchgewijs, afhankelijk van uw gebruik. Het gebruik van Amazon Translate is eenvoudig en vereist geen beheer van onderliggende architectuur of ML-vaardigheden. Amazon Translate heeft verschillende functies, zoals het maken en gebruiken van een aangepaste terminologie om mapping tussen branchespecifieke termen af ​​te handelen. Raadpleeg voor meer informatie over de servicelimieten van Amazon Translate: Richtlijnen en limieten. Nadat de applicatie de vertaalde tekst in onze doeltaal heeft ontvangen, stuurt deze de vertaalde tekst naar Amazon Polly voor onmiddellijke vertaalde audioweergave.

Amazon Polly: volledig beheerde tekst-naar-spraak-API

Ten slotte stuurt u de vertaalde tekst naar Amazon Polly, een volledig beheerde tekst-naar-spraakservice die levensechte audioclipreacties kan terugsturen voor onmiddellijke streaming of gegroepeerd en opgeslagen in Amazon eenvoudige opslagservice (Amazon S3) voor later gebruik. U kunt verschillende aspecten van spraak regelen, zoals uitspraak, volume, toonhoogte, spreeksnelheid en meer met behulp van gestandaardiseerde Spraaksynthese Opmaaktaal (SSML).

U kunt spraak synthetiseren voor bepaalde Amazon Polly Neurale stemmen de Newscaster-stijl gebruiken om ze te laten klinken als een nieuwslezer op tv of radio. U kunt ook detecteren wanneer specifieke woorden of zinnen in de tekst worden uitgesproken op basis van de metadata die in de audiostream zijn opgenomen. Hierdoor kan de ontwikkelaar grafische markeringen en animaties, zoals de lipbewegingen van een avatar, synchroniseren met de gesynthetiseerde spraak.

U kunt de uitspraak van bepaalde woorden wijzigen, zoals bedrijfsnamen, acroniemen, vreemde woorden of neologismen, bijvoorbeeld "P!nk", "ROTFL" of "C'est la vie" (wanneer gesproken in een niet-Frans voice), met behulp van aangepaste lexicons.

Architectuur overzicht

Het volgende diagram illustreert onze oplossingsarchitectuur.

De werkstroom is als volgt:

1. Audio wordt opgenomen door de Python SDK.
2. Amazon Polly zet de spraak om in tekst, in 39 mogelijke talen.
3. Amazon Translate converteert de talen.
4. Amazon Live Transcribe converteert tekst naar spraak.
5. Audio wordt uitgevoerd naar luidsprekers.

Voorwaarden

U hebt een hostmachine nodig met een microfoon, luidsprekers en een betrouwbare internetverbinding. Een moderne laptop zou hiervoor prima moeten werken omdat er geen extra hardware nodig is. Vervolgens moet u de machine instellen met enkele softwaretools.

U moet Python 3.7+ hebben geïnstalleerd om de asynchrone Amazon Transcribe streaming SDK te gebruiken en voor een Python-module genaamd pyaudio, waarmee u de microfoon en luidsprekers van het apparaat bedient. Deze module is afhankelijk van een C-bibliotheek genaamd portaudio.h. Als u problemen ondervindt met: pyaudio fouten, raden we u aan uw besturingssysteem te controleren om te zien of u de portaudio.h bibliotheek geïnstalleerd.

Voor autorisatie en authenticatie van serviceoproepen maakt u een AWS Identiteits- en toegangsbeheer (IAM)-servicerol met machtigingen om de benodigde AWS-services aan te roepen. Door het configureren van de AWS-opdrachtregelinterface (AWS CLI) met deze IAM-servicerol kunt u ons script op uw computer uitvoeren zonder dat u sleutels of wachtwoorden hoeft in te voeren, omdat de AWS-bibliotheken zijn geschreven om de geconfigureerde AWS CLI-gebruikersreferenties te gebruiken. Dit is een handige methode voor rapid prototyping en zorgt ervoor dat onze services worden aangeroepen door een geautoriseerde identiteit. Volg zoals altijd het principe van de minste bevoegdheden bij het toewijzen van IAM-beleid bij het maken van een IAM-gebruiker of -rol.

Om samen te vatten, heb je de volgende voorwaarden nodig:

• Een pc, Mac of Linux-machine met microfoon, luidsprekers en internetverbinding
• De portaudio.h C-bibliotheek voor uw besturingssysteem (brew, apt get, wget), die nodig is om pyaudio te laten werken
• AWS CLI 2.0 met correct geautoriseerde IAM-gebruiker geconfigureerd door aws configure uit te voeren in de AWS CLI
• Python 3.7 +
• De asynchrone Amazon Transcribe Python SDK
• De volgende Python-bibliotheken:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementeer de oplossing

Je zult sterk afhankelijk zijn van de asynchrone Amazon Transcribe streaming SDK voor Python als uitgangspunt, en je gaat bovenop die specifieke SDK bouwen. Nadat je hebt geëxperimenteerd met de streaming-SDK voor Python, voeg je streaming microfoon invoer met behulp van pyaudio, een veelgebruikte open-sourcebibliotheek van Python die wordt gebruikt voor het manipuleren van audiogegevens. Vervolgens voeg je Boto3-oproepen toe aan Amazon Translate en Amazon Polly voor onze vertaling en tekst-naar-spraakfunctionaliteit. Ten slotte streamt u vertaalde spraak weer via de luidsprekers van de computer met pyaudio. De Python-module concurrent geeft je de mogelijkheid om blokkeercode in zijn eigen asynchrone thread uit te voeren om je geretourneerde Amazon Polly-spraak op een naadloze, niet-blokkerende manier af te spelen.

Laten we al onze benodigde modules importeren, streamingklassen transcriberen en enkele globalen instantiëren:

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"

Eerst gebruik je pyaudio om de bemonsteringsfrequentie, de apparaatindex en het aantal kanalen van het invoerapparaat te verkrijgen:

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

Als dit niet werkt, kunt u ook uw apparaten doorlopen en afdrukken zoals weergegeven in de volgende code, en vervolgens de apparaatindex gebruiken om de apparaatinformatie op te halen met 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"]

Je gebruikt channel_count, sample_rate en dev_index als parameters in een microfoonstream. In de callback-functie van die stream gebruik je een asyncio niet-blokkerende thread-safe callback om de invoerbytes van de microfoonstroom in een asyncio invoer wachtrij. Let op de lus- en input_queue-objecten die zijn gemaakt met asyncio en hoe ze worden gebruikt in de volgende code:

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

Nu wanneer de generatorfunctie mic_stream() wordt aangeroepen, levert het continu invoerbytes op zolang er microfooninvoergegevens in de invoerwachtrij staan.

Nu u weet hoe u invoerbytes van de microfoon kunt krijgen, laten we eens kijken hoe u Amazon Polly-uitvoeraudiobytes naar een luidsprekeruitvoerstroom schrijft:

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

Laten we nu verder gaan met wat je in de post hebt gebouwd Asynchrone Amazon Transcribe Streaming SDK voor Python. In de volgende code maakt u een executor-object met behulp van de ThreadPoolExecutor subklasse met drie arbeiders met concurrent. Vervolgens voegt u een Amazon Translate-aanroep toe aan het voltooide geretourneerde transcript in de EventHandler en geeft u die vertaalde tekst, het uitvoerder-object en onze aws_polly_tts() functioneren in een asyncio loop met loop.run_in_executor(), die onze Amazon Polly-functie (met vertaalde invoertekst) asynchroon uitvoert aan het begin van de volgende iteratie van de asyncio lus.

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

Eindelijk hebben we de loop_me() functie. Daarin definieer je write_chunks(), die een Amazon Transcribe-stream als argument neemt en er asynchroon stukjes streaming microfooninvoer naar schrijft. Je gebruikt dan MyEventHandler() met de uitvoertranscriptiestroom als argument en maak een handlerobject. Dan gebruik je wait with asyncio.gather() en geef de write_chunks() en handler door met de handle_events() methode om de uiteindelijke toekomst van deze coroutines af te handelen. Ten slotte verzamel je alle gebeurtenislussen en loop je de loop_me() functie met run_until_complete(). Zie de volgende code:

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

Wanneer de voorgaande code zonder fouten wordt uitgevoerd, kunt u in de microfoon spreken en snel uw stem horen die is vertaald naar het Mandarijn-Chinees. De automatische taaldetectiefunctie voor Amazon Transcribe en Amazon Translate vertaalt elke ondersteunde invoertaal in de doeltaal. U kunt geruime tijd spreken en vanwege het niet-blokkerende karakter van de functieaanroepen, wordt al uw spraakinvoer vertaald en uitgesproken, waardoor dit een uitstekend hulpmiddel is voor het vertalen van live toespraken.

Conclusie

Hoewel dit bericht laat zien hoe deze drie volledig beheerde AWS-API's naadloos kunnen samenwerken, raden we u aan na te denken over hoe u deze services op andere manieren kunt gebruiken om meertalige ondersteuning te bieden voor services of media zoals meertalige ondertiteling voor een fractie van de huidige kosten . Geneeskunde, zaken en zelfs diplomatieke betrekkingen kunnen allemaal profiteren van een steeds betere, goedkope en onderhoudsarme vertaaldienst.

Voor meer informatie over de proof of concept-codebasis voor deze use case, bekijk onze GitHub.

Over de auteurs

Michael Tran is een Solutions Architect bij het Envision Engineering-team bij Amazon Web Services. Hij geeft technische begeleiding en helpt klanten hun innovatievermogen te versnellen door de kunst van het mogelijke te laten zien op AWS. Hij heeft voor onze klanten meerdere prototypes gebouwd rond AI/ML en IoT. U kunt contact met mij opnemen @Mike_Trann op Twitter.

Cameron Wilkes is een Prototyping Architect in het AWS Industry Accelerator-team. In het team leverde hij verschillende op ML gebaseerde prototypen aan klanten om de "kunst van het mogelijke" van ML op AWS te demonstreren. Hij houdt van muziekproductie, off-road rijden en design.