Prebijte jezikovne ovire z Amazon Transcribe, Amazon Translate in Amazon Polly

Predstavljajte si kirurga, ki sprejema video klice s pacienti po vsem svetu, ne da bi potreboval človeškega prevajalca. Kaj pa, če bi novoustanovljeno podjetje zlahka razširilo svoj izdelek prek meja in na nove geografske trge s ponudbo tekoče, natančne, večjezične podpore strankam in prodaje, vse brez potrebe po živem prevajalcu? Kaj se zgodi z vašim podjetjem, ko niste več vezani na jezik?

Danes je običajno imeti virtualna srečanja z mednarodnimi ekipami in strankami, ki govorijo veliko različnih jezikov. Ne glede na to, ali gre za interna ali zunanja srečanja, se pomen pogosto izgubi v zapletenih razpravah in lahko naletite na jezikovne ovire, ki vam preprečujejo, da bi bili tako učinkoviti, kot bi lahko bili.

V tej objavi se boste naučili uporabljati tri v celoti upravljane storitve AWS (Amazonski prepis, Amazon prevodin Amazon Polly) za izdelavo rešitve prevajalnika govora v skoraj realnem času, ki lahko hitro prevede glasovni vnos izvornega govorca v živo v govorjen, natančen, preveden ciljni jezik, vse brez izkušenj s strojnim učenjem (ML).

Pregled rešitve

Naš prevajalnik je sestavljen iz treh popolnoma upravljanih storitev AWS ML, ki delujejo skupaj v enem samem skriptu Python z uporabo AWS SDK za Python (Boto3) za naše dele prevajanja besedila in pretvorbe besedila v govor ter asinhroni pretočni SDK za transkripcijo zvočnega vnosa.

Amazon Transcribe: pretakanje govora v besedilo

Prva storitev, ki jo uporabljate v našem naboru, je Amazon Transcribe, popolnoma upravljana storitev govora v besedilo, ki sprejme vneseni govor in ga prepiše v besedilo. Amazon Transcribe ima prilagodljive metode vnosa, paketno ali pretočno, ker sprejema shranjene zvočne datoteke ali pretočne zvočne podatke. V tej objavi uporabljate asinhroni SDK za pretakanje Amazon Transcribe za Python, ki uporablja pretočni protokol HTTP/2 za pretakanje zvoka v živo in prejemanje prepisov v živo.

Ko smo prvič izdelali ta prototip, pretočno zaužitje Amazon Transcribe ni podpiralo samodejnega zaznavanja jezika, vendar to od novembra 2021 ni več tako. Paketno in pretočno zaužitje zdaj podpirata samodejno zaznavanje jezika za vse podprti jeziki. V tem prispevku prikazujemo, kako je možna rešitev, ki temelji na parametrih, čeprav je brezhibna večjezična zasnova brez parametrov z uporabo pretočnega samodejnega zaznavanja jezika. Ko je naš segment prepisanega govora vrnjen kot besedilo, pošljete Amazon Translate zahtevo za prevod in vrne rezultate v naš Amazon Transcribe EventHandler metoda.

Amazon Translate: najsodobnejši, popolnoma upravljan API za prevajanje

Naslednji v našem naboru je Amazon Translate, storitev nevronskega strojnega prevajanja, ki zagotavlja hitro, visokokakovostno, cenovno dostopno in prilagodljivo prevajanje jezikov. Od junija 2022 Amazon Translate podpira prevajanje v 75 jezikov z novimi jezikovnimi pari in stalnimi izboljšavami. Amazon Translate uporablja modele globokega učenja, ki gostujejo v zelo razširljivi in ​​odporni arhitekturi AWS Cloud, za hitro zagotavljanje natančnih prevodov v realnem času ali v paketu, odvisno od vašega primera uporabe. Uporaba Amazon Translate je enostavna in ne zahteva upravljanja osnovne arhitekture ali spretnosti ML. Amazon Translate ima več funkcij, kot je ustvarjanje in uporaba terminologija po meri za preslikavo med izrazi, specifičnimi za panogo. Za več informacij o omejitvah storitve Amazon Translate glejte Smernice in omejitve. Ko aplikacija prejme prevedeno besedilo v naš ciljni jezik, pošlje prevedeno besedilo v Amazon Polly za takojšnje prevedeno predvajanje zvoka.

Amazon Polly: popolnoma upravljan API za pretvorbo besedila v govor

Na koncu prevedeno besedilo pošljete Amazonu Polly, popolnoma upravljani storitvi pretvorbe besedila v govor, ki lahko bodisi pošlje nazaj realistične zvočne odzive za takojšnje pretočno predvajanje bodisi paketno in shrani v Preprosta storitev shranjevanja Amazon (Amazon S3) za poznejšo uporabo. Z uporabo standardiziranih Označevalni jezik za sintezo govora (SSML).

Sintetizirate lahko govor za nekatere Amazon Polly Nevralni glasovi z uporabo sloga Newscaster, da zvenijo kot TV ali radijski voditelj. Na podlagi metapodatkov, vključenih v zvočni tok, lahko zaznate tudi, kdaj so določene besede ali stavki v besedilu izgovorjeni. To omogoča razvijalcu, da sinhronizira grafično poudarjanje in animacije, kot so gibi ustnic avatarja, s sintetiziranim govorom.

Spremenite lahko izgovorjavo določenih besed, kot so imena podjetij, akronimi, tuje besede ali neologizmi, na primer »P!nk«, »ROTFL« ali »C'est la vie« (če jih izgovorite v nefrancoskem jeziku). glas), z uporabo leksikonov po meri.

Pregled arhitekture

Naslednji diagram ponazarja našo arhitekturo rešitev.

Potek dela je naslednji:

1. Zvok zaužije Python SDK.
2. Amazon Polly pretvori govor v besedilo v 39 možnih jezikih.
3. Amazon Translate pretvori jezike.
4. Amazon Live Transcribe pretvori besedilo v govor.
5. Zvok se prenaša v zvočnike.

Predpogoji

Potrebujete gostiteljsko napravo z mikrofonom, zvočniki in zanesljivo internetno povezavo. Sodoben prenosnik bi moral za to dobro delovati, ker dodatna strojna oprema ni potrebna. Nato morate stroj nastaviti z nekaj programskimi orodji.

Za uporabo asinhronega SDK-ja za pretakanje Amazon Transcribe in za modul Python, imenovan pyaudio, ki ga uporabljate za upravljanje mikrofona in zvočnikov naprave. Ta modul je odvisen od knjižnice C, imenovane portaudio.h. Če naletite na težave z pyaudio napake, predlagamo, da preverite svoj operacijski sistem, da vidite, ali imate portaudio.h nameščena knjižnica.

Za avtorizacijo in avtentikacijo servisnih klicev ustvarite AWS upravljanje identitete in dostopa (IAM) storitvena vloga z dovoljenji za klicanje potrebnih storitev AWS. S konfiguracijo Vmesnik ukazne vrstice AWS (AWS CLI) s to vlogo storitve IAM lahko zaženete naš skript na svojem računalniku, ne da bi morali posredovati ključe ali gesla, ker so knjižnice AWS napisane tako, da uporabljajo konfigurirane uporabniške poverilnice AWS CLI. To je priročna metoda za hitro izdelavo prototipov in zagotavlja, da naše storitve kliče pooblaščena identiteta. Kot vedno upoštevajte načelo najmanjših privilegijev pri dodeljevanju pravilnikov IAM, ko ustvarjate uporabnika ali vlogo IAM.

Če povzamem, potrebujete naslednje predpogoje:

• Naprava PC, Mac ali Linux z mikrofonom, zvočniki in internetno povezavo
• O portaudio.h Knjižnica C za vaš OS (brew, apt get, wget), ki je potrebna za delovanje pyaudio
• AWS CLI 2.0 s pravilno pooblaščenim uporabnikom IAM, konfiguriranim z zagonom aws configure v AWS CLI
• Python 3.7+
• Asinhroni Amazon Transcribe Python SDK
• Naslednje knjižnice Python:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Izvedite rešitev

Kot izhodišče se boste močno zanašali na asinhroni pretočni SDK Amazon Transcribe za Python in nadgrajevali boste ta specifični SDK. Ko ste preizkusili pretočni SDK za Python, dodate pretočni mikrofon vnos z uporabo pyaudio, pogosto uporabljena odprtokodna knjižnica Python, ki se uporablja za obdelavo zvočnih podatkov. Nato dodate klice Boto3 v Amazon Translate in Amazon Polly za našo funkcijo prevajanja in pretvorbe besedila v govor. Nazadnje prevedeni govor ponovno predvajate skozi zvočnike računalnika pyaudio. Modul Python concurrent vam omogoča zagon kode za blokiranje v lastni asinhroni niti za predvajanje vašega vrnjenega govora Amazon Polly na brezhiben način brez blokiranja.

Uvozimo vse potrebne module, prepišimo pretočne razrede in ustvarimo nekaj globalov:

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"

Najprej uporabite pyaudio za pridobitev stopnje vzorčenja, indeksa naprave in števila kanalov vhodne naprave:

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

Če to ne deluje, lahko svoje naprave pregledate in natisnete, kot je prikazano v naslednji kodi, nato pa uporabite indeks naprave za pridobitev informacij o napravi z 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"]

Uporabljaš channel_count, sample_ratein dev_index kot parametre v toku mikrofona. V funkciji povratnega klica tega toka uporabite asyncio neblokirni nitno varen povratni klic za vnos vhodnih bajtov toka mikrofona v an asyncio vhodna čakalna vrsta. Upoštevajte objekte zanke in input_queue, ustvarjene s asyncio in kako se uporabljajo v naslednji kodi:

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

Zdaj, ko generator deluje mic_stream() se kliče, nenehno daje vhodne bajte, dokler so v vhodni čakalni vrsti vhodni podatki mikrofona.

Zdaj, ko veste, kako pridobiti vhodne bajte iz mikrofona, si poglejmo, kako zapisati izhodne zvočne bajte Amazon Polly v izhodni tok zvočnika:

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

Zdaj pa razširimo, kaj ste zgradili v objavi Asynchronous Amazon Transcribe Streaming SDK za Python. V naslednji kodi ustvarite izvršilni objekt z uporabo ThreadPoolExecutor podrazred s tremi delavci s sočasnim. Nato dodate klic Amazon Translate končnemu vrnjenemu prepisu v EventHandlerju in posredujete to prevedeno besedilo, objekt izvajalca in naš aws_polly_tts() funkcijo v an asyncio zanka z loop.run_in_executor(), ki izvaja našo funkcijo Amazon Polly (s prevedenim vhodnim besedilom) asinhrono na začetku naslednje ponovitve asyncio zanke.

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

Končno imamo loop_me() funkcijo. V njej definirate write_chunks(), ki vzame tok Amazon Transcribe kot argument in vanj asinhrono zapiše dele pretočnega vnosa mikrofona. Nato uporabite MyEventHandler() z izhodnim tokom transkripcije kot argumentom in ustvarite predmet obravnave. Nato uporabite await z asyncio.gather() in posredujte write_chunks() in obravnavo z metodo handle_events() za obravnavo morebitnih prihodnosti teh korutin. Nazadnje zberete vse zanke dogodkov in izvedete zanko loop_me() funkcija s run_until_complete(). Glej naslednjo kodo:

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

Ko se prejšnja koda izvede skupaj brez napak, lahko govorite v mikrofon in hitro slišite svoj glas, preveden v mandarinsko kitajščino. Funkcija samodejnega zaznavanja jezika za Amazon Transcribe in Amazon Translate prevede vse podprte jezike vnosa v ciljni jezik. Govorite lahko kar nekaj časa in zaradi neblokirne narave funkcijskih klicev je ves vaš govorni vnos preveden in izgovorjen, zaradi česar je to odlično orodje za prevajanje govorov v živo.

zaključek

Čeprav je ta objava pokazala, kako lahko ti trije v celoti upravljani API-ji AWS brezhibno delujejo skupaj, vas spodbujamo, da razmislite o tem, kako bi lahko te storitve uporabili na druge načine za zagotavljanje večjezične podpore za storitve ali medije, kot so večjezični podnapisi, za delček trenutnih stroškov. . Medicina, poslovni in celo diplomatski odnosi bi lahko imeli koristi od vse boljše, poceni prevajalske storitve z nizkimi stroški.

Za več informacij o bazi kode za dokaz koncepta za ta primer uporabe si oglejte naše GitHub.

O avtorjih

Michael Tran je arhitekt rešitev pri ekipi Envision Engineering pri Amazon Web Services. Zagotavlja tehnično vodenje in strankam pomaga pospešiti njihovo sposobnost inovativnosti s prikazovanjem umetnosti mogočega na AWS. Za naše stranke je izdelal več prototipov okoli AI/ML in IoT. Lahko me kontaktirate @Mike_Trann na Twitterju.

Cameron Wilkes je arhitekt prototipov v ekipi AWS Industry Accelerator. Medtem ko je bil v ekipi, je strankam dostavil več prototipov, ki temeljijo na ML, da bi prikazal »umetnost možnega« ML na AWS. Uživa v glasbeni produkciji, terenski vožnji in oblikovanju.