Murra keelebarjääridest Amazon Transcribe, Amazon Translate ja Amazon Polly abil

Kujutage ette, et kirurg võtab videokõnesid patsientidega üle kogu maailma, ilma et oleks vaja inimtõlki. Mis siis, kui äsja asuv idufirma saaks hõlpsasti laiendada oma toodet piiriüleselt uutele geograafilistele turgudele, pakkudes sujuvat, täpset ja mitmekeelset kliendituge ja müüki, ilma et oleks vaja elavat inimtõlki? Mis juhtub teie ettevõttega, kui keel teid enam ei seo?

Tänapäeval on tavapärane pidada virtuaalseid kohtumisi rahvusvaheliste meeskondade ja klientidega, kes räägivad paljusid erinevaid keeli. Olenemata sellest, kas tegemist on sise- või väliskoosolekutega, kaob tähendus sageli keerulistes aruteludes ja võite kokku puutuda keelebarjääriga, mis ei lase teil olla nii tõhus kui võiksite olla.

Sellest postitusest saate teada, kuidas kasutada kolme täielikult hallatud AWS-i teenust (Amazoni transkribeerimine, Amazoni tõlgeja Amazon Polly), et toota peaaegu reaalajas kõne-kõneks tõlkimise lahendus, mis suudab kiiresti tõlkida lähtekõneleja reaalajas häälsisendi kõneldavasse, täpsesse tõlgitud sihtkeelde ja seda kõike ilma masinõppe (ML) kogemuseta.

Ülevaade lahendusest

Meie tõlkija koosneb kolmest täielikult hallatavast AWS ML-teenusest, mis töötavad koos ühes Pythoni skriptis, kasutades AWS SDK Pythoni jaoks (Boto3) meie tekstitõlke ja teksti kõneks muutmise osade jaoks ning asünkroonse voogesituse SDK helisisendi transkriptsiooni jaoks.

Amazon Transcribe: kõne voogesitamine tekstiks

Esimene teenus, mida meie virnas kasutate, on Amazon Transcribe, täielikult hallatav kõne tekstiks muutmise teenus, mis võtab sisendkõne ja transkribeerib selle tekstiks. Amazon Transcribeil on paindlikud neelamismeetodid, pakett- või voogesitus, kuna see aktsepteerib kas salvestatud helifaile või voogesitatud heliandmeid. Selles postituses kasutate asünkroonne Amazon Transcribe voogesituse SDK Pythoni jaoks, mis kasutab reaalajas heli voogesitamiseks ja transkriptsioonide vastuvõtmiseks HTTP/2 voogedastusprotokolli.

Kui me seda prototüüpi esimest korda koostasime, ei toetanud Amazon Transcribe'i voogesituse sisestamine automaatset keeletuvastust, kuid see ei kehti enam alates 2021. aasta novembrist. Nii pakett- kui ka voogesitus toetavad nüüd kõigi jaoks automaatset keeletuvastust. toetatud keeled. Selles postituses näitame, kuidas automaatse keeletuvastuse voogesituse abil on võimalik parameetripõhine lahendus, kuigi mitmekeelse parameetriteta kujundusega. Kui meie transkribeeritud kõnesegment on tekstina tagastatud, saadate Amazon Translate'ile taotluse tõlkida ja tagastada tulemused meie Amazon Transcribe'is. EventHandler meetod.

Amazon Translate: tipptasemel, täielikult hallatud tõlke API

Järgmine meie virnas on Amazon Translate, närvisüsteemi masintõlketeenus, mis pakub kiiret, kvaliteetset, taskukohast ja kohandatavat keeletõlget. Alates 2022. aasta juunist toetab Amazon Translate tõlget 75 keeles ning pidevalt tehakse uusi keelepaare ja täiustusi. Amazon Translate kasutab süvaõppemudeleid, mis on majutatud väga skaleeritavas ja vastupidavas AWS-i pilvarhitektuuris, et kiiresti tarnida täpseid tõlkeid kas reaalajas või pakettidena, olenevalt teie kasutusjuhtumist. Amazon Translate'i kasutamine on lihtne ega nõua aluseks oleva arhitektuuri ega ML-oskuste haldamist. Amazon Translate'il on mitmeid funktsioone, nagu a. loomine ja kasutamine kohandatud terminoloogia valdkonnapõhiste terminite vahelise kaardistamise käsitlemiseks. Lisateavet Amazon Translate'i teenusepiirangute kohta leiate aadressilt Juhised ja piirangud. Pärast seda, kui rakendus on saanud tõlgitud teksti meie sihtkeeles, saadab see tõlgitud teksti Amazon Pollyle, et tõlgitud heli kohe taasesitada.

Amazon Polly: täielikult hallatav tekst kõneks API

Lõpuks saadate tõlgitud teksti Amazon Pollyle, täielikult hallatavale kõneks muutmise teenusele, mis võib saata tagasi elutruud heliklippide vastused koheseks voogesituse taasesitamiseks või pakitud ja salvestatud Amazoni lihtne salvestusteenus (Amazon S3) hilisemaks kasutamiseks. Standardiseeritud funktsioonide abil saate juhtida kõne erinevaid aspekte, nagu hääldus, helitugevus, helikõrgus, kõne kiirus ja palju muud. Kõnesünteesi märgistuskeel (SSML).

Saate sünteesida kõne teatud Amazon Polly jaoks Neuraalsed hääled kasutades Newscasteri stiili, et need kõlaksid nagu tele- või raadiouudiste saates. Samuti saate helivoos sisalduvate metaandmete põhjal tuvastada, millal konkreetseid sõnu või lauseid tekstis räägitakse. See võimaldab arendajal sünteesitud kõnega sünkroonida graafilist esiletõstmist ja animatsioone, näiteks avatari huulte liigutusi.

Saate muuta teatud sõnade hääldust, nagu ettevõtete nimed, akronüümid, võõrsõnad või neologismid, näiteks "P!nk", "ROTFL" või "C'est la vie" (kui seda räägitakse mitte-prantsuse keeles hääl), kasutades kohandatud leksikone.

Arhitektuuri ülevaade

Järgmine diagramm illustreerib meie lahenduse arhitektuuri.

Töövoog on järgmine:

1. Heli neelab Pythoni SDK.
2. Amazon Polly teisendab kõne tekstiks 39 võimalikus keeles.
3. Amazon Translate teisendab keeled.
4. Amazon Live Transcribe teisendab teksti kõneks.
5. Heli väljastatakse kõlaritesse.

Eeldused

Teil on vaja hostmasinat, millel on mikrofon, kõlarid ja usaldusväärne Interneti-ühendus. Kaasaegne sülearvuti peaks selle jaoks hästi toimima, kuna täiendavat riistvara pole vaja. Järgmiseks peate masina mõne tarkvaratööriistaga seadistama.

Asünkroonse Amazon Transcribe'i voogesituse SDK kasutamiseks ja Pythoni mooduli nimega Python 3.7+ kasutamiseks peab teil olema installitud versioon pyaudio, mida kasutate masina mikrofoni ja kõlarite juhtimiseks. See moodul sõltub nimega C teegist portaudio.h. Kui teil tekib probleeme pyaudio vead, soovitame kontrollida oma operatsioonisüsteemi, et näha, kas see on olemas portaudio.h raamatukogu installitud.

Teenusekõnede autoriseerimiseks ja autentimiseks loote AWS-i identiteedi- ja juurdepääsuhaldus (IAM) teenuseroll, millel on õigused helistada vajalikele AWS-teenustele. Konfigureerides AWS-i käsurea liides (AWS CLI) selle IAM-i teenuserolliga saate käitada meie skripti oma masinas ilma võtmeid või paroole sisestamata, kuna AWS-i teegid on kirjutatud kasutama konfigureeritud AWS-i CLI kasutaja mandaate. See on mugav meetod kiireks prototüüpimiseks ja tagab, et meie teenustele helistab volitatud identiteet. Nagu alati, järgige IAM-i kasutaja või rolli loomisel IAM-i poliitikate määramisel minimaalsete privileegide põhimõtet.

Kokkuvõtteks vajate järgmisi eeltingimusi:

• PC-, Mac- või Linux-masin mikrofoni, kõlarite ja Interneti-ühendusega
• . portaudio.h C-teek teie operatsioonisüsteemi jaoks (brew, apt get, wget), mis on vajalik pyaudio töötamiseks
• AWS CLI 2.0 koos õigesti volitatud IAM-i kasutajaga, mis on konfigureeritud, käivitades AWS CLI-s aws configure
• Python 3.7+
• Asünkroonne Amazon Transcribe Python SDK
• Järgmised Pythoni teegid:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Rakenda lahendus

Toetute lähtepunktina suuresti Pythoni jaoks mõeldud asünkroonsele Amazon Transcribe'i voogesituse SDK-le ja kavatsete toetuda sellele konkreetsele SDK-le. Kui olete Pythoni jaoks voogesituse SDK-ga katsetanud, lisate voogesituse mikrofon sisend kasutades pyaudio, tavaliselt kasutatav Pythoni avatud lähtekoodiga teek, mida kasutatakse heliandmete töötlemiseks. Seejärel lisate meie tõlkimise ja kõneks muutmise funktsioonide jaoks Boto3 kõned Amazon Translate'ile ja Amazon Pollyle. Lõpuks edastate tõlgitud kõne uuesti arvuti kõlarite kaudu pyaudio. Pythoni moodul concurrent annab teile võimaluse käivitada blokeerimiskoodi oma asünkroonses lõimes, et taasesitada teie tagastatud Amazon Polly kõnet sujuvalt ja mitteblokeerival viisil.

Impordime kõik vajalikud moodulid, transkribeerime voogesituse klassid ja loome mõned globaalsed moodulid:

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"

Esiteks kasutate pyaudio sisendseadme diskreetimissageduse, seadme indeksi ja kanalite arvu saamiseks tehke järgmist.

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

Kui see ei tööta, saate oma seadmeid läbi vaadata ja printida, nagu on näidatud järgmises koodis, ning seejärel kasutada seadme registrit seadme teabe hankimiseks 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"]

Sa kasutad channel_count, sample_rateja dev_index parameetritena mikrofonivoos. Selle voo tagasihelistamise funktsioonis kasutate asyncio mitteblokeeriv lõimeohutu tagasihelistamine, et paigutada mikrofonivoo sisendbaidid an asyncio sisendjärjekord. Pange tähele tsükli- ja input_queue-objekte, mis on loodud asyncio ja kuidas neid kasutatakse järgmises koodis:

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üüd, kui generaator funktsioon mic_stream() kutsutakse, annab see pidevalt sisendbaite seni, kuni sisendjärjekorras on mikrofoni sisendandmeid.

Nüüd, kui teate, kuidas mikrofonist sisendbaite hankida, vaatame, kuidas kirjutada Amazon Polly väljundhelibaite kõlari väljundvoogu:

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

Nüüd laiendame seda, mida postituses üles ehitasite Asünkroonne Amazoni transkriptsiooni voogesituse SDK Pythoni jaoks. Järgmises koodis loote täitjaobjekti, kasutades ThreadPoolExecutor alamklass kolme töötajaga samaaegselt. Seejärel lisate EventHandleris lõplikule tagastatud transkriptsioonile Amazon Translate'i kutse ja edastate selle tõlgitud teksti, täitjaobjekti ja meie aws_polly_tts() funktsiooni an asyncio silmus koos loop.run_in_executor(), mis käivitab meie Amazon Polly funktsiooni (koos tõlgitud sisendtekstiga) asünkroonselt järgmise iteratsiooni alguses. asyncio silmus

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

Lõpuks on meil olemas loop_me() funktsiooni. Selles määratlete write_chunks(), mis võtab argumendina Amazoni transkriptsioonivoo ja kirjutab sellele asünkroonselt voogesituse mikrofonisisendi tükke. Seejärel kasutate MyEventHandler() mille argumendiks on väljundi transkriptsioonivoog ja looge käitleja objekt. Seejärel kasutate ootamist koos asyncio.gather() ja sisestada write_chunks() ja töötleja hand_events() meetodiga, et käsitleda nende korutiinide võimalikke tulevikku. Lõpuks kogute kokku kõik sündmuste tsüklid ja looge silmus loop_me() funktsiooniga run_until_complete(). Vaadake järgmist koodi:

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

Kui eelnev kood käivitatakse koos vigadeta, saate rääkida mikrofoni ja kuulda kiiresti oma häält mandariini hiina keelde tõlgituna. Amazon Transcribe'i ja Amazon Translate'i automaatne keeletuvastuse funktsioon tõlgib mis tahes toetatud sisestuskeele sihtkeelde. Saate rääkida üsna pikka aega ja funktsioonikutsete mitteblokeeriva olemuse tõttu tõlgitakse ja räägitakse kogu teie kõnesisend, mis teeb sellest suurepärase tööriista otsekõnede tõlkimiseks.

Järeldus

Kuigi see postitus näitas, kuidas need kolm täielikult hallatud AWS-i API-d saavad sujuvalt koos toimida, soovitame teil mõelda, kuidas saaksite neid teenuseid muul viisil kasutada, et pakkuda teenustele või meediale mitmekeelset tuge, näiteks mitmekeelsed subtiitrid murdosa praegusest kulust. . Meditsiin, äri ja isegi diplomaatilised suhted võiksid kasu saada järjest paranevast, odavast ja vähese hooldusega tõlketeenusest.

Selle kasutusjuhtumi kontseptsiooni tõendamise koodibaasi kohta lisateabe saamiseks vaadake meie Github.

Autoritest

Michael Tran on lahenduste arhitekt koos Envisioni insenerimeeskonnaga ettevõttes Amazon Web Services. Ta annab tehnilisi juhiseid ja aitab klientidel kiirendada oma uuendusvõimet, näidates AWS-is võimaluste kunsti. Ta on meie klientide jaoks loonud mitu prototüüpi AI/ML ja asjade Interneti ümber. Võite minuga Twitteris ühendust võtta @Mike_Trann.

Cameron Wilkes on AWS Industry Acceleratori meeskonna prototüüpimise arhitekt. Meeskonnas olles tarnis ta klientidele mitmeid ML-põhiseid prototüüpe, et demonstreerida ML-i võimalikku kunsti AWS-is. Talle meeldib muusika tootmine, maastikusõit ja disain.