Depășiți barierele lingvistice cu Amazon Transcribe, Amazon Translate și Amazon Polly

Imaginați-vă un chirurg care efectuează apeluri video cu pacienți din întreaga lume fără a avea nevoie de un traducător uman. Ce s-ar întâmpla dacă o companie nou-înființată și-ar putea extinde cu ușurință produsul peste granițe și pe noi piețe geografice, oferind asistență și vânzări fluide, precise și multilingve, toate fără a fi nevoie de un traducător uman activ? Ce se întâmplă cu afacerea ta când nu mai ești legat de limbă?

Este obișnuit astăzi să avem întâlniri virtuale cu echipe internaționale și clienți care vorbesc multe limbi diferite. Fie că sunt întâlniri interne sau externe, ceea ce înseamnă că se pierde adesea în discuții complexe și s-ar putea să întâlnești bariere lingvistice care te împiedică să fii la fel de eficient pe cât ai putea fi.

În această postare, veți învăța cum să utilizați trei servicii AWS complet gestionate (Transcriere Amazon, Traducerea Amazon, și Amazon Polly) pentru a produce o soluție de traducător vorbire în vorbire aproape în timp real, care poate traduce rapid intrarea vocală live a unui vorbitor sursă într-o limbă țintă vorbită, precisă și tradusă, toate fără experiență de învățare automată (ML).

Prezentare generală a soluției

Traducătorul nostru constă din trei servicii AWS ML complet gestionate care lucrează împreună într-un singur script Python, folosind SDK AWS pentru Python (Boto3) pentru traducerea textului și porțiunile text în vorbire și un SDK de streaming asincron pentru transcrierea intrării audio.

Amazon Transcribe: transmiterea în flux a vorbirii în text

Primul serviciu pe care îl utilizați în stiva noastră este Amazon Transcribe, un serviciu de transmitere a vorbirii în text complet gestionat, care preia vocea de intrare și o transcrie în text. Amazon Transcribe are metode flexibile de asimilare, lot sau streaming, deoarece acceptă fie fișiere audio stocate, fie date audio în flux. În această postare, utilizați SDK de streaming Amazon Transcribe asincron pentru Python, care utilizează protocolul de streaming HTTP/2 pentru a transmite în flux audio live și pentru a primi transcrieri live.

Când am construit pentru prima dată acest prototip, Amazon Transcribe asimilarea în flux nu a acceptat detectarea automată a limbii, dar acest lucru nu mai este cazul din noiembrie 2021. Atât asimilarea loturilor, cât și asimilarea în flux acceptă acum detectarea automată a limbii pentru toți limbi acceptate. În această postare, arătăm cum este posibilă o soluție bazată pe parametri printr-un design fără parametri, în mai multe limbi, prin utilizarea detectării automate a limbii în flux. După ce segmentul nostru de vorbire transcris este returnat ca text, trimiteți o solicitare către Amazon Translate pentru a traduce și a returna rezultatele în Amazon Transcribe. EventHandler metodă.

Amazon Translate: API de traducere de ultimă generație, gestionat complet

Următorul în teancul nostru este Amazon Translate, un serviciu de traducere automată neuronală care oferă traducere rapidă, de înaltă calitate, accesibilă și personalizabilă. Începând cu iunie 2022, Amazon Translate acceptă traducerea în 75 de limbi, noi perechi de limbi și îmbunătățiri fiind aduse în mod constant. Amazon Translate utilizează modele de învățare profundă găzduite pe o arhitectură AWS Cloud extrem de scalabilă și rezistentă pentru a furniza rapid traduceri precise, fie în timp real, fie în loturi, în funcție de cazul dvs. de utilizare. Utilizarea Amazon Translate este simplă și nu necesită gestionarea arhitecturii de bază sau a abilităților ML. Amazon Translate are mai multe funcții, cum ar fi crearea și utilizarea unui terminologie personalizată pentru a gestiona maparea între termenii specifici industriei. Pentru mai multe informații despre limitele serviciului Amazon Translate, consultați Orientări și limite. După ce aplicația primește textul tradus în limba noastră țintă, trimite textul tradus către Amazon Polly pentru redare audio tradusă imediată.

Amazon Polly: API-ul text-to-speech complet gestionat

În cele din urmă, trimiteți textul tradus către Amazon Polly, un serviciu de transformare a textului în vorbire complet gestionat care poate fie să trimită răspunsuri la clipuri audio realiste pentru redare imediată în flux, fie grupate și salvate în Serviciul Amazon de stocare simplă (Amazon S3) pentru utilizare ulterioară. Puteți controla diferite aspecte ale vorbirii, cum ar fi pronunția, volumul, înălțimea, rata de vorbire și multe altele folosind standarde Limbajul de marcare pentru sinteza vorbirii (SSML).

Puteți sintetiza vorbirea pentru anumite Amazon Polly Voci neuronale folosind stilul Newscaster pentru a le face să sune ca un prezentator de știri TV sau radio. De asemenea, puteți detecta când anumite cuvinte sau propoziții din text sunt rostite pe baza metadatelor incluse în fluxul audio. Acest lucru permite dezvoltatorului să sincronizeze evidențierea grafică și animațiile, cum ar fi mișcările buzelor unui avatar, cu vorbirea sintetizată.

Puteți modifica pronunția anumitor cuvinte, cum ar fi numele companiilor, acronimele, cuvintele străine sau neologismele, de exemplu „P!nk”, „ROTFL” sau „C'est la vie” (când sunt vorbite într-un limbaj non-francez). voce), folosind lexiconi personalizate.

Privire de ansamblu asupra arhitecturii

Următoarea diagramă ilustrează arhitectura soluției noastre.

Fluxul de lucru este următorul:

1. Audio este ingerat de Python SDK.
2. Amazon Polly convertește discursul în text, în 39 de limbi posibile.
3. Amazon Translate convertește limbile.
4. Amazon Live Transcribe convertește textul în vorbire.
5. Audio este transmis la difuzoare.

Cerințe preliminare

Aveți nevoie de o mașină gazdă configurată cu un microfon, difuzoare și o conexiune de încredere la internet. Un laptop modern ar trebui să funcționeze bine pentru asta, deoarece nu este nevoie de hardware suplimentar. Apoi, trebuie să configurați aparatul cu unele instrumente software.

Trebuie să aveți instalat Python 3.7+ pentru a utiliza SDK-ul de streaming Amazon Transcribe asincron și pentru un modul Python numit pyaudio, pe care îl utilizați pentru a controla microfonul și difuzoarele aparatului. Acest modul depinde de o bibliotecă C numită portaudio.h. Dacă întâmpinați probleme cu pyaudio erori, vă sugerăm să vă verificați sistemul de operare pentru a vedea dacă aveți portaudio.h biblioteca instalată.

Pentru autorizarea și autentificarea apelurilor de service, creați un Gestionarea identității și accesului AWS (IAM) cu permisiuni de a apela serviciile AWS necesare. Prin configurarea Interfața liniei de comandă AWS (AWS CLI) cu acest rol de serviciu IAM, puteți rula scriptul nostru pe mașina dvs. fără a fi necesar să transmiteți chei sau parole, deoarece bibliotecile AWS sunt scrise pentru a utiliza acreditările configurate ale utilizatorului AWS CLI. Aceasta este o metodă convenabilă de prototipare rapidă și asigură că serviciile noastre sunt apelate de o identitate autorizată. Ca întotdeauna, urmați principiul celui mai mic privilegiu atunci când atribuiți politici IAM atunci când creați un utilizator sau un rol IAM.

Pentru a rezuma, aveți nevoie de următoarele condiții preliminare:

• Un computer, Mac sau Linux cu microfon, difuzoare și conexiune la internet
• portaudio.h Biblioteca C pentru sistemul de operare (brew, apt get, wget), care este necesară pentru ca pyaudio să funcționeze
• AWS CLI 2.0 cu utilizator IAM autorizat corespunzător, configurat prin rularea aws configure în AWS CLI
• Python 3.7+
• SDK-ul Amazon Transcribe Python asincron
• Următoarele biblioteci Python:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementează soluția

Vă veți baza în mare măsură pe SDK-ul de streaming Amazon Transcribe asincron pentru Python ca punct de plecare și veți construi pe baza acelui SDK specific. După ce ați experimentat cu SDK-ul de streaming pentru Python, adăugați microfon de streaming introducere prin utilizarea pyaudio, o bibliotecă open-source Python folosită în mod obișnuit, folosită pentru manipularea datelor audio. Apoi adăugați apeluri Boto3 la Amazon Translate și Amazon Polly pentru funcționalitatea noastră de traducere și text-to-speech. În cele din urmă, transmiteți din nou vorbirea tradusă prin difuzoarele computerului pyaudio. Modulul Python concurrent vă oferă posibilitatea de a rula cod de blocare în propriul fir asincron pentru a reda discursul returnat Amazon Polly într-un mod fără întreruperi, fără blocare.

Să importăm toate modulele noastre necesare, să transcriem clasele de streaming și să instanțiem câteva globaluri:

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"

În primul rând, folosești pyaudio pentru a obține rata de eșantionare a dispozitivului de intrare, indicele dispozitivului și numărul de canale:

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

Dacă acest lucru nu funcționează, puteți, de asemenea, să parcurgeți și să imprimați dispozitivele, așa cum se arată în următorul cod, apoi să utilizați indexul dispozitivului pentru a prelua informațiile despre dispozitiv cu 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"]

Să utilizați channel_count, sample_rate, și dev_index ca parametri într-un flux de microfon. În funcția de apel invers a acelui flux, utilizați un asyncio apel invers fără blocare thread-safe pentru a pune octeții de intrare ai fluxului de microfon într-un asyncio coada de intrare. Luați notă de obiectele buclă și input_queue create cu asyncio și cum sunt utilizate în următorul cod:

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

Acum, când funcția generatorului mic_stream() este apelat, furnizează continuu octeți de intrare atâta timp cât există date de intrare ale microfonului în coada de intrare.

Acum că știți cum să obțineți octeți de intrare de la microfon, să vedem cum să scrieți octeți audio de ieșire Amazon Polly într-un flux de ieșire a difuzorului:

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

Acum haideți să extindem ceea ce ați construit în postare SDK de streaming Amazon Transcribe asincron pentru Python. În următorul cod, creați un obiect executor utilizând ThreadPoolExecutor subclasa cu trei muncitori cu concurente. Apoi adăugați un apel Amazon Translate pe transcrierea returnată finalizată în EventHandler și transmiteți acel text tradus, obiectul executor și aws_polly_tts() funcția într-o asyncio buclă cu loop.run_in_executor(), care rulează funcția noastră Amazon Polly (cu text de intrare tradus) asincron la începutul următoarei iterații a asyncio buclă.

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

În cele din urmă, avem loop_me() funcţie. În ea, definiți write_chunks(), care ia un flux Amazon Transcribe ca argument și scrie în mod asincron bucăți de intrare de microfon în flux. Apoi folosești MyEventHandler() cu fluxul de transcriere de ieșire ca argument și creați un obiect handler. Apoi folosiți așteptați cu asyncio.gather() și treceți write_chunks() și handlerul cu metoda handle_events() pentru a gestiona eventualele viitoare ale acestor coroutine. În cele din urmă, adunați toate buclele de evenimente și buclați loop_me() funcționează cu run_until_complete(). Consultați următorul cod:

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

Când codul precedent este rulat împreună, fără erori, puteți vorbi în microfon și vă puteți auzi rapid vocea tradusă în chineza mandarină. Funcția de detectare automată a limbii pentru Amazon Transcribe și Amazon Translate traduce orice limbă de intrare acceptată în limba țintă. Puteți vorbi destul de mult timp și, din cauza naturii neblocante a apelurilor de funcție, toată intrarea dvs. de vorbire este tradusă și vorbită, ceea ce face din acesta un instrument excelent pentru traducerea discursurilor live.

Concluzie

Deși această postare a demonstrat modul în care aceste trei API-uri AWS complet gestionate pot funcționa împreună, vă încurajăm să vă gândiți la modul în care puteți utiliza aceste servicii în alte moduri pentru a oferi suport multilingv pentru servicii sau media, cum ar fi subtitrări multilingve, pentru o fracțiune din costul actual. . Medicina, afacerile și chiar relațiile diplomatice ar putea beneficia de un serviciu de traducere în continuă îmbunătățire, cu costuri reduse și cu întreținere redusă.

Pentru mai multe informații despre baza codului de dovadă a conceptului pentru acest caz de utilizare, consultați-ne Github.

Despre Autori

Michael Trans este arhitect de soluții cu echipa Envision Engineering la Amazon Web Services. El oferă îndrumări tehnice și îi ajută pe clienți să-și accelereze capacitatea de a inova prin arătarea artei posibilului pe AWS. El a construit mai multe prototipuri în jurul AI/ML și IoT pentru clienții noștri. Mă puteți contacta pe @Mike_Trann pe Twitter.

Cameron Wilkes este arhitect de prototipuri în echipa AWS Industry Accelerator. În timp ce era în echipă, el a livrat clienților câteva prototipuri bazate pe ML pentru a demonstra „Arta posibilului” a ML pe AWS. Îi place producția muzicală, off-roading și design.