Murtaudu kielimuurien läpi Amazon Transcriben, Amazon Translaten ja Amazon Pollyn avulla

Kuvittele kirurgi, joka soittaa videopuheluita potilaiden kanssa ympäri maailmaa ilman ihmiskääntäjää. Entä jos aloitteleva startup voisi helposti laajentaa tuotettaan yli rajojen ja uusille maantieteellisille markkinoille tarjoamalla sujuvaa, tarkkaa, monikielistä asiakastukea ja myyntiä, kaikki ilman elävää ihmiskääntäjää? Mitä yrityksellesi tapahtuu, kun kieli ei enää sido sinua?

Nykyään on tavallista pitää virtuaalisia tapaamisia kansainvälisten tiimien ja asiakkaiden kanssa, jotka puhuvat monia eri kieliä. Olipa kyseessä sisäisiä tai ulkoisia kokouksia, merkitys katoaa usein monimutkaisissa keskusteluissa ja saatat kohdata kielimuurit, jotka estävät sinua olemasta yhtä tehokas kuin voisit olla.

Tässä viestissä opit käyttämään kolmea täysin hallittua AWS-palvelua (Amazonin transkriptio, Amazon Käännäja Amazon Polly) tuottaa lähes reaaliaikainen puheen puheeksi kääntäjäratkaisu, joka voi nopeasti kääntää lähdepuhujan elävän puhesyötteen puhutuksi, tarkaksi, käännetyksi kohdekieleksi ilman koneoppimiskokemusta (ML).

Katsaus ratkaisuun

Kääntäjämme koostuu kolmesta täysin hallitusta AWS ML -palvelusta, jotka toimivat yhdessä yhdessä Python-komentosarjassa käyttämällä AWS SDK Pythonille (Boto3) tekstin käännökselle ja tekstistä puheeksi -osille sekä asynkroniselle suoratoisto-SDK:lle audiosyötteen transkriptioon.

Amazon Transcribe: Puheen suoratoisto tekstiksi

Ensimmäinen palvelu, jota käytät pinossamme, on Amazon Transcribe, täysin hallittu puheen tekstiksi -palvelu, joka ottaa syötetyn puheen ja litteroi sen tekstiksi. Amazon Transcribeilla on joustavia käsittelymenetelmiä, erä tai suoratoisto, koska se hyväksyy joko tallennetut äänitiedostot tai suoratoiston äänidatan. Tässä viestissä käytät asynkroninen Amazon Transcribe -suoratoisto-SDK Pythonille, joka käyttää HTTP/2-suoratoistoprotokollaa suoratoistaakseen suoraa ääntä ja vastaanottaakseen suoria transkriptioita.

Kun rakensimme tämän prototyypin ensimmäisen kerran, Amazon Transcriben suoratoisto ei tukenut automaattista kielentunnistusta, mutta näin ei ole enää marraskuusta 2021 lähtien. Sekä erä- että suoratoisto tukevat nyt automaattista kielentunnistusta kaikille. tuetut kielet. Tässä viestissä näytämme, kuinka parametreihin perustuva ratkaisu saumattoman monikielisen parametrittoman suunnittelun kautta on mahdollista suoratoiston automaattisen kielentunnistuksen avulla. Kun litteroitu puhesegmenttimme on palautettu tekstinä, lähetät Amazon Translatelle pyynnön kääntää ja palauttaa tulokset Amazon Transcribessamme. EventHandler menetelmällä.

Amazon Translate: Huippumoderni, täysin hallittu käännössovellusliittymä

Seuraavaksi pinossamme on Amazon Translate, hermoston konekäännöspalvelu, joka tarjoaa nopean, laadukkaan, edullisen ja muokattavissa olevan kielikäännöksen. Kesäkuusta 2022 lähtien Amazon Translate tukee kääntämistä 75 kielelle, ja uusia kielipareja ja parannuksia tehdään jatkuvasti. Amazon Translate käyttää syväoppimismalleja, jotka isännöidään erittäin skaalautuvassa ja joustavassa AWS-pilviarkkitehtuurissa, jotta ne toimittavat nopeasti tarkat käännökset joko reaaliajassa tai erässä käyttötapauksestasi riippuen. Amazon Translaten käyttäminen on yksinkertaista eikä vaadi taustalla olevan arkkitehtuurin tai ML-taitojen hallintaa. Amazon Translatessa on useita ominaisuuksia, kuten luominen ja käyttö a mukautettu terminologia hoitaa kartoitusta toimialakohtaisten termien välillä. Lisätietoja Amazon Translate -palvelun rajoituksista on kohdassa Ohjeet ja rajat. Kun sovellus vastaanottaa käännetyn tekstin kohdekielellämme, se lähettää käännetyn tekstin Amazon Pollylle välitöntä käännettyä äänentoistoa varten.

Amazon Polly: Täysin hallittu tekstistä puheeksi API

Lopuksi lähetät käännetyn tekstin Amazon Pollylle, täysin hallittavalle tekstistä puheeksi -palvelulle, joka voi joko lähettää takaisin todentuntuisia äänileikkeiden vastauksia välitöntä suoratoistoa varten tai koota ja tallentaa Amazonin yksinkertainen tallennuspalvelu (Amazon S3) myöhempää käyttöä varten. Voit hallita puheen eri näkökohtia, kuten ääntämistä, äänenvoimakkuutta, äänenkorkeutta, puhenopeutta ja paljon muuta käyttämällä standardoitua Puhesynteesin merkintäkieli (SSML).

Voit syntetisoida puhetta tietyille Amazon Pollylle Neuraaliset äänet käyttämällä Newscaster-tyyliä saadakseen ne kuulostamaan television tai radion uutislähettäjältä. Voit myös havaita, milloin tekstissä puhutaan tiettyjä sanoja tai lauseita äänivirran sisältämien metatietojen perusteella. Näin kehittäjä voi synkronoida graafiset korostukset ja animaatiot, kuten avatarin huulten liikkeet, syntetisoidun puheen kanssa.

Voit muokata tiettyjen sanojen ääntämistä, kuten yritysten nimiä, lyhenteitä, vieraita sanoja tai neologismeja, esimerkiksi "P!nk", "ROTFL" tai "C'est la vie" (kun puhutaan ei-ranskan kielellä ääni), käyttämällä mukautettuja sanastoja.

Arkkitehtuurin yleiskatsaus

Seuraava kaavio kuvaa ratkaisuarkkitehtuuriamme.

Työnkulku on seuraava:

1. Python SDK käyttää ääntä.
2. Amazon Polly muuntaa puheen tekstiksi 39 mahdollisella kielellä.
3. Amazon Translate muuntaa kielet.
4. Amazon Live Transcribe muuntaa tekstin puheeksi.
5. Ääni lähetetään kaiuttimiin.

Edellytykset

Tarvitset isäntäkoneen, jossa on mikrofoni, kaiuttimet ja luotettava internetyhteys. Nykyaikaisen kannettavan tietokoneen pitäisi toimia hyvin tähän, koska lisälaitteita ei tarvita. Seuraavaksi sinun on määritettävä kone jollakin ohjelmistotyökalulla.

Sinulla on oltava Python 3.7+ asennettuna, jotta voit käyttää asynkronista Amazon Transcriben suoratoisto-SDK:ta ja Python-moduulia pyaudio, jolla ohjaat koneen mikrofonia ja kaiuttimia. Tämä moduuli riippuu C-kirjastosta nimeltä portaudio.h. Jos kohtaat ongelmia pyaudio virheitä, suosittelemme tarkistamaan käyttöjärjestelmästäsi, onko sinulla portaudio.h kirjasto asennettuna.

Palvelupuheluiden valtuutusta ja todennusta varten luot AWS-henkilöllisyyden ja käyttöoikeuksien hallinta (IAM) palvelurooli, jolla on oikeudet kutsua tarvittavat AWS-palvelut. Konfiguroimalla AWS-komentoriviliitäntä (AWS CLI) tällä IAM-palveluroolilla voit suorittaa komentosarjamme koneellasi ilman avaimien tai salasanojen syöttämistä, koska AWS-kirjastot on kirjoitettu käyttämään määritettyä AWS CLI -käyttäjän tunnistetietoja. Tämä on kätevä tapa nopeaan prototyyppien luomiseen ja varmistaa, että palveluihimme soittaa valtuutettu henkilöllisyys. Kuten aina, noudata pienimmän etuoikeuden periaatetta määrittäessäsi IAM-käytäntöjä luodessasi IAM-käyttäjää tai -roolia.

Yhteenvetona tarvitset seuraavat edellytykset:

• PC-, Mac- tai Linux-kone, jossa on mikrofoni, kaiuttimet ja internetyhteys
• - portaudio.h C-kirjasto käyttöjärjestelmällesi (brew, apt get, wget), jota tarvitaan pyaudion toimimiseen
• AWS CLI 2.0, jossa on asianmukaisesti valtuutettu IAM-käyttäjä, joka on määritetty suorittamalla aws configure AWS CLI:ssä
• Python 3.7+
• Asynkroninen Amazon Transcribe Python SDK
• Seuraavat Python-kirjastot:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

Toteuta ratkaisu

Luotat vahvasti Pythonin asynkroniseen Amazon Transcriben suoratoisto-SDK:hen, ja aiot rakentaa tämän tietyn SDK:n päälle. Kun olet kokeillut Pythonin suoratoisto-SDK:ta, lisää suoratoisto mikrofoni syötä käyttämällä pyaudio, yleisesti käytetty Python avoimen lähdekoodin kirjasto, jota käytetään äänidatan käsittelyyn. Sitten lisäät Boto3-kutsut Amazon Translateen ja Amazon Pollyyn käännös- ja tekstistä puheeksi -toimintoihimme varten. Lopuksi suoratoistat käännetyn puheen uudelleen tietokoneen kaiuttimien kautta pyaudio. Python-moduuli concurrent antaa sinulle mahdollisuuden suorittaa estokoodia omassa asynkronisessa säikeessään toistaaksesi palautetun Amazon Polly -puheen saumattomalla, estämättömällä tavalla.

Tuodaan kaikki tarvittavat moduulimme, litteroitetaan suoratoistoluokat ja luodaan joitain globaaleja:

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"

Ensinnäkin käytät pyaudio saadaksesi syöttölaitteen näytteenottotaajuuden, laiteindeksin ja kanavien lukumäärän:

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

Jos tämä ei auta, voit myös käydä läpi ja tulostaa laitteesi seuraavan koodin osoittamalla tavalla ja sitten käyttää laitehakemistoa laitteen tietojen hakemiseen 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"]

Sinä käytät channel_count, sample_rateja dev_index parametreina mikrofonivirrassa. Tämän streamin takaisinsoittotoiminnossa käytät asyncio estoton säikeen varma takaisinsoitto siirtääksesi mikrofonivirran syöttötavut an asyncio syöttöjono. Ota huomioon silmukka- ja input_queue-objektit, jotka on luotu asyncio ja miten niitä käytetään seuraavassa koodissa:

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

Nyt kun generaattori toimii mic_stream() kutsutaan, se tuottaa jatkuvasti syöttötavuja niin kauan kuin syöttöjonossa on mikrofonin syöttödataa.

Nyt kun tiedät kuinka saada syöttötavuja mikrofonista, katsotaanpa kuinka kirjoittaa Amazon Polly -äänitavut kaiuttimen lähtövirtaan:

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

Laajennamme nyt sitä, mitä rakensit viestissä Asynkroninen Amazon Transcribe Streaming SDK Pythonille. Seuraavassa koodissa luot suorittajaobjektin käyttämällä ThreadPoolExecutor alaluokka, jossa on kolme työntekijää samanaikaisesti. Lisäät sitten Amazon Translate -kutsun viimeisteltylle palautetulle transkriptiolle EventHandleriin ja välität käännetyn tekstin, suoritinobjektin ja aws_polly_tts() toimia an asyncio lenkki kanssa loop.run_in_executor(), joka käyttää Amazon Polly -toimintoamme (käännetyllä syöttötekstillä) asynkronisesti seuraavan iteraation alussa asyncio silmukka.

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

Viimeinkin meillä on loop_me() toiminto. Siinä sinä määrittelet write_chunks(), joka ottaa Amazon Transcriben streamin argumenttina ja kirjoittaa siihen asynkronisesti osia suoratoistomikrofonista. Käytät sitten MyEventHandler() käyttämällä lähtötranskriptiovirtaa argumenttina ja luo käsittelijäobjekti. Sitten käytät odota kanssa asyncio.gather() ja välitä write_chunks() ja käsittelijä hand_events()-metodilla näiden korutiinien mahdollisten futuurien käsittelemiseksi. Lopuksi kokoat kaikki tapahtumasilmukat ja silmukat loop_me() toimimaan kanssa run_until_complete(). Katso seuraava koodi:

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

Kun edellinen koodi suoritetaan yhdessä ilman virheitä, voit puhua mikrofoniin ja kuulla äänesi nopeasti käännettynä mandariinikiinaksi. Amazon Transcriben ja Amazon Translaten automaattinen kielentunnistusominaisuus kääntää minkä tahansa tuetun syöttökielen kohdekieleksi. Voit puhua jonkin aikaa, ja toimintokutsujen estävän luonteen vuoksi kaikki puhesyötteesi käännetään ja puhutaan, joten tämä on erinomainen työkalu live-puheiden kääntämiseen.

Yhteenveto

Vaikka tämä viesti osoitti, kuinka nämä kolme täysin hallittua AWS-sovellusliittymää voivat toimia saumattomasti yhdessä, kehotamme sinua miettimään, kuinka voit käyttää näitä palveluita muilla tavoilla tarjotaksesi monikielistä tukea palveluille tai medialle, kuten monikielinen tekstitys murto-osalla nykyisistä kustannuksista. . Lääketiede, liike-elämä ja jopa diplomaattisuhteet voisivat kaikki hyötyä jatkuvasti kehittyvästä, edullisesta ja vähän huoltoa vaativasta käännöspalvelusta.

Lisätietoja tämän käyttötapauksen proof of concept -koodipohjasta on meidän Github.

Tietoja Tekijät

Michael Tran on ratkaisuarkkitehti ja Envision Engineering -tiimi Amazon Web Services -palvelussa. Hän tarjoaa teknistä ohjausta ja auttaa asiakkaita nopeuttamaan innovaatiokykyään näyttämällä AWS:n mahdollisuuksien taidetta. Hän on rakentanut asiakkaillemme useita prototyyppejä tekoälyn/ML:n ja IoT:n ympärille. Voit ottaa minuun yhteyttä @Mike_Trann Twitterissä.

Cameron Wilkes on prototyyppiarkkitehti AWS Industry Accelerator -tiimissä. Ryhmässä ollessaan hän toimitti asiakkaille useita ML-pohjaisia ​​prototyyppejä demonstroidakseen ML:n "mahdollisuuden taitoa" AWS:ssä. Hän pitää musiikin tuotannosta, off-roadista ja suunnittelusta.