Przełam bariery językowe dzięki Amazon Transscribe, Amazon Translate i Amazon Polly

Wyobraź sobie chirurga, który prowadzi wideorozmowy z pacjentami na całym świecie bez konieczności korzystania z tłumacza. Co by było, gdyby początkujący startup mógł z łatwością rozszerzyć swój produkt za granicę i na nowe rynki geograficzne, oferując płynną, dokładną, wielojęzyczną obsługę klienta i sprzedaż, a wszystko to bez potrzeby żywego tłumacza? Co dzieje się z Twoją firmą, gdy nie jesteś już związany językiem?

W dzisiejszych czasach często odbywają się wirtualne spotkania z międzynarodowymi zespołami i klientami posługującymi się wieloma różnymi językami. Niezależnie od tego, czy są to spotkania wewnętrzne, czy zewnętrzne, znaczenie często gubi się w skomplikowanych dyskusjach i możesz napotkać bariery językowe, które uniemożliwiają Ci osiągnięcie maksymalnej skuteczności.

W tym poście dowiesz się, jak korzystać z trzech w pełni zarządzanych usług AWS (Amazon Transcribe, Tłumacz Amazon, Amazon Polly) w celu stworzenia rozwiązania do tłumaczenia mowy na mowę w czasie zbliżonym do rzeczywistego, które może szybko przetłumaczyć na żywo dane głosowe mówcy źródłowego na mówiony, dokładny, przetłumaczony język docelowy, a wszystko to bez doświadczenia w uczeniu maszynowym (ML).

Przegląd rozwiązania

Nasz tłumacz składa się z trzech w pełni zarządzanych usług AWS ML współpracujących ze sobą w jednym skrypcie Pythona przy użyciu AWS SDK dla Pythona (Boto3) za tłumaczenie tekstu i fragmenty tekstu na mowę oraz pakiet SDK do asynchronicznego przesyłania strumieniowego do transkrypcji danych wejściowych audio.

Amazon Transscribe: przesyłanie strumieniowe mowy do tekstu

Pierwszą usługą, z której korzystasz w naszym stosie, jest Amazon Transscribe, w pełni zarządzana usługa zamiany mowy na tekst, która pobiera mowę wejściową i transkrybuje ją na tekst. Amazon Transscribe ma elastyczne metody przyjmowania, wsadowe lub strumieniowe, ponieważ akceptuje zapisane pliki audio lub strumieniowe dane audio. W tym poście używasz asynchroniczny pakiet SDK do przesyłania strumieniowego Amazon Transscribe dla Pythona, który używa protokołu przesyłania strumieniowego HTTP/2 do strumieniowego przesyłania dźwięku na żywo i odbierania transkrypcji na żywo.

Kiedy po raz pierwszy zbudowaliśmy ten prototyp, przetwarzanie strumieniowe Amazon Transcribe nie obsługiwało automatycznego wykrywania języka, ale nie ma to już miejsca od listopada 2021 r. Zarówno przetwarzanie wsadowe, jak i strumieniowe obsługują teraz automatyczne wykrywanie języka dla wszystkich obsługiwane języki. W tym poście pokazujemy, w jaki sposób rozwiązanie oparte na parametrach, chociaż bezproblemowy, wielojęzyczny projekt bez parametrów jest możliwy dzięki zastosowaniu automatycznego wykrywania języka w trybie strumieniowym. Po tym, jak nasz transkrybowany segment mowy zostanie zwrócony jako tekst, wyślesz prośbę do Tłumacza Amazon o przetłumaczenie i zwrócenie wyników w naszym Transkrypcji Amazon EventHandler Metoda.

Amazon Translate: najnowocześniejszy, w pełni zarządzany interfejs API tłumaczeń

Następna w naszym zestawie jest Amazon Translate, neuronowa usługa tłumaczenia maszynowego, która zapewnia szybkie, wysokiej jakości, niedrogie i konfigurowalne tłumaczenie językowe. Od czerwca 2022 r. Amazon Translate obsługuje tłumaczenie w 75 językach, przy czym stale wprowadzane są nowe pary językowe i ulepszenia. Amazon Translate wykorzystuje modele uczenia głębokiego hostowane na wysoce skalowalnej i odpornej architekturze AWS Cloud, aby szybko dostarczać dokładne tłumaczenia w czasie rzeczywistym lub wsadowo, w zależności od przypadku użycia. Korzystanie z Amazon Translate jest proste i nie wymaga zarządzania podstawową architekturą ani umiejętnościami ML. Amazon Translate ma kilka funkcji, takich jak tworzenie i używanie niestandardowa terminologia do obsługi mapowania terminów branżowych. Aby uzyskać więcej informacji na temat limitów usługi Amazon Translate, zobacz Wytyczne i ograniczenia. Gdy aplikacja otrzyma przetłumaczony tekst w naszym języku docelowym, wysyła przetłumaczony tekst do Amazon Polly w celu natychmiastowego odtworzenia przetłumaczonego dźwięku.

Amazon Polly: w pełni zarządzany interfejs API zamiany tekstu na mowę

Na koniec przesyłasz przetłumaczony tekst do Amazon Polly, w pełni zarządzanej usługi zamiany tekstu na mowę, która może odesłać realistyczne odpowiedzi na klipy audio w celu natychmiastowego odtwarzania strumieniowego lub grupować i zapisywać w Usługa Amazon Simple Storage (Amazon S3) do późniejszego wykorzystania. Możesz kontrolować różne aspekty mowy, takie jak wymowa, głośność, ton, tempo mowy i inne, korzystając ze standardowego Język znaczników syntezy mowy (SSML).

Możesz syntetyzować mowę dla niektórych Amazon Polly Głosy neuronowe używając stylu Newscaster, aby brzmiały jak prezenter telewizyjny lub radiowy. Na podstawie metadanych zawartych w strumieniu audio można również wykrywać wypowiadanie określonych słów lub zdań w tekście. Pozwala to programiście na synchronizację podświetleń graficznych i animacji, takich jak ruchy ust awatara, z syntezowaną mową.

Możesz modyfikować wymowę określonych słów, takich jak nazwy firm, akronimy, obce słowa lub neologizmy, na przykład „P!nk”, „ROTFL” lub „C'est la vie” (jeśli mówi się w języku innym niż francuski głos), przy użyciu niestandardowych leksykonów.

Przegląd architektury

Poniższy diagram ilustruje naszą architekturę rozwiązania.

Przepływ pracy wygląda następująco:

1. Dźwięk jest przetwarzany przez pakiet Python SDK.
2. Amazon Polly konwertuje mowę na tekst w 39 możliwych językach.
3. Tłumacz Amazon konwertuje języki.
4. Amazon Live Transscribe konwertuje tekst na mowę.
5. Dźwięk jest przesyłany do głośników.

Wymagania wstępne

Potrzebujesz komputera hosta skonfigurowanego z mikrofonem, głośnikami i niezawodnym połączeniem internetowym. Nowoczesny laptop powinien działać dobrze, ponieważ nie jest potrzebny żaden dodatkowy sprzęt. Następnie musisz skonfigurować maszynę za pomocą narzędzi programowych.

Musisz mieć zainstalowany Python 3.7+, aby korzystać z asynchronicznego pakietu SDK do przesyłania strumieniowego Amazon Transcribe i modułu Pythona o nazwie pyaudio, który służy do sterowania mikrofonem i głośnikami urządzenia. Ten moduł zależy od biblioteki C o nazwie portaudio.h. Jeśli napotkasz problemy z pyaudio błędów, sugerujemy sprawdzenie systemu operacyjnego, aby sprawdzić, czy masz portaudio.h zainstalowana biblioteka.

W celu autoryzacji i uwierzytelniania połączeń serwisowych tworzysz AWS Zarządzanie tożsamością i dostępem Rola usługi (IAM) z uprawnieniami do wywoływania niezbędnych usług AWS. Konfigurując Interfejs wiersza poleceń AWS (AWS CLI) dzięki tej roli usługi IAM możesz uruchomić nasz skrypt na swoim komputerze bez konieczności przekazywania kluczy lub haseł, ponieważ biblioteki AWS są napisane tak, aby używały skonfigurowanych poświadczeń użytkownika AWS CLI. Jest to wygodna metoda szybkiego prototypowania i zapewnia, że ​​nasze usługi są wywoływane przez autoryzowaną tożsamość. Jak zawsze, podczas przypisywania zasad uprawnień podczas tworzenia użytkownika lub roli uprawnień postępuj zgodnie z zasadą najmniejszych uprawnień.

Podsumowując, potrzebujesz następujących warunków wstępnych:

• Komputer PC, Mac lub Linux z mikrofonem, głośnikami i połączeniem internetowym
• Połączenia portaudio.h Biblioteka C dla twojego systemu operacyjnego (brew, apt get, wget), która jest potrzebna do działania pyaudio
• AWS CLI 2.0 z odpowiednio autoryzowanym użytkownikiem uprawnień skonfigurowanym przez uruchomienie aws configure w AWS CLI
• Pythona 3.7+
• Asynchroniczny pakiet SDK do transkrypcji w języku Amazon Transscribe w języku Python
• Następujące biblioteki Pythona:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Zaimplementuj rozwiązanie

Będziesz w dużym stopniu polegać na asynchronicznym pakiecie SDK do przesyłania strumieniowego Amazon Transcribe dla Pythona jako punkcie wyjścia i będziesz budować na tym konkretnym pakiecie SDK. Po eksperymentowaniu z pakietem SDK do przesyłania strumieniowego dla Pythona dodajesz mikrofon strumieniowy wprowadź za pomocą pyaudio, powszechnie używana biblioteka open-source Pythona używana do manipulowania danymi audio. Następnie dodajesz wywołania Boto3 do Amazon Translate i Amazon Polly, aby uzyskać nasze funkcje tłumaczenia i zamiany tekstu na mowę. Na koniec ponownie przesyłasz przetłumaczoną mowę przez głośniki komputera za pomocą pyaudio. Moduł Pythona concurrent daje możliwość uruchomienia kodu blokującego we własnym asynchronicznym wątku, aby odtworzyć zwróconą mowę Amazon Polly w płynny, nieblokujący sposób.

Zaimportujmy wszystkie niezbędne moduły, dokonajmy transkrypcji klas strumieniowania i stwórzmy instancje globalne:

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"

Po pierwsze, używasz pyaudio aby uzyskać częstotliwość próbkowania urządzenia wejściowego, indeks urządzenia i liczbę kanałów:

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

Jeśli to nie zadziała, możesz także przeglądać i drukować urządzenia, jak pokazano w poniższym kodzie, a następnie użyć indeksu urządzenia, aby pobrać informacje o urządzeniu za pomocą 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"]

Używasz channel_count, sample_rate, dev_index jako parametry w strumieniu mikrofonowym. W funkcji zwrotnej tego strumienia używasz an asyncio nieblokujące, bezpieczne wątkowo wywołanie zwrotne w celu umieszczenia wejściowych bajtów strumienia mikrofonu w asyncio kolejka wejściowa. Zwróć uwagę na obiekty pętli i input_queue utworzone za pomocą asyncio i jak są używane w następującym kodzie:

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

Teraz, gdy funkcja generatora mic_stream() jest wywoływana, stale dostarcza bajty wejściowe, o ile w kolejce wejściowej znajdują się dane wejściowe mikrofonu.

Teraz, gdy wiesz, jak uzyskać bajty wejściowe z mikrofonu, przyjrzyjmy się, jak zapisać bajty wyjściowe Amazon Polly w strumieniu wyjściowym głośnika:

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

Teraz rozwińmy to, co zbudowałeś we wpisie Asynchroniczne Amazon Transscribe Streaming SDK dla Pythona. W poniższym kodzie tworzysz obiekt executor za pomocą ThreadPoolExecutor podklasa z trzema pracownikami z równoczesnymi. Następnie dodajesz wywołanie Amazon Translate do sfinalizowanego zwróconego transkrypcji w EventHandler i przekazujesz przetłumaczony tekst, obiekt executora i nasz aws_polly_tts() funkcjonować w asyncio pętla z loop.run_in_executor(), który uruchamia naszą funkcję Amazon Polly (z przetłumaczonym tekstem wejściowym) asynchronicznie na początku następnej iteracji asyncio pętla.

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

Wreszcie mamy loop_me() funkcjonować. W nim definiujesz write_chunks(), który przyjmuje strumień Amazon Transcribe jako argument i asynchronicznie zapisuje w nim fragmenty strumieniowego sygnału wejściowego mikrofonu. Następnie używasz MyEventHandler() z wyjściowym strumieniem transkrypcji jako argumentem i utwórz obiekt obsługi. Następnie używasz czekać z asyncio.gather() i przekaż write_chunks() i procedurę obsługi za pomocą metody handle_events(), aby obsłużyć ewentualną przyszłość tych współprogramów. Na koniec zbierasz wszystkie pętle zdarzeń i zapętlasz loop_me() funkcja z run_until_complete(). Zobacz następujący kod:

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

Gdy poprzedni kod zostanie uruchomiony bez błędów, możesz mówić do mikrofonu i szybko usłyszeć swój głos przetłumaczony na chiński mandaryński. Funkcja automatycznego wykrywania języka dla Amazon Transscribe i Amazon Translate tłumaczy dowolny obsługiwany język wprowadzania na język docelowy. Możesz mówić przez dłuższy czas, a ze względu na nieblokujący charakter wywołań funkcji, wszystkie wprowadzane przez Ciebie słowa są tłumaczone i wypowiadane, co czyni to doskonałe narzędzie do tłumaczenia przemówień na żywo.

Wnioski

Chociaż ten post pokazał, w jaki sposób te trzy w pełni zarządzane interfejsy API AWS mogą bezproblemowo ze sobą współpracować, zachęcamy do zastanowienia się, w jaki sposób można wykorzystać te usługi w inny sposób, aby zapewnić wielojęzyczną obsługę usług lub multimediów, takich jak wielojęzyczne napisy kodowane za ułamek obecnych kosztów . Medycyna, biznes, a nawet stosunki dyplomatyczne mogą czerpać korzyści z coraz lepszej, taniej i łatwej w utrzymaniu usługi tłumaczeniowej.

Aby uzyskać więcej informacji na temat podstawy kodu weryfikacji koncepcji dla tego przypadku użycia, zapoznaj się z naszym Github.

O autorach

Michael Tran jest architektem rozwiązań w zespole Envision Engineering w Amazon Web Services. Zapewnia wskazówki techniczne i pomaga klientom przyspieszyć ich zdolność do innowacji, pokazując sztukę tego, co możliwe w AWS. Zbudował wiele prototypów wokół AI/ML i IoT dla naszych klientów. Możesz skontaktować się ze mną @Mike_Trann na Twitterze.

Camerona Wilkesa jest architektem prototypów w zespole AWS Industry Accelerator. Będąc w zespole, dostarczył klientom kilka prototypów opartych na ML, aby zademonstrować „sztukę możliwości” ML na AWS. Lubi produkcję muzyczną, off-road i design.