Törje át a nyelvi korlátokat az Amazon Transcribe, az Amazon Translate és az Amazon Polly segítségével

Képzeljen el egy sebészt, aki emberi fordító nélkül folytat videohívásokat betegekkel szerte a világon. Mi lenne, ha egy újonnan induló startup könnyen kiterjeszthetné termékét a határokon átívelőre és új földrajzi piacokra azáltal, hogy rugalmas, pontos, többnyelvű ügyfélszolgálatot és értékesítést kínál, mindezt élő emberi fordító nélkül? Mi történik a vállalkozásával, ha már nem köti a nyelv?

Manapság gyakoriak a virtuális találkozók olyan nemzetközi csapatokkal és ügyfelekkel, akik sok különböző nyelven beszélnek. Legyen szó belső vagy külső megbeszélésekről, a jelentés gyakran elveszik az összetett megbeszélések során, és olyan nyelvi akadályokba ütközhet, amelyek megakadályozzák, hogy a lehető leghatékonyabb legyen.

Ebben a bejegyzésben megtudhatja, hogyan használhat három teljesen felügyelt AWS-szolgáltatást (Amazon átirat, Amazon Translateés Amazon Polly), hogy olyan közel valós idejű beszéd-beszéd fordító megoldást készítsünk, amely gyorsan le tudja fordítani a forrásbeszélő élő hangját egy beszélt, pontos, lefordított célnyelvre, mindezt nulla gépi tanulási (ML) tapasztalattal.

A megoldás áttekintése

Fordítónk három teljesen felügyelt AWS ML szolgáltatásból áll, amelyek egyetlen Python-szkriptben működnek együtt a AWS SDK Pythonhoz (Boto3) szövegfordítási és szövegfelolvasó részeinkhez, valamint egy aszinkron streaming SDK-hoz a hangbemeneti átíráshoz.

Amazon Transcribe: Beszéd streamelése szöveggé

Az első szolgáltatás, amelyet a veremünkben használ, az Amazon Transcribe, egy teljesen felügyelt beszéd-szöveg szolgáltatás, amely átveszi a bemeneti beszédet és átírja azt szöveggé. Az Amazon Transcribe rugalmas feldolgozási módszerekkel rendelkezik, kötegelt vagy streaming, mert vagy tárolt hangfájlokat, vagy streamelt hangadatokat fogad el. Ebben a bejegyzésben a aszinkron Amazon Transcribe streaming SDK Pythonhoz, amely a HTTP/2 streaming protokollt használja élő hang streamelésére és élő átiratok fogadására.

Amikor először megépítettük ezt a prototípust, az Amazon Transcribe adatfolyam-feldolgozás nem támogatta az automatikus nyelvészlelést, de 2021 novemberétől ez már nem így van. A kötegelt és az adatfolyam-feldolgozás is támogatja az automatikus nyelvészlelést mindenki számára. támogatott nyelvek. Ebben a bejegyzésben bemutatjuk, hogyan lehetséges egy paraméter-alapú megoldás a zökkenőmentes, többnyelvű, paraméter nélküli tervezésen keresztül a streaming automatikus nyelvészlelés használatával. Miután az átírt beszédszegmensünket szövegként visszaküldjük, kérést küld az Amazon Translate-nek, hogy fordítsa le, és küldje vissza az eredményeket az Amazon Transcribe-unkban. EventHandler módszer.

Amazon Translate: Korszerű, teljesen felügyelt fordítási API

Következő az Amazon Translate, egy neurális gépi fordítási szolgáltatás, amely gyors, kiváló minőségű, megfizethető és testreszabható nyelvi fordítást biztosít. 2022 júniusától az Amazon Translate 75 nyelven támogatja a fordítást, folyamatosan új nyelvpárokkal és fejlesztésekkel. Az Amazon Translate mély tanulási modelleket használ, amelyek egy nagymértékben méretezhető és rugalmas AWS Cloud architektúrán vannak tárolva, hogy gyorsan pontos fordításokat készítsen akár valós időben, akár kötegelt formában, az Ön használati esetétől függően. Az Amazon Translate használata egyszerű, és nem igényli a mögöttes architektúra vagy az ML-készségek kezelését. Az Amazon Translate számos funkcióval rendelkezik, például létrehozása és használata a egyéni terminológia az iparág-specifikus kifejezések közötti leképezés kezelésére. Az Amazon Translate szolgáltatási korlátokkal kapcsolatos további információkért lásd: Irányelvek és korlátok. Miután az alkalmazás megkapta a lefordított szöveget a célnyelvünkön, elküldi a lefordított szöveget az Amazon Polly-nak azonnali lefordított hanglejátszás céljából.

Amazon Polly: Teljesen felügyelt szövegfelolvasó API

Végül elküldi a lefordított szöveget az Amazon Polly-nak, egy teljesen felügyelt szövegfelolvasó szolgáltatásnak, amely élethű hangklip válaszokat küldhet vissza azonnali streaming lejátszáshoz, vagy kötegelt és menthető. Amazon egyszerű tárolási szolgáltatás (Amazon S3) későbbi használatra. Szabványosított módon szabályozhatja a beszéd különböző aspektusait, például a kiejtést, a hangerőt, a hangmagasságot, a beszédsebességet és még sok mást. Beszédszintézis jelölőnyelv (SSML).

Beszédet szintetizálhat bizonyos Amazon Polly számára Neurális hangok a Newscaster stílus használatával, hogy úgy szóljanak, mint egy tévé- vagy rádióhíradó. A hangfolyamban található metaadatok alapján azt is észlelheti, hogy a szöveg bizonyos szavai vagy mondatai hangzanak el. Ez lehetővé teszi a fejlesztő számára, hogy a szintetizált beszéddel szinkronizálja a grafikus kiemeléseket és animációkat, például egy avatar ajakmozgását.

Módosíthatja bizonyos szavak kiejtését, például cégneveket, betűszavakat, idegen szavakat vagy neologizmusokat, például „P!nk”, „ROTFL” vagy „C'est la vie” (ha nem franciául beszélünk). hang), egyéni lexikonok segítségével.

Építészeti áttekintés

Az alábbi ábra szemlélteti megoldásunk architektúráját.

A munkafolyamat a következő:

1. A hangot a Python SDK veszi fel.
2. Az Amazon Polly a beszédet szöveggé alakítja, 39 lehetséges nyelven.
3. Az Amazon Translate konvertálja a nyelveket.
4. Az Amazon Live Transcribe a szöveget beszéddé alakítja.
5. A hangot a hangszórókon továbbítják.

Előfeltételek

Szüksége van egy mikrofonnal, hangszórókkal és megbízható internetkapcsolattal felszerelt gazdagépre. Egy modern laptopnak jól kell működnie ehhez, mert nincs szükség további hardverre. Ezután be kell állítania a gépet néhány szoftvereszközzel.

Az aszinkron Amazon Transcribe streaming SDK használatához és az úgynevezett Python modulhoz telepíteni kell a Python 3.7+ verziót. pyaudio, amellyel a gép mikrofonját és hangszóróit vezérelheti. Ez a modul egy nevezett C könyvtártól függ portaudio.h. Ha problémákba ütközik a pyaudio hibákat, javasoljuk, hogy ellenőrizze az operációs rendszert, és ellenőrizze, hogy rendelkezik-e a portaudio.h könyvtár telepítve.

A szolgáltatáshívások engedélyezéséhez és hitelesítéséhez hozzon létre egy AWS Identity and Access Management (IAM) szolgáltatási szerepkör a szükséges AWS-szolgáltatások meghívására vonatkozó engedéllyel. Konfigurálásával a AWS parancssori interfész (AWS CLI) ezzel az IAM-szolgáltatási szerepkörrel futtathatja szkriptünket a gépén anélkül, hogy kulcsokat vagy jelszavakat kellene átadnia, mivel az AWS-könyvtárak a konfigurált AWS CLI-felhasználó hitelesítő adatainak használatára vannak írva. Ez egy kényelmes módszer a gyors prototípuskészítéshez, és biztosítja, hogy szolgáltatásainkat felhatalmazott személy hívja. Mint mindig, kövesse a legkisebb jogosultság elvét, amikor IAM-házirendeket rendel hozzá, amikor IAM-felhasználót vagy szerepkört hoz létre.

Összefoglalva, a következő előfeltételekre van szüksége:

• PC, Mac vagy Linux gép mikrofonnal, hangszórókkal és internetkapcsolattal
• A portaudio.h C könyvtár az operációs rendszerhez (brew, apt get, wget), amely szükséges a pyaudio működéséhez
• AWS CLI 2.0 megfelelően jogosult IAM felhasználóval, amelyet az aws configure futtatásával konfigurált az AWS CLI-ben
• Python 3.7+
• Az aszinkron Amazon Transcribe Python SDK
• A következő Python-könyvtárak:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Valósítsa meg a megoldást

Kiindulópontként nagymértékben támaszkodik a Pythonhoz készült aszinkron Amazon Transcribe streaming SDK-ra, és az adott SDK-ra fog építeni. Miután kísérletezett a Python streaming SDK-val, adja hozzá streaming mikrofon használatával adja meg pyaudio, egy gyakran használt Python nyílt forráskódú könyvtár, amelyet hangadatok kezelésére használnak. Ezután hozzáadhat Boto3-hívásokat az Amazon Translate-hez és az Amazon Polly-hoz a fordítási és szövegfelolvasó funkciónk érdekében. Végül a lefordított beszédet ismét a számítógép hangszóróin keresztül továbbítja pyaudio. A Python modul concurrent lehetővé teszi a blokkoló kód futtatását a saját aszinkron szálában, hogy a visszaküldött Amazon Polly beszédet zökkenőmentesen, nem blokkoló módon játssza le.

Importáljuk az összes szükséges modulunkat, írjuk át a streaming osztályokat, és példányosítsunk néhány globálist:

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"

Először is használd pyaudio a bemeneti eszköz mintavételi gyakoriságának, eszközindexének és csatornaszámának megszerzéséhez:

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

Ha ez nem működik, akkor a következő kódban látható módon végignézheti és kinyomtathatja az eszközöket, majd az eszközindex segítségével lekérheti az eszköz adatait 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"]

Használod channel_count, sample_rateés dev_index mint paraméterek egy mikrofon adatfolyamban. Az adott adatfolyam visszahívási funkciójában egy asyncio nem blokkoló szálbiztos visszahívás, hogy a mikrofonfolyam bemeneti bájtjait egy asyncio beviteli sor. Vegye figyelembe a ciklus és input_queue objektumokat, amelyekkel létrehozott asyncio és hogyan használják őket a következő kódban:

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

Most, amikor a generátor funkció mic_stream() hívják, folyamatosan ad bemeneti bájtokat, amíg van mikrofon bemeneti adat a bemeneti sorban.

Most, hogy tudja, hogyan szerezhet be bemeneti bájtokat a mikrofonból, nézzük meg, hogyan írhat Amazon Polly kimeneti audio byte-okat a hangszóró kimeneti adatfolyamába:

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

Most pedig térjünk ki arra, hogy mit építettél fel a bejegyzésben Aszinkron Amazon Transcribe Streaming SDK Pythonhoz. A következő kódban egy végrehajtó objektumot hoz létre a ThreadPoolExecutor alosztály három dolgozóval egyidejűleg. Ezután hozzáad egy Amazon Translate hívást a véglegesített átirathoz az EventHandlerben, és továbbítja a lefordított szöveget, a végrehajtó objektumot és aws_polly_tts() függvény egy asyncio hurok vele loop.run_in_executor(), amely aszinkron módon futtatja az Amazon Polly függvényünket (lefordított beviteli szöveggel) a következő iteráció elején. asyncio hurok.

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

Végül megvan a loop_me() funkció. Ebben te határozod meg write_chunks(), amely egy Amazon Transcribe adatfolyamot vesz argumentumként, és aszinkron módon írja rá a streaming mikrofonbemenet darabjait. Akkor használd MyEventHandler() argumentumaként a kimeneti átírási folyamot, és hozzon létre egy kezelőobjektumot. Ezután használja a await with-t asyncio.gather() és adja át a write_chunks()-t és a kezelőt a handle_events() metódussal, hogy kezelje e korutinok esetleges jövőjét. Végül összegyűjti az összes eseményhurkot, és hurkolja a loop_me() funkcióval run_until_complete(). Lásd a következő kódot:

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

Ha az előző kódot hiba nélkül lefutja, beszélhet a mikrofonba, és gyorsan hallhatja hangját mandarin kínai nyelvre lefordítva. Az Amazon Transcribe és az Amazon Translate automatikus nyelvészlelési funkciója minden támogatott beviteli nyelvet lefordít a célnyelvre. Elég sokáig beszélhet, és a függvényhívások nem blokkoló jellege miatt az összes beszédbevitelt lefordítják és kimondják, így ez kiváló eszköz az élő beszédek fordítására.

Következtetés

Bár ez a bejegyzés bemutatta, hogy ez a három teljesen felügyelt AWS API hogyan tud zökkenőmentesen együtt működni, javasoljuk, hogy gondolja át, hogyan használhatná más módon ezeket a szolgáltatásokat a szolgáltatások vagy médiák többnyelvű támogatására, például a többnyelvű feliratozás a jelenlegi költség töredékéért. . Az orvostudomány, az üzleti élet, sőt a diplomáciai kapcsolatok is profitálhatnak egy folyamatosan fejlődő, olcsó és alacsony karbantartási költségű fordítási szolgáltatásból.

Ha további információra van szüksége a proof of concept kódalapról ehhez a használati esethez, tekintse meg a mi oldalunkat GitHub.

A szerzőkről

Michael Tran megoldástervező az Amazon Web Services Envision Engineering csapatával. Technikai útmutatást ad, és segít az ügyfeleknek innovációs képességük felgyorsításában azáltal, hogy bemutatja a lehetséges művészetet az AWS-en. Több prototípust épített az AI/ML és az IoT köré ügyfeleink számára. Felveheti velem a kapcsolatot @Mike_Trann-nal a Twitteren.

Cameron Wilkes prototípuskészítő építész az AWS Industry Accelerator csapatában. A csapat tagjaként számos ML alapú prototípust szállított az ügyfeleknek, hogy bemutassa az ML „Lehetséges művészetét” az AWS-en. Élvezi a zenei produkciót, az off-roadozást és a tervezést.