Durchbrechen Sie Sprachbarrieren mit Amazon Transcribe, Amazon Translate und Amazon Polly

Stellen Sie sich einen Chirurgen vor, der Videoanrufe mit Patienten auf der ganzen Welt führt, ohne dass ein menschlicher Übersetzer benötigt wird. Was wäre, wenn ein junges Startup sein Produkt problemlos über Grenzen hinweg und in neue geografische Märkte expandieren könnte, indem es flüssigen, genauen, mehrsprachigen Kundensupport und Vertrieb anbietet, und das alles ohne die Notwendigkeit eines menschlichen Live-Übersetzers? Was passiert mit Ihrem Unternehmen, wenn Sie nicht mehr an Sprache gebunden sind?

Heutzutage ist es üblich, virtuelle Meetings mit internationalen Teams und Kunden abzuhalten, die viele verschiedene Sprachen sprechen. Ob es sich um interne oder externe Meetings handelt, in komplexen Diskussionen geht oft die Bedeutung verloren und es kann vorkommen, dass Sie auf Sprachbarrieren stoßen, die Sie daran hindern, so effektiv zu sein, wie Sie sein könnten.

In diesem Beitrag erfahren Sie, wie Sie drei vollständig verwaltete AWS-Services verwenden (Amazon Transcribe, Amazon Übersetzen und Amazonas Polly), um eine Sprach-zu-Sprache-Übersetzungslösung nahezu in Echtzeit zu erstellen, die die Live-Spracheingabe eines Quellsprechers schnell in eine gesprochene, genaue, übersetzte Zielsprache übersetzen kann, und das alles ohne Erfahrung mit maschinellem Lernen (ML).

Lösungsübersicht

Unser Übersetzer besteht aus drei vollständig verwalteten AWS ML-Services, die mithilfe von in einem einzigen Python-Skript zusammenarbeiten AWS SDK für Python (Boto3) für unsere Textübersetzung und Text-zu-Sprache-Teile und ein asynchrones Streaming-SDK für die Transkription von Audioeingaben.

Amazon Transcribe: Sprache in Text streamen

Der erste Dienst, den Sie in unserem Stack verwenden, ist Amazon Transcribe, ein vollständig verwalteter Speech-to-Text-Dienst, der Spracheingaben aufnimmt und in Text transkribiert. Amazon Transcribe verfügt über flexible Aufnahmemethoden, Batch oder Streaming, da es entweder gespeicherte Audiodateien oder Streaming-Audiodaten akzeptiert. In diesem Beitrag verwenden Sie die asynchrones Amazon Transcribe-Streaming-SDK für Python, das das HTTP/2-Streamingprotokoll verwendet, um Live-Audio zu streamen und Live-Transkriptionen zu empfangen.

Als wir diesen Prototyp zum ersten Mal erstellten, unterstützte die Streaming-Aufnahme von Amazon Transcribe keine automatische Spracherkennung, aber das ist seit November 2021 nicht mehr der Fall. Sowohl die Batch- als auch die Streaming-Aufnahme unterstützen jetzt die automatische Spracherkennung für alle unterstützte Sprachen. In diesem Beitrag zeigen wir, wie eine parameterbasierte Lösung durch ein nahtloses, mehrsprachiges, parameterloses Design durch die Verwendung der automatischen Streaming-Spracherkennung möglich ist. Nachdem unser transkribiertes Sprachsegment als Text zurückgegeben wurde, senden Sie eine Anfrage an Amazon Translate, um die Ergebnisse zu übersetzen und in unserem Amazon Transcribe zurückzugeben EventHandler Methode.

Amazon Translate: Hochmoderne, vollständig verwaltete Übersetzungs-API

Als nächstes in unserem Stack ist Amazon Translate, ein neuronaler maschineller Übersetzungsdienst, der schnelle, qualitativ hochwertige, erschwingliche und anpassbare Sprachübersetzungen liefert. Ab Juni 2022 unterstützt Amazon Translate die Übersetzung in 75 Sprachen, wobei ständig neue Sprachpaare und Verbesserungen vorgenommen werden. Amazon Translate verwendet Deep-Learning-Modelle, die auf einer hochskalierbaren und robusten AWS Cloud-Architektur gehostet werden, um schnell genaue Übersetzungen zu liefern, entweder in Echtzeit oder im Stapelbetrieb, je nach Ihrem Anwendungsfall. Die Verwendung von Amazon Translate ist unkompliziert und erfordert keine Verwaltung der zugrunde liegenden Architektur oder ML-Kenntnisse. Amazon Translate hat mehrere Funktionen, wie das Erstellen und Verwenden einer benutzerdefinierte Terminologie um die Zuordnung zwischen branchenspezifischen Begriffen zu handhaben. Weitere Informationen zu den Dienstbeschränkungen von Amazon Translate finden Sie unter Richtlinien und Grenzen. Nachdem die Anwendung den übersetzten Text in unserer Zielsprache erhalten hat, sendet sie den übersetzten Text zur sofortigen übersetzten Audiowiedergabe an Amazon Polly.

Amazon Polly: Vollständig verwaltete Text-to-Speech-API

Schließlich senden Sie den übersetzten Text an Amazon Polly, einen vollständig verwalteten Text-to-Speech-Dienst, der entweder lebensechte Audioclip-Antworten für die sofortige Streaming-Wiedergabe zurücksenden oder stapeln und speichern kann Amazon Simple Storage-Service (Amazon S3) zur späteren Verwendung. Sie können verschiedene Aspekte der Sprache steuern, z. B. Aussprache, Lautstärke, Tonhöhe, Sprechgeschwindigkeit und mehr, indem Sie standardisiert verwenden Sprachsynthese-Markup-Sprache (SSML).

Sie können Sprache für bestimmte Amazon Polly synthetisieren Neurale Stimmen Verwenden Sie den Newscaster-Stil, um sie wie einen TV- oder Radio-Nachrichtensprecher klingen zu lassen. Sie können auch erkennen, wenn bestimmte Wörter oder Sätze im Text gesprochen werden, basierend auf den im Audiostream enthaltenen Metadaten. Dadurch kann der Entwickler grafische Hervorhebungen und Animationen, wie z. B. die Lippenbewegungen eines Avatars, mit der synthetisierten Sprache synchronisieren.

Sie können die Aussprache bestimmter Wörter wie Firmennamen, Akronyme, Fremdwörter oder Wortneuschöpfungen ändern, zum Beispiel „P!nk“, „ROTFL“ oder „C'est la vie“ (wenn in einer nicht-französischen Sprache gesprochen). Stimme), mit benutzerdefinierten Lexika.

Architektur Überblick

Das folgende Diagramm zeigt unsere Lösungsarchitektur.

Der Arbeitsablauf ist wie folgt:

1. Audio wird vom Python SDK aufgenommen.
2. Amazon Polly wandelt die Sprache in Text in 39 möglichen Sprachen um.
3. Amazon Translate konvertiert die Sprachen.
4. Amazon Live Transcribe wandelt Text in Sprache um.
5. Audio wird an Lautsprecher ausgegeben.

Voraussetzungen:

Sie benötigen einen Host-Computer, der mit einem Mikrofon, Lautsprechern und einer zuverlässigen Internetverbindung ausgestattet ist. Ein moderner Laptop sollte dafür gut funktionieren, da keine zusätzliche Hardware benötigt wird. Als nächstes müssen Sie die Maschine mit einigen Softwaretools einrichten.

Sie müssen Python 3.7+ installiert haben, um das asynchrone Amazon Transcribe-Streaming-SDK und ein aufgerufenes Python-Modul verwenden zu können pyaudio, mit dem Sie das Mikrofon und die Lautsprecher des Geräts steuern. Dieses Modul hängt von einer C-Bibliothek namens ab portaudio.h. Wenn Sie Probleme mit haben pyaudio Fehler, empfehlen wir, Ihr Betriebssystem zu überprüfen, um zu sehen, ob Sie die haben portaudio.h Bibliothek installiert.

Für die Autorisierung und Authentifizierung von Serviceabrufen erstellen Sie eine AWS Identity and Access Management and (IAM)-Servicerolle mit Berechtigungen zum Aufrufen der erforderlichen AWS-Services. Durch die Konfiguration der AWS-Befehlszeilenschnittstelle (AWS CLI) mit dieser IAM-Servicerolle können Sie unser Skript auf Ihrem Computer ausführen, ohne Schlüssel oder Passwörter übergeben zu müssen, da die AWS-Bibliotheken so geschrieben sind, dass sie die Anmeldeinformationen des konfigurierten AWS CLI-Benutzers verwenden. Dies ist eine bequeme Methode für schnelles Prototyping und stellt sicher, dass unsere Dienste von einer autorisierten Identität aufgerufen werden. Befolgen Sie beim Zuweisen von IAM-Richtlinien beim Erstellen eines IAM-Benutzers oder einer IAM-Rolle wie immer das Prinzip der geringsten Rechte.

Zusammenfassend benötigen Sie folgende Voraussetzungen:

• Ein PC, Mac oder Linux-Rechner mit Mikrofon, Lautsprechern und Internetverbindung
• Das portaudio.h C-Bibliothek für Ihr Betriebssystem (brew, apt get, wget), die benötigt wird, damit Pyaudio funktioniert
• AWS CLI 2.0 mit ordnungsgemäß autorisiertem IAM-Benutzer, konfiguriert durch Ausführen von aws configure in der AWS CLI
• Python 3.7 +
• Das asynchrone Amazon Transcribe Python SDK
• Die folgenden Python-Bibliotheken:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Implementieren Sie die Lösung

Sie werden sich stark auf das asynchrone Amazon Transcribe-Streaming-SDK für Python als Ausgangspunkt verlassen und auf diesem speziellen SDK aufbauen. Nachdem Sie mit dem Streaming-SDK für Python experimentiert haben, fügen Sie hinzu Streaming-Mikrofon Eingabe mit pyaudio, eine häufig verwendete Python-Open-Source-Bibliothek zur Bearbeitung von Audiodaten. Dann fügen Sie Amazon Translate und Amazon Polly Boto3-Aufrufe für unsere Übersetzungs- und Text-zu-Sprache-Funktionalität hinzu. Abschließend streamen Sie die übersetzte Sprache wieder über die Lautsprecher des Computers pyaudio. Das Python-Modul concurrent gibt Ihnen die Möglichkeit, blockierenden Code in einem eigenen asynchronen Thread auszuführen, um Ihre zurückgegebene Amazon Polly-Sprache nahtlos und nicht blockierend wiederzugeben.

Lassen Sie uns alle unsere notwendigen Module importieren, Streaming-Klassen transkribieren und einige Globals instanziieren:

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"

Zuerst verwenden Sie pyaudio So erhalten Sie die Abtastrate, den Geräteindex und die Kanalanzahl des Eingabegeräts:

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

Wenn dies nicht funktioniert, können Sie Ihre Geräte auch wie im folgenden Code gezeigt durchlaufen und drucken und dann den Geräteindex verwenden, um die Geräteinformationen abzurufen 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"]

Sie nutzen channel_count, sample_rate und dev_index als Parameter in einem Mikrofonstream. In der Rückruffunktion dieses Streams verwenden Sie eine asyncio nicht blockierender Thread-sicherer Rückruf, um die Eingabebytes des Mikrofonstroms in eine asyncio Eingangswarteschlange. Beachten Sie die mit erstellten loop- und input_queue-Objekte asyncio und wie sie im folgenden Code verwendet werden:

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

Jetzt, wenn der Generator funktioniert mic_stream() aufgerufen wird, liefert es kontinuierlich Eingabebytes, solange es Mikrofoneingabedaten in der Eingabewarteschlange gibt.

Nachdem Sie nun wissen, wie Sie Eingabebytes vom Mikrofon erhalten, schauen wir uns an, wie Sie Amazon Polly-Ausgabeaudiobytes in einen Lautsprecherausgabestream schreiben:

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

Lassen Sie uns nun auf das eingehen, was Sie im Beitrag erstellt haben Asynchrones Amazon Transcribe Streaming SDK für Python. Im folgenden Code erstellen Sie ein Executor-Objekt mit der ThreadPoolExecutor Unterklasse mit drei Arbeitern mit gleichzeitiger. Anschließend fügen Sie dem abgeschlossenen zurückgegebenen Transkript im EventHandler einen Amazon Translate-Aufruf hinzu und übergeben diesen übersetzten Text, das Executor-Objekt und unsere aws_polly_tts() Funktion in ein asyncio Schleife mit loop.run_in_executor(), die unsere Amazon Polly-Funktion (mit übersetztem Eingabetext) asynchron zu Beginn der nächsten Iteration von ausführt asyncio Schleife.

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

Endlich haben wir die loop_me() Funktion. Darin definieren Sie write_chunks(), das einen Amazon Transcribe-Stream als Argument verwendet und asynchron Chunks von Streaming-Mikrofoneingaben darauf schreibt. Sie verwenden dann MyEventHandler() mit dem Ausgabe-Transkriptionsstream als Argument und erstellen Sie ein Handler-Objekt. Dann verwenden Sie await with asyncio.gather() und übergeben Sie write_chunks() und den Handler mit der Methode handle_events(), um die eventuellen Futures dieser Coroutinen zu behandeln. Zuletzt sammeln Sie alle Ereignisschleifen und wiederholen die loop_me() funktionieren mit run_until_complete(). Siehe folgenden Code:

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

Wenn der vorangehende Code ohne Fehler zusammen ausgeführt wird, können Sie in das Mikrofon sprechen und Ihre Stimme schnell in Mandarin-Chinesisch übersetzt hören. Die automatische Spracherkennungsfunktion für Amazon Transcribe und Amazon Translate übersetzt jede unterstützte Eingabesprache in die Zielsprache. Sie können eine ganze Weile sprechen, und aufgrund der nicht blockierenden Natur der Funktionsaufrufe wird Ihre gesamte Spracheingabe übersetzt und gesprochen, was dies zu einem hervorragenden Werkzeug zum Übersetzen von Live-Reden macht.

Zusammenfassung

Obwohl dieser Beitrag gezeigt hat, wie diese drei vollständig verwalteten AWS-APIs nahtlos zusammenarbeiten können, empfehlen wir Ihnen, darüber nachzudenken, wie Sie diese Dienste auf andere Weise nutzen könnten, um mehrsprachige Unterstützung für Dienste oder Medien wie mehrsprachige Untertitel für einen Bruchteil der aktuellen Kosten bereitzustellen . Medizin, Wirtschaft und sogar diplomatische Beziehungen könnten alle von einem sich ständig verbessernden, kostengünstigen und wartungsarmen Übersetzungsdienst profitieren.

Weitere Informationen zur Proof-of-Concept-Codebasis für diesen Anwendungsfall finden Sie in unserem Github.

Über die Autoren

Michael Tran ist ein Lösungsarchitekt im Envision Engineering-Team bei Amazon Web Services. Er bietet technische Beratung und hilft Kunden, ihre Innovationsfähigkeit zu beschleunigen, indem er die Kunst des Möglichen auf AWS zeigt. Er hat für unsere Kunden mehrere Prototypen rund um AI/ML und IoT gebaut. Sie können mich unter @Mike_Trann auf Twitter kontaktieren.

Cameron Wilke ist Prototyping Architect im AWS Industry Accelerator-Team. Während seiner Zeit im Team lieferte er mehrere ML-basierte Prototypen an Kunden, um die „Kunst des Möglichen“ von ML auf AWS zu demonstrieren. Er mag Musikproduktion, Offroading und Design.