Bryt gjennom språkbarrierer med Amazon Transcribe, Amazon Translate og Amazon Polly

Se for deg en kirurg som tar videosamtaler med pasienter over hele verden uten behov for en menneskelig oversetter. Hva om en nystartet bedrift enkelt kunne utvide produktet sitt på tvers av landegrenser og inn i nye geografiske markeder ved å tilby flytende, nøyaktig, flerspråklig kundestøtte og salg, alt uten behov for en levende menneskelig oversetter? Hva skjer med virksomheten din når du ikke lenger er bundet av språk?

Det er vanlig i dag å ha virtuelle møter med internasjonale team og kunder som snakker mange forskjellige språk. Enten det er interne eller eksterne møter, går mening ofte seg vill i komplekse diskusjoner, og du kan støte på språkbarrierer som hindrer deg i å være så effektiv som du kunne vært.

I dette innlegget vil du lære hvordan du bruker tre fullt administrerte AWS-tjenester (Amazon Transcribe, Amazon Oversettog Amazon Polly) for å produsere en tale-til-tale-oversetterløsning i nær sanntid som raskt kan oversette en kildetalers direkte stemmeinndata til et muntlig, nøyaktig, oversatt målspråk, alt uten maskinlæring (ML).

Oversikt over løsning

Oversetteren vår består av tre fullt administrerte AWS ML-tjenester som jobber sammen i et enkelt Python-skript ved å bruke AWS SDK for Python (Boto3) for tekstoversettelse og tekst-til-tale-deler, og en asynkron streaming-SDK for transkripsjon av lydinndata.

Amazon Transkribering: Streaming av tale til tekst

Den første tjenesten du bruker i stabelen vår er Amazon Transcribe, en fullt administrert tale-til-tekst-tjeneste som tar inn tale og transkriberer den til tekst. Amazon Transcribe har fleksible inntaksmetoder, batch eller streaming, fordi den aksepterer enten lagrede lydfiler eller streaming av lyddata. I dette innlegget bruker du asynkron Amazon Transcribe streaming SDK for Python, som bruker HTTP/2-strømmeprotokollen for å streame direkte lyd og motta direkte transkripsjoner.

Da vi først bygde denne prototypen, støttet ikke Amazon Transcribe streaming-inntak automatisk språkdeteksjon, men dette er ikke lenger tilfellet fra og med november 2021. Både batch- og streaming-inntak støtter nå automatisk språkdeteksjon for alle støttede språk. I dette innlegget viser vi hvordan en parameterbasert løsning gjennom en sømløs flerspråklig parameterløs design er mulig ved bruk av streaming automatisk språkdeteksjon. Etter at vårt transkriberte talesegment er returnert som tekst, sender du en forespørsel til Amazon Translate om å oversette og returnere resultatene i vår Amazon Transcribe EventHandler metoden.

Amazon Translate: State-of-the-art, fullt administrert oversettelses-API

Neste i stabelen vår er Amazon Translate, en nevral maskinoversettelsestjeneste som leverer rask, høykvalitets, rimelig og tilpassbar språkoversettelse. Fra juni 2022 støtter Amazon Translate oversettelse på tvers av 75 språk, med nye språkpar og forbedringer som gjøres kontinuerlig. Amazon Translate bruker dyplæringsmodeller som er vert for en svært skalerbar og spenstig AWS Cloud-arkitektur for raskt å levere nøyaktige oversettelser enten i sanntid eller batch, avhengig av din brukssituasjon. Å bruke Amazon Translate er enkelt og krever ingen administrasjon av underliggende arkitektur eller ML-ferdigheter. Amazon Translate har flere funksjoner, som å lage og bruke en tilpasset terminologi å håndtere kartlegging mellom bransjespesifikke termer. For mer informasjon om Amazon Translate-tjenestegrenser, se Retningslinjer og grenser. Etter at applikasjonen mottar den oversatte teksten på målspråket vårt, sender den den oversatte teksten til Amazon Polly for umiddelbar oversatt lydavspilling.

Amazon Polly: Fullt administrert tekst-til-tale API

Til slutt sender du den oversatte teksten til Amazon Polly, en fullt administrert tekst-til-tale-tjeneste som enten kan sende tilbake naturtro lydklippsvar for umiddelbar streaming-avspilling eller gruppert og lagret i Amazon enkel lagringstjeneste (Amazon S3) for senere bruk. Du kan kontrollere ulike aspekter av tale som uttale, volum, tonehøyde, talehastighet og mer ved å bruke standardiserte Markup Language for talesyntese (SSML).

Du kan syntetisere tale for visse Amazon Polly Nevrale stemmer bruke Newscaster-stilen for å få dem til å høres ut som en TV- eller radionyhetsoppleser. Du kan også oppdage når spesifikke ord eller setninger i teksten blir sagt basert på metadataene som er inkludert i lydstrømmen. Dette lar utvikleren synkronisere grafisk fremheving og animasjoner, for eksempel leppebevegelsene til en avatar, med den syntetiserte talen.

Du kan endre uttalen av bestemte ord, for eksempel firmanavn, akronymer, fremmedord eller neologismer, for eksempel "P!nk", "ROTFL" eller "C'est la vie" (når det snakkes på en ikke-fransk stemme), ved å bruke tilpassede leksikon.

Arkitekturoversikt

Følgende diagram illustrerer løsningsarkitekturen.

Arbeidsflyten er som følger:

1. Lyd inntas av Python SDK.
2. Amazon Polly konverterer talen til tekst, på 39 mulige språk.
3. Amazon Translate konverterer språkene.
4. Amazon Live Transcribe konverterer tekst til tale.
5. Lyd sendes ut til høyttalere.

Forutsetninger

Du trenger en vertsmaskin satt opp med mikrofon, høyttalere og pålitelig internettforbindelse. En moderne bærbar PC bør fungere bra for dette fordi ingen ekstra maskinvare er nødvendig. Deretter må du sette opp maskinen med noen programvareverktøy.

Du må ha Python 3.7+ installert for å bruke den asynkrone Amazon Transcribe streaming SDK og for en Python-modul kalt pyaudio, som du bruker til å kontrollere maskinens mikrofon og høyttalere. Denne modulen avhenger av et C-bibliotek kalt portaudio.h. Hvis du støter på problemer med pyaudio feil, foreslår vi at du sjekker operativsystemet ditt for å se om du har portaudio.h bibliotek installert.

For autorisasjon og autentisering av serviceanrop oppretter du en AWS identitets- og tilgangsadministrasjon (IAM) tjenesterolle med tillatelser til å ringe de nødvendige AWS-tjenestene. Ved å konfigurere AWS kommandolinjegrensesnitt (AWS CLI) med denne IAM-tjenesterollen kan du kjøre skriptet vårt på maskinen din uten å måtte sende inn nøkler eller passord, fordi AWS-bibliotekene er skrevet for å bruke den konfigurerte AWS CLI-brukerens legitimasjon. Dette er en praktisk metode for rask prototyping og sikrer at tjenestene våre blir oppringt av en autorisert identitet. Som alltid, følg prinsippet om minste privilegium når du tildeler IAM-policyer når du oppretter en IAM-bruker eller -rolle.

For å oppsummere trenger du følgende forutsetninger:

• En PC-, Mac- eller Linux-maskin med mikrofon, høyttalere og internettforbindelse
• De portaudio.h C-bibliotek for operativsystemet ditt (brew, apt get, wget), som er nødvendig for at pyaudio skal fungere
• AWS CLI 2.0 med riktig autorisert IAM-bruker konfigurert ved å kjø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 stole sterkt på den asynkrone Amazon Transcribe streaming-SDK-en for Python som utgangspunkt, og kommer til å bygge på toppen av den spesifikke SDK-en. Etter at du har eksperimentert med streaming-SDK for Python, legger du til streaming mikrofon input ved å bruke pyaudio, et ofte brukt Python åpen kildekode-bibliotek som brukes til å manipulere lyddata. Deretter legger du til Boto3-anrop til Amazon Translate og Amazon Polly for vår oversettelses- og tekst-til-tale-funksjonalitet. Til slutt strømmer du ut oversatt tale gjennom datamaskinens høyttalere igjen med pyaudio. Python-modulen concurrent gir deg muligheten til å kjøre blokkeringskode i sin egen asynkrone tråd for å spille av den returnerte Amazon Polly-talen din på en sømløs, ikke-blokkerende måte.

La oss importere alle nødvendige moduler, transkribere strømmeklasser og instansiere noen 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 bruker du pyaudio for å få inndataenhetens samplingsfrekvens, enhetsindeks og kanalantall:

#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 fungerer, kan du også gå gjennom og skrive ut enhetene dine som vist i følgende kode, og deretter bruke enhetsindeksen til å hente enhetsinformasjonen 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 bruker channel_count, sample_rateog dev_index som parametere i en mikrofonstrøm. I den strømmens tilbakeringingsfunksjon bruker du en asyncio ikke-blokkerende trådsikker tilbakeringing for å sette inngangsbytene til mikrofonstrømmen i en asyncio inndatakø. Legg merke til loop- og input_queue-objektene som er opprettet med asyncio og hvordan de brukes 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

Nå når generatoren fungerer mic_stream() kalles, gir den kontinuerlig input-byte så lenge det er mikrofoninngangsdata i inngangskøen.

Nå som du vet hvordan du får inngangsbyte fra mikrofonen, la oss se på hvordan du skriver Amazon Polly utgangslydbyte til en høyttalerutgangsstrø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.")

La oss nå utvide det du bygde i innlegget Asynkron Amazon Transcribe Streaming SDK for Python. I den følgende koden oppretter du et eksekveringsobjekt ved å bruke ThreadPoolExecutor underklasse med tre arbeidere med samtidig. Du legger deretter til et Amazon Translate-anrop på det ferdigstilte returnerte transkripsjonen i EventHandler og sender den oversatte teksten, eksekveringsobjektet og vår aws_polly_tts() fungere til en asyncio løkke med loop.run_in_executor(), som kjører vår Amazon Polly-funksjon (med oversatt inndatatekst) asynkront ved starten av neste iterasjon av asyncio sløyfe.

#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() funksjon. I den definerer du write_chunks(), som tar en Amazon Transcribe-strøm som et argument og asynkront skriver biter av streaming-mikrofoninndata til den. Da bruker du MyEventHandler() med utgangstranskripsjonsstrømmen som argument og lag et behandlerobjekt. Da bruker du avvente med asyncio.gather() og send inn write_chunks() og behandler med handle_events()-metoden for å håndtere den eventuelle fremtiden til disse koroutinene. Til slutt samler du alle hendelsesløkkene og sløyfer loop_me() funksjon 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 koden kjøres sammen uten feil, kan du snakke inn i mikrofonen og raskt høre stemmen din oversatt til mandarin-kinesisk. Den automatiske språkdeteksjonsfunksjonen for Amazon Transcribe og Amazon Translate oversetter alle støttede inndataspråk til målspråket. Du kan snakke i ganske lang tid, og på grunn av funksjonssamtalenes ikke-blokkerende natur, blir alle dine taleinndata oversatt og talt, noe som gjør dette til et utmerket verktøy for å oversette levende taler.

konklusjonen

Selv om dette innlegget demonstrerte hvordan disse tre fullt administrerte AWS API-ene kan fungere sømløst sammen, oppfordrer vi deg til å tenke på hvordan du kan bruke disse tjenestene på andre måter for å levere flerspråklig støtte for tjenester eller medier som flerspråklig teksting for en brøkdel av dagens kostnad . Medisin, forretninger og til og med diplomatiske forbindelser kan alle dra nytte av en stadig bedre oversettelsestjeneste til lave kostnader og lite vedlikehold.

For mer informasjon om proof of concept-kodebasen for denne brukssaken, sjekk ut vår Github.

Om forfatterne

Michael Tran er en løsningsarkitekt med Envision Engineering-teamet hos Amazon Web Services. Han gir teknisk veiledning og hjelper kunder med å akselerere deres evne til innovasjon gjennom å vise kunsten til det mulige på AWS. Han har bygget flere prototyper rundt AI/ML, og IoT for våre kunder. Du kan kontakte meg @Mike_Trann på Twitter.

Cameron Wilkes er en Prototyping Architect på AWS Industry Accelerator-teamet. Mens han var på teamet leverte han flere ML-baserte prototyper til kunder for å demonstrere «Art of the Possible» til ML på AWS. Han liker musikkproduksjon, off-roading og design.