ก้าวข้ามอุปสรรคด้านภาษาด้วย Amazon Transcribe, Amazon Translate และ Amazon Polly

ลองนึกภาพศัลยแพทย์กำลังสนทนาทางวิดีโอกับผู้ป่วยทั่วโลกโดยไม่จำเป็นต้องใช้คนแปล จะเกิดอะไรขึ้นหากสตาร์ทอัพที่เพิ่งเริ่มต้นสามารถขยายผลิตภัณฑ์ของตนข้ามพรมแดนและเข้าสู่ตลาดทางภูมิศาสตร์ใหม่ ๆ ได้โดยง่าย โดยนำเสนอการสนับสนุนและการขายลูกค้าที่คล่องแคล่ว แม่นยำ และพูดได้หลายภาษา ทั้งหมดนี้โดยไม่ต้องใช้นักแปลที่เป็นมนุษย์ จะเกิดอะไรขึ้นกับธุรกิจของคุณเมื่อคุณไม่ผูกมัดด้วยภาษาอีกต่อไป

เป็นเรื่องปกติในปัจจุบันที่จะมีการประชุมเสมือนจริงกับทีมต่างประเทศและลูกค้าที่พูดภาษาต่างๆ มากมาย ไม่ว่าจะเป็นการประชุมภายในหรือภายนอก ความหมายมักจะหายไปในการอภิปรายที่ซับซ้อน และคุณอาจพบกับอุปสรรคทางภาษาที่ขัดขวางไม่ให้คุณมีประสิทธิภาพเท่าที่ควร

ในโพสต์นี้ คุณจะได้เรียนรู้วิธีใช้บริการของ AWS ที่มีการจัดการเต็มรูปแบบสามบริการ (ถอดความจากอเมซอน, อเมซอนแปลภาษาและ Amazon Polly) เพื่อผลิตโซลูชันตัวแปลคำพูดเป็นคำพูดที่เกือบจะเรียลไทม์ ซึ่งสามารถแปลการป้อนข้อมูลด้วยเสียงสดของผู้พูดแหล่งที่มาเป็นภาษาเป้าหมายที่พูด ถูกต้อง และแปลได้อย่างรวดเร็ว ทั้งหมดนี้ไม่มีประสบการณ์การเรียนรู้ด้วยเครื่อง (ML)

ภาพรวมของโซลูชัน

นักแปลของเราประกอบด้วยบริการ AWS ML ที่มีการจัดการเต็มรูปแบบสามบริการที่ทำงานร่วมกันในสคริปต์ Python เดียวโดยใช้ AWS SDK สำหรับ Python (Boto3) สำหรับการแปลข้อความและส่วนของข้อความเป็นคำพูดของเรา และ SDK สตรีมมิงแบบอะซิงโครนัสสำหรับการถอดความอินพุตเสียง

Amazon Transcribe: สตรีมเสียงพูดเป็นข้อความ

บริการแรกที่คุณใช้ในสแตกของเราคือ Amazon Transcribe ซึ่งเป็นบริการแปลงเสียงพูดเป็นข้อความที่มีการจัดการเต็มรูปแบบซึ่งจะนำเสียงพูดที่ป้อนเข้าและแปลงเป็นข้อความ Amazon Transcribe มีวิธีการนำเข้าที่ยืดหยุ่น แบทช์หรือการสตรีม เนื่องจากยอมรับไฟล์เสียงที่จัดเก็บไว้หรือการสตรีมข้อมูลเสียง ในโพสต์นี้คุณใช้ อะซิงโครนัส Amazon Transcribe การสตรีม SDK สำหรับ Pythonซึ่งใช้โปรโตคอลการสตรีม HTTP/2 เพื่อสตรีมเสียงสดและรับการถอดเสียงแบบสด

เมื่อเราสร้างต้นแบบนี้ครั้งแรก การส่งผ่านข้อมูลแบบสตรีมของ Amazon Transcribe ไม่รองรับการตรวจจับภาษาอัตโนมัติ แต่จะไม่มีกรณีนี้อีกต่อไปในเดือนพฤศจิกายน 2021 การนำเข้าทั้งแบบชุดและแบบสตรีมรองรับการตรวจจับภาษาอัตโนมัติสำหรับทุกคน ภาษาที่รองรับ. ในโพสต์นี้ เราแสดงให้เห็นว่าโซลูชันแบบอิงพารามิเตอร์ได้อย่างไร แม้ว่าการออกแบบแบบไม่มีพารามิเตอร์หลายภาษาแบบไร้รอยต่อสามารถทำได้โดยใช้การสตรีมการตรวจจับภาษาอัตโนมัติ หลังจากที่ส่งคืนส่วนคำพูดที่ถอดเสียงเป็นข้อความแล้ว คุณส่งคำขอไปที่ Amazon Translate เพื่อแปลและส่งคืนผลลัพธ์ใน Amazon Transcribe EventHandler วิธี

Amazon Translate: API การแปลที่ล้ำสมัยและมีการจัดการเต็มรูปแบบ

ถัดไปในกลุ่มของเราคือ Amazon Translate ซึ่งเป็นบริการแปลภาษาด้วยเครื่องประสาทที่ให้การแปลภาษาที่รวดเร็ว คุณภาพสูง ราคาไม่แพง และปรับแต่งได้ ในเดือนมิถุนายน 2022 Amazon Translate รองรับการแปลใน 75 ภาษา โดยมีคู่ภาษาใหม่และการปรับปรุงอย่างต่อเนื่อง Amazon Translate ใช้โมเดลการเรียนรู้เชิงลึกที่โฮสต์บนสถาปัตยกรรม AWS Cloud ที่ปรับขนาดได้สูงและยืดหยุ่นได้ เพื่อส่งมอบการแปลที่แม่นยำอย่างรวดเร็วทั้งในแบบเรียลไทม์หรือแบบกลุ่ม ขึ้นอยู่กับกรณีการใช้งานของคุณ การใช้ Amazon Translate นั้นตรงไปตรงมาและไม่ต้องการการจัดการสถาปัตยกรรมพื้นฐานหรือทักษะ ML Amazon Translate มีคุณสมบัติหลายอย่าง เช่น การสร้างและการใช้ a คำศัพท์ที่กำหนดเอง เพื่อจัดการการทำแผนที่ระหว่างข้อกำหนดเฉพาะของอุตสาหกรรม สำหรับข้อมูลเพิ่มเติมเกี่ยวกับขีดจำกัดบริการของ Amazon Translate โปรดดูที่ แนวทางและข้อจำกัด. หลังจากที่แอปพลิเคชันได้รับข้อความที่แปลแล้วในภาษาเป้าหมายของเรา แอปพลิเคชันจะส่งข้อความที่แปลแล้วไปยัง Amazon Polly เพื่อเล่นเสียงที่แปลทันที

Amazon Polly: API การแปลงข้อความเป็นคำพูดที่มีการจัดการเต็มรูปแบบ

สุดท้าย คุณส่งข้อความที่แปลแล้วไปยัง Amazon Polly ซึ่งเป็นบริการแปลงข้อความเป็นคำพูดที่มีการจัดการเต็มรูปแบบ ซึ่งสามารถส่งกลับเสียงตอบกลับคลิปเสียงที่เหมือนจริงสำหรับการเล่นสตรีมแบบทันทีหรือจัดกลุ่มและบันทึกไว้ใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) เพื่อใช้ในภายหลัง คุณสามารถควบคุมคำพูดในด้านต่างๆ เช่น การออกเสียง ระดับเสียง ระดับเสียง อัตราการพูด และอื่นๆ โดยใช้มาตรฐาน ภาษามาร์กอัปการสังเคราะห์เสียง (ส.ส.ม.).

คุณสามารถสังเคราะห์เสียงพูดสำหรับ Amazon Polly บางอย่างได้ เสียงประสาท โดยใช้รูปแบบผู้ประกาศข่าวเพื่อให้เสียงเหมือนผู้ประกาศข่าวทางโทรทัศน์หรือวิทยุ คุณยังสามารถตรวจจับได้เมื่อมีการพูดคำหรือประโยคเฉพาะในข้อความโดยอิงจากข้อมูลเมตาที่รวมอยู่ในสตรีมเสียง ซึ่งช่วยให้นักพัฒนาสามารถซิงโครไนซ์การเน้นกราฟิกและแอนิเมชั่น เช่น การเคลื่อนไหวของริมฝีปากของอวาตาร์ กับคำพูดที่สังเคราะห์ได้

คุณสามารถแก้ไขการออกเสียงของคำบางคำได้ เช่น ชื่อบริษัท ตัวย่อ คำต่างประเทศ หรือ neologisms เช่น “P!nk,” “ROTFL” หรือ “C'est la vie” (เมื่อพูดในภาษาที่ไม่ใช่ภาษาฝรั่งเศส เสียง) โดยใช้ศัพท์เฉพาะที่กำหนดเอง

ภาพรวมสถาปัตยกรรม

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมโซลูชันของเรา

เวิร์กโฟลว์มีดังนี้:

1. เสียงถูกนำเข้าโดย Python SDK
2. Amazon Polly แปลงคำพูดเป็นข้อความใน 39 ภาษาที่เป็นไปได้
3. Amazon Translate แปลงภาษา
4. Amazon Live Transcribe แปลงข้อความเป็นคำพูด
5. เสียงจะถูกส่งออกไปยังลำโพง

เบื้องต้น

คุณต้องมีเครื่องโฮสต์ที่ติดตั้งไมโครโฟน ลำโพง และการเชื่อมต่ออินเทอร์เน็ตที่เชื่อถือได้ แล็ปท็อปสมัยใหม่น่าจะทำงานได้ดีเพราะไม่จำเป็นต้องใช้ฮาร์ดแวร์เพิ่มเติม ถัดไป คุณต้องตั้งค่าเครื่องด้วยเครื่องมือซอฟต์แวร์บางอย่าง

คุณต้องติดตั้ง Python 3.7+ เพื่อใช้การสตรีม SDK ของ Amazon Transcribe แบบอะซิงโครนัสและสำหรับโมดูล Python ที่เรียกว่า pyaudioซึ่งคุณใช้ควบคุมไมโครโฟนและลำโพงของเครื่อง โมดูลนี้ขึ้นอยู่กับไลบรารี C ที่เรียกว่า portaudio.h. หากคุณประสบปัญหากับ pyaudio ข้อผิดพลาด เราแนะนำให้ตรวจสอบระบบปฏิบัติการของคุณเพื่อดูว่าคุณมี portaudio.h ติดตั้งห้องสมุดแล้ว

สำหรับการอนุญาตและการรับรองความถูกต้องของการเรียกบริการ คุณสร้าง AWS Identity และการจัดการการเข้าถึง บทบาทบริการ (IAM) ที่มีสิทธิ์เรียกใช้บริการของ AWS ที่จำเป็น โดยการกำหนดค่า อินเทอร์เฟซบรรทัดคำสั่ง 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 กำหนดค่าใน AWS CLI
• หลาม 3.7+
• Amazon Transcribe Python SDK แบบอะซิงโครนัส
• ไลบรารี Python ต่อไปนี้:
  • boto3
  • amazon-transcribe
  • pyaudio
  • asyncio
  • concurrent

ดำเนินการแก้ปัญหา

คุณจะต้องใช้ Amazon Transcribe สตรีมมิ่ง SDK แบบอะซิงโครนัสสำหรับ 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 เป็นพารามิเตอร์ในสตรีมไมค์ ในฟังก์ชันเรียกกลับของสตรีมนั้น คุณใช้ an asyncio nonblocking thread-safe callback เพื่อใส่ไบต์อินพุตของสตรีมไมค์ลงใน 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() ถูกเรียก มันให้ผลลัพธ์อย่างต่อเนื่องตราบใดที่มีข้อมูลอินพุตไมโครโฟนในคิวอินพุต

ตอนนี้ คุณรู้วิธีรับไบต์อินพุตจากไมโครโฟนแล้ว มาดูวิธีเขียนไบต์ของเสียงที่ส่งออกของ Amazon Polly ไปยังสตรีมเอาท์พุตของลำโพงกัน:

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

ตอนนี้เรามาขยายสิ่งที่คุณสร้างในโพสต์กัน Amazon Transcribe Streaming SDK แบบอะซิงโครนัสสำหรับ Python. ในรหัสต่อไปนี้ คุณสร้างวัตถุตัวดำเนินการโดยใช้ ThreadPoolExecutor คลาสย่อยที่มีคนงานสามคนพร้อมกัน จากนั้นคุณเพิ่มการเรียกของ Amazon 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() และ handler ด้วยเมธอด handle_events() เพื่อจัดการฟิวเจอร์สในที่สุดของ coroutines เหล่านี้ สุดท้าย คุณรวบรวมลูปเหตุการณ์ทั้งหมดและวนรอบ 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 จะแปลภาษาอินพุตที่รองรับเป็นภาษาเป้าหมาย คุณสามารถพูดได้สักระยะหนึ่งและเนื่องจากการเรียกใช้ฟังก์ชันที่ไม่มีการปิดกั้น การป้อนข้อมูลด้วยคำพูดทั้งหมดของคุณจึงได้รับการแปลและพูด ทำให้เป็นเครื่องมือที่ยอดเยี่ยมสำหรับการแปลสุนทรพจน์สด

สรุป

แม้ว่าโพสต์นี้จะแสดงให้เห็นว่า AWS API ที่มีการจัดการเต็มรูปแบบทั้งสามนี้สามารถทำงานร่วมกันได้อย่างราบรื่นอย่างไร เราขอแนะนำให้คุณคิดว่าคุณจะใช้บริการเหล่านี้ด้วยวิธีอื่นๆ ได้อย่างไรเพื่อให้บริการสนับสนุนหลายภาษาสำหรับบริการหรือสื่อ เช่น คำบรรยายใต้ภาพแบบหลายภาษาสำหรับค่าใช้จ่ายในปัจจุบันเพียงเล็กน้อย . การแพทย์ ธุรกิจ และแม้กระทั่งความสัมพันธ์ทางการฑูตทั้งหมดสามารถได้รับประโยชน์จากบริการแปลที่มีต้นทุนต่ำและบำรุงรักษาต่ำ

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการพิสูจน์ฐานรหัสแนวคิดสำหรับกรณีการใช้งานนี้ โปรดดูที่ Github.

เกี่ยวกับผู้เขียน

ไมเคิล ทราน เป็นสถาปนิกโซลูชันพร้อมทีม Envision Engineering ที่ Amazon Web Services เขาให้คำแนะนำทางเทคนิคและช่วยลูกค้าเร่งความสามารถในการสร้างสรรค์ผ่านการแสดงศิลปะที่เป็นไปได้บน AWS เขาได้สร้างต้นแบบหลายตัวเกี่ยวกับ AI/ML และ IoT สำหรับลูกค้าของเรา คุณสามารถติดต่อฉัน @Mike_Trann บน Twitter

คาเมรอน วิลค์ส เป็นสถาปนิกต้นแบบในทีม AWS Industry Accelerator ขณะอยู่ในทีม เขาได้ส่งต้นแบบ ML หลายตัวให้กับลูกค้าเพื่อสาธิต "ศิลปะแห่งความเป็นไปได้" ของ ML บน AWS เขาชอบผลิตเพลง ออฟโรด และการออกแบบ