לפרוץ את מחסומי השפה עם Amazon Transcribe, Amazon Translate ו- Amazon Polly

דמיינו לעצמכם מנתח שמקבל שיחות וידאו עם מטופלים ברחבי העולם ללא צורך במתרגם אנושי. מה אם סטארטאפ בתחילת דרכו יוכל בקלות להרחיב את המוצר שלו אל מעבר לגבולות ולשווקים גיאוגרפיים חדשים על ידי מתן תמיכת לקוחות ומכירות זורמים, מדויקים ורב-לשוניים, והכל ללא צורך במתרגם אנושי חי? מה קורה לעסק שלך כשאתה כבר לא קשור לשפה?

מקובל היום לקיים פגישות וירטואליות עם צוותים בינלאומיים ולקוחות הדוברים שפות רבות ושונות. בין אם מדובר בפגישות פנימיות או חיצוניות, פירוש הדבר לרוב הולך לאיבוד בדיונים מורכבים ואתם עלולים להיתקל במחסומי שפה שמונעים מכם להיות יעילים ככל האפשר.

בפוסט זה תלמדו כיצד להשתמש בשלושה שירותי AWS מנוהלים במלואם (אמזון תעתיק, אמזון תרגם, ו אמזון פולי) לייצר פתרון מתרגם דיבור לדיבור כמעט בזמן אמת שיכול לתרגם במהירות את קלט הקול החי של דובר מקור לשפת יעד מדוברת, מדויקת ומתורגמת, והכל עם חוויית למידת מכונה אפסית (ML).

סקירה כללית של הפיתרון

המתרגם שלנו מורכב משלושה שירותי AWS ML מנוהלים במלואם הפועלים יחד בסקריפט Python יחיד באמצעות AWS SDK עבור Python (Boto3) עבור תרגום הטקסט וחלקי הטקסט לדיבור שלנו, ו-SDK סטרימינג אסינכרוני לתמלול קלט שמע.

אמזון תמלול: הזרמת דיבור לטקסט

השירות הראשון שבו אתה משתמש במחסנית שלנו הוא Amazon Transcribe, שירות דיבור לטקסט מנוהל במלואו שלוקח דיבור קלט ומתמלל אותו לטקסט. ל- Amazon Transcribe יש שיטות קליטה גמישות, אצווה או סטרימינג, מכיוון שהיא מקבלת קבצי אודיו מאוחסנים או זרימת נתוני אודיו. בפוסט הזה אתה משתמש ב- Amazon Transcribe סטרימינג SDK אסינכרוני עבור Python, המשתמש בפרוטוקול הסטרימינג של HTTP/2 כדי להזרים אודיו חי ולקבלת תמלילים חיים.

כשבנינו את אב הטיפוס הזה לראשונה, הטמעת סטרימינג של Amazon Transcribe לא תמכה בזיהוי שפה אוטומטי, אבל זה כבר לא המקרה החל מנובמבר 2021. גם הטמעת אצווה וגם הזרמת סטרימינג תומכת כעת בזיהוי שפה אוטומטי עבור כולם שפות נתמכות. בפוסט זה, אנו מראים כיצד פתרון מבוסס פרמטרים באמצעות עיצוב ללא פרמטרים רב שפות חלק אפשרי באמצעות שימוש בזיהוי שפות אוטומטי בסטרימינג. לאחר שקטע הדיבור המתומלל שלנו מוחזר כטקסט, אתה שולח בקשה ל-Amazon Translate כדי לתרגם ולהחזיר את התוצאות ב-Amazon Transcribe. EventHandler שִׁיטָה.

Amazon Translate: ממשק-of-the-art, API לתרגום מנוהל במלואו

הבא בערימה שלנו הוא Amazon Translate, שירות תרגום מכונות עצביות המספק תרגום שפה מהיר, איכותי, זול וניתן להתאמה אישית. החל מיוני 2022, אמזון Translate תומכת בתרגום ל-75 שפות, כאשר צמדי שפות חדשים ושיפורים נעשים ללא הרף. Amazon Translate משתמשת במודלים של למידה עמוקה המתארחים בארכיטקטורת ענן AWS ניתנת להרחבה ועמידה במיוחד כדי לספק במהירות תרגומים מדויקים בזמן אמת או באצווה, בהתאם למקרה השימוש שלך. השימוש ב-Amazon Translate הוא פשוט ואינו דורש ניהול של ארכיטקטורה או מיומנויות ML הבסיסיות. ל- Amazon Translate יש מספר תכונות, כמו יצירה ושימוש ב- מונחים מותאמים אישית לטפל במיפוי בין מונחים ספציפיים לתעשייה. למידע נוסף על מגבלות השירות של Amazon Translate, עיין ב הנחיות ומגבלות. לאחר שהאפליקציה מקבלת את הטקסט המתורגם בשפת היעד שלנו, היא שולחת את הטקסט המתורגם לאמזון פולי לצורך השמעת אודיו מתורגמת מיידית.

Amazon Polly: ממשק API של טקסט לדיבור מנוהל במלואו

לבסוף, אתה שולח את הטקסט המתורגם לאמזון פולי, שירות טקסט-לדיבור מנוהל במלואו שיכול לשלוח בחזרה תגובות של קטעי אודיו אמיתיים להפעלת סטרימינג מיידית או באצווה ונשמר ב שירות אחסון פשוט של אמזון (Amazon S3) לשימוש מאוחר יותר. אתה יכול לשלוט בהיבטים שונים של דיבור כגון הגייה, עוצמת קול, גובה הצליל, קצב דיבור ועוד באמצעות סטנדרטי שפת סימון של סינתזת דיבור (SSML).

אתה יכול לסנתז דיבור עבור פולי מסויים של אמזון קולות עצביים שימוש בסגנון מגיש חדשות כדי לגרום להם להישמע כמו מגיש חדשות בטלוויזיה או ברדיו. אתה יכול גם לזהות מתי נאמרים מילים או משפטים ספציפיים בטקסט על סמך המטא נתונים הכלולים בזרם האודיו. זה מאפשר למפתח לסנכרן הדגשה גרפית ואנימציות, כגון תנועות שפתיים של אווטאר, עם הדיבור המסונתז.

אתה יכול לשנות את ההגייה של מילים מסוימות, כגון שמות חברות, ראשי תיבות, מילים לועזיות או ניאולוגיזם, למשל "P!nk", "ROTFL" או "C'est la vie" (כאשר מדובר בשפה שאינה צרפתית קול), תוך שימוש בלקסיקונים מותאמים אישית.

סקירה כללית של אדריכלות

התרשים הבא ממחיש את ארכיטקטורת הפתרונות שלנו.

זרימת העבודה היא כדלקמן:

1. השמע נקלט על ידי Python SDK.
2. אמזון פולי ממירה את הדיבור לטקסט, ב-39 שפות אפשריות.
3. Amazon Translate ממירה את השפות.
4. Amazon Live Transcribe ממיר טקסט לדיבור.
5. אודיו יוצא לרמקולים.

תנאים מוקדמים

אתה צריך להגדיר מכונה מארח עם מיקרופון, רמקולים וחיבור אינטרנט אמין. מחשב נייד מודרני אמור לעבוד מצוין עבור זה כי אין צורך בחומרה נוספת. לאחר מכן, עליך להגדיר את המכשיר עם כמה כלי תוכנה.

עליך להתקין את Python 3.7+ כדי להשתמש ב-SDK הזרימה האסינכרוני של Amazon Transcribe ועבור מודול Python בשם pyaudio, שבו אתה משתמש כדי לשלוט במיקרופון וברמקולים של המכשיר. מודול זה תלוי בספריית C בשם portaudio.h. אם אתה נתקל בבעיות עם pyaudio שגיאות, אנו מציעים לבדוק את מערכת ההפעלה שלך כדי לראות אם יש לך את portaudio.h ספרייה מותקנת.

להרשאה ואימות של קריאות שירות, אתה יוצר AWS זהות וניהול גישה תפקיד שירות (IAM) עם הרשאות להתקשר לשירותי AWS הדרושים. על ידי הגדרת ה ממשק שורת הפקודה של AWS (AWS CLI) עם תפקיד שירות IAM זה, אתה יכול להריץ את הסקריפט שלנו במחשב שלך ללא צורך בהעברת מפתחות או סיסמאות, מכיוון שספריות AWS נכתבות כדי להשתמש באישורים המוגדרים של משתמש AWS CLI. זוהי שיטה נוחה ליצירת אבות טיפוס מהירה ומבטיחה שהשירותים שלנו נקראים על ידי זהות מורשית. כמו תמיד, עקוב אחר עקרון ההרשאות הקטנות ביותר בעת הקצאת מדיניות IAM בעת יצירת משתמש או תפקיד IAM.

לסיכום, אתה צריך את התנאים המוקדמים הבאים:

• מחשב PC, Mac או Linux עם מיקרופון, רמקולים וחיבור לאינטרנט
• השמיים portaudio.h ספריית C עבור מערכת ההפעלה שלך (brew, apt get, wget), הדרושה כדי ש-pyaudio יפעל
• AWS CLI 2.0 עם משתמש IAM מורשה כהלכה שהוגדר על ידי הפעלת aws configure ב-AWS CLI
• פייתון 3.7+
• ה-SDK האסינכרוני של Amazon Transcribe Python
• ספריות Python הבאות:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

מיישמים את הפתרון

אתה תסתמך מאוד על ה-SDK הזרימה של Amazon Transcribe האסינכרוני עבור Python כנקודת התחלה, ותתבסס על ה-SDK הספציפי הזה. לאחר שהתנסת ב-SDK הסטרימינג עבור Python, אתה מוסיף מיקרופון זורם קלט על ידי שימוש pyaudio, ספריית Python בקוד פתוח נפוצה המשמשת למניפולציה של נתוני אודיו. לאחר מכן אתה מוסיף קריאות Boto3 ל-Amazon Translate ו-Amazon Polly עבור פונקציונליות התרגום והטקסט לדיבור שלנו. לבסוף, אתה מזרים שוב דיבור מתורגם דרך הרמקולים של המחשב pyaudio. מודול Python concurrent נותן לך את היכולת להריץ קוד חסימה בשרשור אסינכרוני משלו כדי להשמיע את הנאום של Amazon Polly שהוחזר בצורה חלקה, לא חוסמת.

בואו לייבא את כל המודולים הדרושים שלנו, לתמלל שיעורי סטרימינג, ולהציג כמה גלובלים:

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"

ראשית, אתה משתמש pyaudio כדי לקבל את קצב הדגימה של התקן הקלט, אינדקס המכשיר וספירת הערוצים:

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

אם זה לא עובד, אתה יכול גם לעבור ולהדפיס את המכשירים שלך כפי שמוצג בקוד הבא, ולאחר מכן להשתמש באינדקס המכשיר כדי לאחזר את פרטי המכשיר עם 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"]

אתה משתמש channel_count, sample_rate, ו dev_index כפרמטרים בזרם מיקרופון. בפונקציית ההתקשרות חזרה של הזרם הזה, אתה משתמש ב- asyncio התקשרות לא חוסמת חוט בטוח כדי להכניס את בתים הקלט של זרם המיקרופון לתוך an asyncio תור קלט. שימו לב לאובייקטי הלולאה וה-input_queue שנוצרו איתם asyncio וכיצד הם משמשים בקוד הבא:

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

עכשיו כאשר הגנרטור פועל mic_stream() נקרא, הוא מניב ללא הרף בתים של קלט כל עוד יש נתוני קלט של מיקרופון בתור הקלט.

עכשיו כשאתה יודע איך לקבל בתים קלט מהמיקרופון, בואו נראה איך לכתוב בתים של פלט אמזון פולי לזרם פלט רמקול:

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

עכשיו בואו נרחיב על מה שבניתם בפוסט A-Synchronous Amazon Transcribe Streaming SDK עבור Python. בקוד הבא, אתה יוצר אובייקט מבצע באמצעות ה- ThreadPoolExecutor תת כיתה עם שלושה עובדים במקביל. לאחר מכן אתה מוסיף קריאת אמזון Translate לתמליל שהוחזר הסופי ב-EventHandler ומעביר את הטקסט המתורגם הזה, אובייקט המבצע והנושא שלנו aws_polly_tts() לתפקד לתוך asyncio לולאה עם loop.run_in_executor(), אשר מריץ את פונקציית Amazon Polly שלנו (עם טקסט קלט מתורגם) באופן אסינכרוני בתחילת האיטרציה הבאה של asyncio לולאה.

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

לבסוף, יש לנו את loop_me() פוּנקצִיָה. בו אתה מגדיר write_chunks(), שלוקח זרם של Amazon Transcribe כארגומנט וכותב אליו באופן אסינכרוני נתחים של קלט מיקרופון זורם. לאחר מכן אתה משתמש MyEventHandler() עם זרם תמלול הפלט כארגומנט שלו וצור אובייקט מטפל. אז אתה משתמש לחכות עם asyncio.gather() והעבירו את ה-write_chunks() ואת המטפל עם שיטת handle_events() כדי לטפל בעתידים בסופו של דבר של קורוטינים אלו. לבסוף, אתה אוסף את כל לולאות האירוע ולופ את loop_me() לתפקד עם run_until_complete(). ראה את הקוד הבא:

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

כאשר הקוד הקודם מופעל יחד ללא שגיאות, אתה יכול לדבר לתוך המיקרופון ולשמוע במהירות את קולך מתורגם לסינית מנדרינית. תכונת זיהוי השפה האוטומטית עבור Amazon Transcribe ו- Amazon Translate מתרגמת כל שפת קלט נתמכת לשפת היעד. אתה יכול לדבר די הרבה זמן ובגלל האופי הבלתי-חוסם של קריאות הפונקציה, כל קלט הדיבור שלך מתורגם ומדובר, מה שהופך את זה לכלי מצוין לתרגום נאומים חיים.

סיכום

למרות שפוסט זה הדגים כיצד שלושת ממשקי ה-API של AWS המנוהלים במלואם יכולים לתפקד ביחד בצורה חלקה, אנו ממליצים לך לחשוב כיצד תוכל להשתמש בשירותים אלה בדרכים אחרות כדי לספק תמיכה רב-לשונית עבור שירותים או מדיה כמו כתוביות סגורות רב-לשוניות תמורת חלק מהעלות הנוכחית . רפואה, עסקים ואפילו יחסים דיפלומטיים יכולים כולם ליהנות משירות תרגום המשתפר ללא הרף, בעלות נמוכה ובתחזוקה נמוכה.

למידע נוסף על בסיס קוד הוכחת הרעיון עבור מקרה שימוש זה, עיין ב- שלנו GitHub.

על הכותבים

מייקל טראן הוא אדריכל פתרונות עם צוות הנדסת Envision בשירותי האינטרנט של אמזון. הוא מספק הדרכה טכנית ומסייע ללקוחות להאיץ את יכולתם לחדש באמצעות הצגת אמנות האפשרי ב-AWS. הוא בנה מספר אבות טיפוס סביב AI/ML, ו-IoT עבור הלקוחות שלנו. אתה יכול לפנות אליי @Mike_Trann בטוויטר.

קמרון ווילקס הוא אדריכל אבות טיפוס בצוות ה-AWS Industry Accelerator. בעודו בצוות הוא סיפק מספר אבות טיפוס מבוססי ML ללקוחות כדי להדגים את "אמנות האפשר" של ML ב-AWS. הוא נהנה מהפקה מוזיקלית, משטח ועיצוב.