Supera le barriere linguistiche con Amazon Transcribe, Amazon Translate e Amazon Polly

Immagina un chirurgo che effettua videochiamate con pazienti in tutto il mondo senza la necessità di un traduttore umano. E se una startup alle prime armi potesse facilmente espandere il proprio prodotto oltre i confini e in nuovi mercati geografici offrendo assistenza e vendite fluide, accurate e multilingue, il tutto senza la necessità di un traduttore umano dal vivo? Cosa succede alla tua attività quando non sei più vincolato dalla lingua?

Oggigiorno è comune avere riunioni virtuali con team internazionali e clienti che parlano molte lingue diverse. Che si tratti di riunioni interne o esterne, il significato spesso si perde in discussioni complesse e potresti incontrare barriere linguistiche che ti impediscono di essere efficace quanto potresti essere.

In questo post imparerai come utilizzare tre servizi AWS completamente gestiti (Amazon Transcribe, Amazon Traduttoree Amazon Polly) per produrre una soluzione di traduzione vocale quasi in tempo reale in grado di tradurre rapidamente l'input vocale dal vivo di un oratore sorgente in una lingua di destinazione parlata, accurata e tradotta, il tutto senza esperienza di apprendimento automatico (ML).

Panoramica della soluzione

Il nostro traduttore è composto da tre servizi AWS ML completamente gestiti che lavorano insieme in un unico script Python utilizzando il SDK AWS per Python (Boto3) per la nostra traduzione di testo e porzioni di sintesi vocale e un SDK di streaming asincrono per la trascrizione dell'input audio.

Amazon Transcribe: streaming vocale in testo

Il primo servizio che utilizzi nel nostro stack è Amazon Transcribe, un servizio di sintesi vocale completamente gestito che accetta la voce di input e la trascrive in testo. Amazon Transcribe dispone di metodi di importazione flessibili, batch o streaming, perché accetta file audio archiviati o dati audio in streaming. In questo post, usi il asincrono Amazon Transcribe streaming SDK per Python, che utilizza il protocollo di streaming HTTP/2 per lo streaming di audio dal vivo e la ricezione di trascrizioni in tempo reale.

Quando abbiamo creato questo prototipo per la prima volta, l'importazione in streaming di Amazon Transcribe non supportava il rilevamento automatico della lingua, ma non è più così a partire da novembre 2021. Sia l'importazione in batch che quella in streaming ora supportano il rilevamento automatico della lingua per tutti lingue supportate. In questo post, mostriamo come una soluzione basata su parametri attraverso un design multilingua senza parametri è possibile attraverso l'uso del rilevamento automatico della lingua in streaming. Dopo che il nostro segmento vocale trascritto è stato restituito come testo, invii una richiesta ad Amazon Translate per tradurre e restituire i risultati nel nostro Amazon Transcribe EventHandler metodo.

Amazon Translate: API di traduzione all'avanguardia e completamente gestita

Il prossimo nel nostro stack è Amazon Translate, un servizio di traduzione automatica neurale che offre traduzioni linguistiche veloci, di alta qualità, convenienti e personalizzabili. A partire da giugno 2022, Amazon Translate supporta la traduzione in 75 lingue, con nuove coppie linguistiche e miglioramenti costantemente apportati. Amazon Translate utilizza modelli di deep learning ospitati su un'architettura AWS Cloud altamente scalabile e resiliente per fornire rapidamente traduzioni accurate in tempo reale o in batch, a seconda del caso d'uso. L'utilizzo di Amazon Translate è semplice e non richiede la gestione dell'architettura sottostante o delle competenze di machine learning. Amazon Translate ha diverse funzionalità, come la creazione e l'utilizzo di a terminologia personalizzata per gestire la mappatura tra termini specifici del settore. Per ulteriori informazioni sui limiti del servizio Amazon Translate, fare riferimento a Linee guida e limiti. Dopo che l'applicazione ha ricevuto il testo tradotto nella nostra lingua di destinazione, invia il testo tradotto ad Amazon Polly per la riproduzione immediata dell'audio tradotto.

Amazon Polly: API di sintesi vocale completamente gestita

Infine, invii il testo tradotto ad Amazon Polly, un servizio di sintesi vocale completamente gestito che può inviare risposte di clip audio realistiche per la riproduzione immediata in streaming o raggruppate e salvate in Servizio di archiviazione semplice Amazon (Amazon S3) per un uso successivo. Puoi controllare vari aspetti del parlato come pronuncia, volume, tono, velocità del parlato e altro usando standardizzato Linguaggio di sintesi vocale Markup (SSML).

Puoi sintetizzare il parlato per determinati Amazon Polly Voci neurali usando lo stile Newscaster per farli suonare come un giornalista televisivo o radiofonico. Puoi anche rilevare quando vengono pronunciate parole o frasi specifiche nel testo in base ai metadati inclusi nel flusso audio. Ciò consente allo sviluppatore di sincronizzare l'evidenziazione grafica e le animazioni, come i movimenti delle labbra di un avatar, con il discorso sintetizzato.

È possibile modificare la pronuncia di parole particolari, come nomi di società, acronimi, parole straniere o neologismi, ad esempio "P!nk", "ROTFL" o "C'est la vie" (se pronunciate in un voce), utilizzando lessici personalizzati.

Panoramica sull'architettura

Il diagramma seguente illustra l'architettura della nostra soluzione.

Il flusso di lavoro è il seguente:

1. L'audio viene acquisito dall'SDK Python.
2. Amazon Polly converte il parlato in testo, in 39 lingue possibili.
3. Amazon Translate converte le lingue.
4. Amazon Live Transcribe converte il testo in voce.
5. L'audio viene trasmesso agli altoparlanti.

Prerequisiti

È necessaria una macchina host configurata con microfono, altoparlanti e una connessione Internet affidabile. Un laptop moderno dovrebbe funzionare bene per questo perché non è necessario hardware aggiuntivo. Successivamente, è necessario configurare la macchina con alcuni strumenti software.

Devi avere Python 3.7+ installato per utilizzare l'SDK di streaming asincrono Amazon Transcribe e per un modulo Python chiamato pyaudio, che utilizzi per controllare il microfono e gli altoparlanti della macchina. Questo modulo dipende da una libreria C chiamata portaudio.h. Se riscontri problemi con pyaudio errori, ti suggeriamo di controllare il tuo sistema operativo per vedere se hai il portaudio.h libreria installata.

Per l'autorizzazione e l'autenticazione delle chiamate di servizio, si crea un file Gestione dell'identità e dell'accesso di AWS (IAM) ruolo del servizio con autorizzazioni per chiamare i servizi AWS necessari. Configurando il Interfaccia della riga di comando di AWS (AWS CLI) con questo ruolo del servizio IAM, puoi eseguire il nostro script sulla tua macchina senza dover passare chiavi o password, perché le librerie AWS sono scritte per utilizzare le credenziali utente dell'AWS CLI configurata. Questo è un metodo conveniente per la prototipazione rapida e garantisce che i nostri servizi vengano chiamati da un'identità autorizzata. Come sempre, segui il principio del privilegio minimo durante l'assegnazione delle policy IAM durante la creazione di un utente o ruolo IAM.

Per riassumere, sono necessari i seguenti prerequisiti:

• Un PC, Mac o macchina Linux con microfono, altoparlanti e connessione a Internet
• I portaudio.h Libreria C per il tuo sistema operativo (brew, apt get, wget), necessaria per il funzionamento di pyaudio
• AWS CLI 2.0 con un utente IAM correttamente autorizzato configurato eseguendo aws configure nell'AWS CLI
• Pitone 3.7+
• Amazon Transcribe Python SDK asincrono
• Le seguenti librerie Python:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementa la soluzione

Farai molto affidamento sull'SDK di streaming asincrono Amazon Transcribe per Python come punto di partenza e costruirai su quell'SDK specifico. Dopo aver sperimentato l'SDK di streaming per Python, aggiungi microfono in streaming input usando pyaudio, una libreria open source Python di uso comune utilizzata per manipolare i dati audio. Quindi aggiungi le chiamate Boto3 ad Amazon Translate e Amazon Polly per la nostra funzionalità di traduzione e sintesi vocale. Infine, riproduci in streaming il parlato tradotto attraverso gli altoparlanti del computer pyaudio. Il modulo Python concurrent ti dà la possibilità di eseguire codice di blocco nel proprio thread asincrono per riprodurre il discorso Amazon Polly restituito in modo semplice e non bloccante.

Importiamo tutti i moduli necessari, trascriviamo classi di streaming e istanziamo alcuni globali:

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"

Per prima cosa, usi pyaudio per ottenere la frequenza di campionamento, l'indice del dispositivo e il conteggio dei canali del dispositivo di input:

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

Se non funziona, puoi anche scorrere e stampare i tuoi dispositivi come mostrato nel codice seguente, quindi utilizzare l'indice del dispositivo per recuperare le informazioni sul dispositivo con 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"]

Usate channel_count, sample_ratee dev_index come parametri in un flusso microfonico. Nella funzione di callback di quel flusso, usi un file asyncio callback thread-safe non bloccante per inserire i byte di input del flusso del microfono in un file asyncio coda di input. Prendi nota degli oggetti loop e input_queue creati con asyncio e come vengono utilizzati nel codice seguente:

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

Ora quando la funzione del generatore mic_stream() viene chiamato, restituisce continuamente byte di input fintanto che sono presenti dati di input del microfono nella coda di input.

Ora che sai come ottenere byte di input dal microfono, diamo un'occhiata a come scrivere byte audio di output Amazon Polly su un flusso di output di altoparlanti:

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

Ora espandiamo ciò che hai costruito nel post Amazon Transcribe Streaming SDK asincrono per Python. Nel codice seguente, crei un oggetto executor usando ThreadPoolExecutor sottoclasse con tre lavoratori simultanei. Quindi aggiungi una chiamata Amazon Translate alla trascrizione restituita finalizzata in EventHandler e passi il testo tradotto, l'oggetto executor e il nostro aws_polly_tts() funzione in un asyncio loop con loop.run_in_executor(), che esegue la nostra funzione Amazon Polly (con testo di input tradotto) in modo asincrono all'inizio dell'iterazione successiva del asyncio ciclo continuo.

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

Finalmente, abbiamo il loop_me() funzione. In esso, tu definisci write_chunks(), che accetta un flusso Amazon Transcribe come argomento e scrive in modo asincrono blocchi di input del microfono in streaming su di esso. Quindi usi MyEventHandler() con il flusso di trascrizione di output come argomento e creare un oggetto gestore. Quindi usi wait con asyncio.gather() e passa write_chunks() e handler con il metodo handle_events() per gestire gli eventuali futuri di queste coroutine. Infine, raccogli tutti i loop di eventi e esegui il loop loop_me() funzione con run_until_complete(). Vedi il seguente codice:

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

Quando il codice precedente viene eseguito insieme senza errori, puoi parlare nel microfono e ascoltare rapidamente la tua voce tradotta in cinese mandarino. La funzione di rilevamento automatico della lingua per Amazon Transcribe e Amazon Translate traduce qualsiasi lingua di input supportata nella lingua di destinazione. Puoi parlare per un po' di tempo e, a causa della natura non bloccante delle chiamate di funzione, tutto il tuo input vocale viene tradotto e parlato, rendendolo uno strumento eccellente per la traduzione di discorsi dal vivo.

Conclusione

Sebbene questo post abbia dimostrato come queste tre API AWS completamente gestite possono funzionare perfettamente insieme, ti invitiamo a pensare a come potresti utilizzare questi servizi in altri modi per fornire supporto multilingue per servizi o media come i sottotitoli multilingue per una frazione del costo attuale . Medicina, affari e persino relazioni diplomatiche potrebbero trarre vantaggio da un servizio di traduzione in continuo miglioramento, a basso costo ea bassa manutenzione.

Per ulteriori informazioni sulla base del codice proof of concept per questo caso d'uso, consulta il nostro Github.

Informazioni sugli autori

Michele Trad è un Solutions Architect con il team Envision Engineering presso Amazon Web Services. Fornisce assistenza tecnica e aiuta i clienti ad accelerare la loro capacità di innovare mostrando l'arte del possibile su AWS. Ha costruito più prototipi su AI/ML e IoT per i nostri clienti. Puoi contattarmi @Mike_Trann su Twitter.

Cameron Wilkes è un architetto di prototipi nel team di AWS Industry Accelerator. Mentre faceva parte del team, ha consegnato ai clienti diversi prototipi basati sul ML per dimostrare "l'arte del possibile" del ML su AWS. Gli piace la produzione musicale, il fuoristrada e il design.