Bryd gennem sprogbarrierer med Amazon Transcribe, Amazon Translate og Amazon Polly

Forestil dig en kirurg, der tager videoopkald med patienter over hele kloden uden behov for en menneskelig oversætter. Hvad hvis en nystartet virksomhed nemt kunne udvide deres produkt på tværs af grænser og til nye geografiske markeder ved at tilbyde flydende, præcis, flersproget kundesupport og salg, alt sammen uden behov for en levende menneskelig oversætter? Hvad sker der med din virksomhed, når du ikke længere er bundet af sproget?

Det er almindeligt i dag at have virtuelle møder med internationale teams og kunder, der taler mange forskellige sprog. Uanset om det er interne eller eksterne møder, fortaber mening sig ofte i komplekse diskussioner, og du kan støde på sprogbarrierer, der forhindrer dig i at være så effektiv, som du kunne være.

I dette indlæg lærer du, hvordan du bruger tre fuldt administrerede AWS-tjenester (Amazon Transcrib, Amazon Oversætog Amazon Polly) for at producere en tale-til-tale-oversætterløsning i næsten realtid, der hurtigt kan oversætte en kildetalers levende stemmeinput til et talt, nøjagtigt, oversat målsprog, alt sammen med nul maskinlæring (ML)-oplevelse.

Oversigt over løsning

Vores oversætter består af tre fuldt administrerede AWS ML-tjenester, der arbejder sammen i et enkelt Python-script ved at bruge AWS SDK til Python (Boto3) til vores tekstoversættelse og tekst-til-tale-dele og en asynkron streaming-SDK til transskription af lydinput.

Amazon Transskribering: Streaming af tale til tekst

Den første tjeneste, du bruger i vores stak, er Amazon Transcribe, en fuldt administreret tale-til-tekst-tjeneste, der tager input-tale og transskriberer den til tekst. Amazon Transcribe har fleksible indtagelsesmetoder, batch eller streaming, fordi den accepterer enten lagrede lydfiler eller streaming af lyddata. I dette indlæg bruger du asynkron Amazon Transscribe streaming SDK til Python, som bruger HTTP/2-streamingprotokollen til at streame live lyd og modtage live transskriptioner.

Da vi først byggede denne prototype, understøttede Amazon Transcribe-streamingindtagelse ikke automatisk sprogregistrering, men dette er ikke længere tilfældet fra november 2021. Både batch- og streamingindtagelse understøtter nu automatisk sprogdetektion for alle understøttede sprog. I dette indlæg viser vi, hvordan en parameterbaseret løsning gennem et sømløst flersproget parameterløst design er mulig ved brug af streaming automatisk sprogdetektion. Når vores transskriberede talesegment er returneret som tekst, sender du en anmodning til Amazon Translate om at oversætte og returnere resultaterne i vores Amazon Transscribe EventHandler fremgangsmåde.

Amazon Translate: State-of-the-art, fuldt administreret oversættelses-API

Næste i vores stak er Amazon Translate, en neural maskinoversættelsestjeneste, der leverer hurtig, højkvalitets, overkommelig og tilpasselig sprogoversættelse. Fra juni 2022 understøtter Amazon Translate oversættelse på tværs af 75 sprog, med nye sprogpar og forbedringer, der konstant foretages. Amazon Translate bruger deep learning-modeller, der hostes på en yderst skalerbar og robust AWS Cloud-arkitektur til hurtigt at levere nøjagtige oversættelser enten i realtid eller batch, afhængigt af din brugssituation. Brug af Amazon Translate er ligetil og kræver ingen styring af underliggende arkitektur eller ML-færdigheder. Amazon Translate har flere funktioner, som at oprette og bruge en tilpasset terminologi at håndtere kortlægning mellem branchespecifikke termer. For mere information om Amazon Translate-tjenestegrænser, se Retningslinjer og grænser. Efter at applikationen har modtaget den oversatte tekst på vores målsprog, sender den den oversatte tekst til Amazon Polly til øjeblikkelig oversat lydafspilning.

Amazon Polly: Fuldt administreret tekst-til-tale API

Til sidst sender du den oversatte tekst til Amazon Polly, en fuldt administreret tekst-til-tale-tjeneste, der enten kan sende naturtro lydklip tilbage til øjeblikkelig streaming afspilning eller batched og gemt i Amazon Simple Storage Service (Amazon S3) til senere brug. Du kan kontrollere forskellige aspekter af tale, såsom udtale, lydstyrke, tonehøjde, talehastighed og mere ved at bruge standardiseret Opmærkningssprog for talesyntese (SSML).

Du kan syntetisere tale for visse Amazon Polly Neurale stemmer bruge nyhedsoplæser-stilen til at få dem til at lyde som en tv- eller radio-nyhedsoplæser. Du kan også registrere, hvornår specifikke ord eller sætninger i teksten bliver talt, baseret på de metadata, der er inkluderet i lydstrømmen. Dette gør det muligt for udvikleren at synkronisere grafisk fremhævning og animationer, såsom læbebevægelserne af en avatar, med den syntetiserede tale.

Du kan ændre udtalen af ​​bestemte ord, såsom virksomhedsnavne, akronymer, fremmedord eller neologismer, for eksempel "P!nk", "ROTFL" eller "C'est la vie" (når det tales på et ikke-fransk stemme), ved hjælp af brugerdefinerede leksikon.

Arkitektur oversigt

Følgende diagram illustrerer vores løsningsarkitektur.

Arbejdsgangen er som følger:

1. Lyden indtages af Python SDK.
2. Amazon Polly konverterer talen til tekst på 39 mulige sprog.
3. Amazon Translate konverterer sprogene.
4. Amazon Live Transcribe konverterer tekst til tale.
5. Lyden udsendes til højttalerne.

Forudsætninger

Du har brug for en værtsmaskine opsat med en mikrofon, højttalere og pålidelig internetforbindelse. En moderne bærbar computer burde fungere fint til dette, fordi der ikke er behov for yderligere hardware. Dernæst skal du konfigurere maskinen med nogle softwareværktøjer.

Du skal have Python 3.7+ installeret for at bruge det asynkrone Amazon Transcribe-streaming-SDK og for et Python-modul kaldet pyaudio, som du bruger til at styre maskinens mikrofon og højttalere. Dette modul afhænger af et C-bibliotek kaldet portaudio.h. Hvis du støder på problemer med pyaudio fejl, foreslår vi, at du tjekker dit OS for at se, om du har portaudio.h bibliotek installeret.

Til autorisation og godkendelse af servicekald opretter du en AWS identitets- og adgangsstyring (IAM) servicerolle med tilladelser til at kalde de nødvendige AWS-tjenester. Ved at konfigurere AWS kommandolinjegrænseflade (AWS CLI) med denne IAM-servicerolle kan du køre vores script på din maskine uden at skulle indgive nøgler eller adgangskoder, fordi AWS-bibliotekerne er skrevet til at bruge den konfigurerede AWS CLI-brugers legitimationsoplysninger. Dette er en bekvem metode til hurtig prototyping og sikrer, at vores tjenester bliver kaldt af en autoriseret identitet. Som altid skal du følge princippet om mindste privilegium, når du tildeler IAM-politikker, når du opretter en IAM-bruger eller -rolle.

For at opsummere har du brug for følgende forudsætninger:

• En pc, Mac eller Linux-maskine med mikrofon, højttalere og internetforbindelse
• portaudio.h C-bibliotek til dit OS (brew, apt get, wget), som er nødvendigt for at pyaudio kan fungere
• AWS CLI 2.0 med korrekt autoriseret IAM-bruger konfigureret ved at køre aws configure i AWS CLI
• Python 3.7+
• Den asynkrone Amazon Transcribe Python SDK
• Følgende Python-biblioteker:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementer løsningen

Du vil i høj grad stole på den asynkrone Amazon Transcribe-streaming-SDK til Python som udgangspunkt, og du vil bygge oven på den specifikke SDK. Efter du har eksperimenteret med streaming-SDK'et til Python, tilføjer du streaming mikrofon input ved at bruge pyaudio, et almindeligt brugt Python open source-bibliotek, der bruges til at manipulere lyddata. Derefter tilføjer du Boto3-kald til Amazon Translate og Amazon Polly for vores oversættelses- og tekst-til-tale-funktionalitet. Til sidst streamer du oversat tale ud gennem computerens højttalere igen med pyaudio. Python-modulet concurrent giver dig mulighed for at køre blokeringskode i sin egen asynkrone tråd for at afspille din returnerede Amazon Polly-tale på en sømløs, ikke-blokerende måde.

Lad os importere alle vores nødvendige moduler, transskribere streamingklasser og instansiere nogle globaler:

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 bruger du pyaudio for at få inputenhedens samplinghastighed, enhedsindeks og 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"]

Hvis dette ikke virker, kan du også gå igennem og udskrive dine enheder som vist i følgende kode og derefter bruge enhedsindekset til at hente enhedsoplysningerne 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 bruger channel_count, sample_rateog dev_index som parametre i en mikrofonstrøm. I den streams tilbagekaldsfunktion bruger du en asyncio ikke-blokerende trådsikkert tilbagekald for at sætte input-bytes af mikrofonstrømmen i en asyncio input kø. Bemærk loop- og input_queue-objekterne oprettet med asyncio og hvordan de bruges i følgende kode:

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 generatoren fungerer mic_stream() kaldes, giver det konstant input-bytes, så længe der er mikrofoninputdata i inputkøen.

Nu hvor du ved, hvordan man får input-bytes fra mikrofonen, lad os se på, hvordan man skriver Amazon Polly output-lydbytes til en højttaleroutputstrø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.")

Lad os nu udvide på, hvad du byggede i indlægget Asynkron Amazon Transscribe Streaming SDK til Python. I den følgende kode opretter du et eksekveringsobjekt ved hjælp af ThreadPoolExecutor underklasse med tre arbejdere med samtidige. Du tilføjer derefter et Amazon Translate-kald på det afsluttede returnerede transskript i EventHandler og sender den oversatte tekst, eksekveringsobjektet og vores aws_polly_tts() fungere til en asyncio sløjfe med loop.run_in_executor(), som kører vores Amazon Polly-funktion (med oversat inputtekst) asynkront i starten af ​​næste iteration af 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)  

Endelig har vi loop_me() fungere. I den definerer du write_chunks(), som tager en Amazon Transcribe-stream som et argument og asynkront skriver bidder af streaming-mikrofoninput til den. Så bruger du MyEventHandler() med output-transskriptionsstrømmen som argument og opret et handlerobjekt. Så bruger du afvent med asyncio.gather() og indsend write_chunks() og handler med handle_events()-metoden for at håndtere disse coroutiners fremtidige fremtid. Til sidst samler du alle begivenhedsløkker og sløjfer loop_me() funktion med run_until_complete(). Se følgende kode:

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 den foregående kode køres sammen uden fejl, kan du tale ind i mikrofonen og hurtigt høre din stemme oversat til mandarin-kinesisk. Den automatiske sprogregistreringsfunktion til Amazon Transcribe og Amazon Translate oversætter ethvert understøttet inputsprog til målsproget. Du kan tale i et stykke tid, og på grund af funktionsopkaldenes ikke-blokerende karakter, bliver alle dine taleinput oversat og talt, hvilket gør dette til et glimrende værktøj til at oversætte levende taler.

Konklusion

Selvom dette indlæg demonstrerede, hvordan disse tre fuldt administrerede AWS API'er kan fungere problemfrit sammen, opfordrer vi dig til at tænke over, hvordan du kan bruge disse tjenester på andre måder til at levere flersproget support til tjenester eller medier som flersproget lukket billedtekst til en brøkdel af de nuværende omkostninger . Medicin, forretning og endda diplomatiske forbindelser kunne alle drage fordel af en stadigt forbedret, billig oversættelsestjeneste med lav vedligeholdelse.

For mere information om proof of concept-kodebasen for denne use case, tjek vores Github.

Om forfatterne

Michael Tran er en løsningsarkitekt med Envision Engineering-teamet hos Amazon Web Services. Han giver teknisk vejledning og hjælper kunder med at accelerere deres evne til at innovere ved at vise det muliges kunst på AWS. Han har bygget flere prototyper omkring AI/ML og IoT til vores kunder. Du kan kontakte mig @Mike_Trann på Twitter.

Cameron Wilkes er en Prototyping Architect på AWS Industry Accelerator-teamet. Mens han var på holdet, leverede han adskillige ML-baserede prototyper til kunder for at demonstrere "Art of the Possible" af ML på AWS. Han nyder musikproduktion, off-roading og design.