Bryt igenom språkbarriärer med Amazon Transcribe, Amazon Translate och Amazon Polly

Föreställ dig en kirurg som tar videosamtal med patienter över hela världen utan att behöva en mänsklig översättare. Tänk om en nystartad företag lätt kunde expandera sin produkt över gränser och till nya geografiska marknader genom att erbjuda flytande, korrekt, flerspråkig kundsupport och försäljning, allt utan att behöva en levande mänsklig översättare? Vad händer med ditt företag när du inte längre är bunden av språket?

Det är vanligt idag att ha virtuella möten med internationella team och kunder som talar många olika språk. Oavsett om det är interna eller externa möten, går mening ofta vilse i komplexa diskussioner och du kan stöta på språkbarriärer som hindrar dig från att vara så effektiv som du skulle kunna vara.

I det här inlägget kommer du att lära dig hur du använder tre fullt hanterade AWS-tjänster (Amazon Transcribe, Amazon Translateoch Amazon Polly) för att producera en lösning för tal-till-tal-översättare i nästan realtid som snabbt kan översätta en källtalares direkta röstinmatning till ett talat, korrekt, översatt målspråk, allt med noll upplevelse av maskininlärning (ML).

Översikt över lösningen

Vår översättare består av tre helt hanterade AWS ML-tjänster som arbetar tillsammans i ett enda Python-skript genom att använda AWS SDK för Python (Boto3) för vår textöversättning och text-till-tal-delar, och en asynkron streaming-SDK för transkription av ljudingång.

Amazon Transcribe: Streamar tal till text

Den första tjänsten du använder i vår stack är Amazon Transcribe, en helt hanterad tal-till-text-tjänst som tar inmatat tal och transkriberar det till text. Amazon Transcribe har flexibla intagsmetoder, batch eller streaming, eftersom den accepterar antingen lagrade ljudfiler eller strömmande ljuddata. I det här inlägget använder du asynkron Amazon Transcribe streaming SDK för Python, som använder HTTP/2-strömningsprotokollet för att streama liveljud och ta emot livetranskriptioner.

När vi först byggde den här prototypen, stödde inte Amazon Transcribe-ströminmatning automatisk språkdetektering, men detta är inte längre fallet från och med november 2021. Både batch- och streaminginmatning stöder nu automatisk språkdetektering för alla språk som stöds. I det här inlägget visar vi hur en parameterbaserad lösning genom en sömlös flerspråkig parameterlös design är möjlig genom användning av strömmande automatisk språkdetektering. Efter att vårt transkriberade talsegment har returnerats som text skickar du en begäran till Amazon Translate om att översätta och returnera resultaten i vår Amazon Transcribe EventHandler metod.

Amazon Translate: Toppmodernt, fullt hanterat översättnings-API

Nästa i vår stack är Amazon Translate, en neural maskinöversättningstjänst som levererar snabb, högkvalitativ, prisvärd och anpassningsbar språköversättning. Från och med juni 2022 stöder Amazon Translate översättning över 75 språk, med nya språkpar och förbättringar som görs ständigt. Amazon Translate använder modeller för djupinlärning som är värd för en mycket skalbar och motståndskraftig AWS Cloud-arkitektur för att snabbt leverera korrekta översättningar antingen i realtid eller i grupp, beroende på ditt användningsfall. Att använda Amazon Translate är enkelt och kräver ingen hantering av underliggande arkitektur eller ML-kunskaper. Amazon Translate har flera funktioner, som att skapa och använda en anpassad terminologi att hantera kartläggning mellan branschspecifika termer. För mer information om Amazon Translate-tjänstgränser, se Riktlinjer och gränser. Efter att applikationen har tagit emot den översatta texten på vårt målspråk, skickar den den översatta texten till Amazon Polly för omedelbar översatt ljuduppspelning.

Amazon Polly: Fullständigt hanterad text-till-tal API

Slutligen skickar du den översatta texten till Amazon Polly, en fullt hanterad text-till-tal-tjänst som antingen kan skicka tillbaka verklighetstrogna ljudklippsvar för omedelbar uppspelning av streaming eller batchad och sparad i Amazon enkel lagringstjänst (Amazon S3) för senare användning. Du kan styra olika aspekter av tal som uttal, volym, tonhöjd, talhastighet och mer med hjälp av standardiserade Markeringsspråk för talsyntes (SSML).

Du kan syntetisera tal för vissa Amazon Polly Neurala röster använder stilen Newscaster för att få dem att låta som en nyhetsuppläsare på TV eller radio. Du kan också upptäcka när specifika ord eller meningar i texten läses upp baserat på metadata som ingår i ljudströmmen. Detta gör att utvecklaren kan synkronisera grafisk framhävning och animationer, såsom läpprörelserna hos en avatar, med det syntetiserade talet.

Du kan ändra uttalet för särskilda ord, som företagsnamn, akronymer, främmande ord eller nybildningar, till exempel "P!nk", "ROTFL" eller "C'est la vie" (när det talas på en icke-franska röst), med hjälp av anpassade lexikon.

Arkitekturöversikt

Följande diagram illustrerar vår lösningsarkitektur.

Arbetsflödet är som följer:

1. Ljud tas in av Python SDK.
2. Amazon Polly konverterar talet till text, på 39 möjliga språk.
3. Amazon Translate konverterar språken.
4. Amazon Live Transcribe konverterar text till tal.
5. Ljud matas ut till högtalarna.

Förutsättningar

Du behöver en värddator med mikrofon, högtalare och pålitlig internetanslutning. En modern bärbar dator borde fungera bra för detta eftersom ingen extra hårdvara behövs. Därefter måste du ställa in maskinen med några programvaruverktyg.

Du måste ha Python 3.7+ installerat för att använda den asynkrona Amazon Transcribe-streaming-SDK:n och för en Python-modul som heter pyaudio, som du använder för att styra maskinens mikrofon och högtalare. Denna modul beror på ett C-bibliotek som heter portaudio.h. Om du stöter på problem med pyaudio fel, föreslår vi att du kontrollerar ditt operativsystem för att se om du har portaudio.h biblioteket installerat.

För auktorisering och autentisering av servicesamtal skapar du en AWS identitets- och åtkomsthantering (IAM) tjänstroll med behörighet att anropa nödvändiga AWS-tjänster. Genom att konfigurera AWS-kommandoradsgränssnitt (AWS CLI) med denna IAM-tjänstroll kan du köra vårt skript på din maskin utan att behöva skicka in nycklar eller lösenord, eftersom AWS-biblioteken är skrivna för att använda den konfigurerade AWS CLI-användarens autentiseringsuppgifter. Detta är en bekväm metod för snabb prototypframställning och säkerställer att våra tjänster anropas av en auktoriserad identitet. Som alltid, följ principen om minsta privilegium när du tilldelar IAM-policyer när du skapar en IAM-användare eller roll.

För att sammanfatta behöver du följande förutsättningar:

• En PC, Mac eller Linux-maskin med mikrofon, högtalare och internetanslutning
• Smakämnen portaudio.h C-bibliotek för ditt operativsystem (brew, apt get, wget), som behövs för att pyaudio ska fungera
• AWS CLI 2.0 med korrekt auktoriserad IAM-användare konfigurerad genom att köra aws configure i AWS CLI
• Python 3.7+
• Den asynkrona Amazon Transcribe Python SDK
• Följande Python-bibliotek:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementera lösningen

Du kommer att förlita dig starkt på den asynkrona Amazon Transcribe-streaming-SDK:n för Python som utgångspunkt, och kommer att bygga på den specifika SDK:n. Efter att du har experimenterat med streaming-SDK:n för Python lägger du till strömmande mikrofon input genom att använda pyaudio, ett vanligt Python-bibliotek med öppen källkod som används för att manipulera ljuddata. Sedan lägger du till Boto3-anrop till Amazon Translate och Amazon Polly för vår översättnings- och text-till-tal-funktionalitet. Slutligen strömmar du ut översatt tal genom datorns högtalare igen med pyaudio. Python-modulen concurrent ger dig möjligheten att köra blockeringskod i sin egen asynkrona tråd för att spela upp ditt returnerade Amazon Polly-tal på ett sömlöst, icke-blockerande sätt.

Låt oss importera alla våra nödvändiga moduler, transkribera streamingklasser och instansiera några globala:

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"

Först använder du pyaudio för att erhålla ingångsenhetens samplingsfrekvens, enhetsindex och kanalantal:

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

Om detta inte fungerar kan du också gå igenom och skriva ut dina enheter som visas i följande kod och sedan använda enhetsindexet för att hämta enhetsinformationen med 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"]

Du använder channel_count, sample_rateoch dev_index som parametrar i en mikrofonström. I den streamens callback-funktion använder du en asyncio icke-blockerande trådsäker återuppringning för att lägga in mikrofonströmmens indatabyte i en asyncio ingångskö. Notera loop- och input_queue-objekten som skapats med asyncio och hur de används i följande kod:

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 när generatorn fungerar mic_stream() anropas, ger den kontinuerligt indatabyte så länge det finns mikrofonindata i ingångskön.

Nu när du vet hur man får ingångsbyte från mikrofonen, låt oss titta på hur man skriver Amazon Polly-utgångsljudbytes till en högtalarutgångsström:

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

Låt oss nu utöka vad du byggde i inlägget Asynkron Amazon Transcribe Streaming SDK för Python. I följande kod skapar du ett exekveringsobjekt med hjälp av ThreadPoolExecutor underklass med tre arbetare med samtidiga. Du lägger sedan till ett Amazon Translate-anrop på det slutförda returnerade transkriptet i EventHandler och skickar den översatta texten, executor-objektet och vår aws_polly_tts() fungera till en asyncio slinga med loop.run_in_executor(), som kör vår Amazon Polly-funktion (med översatt inmatningstext) asynkront i början av nästa iteration av asyncio slinga.

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

Slutligen har vi loop_me() fungera. I den definierar du write_chunks(), som tar en Amazon Transcribe-ström som ett argument och asynkront skriver bitar av strömmande mikrofonindata till den. Du använder då MyEventHandler() med utdatatranskriptionsströmmen som argument och skapa ett hanterarobjekt. Då använder du vänta med asyncio.gather() och skicka in write_chunks() och hanteraren med handle_events()-metoden för att hantera de eventuella framtiderna för dessa coroutines. Till sist samlar du alla eventloopar och loopar loop_me() fungera med run_until_complete(). Se följande kod:

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

När föregående kod körs tillsammans utan fel kan du tala in i mikrofonen och snabbt höra din röst översatt till mandarinkinesiska. Den automatiska språkdetekteringsfunktionen för Amazon Transcribe och Amazon Translate översätter alla inmatningsspråk som stöds till målspråket. Du kan tala ganska länge och på grund av funktionsanropens icke-blockerande karaktär översätts och talas all din inmatning, vilket gör detta till ett utmärkt verktyg för att översätta livetal.

Slutsats

Även om det här inlägget visade hur dessa tre fullt hanterade AWS API:er kan fungera sömlöst tillsammans, uppmuntrar vi dig att tänka på hur du kan använda dessa tjänster på andra sätt för att leverera flerspråkigt stöd för tjänster eller media som flerspråkig textning för en bråkdel av den nuvarande kostnaden . Medicin, affärer och till och med diplomatiska förbindelser skulle alla kunna dra nytta av en ständigt förbättrad översättningstjänst till låg kostnad och lågt underhåll.

För mer information om proof of concept-kodbasen för detta användningsfall, kolla in vår Github.

Om författarna

Michael Trans är en lösningsarkitekt med Envision Engineering-teamet på Amazon Web Services. Han ger teknisk vägledning och hjälper kunder att accelerera sin innovationsförmåga genom att visa konsten av det möjliga på AWS. Han har byggt flera prototyper kring AI/ML och IoT för våra kunder. Du kan kontakta mig @Mike_Trann på Twitter.

Cameron Wilkes är en prototyparkitekt på AWS Industry Accelerator-teamet. Medan han var i teamet levererade han flera ML-baserade prototyper till kunder för att demonstrera "Art of the Possible" av ML på AWS. Han tycker om musikproduktion, terrängåkning och design.