ปรับใช้โซลูชัน MLOps ที่โฮสต์ตำแหน่งข้อมูลโมเดลของคุณใน AWS Lambda

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

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

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

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

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

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

สถาปัตยกรรมที่เราปรับใช้ (ดูรูปต่อไปนี้) เป็นแนวทางที่ขับเคลื่อนด้วย CI/CD อย่างสมบูรณ์สำหรับแมชชีนเลิร์นนิง องค์ประกอบถูกแยกออกเพื่อหลีกเลี่ยงการมีโซลูชันแบบเสาหินเดียว

เริ่มจากด้านบนซ้ายของไดอะแกรม เดอะ การประมวลผล – การสร้างภาพ คอมโพเนนต์เป็นแบบ CI/CD-driven AWS CodeCommit พื้นที่เก็บข้อมูลที่ช่วยสร้างและผลักดัน นักเทียบท่า คอนเทนเนอร์ถึง การลงทะเบียน Amazon Elastic Container (อีซีอาร์ของอเมซอน) คอนเทนเนอร์การประมวลผลนี้ทำหน้าที่เป็นขั้นตอนแรกในไปป์ไลน์ ML ของเรา แต่ยังนำมาใช้ซ้ำสำหรับขั้นตอนหลังการประมวลผลอีกด้วย ในกรณีของเรา เราใช้การจำลองแบบมอนติคาร์โลในการประมวลผลภายหลัง เดอะ การฝึกอบรม – การสร้างภาพ พื้นที่เก็บข้อมูลที่แสดงด้านล่างซ้ายมีกลไกเช่นเดียวกับ การประมวลผล บล็อกด้านบน ข้อแตกต่างที่สำคัญคือมันสร้างคอนเทนเนอร์สำหรับการฝึกโมเดล

ท่อส่งหลัก การสร้างแบบจำลอง (Pipeline)เป็นอีกหนึ่งที่เก็บ CodeCommit ที่ดำเนินการไปป์ไลน์ SageMaker ของคุณโดยอัตโนมัติ ไปป์ไลน์นี้ทำงานโดยอัตโนมัติและเชื่อมต่อการประมวลผลข้อมูลล่วงหน้า การฝึกอบรมแบบจำลอง การติดตามตัววัดแบบจำลองใน SageMaker Experiments การประมวลผลข้อมูลภายหลัง และการทำรายการแบบจำลองในการลงทะเบียนแบบจำลองของ SageMaker

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

เบื้องต้น

ในการปรับใช้โซลูชันของเราให้สำเร็จ คุณต้องมีสิ่งต่อไปนี้:

ดาวน์โหลดที่เก็บ GitHub

ในขั้นแรก ให้โคลนไฟล์ พื้นที่เก็บข้อมูล GitHub ไปยังเครื่องของคุณ ประกอบด้วยโครงสร้างโฟลเดอร์ต่อไปนี้:

• การใช้งาน – มีรหัสที่เกี่ยวข้องกับการปรับใช้
• มล — มีรหัส ML สำหรับการประมวลผลล่วงหน้า การฝึกอบรม การให้บริการ และการจำลอง
• การทดสอบ — ประกอบด้วยการทดสอบหน่วยและการรวม

ไฟล์สำคัญสำหรับการปรับใช้คือเชลล์สคริปต์ deployment/deploy.sh. คุณใช้ไฟล์นี้เพื่อปรับใช้ทรัพยากรในบัญชีของคุณ ก่อนที่เราจะรันเชลล์สคริปต์ได้ ให้ทำตามขั้นตอนต่อไปนี้:

1. เปิด deployment/app.py และเปลี่ยน bucket_name ภายใต้ SageMakerPipelineSourceCodeStack. bucket_name จะต้องไม่ซ้ำกันทั่วโลก (เช่น เพิ่มชื่อเต็มของคุณ)
2. In deployment/pipeline/assets/modelbuild/pipelines/energy_management/pipeline.py, เปลี่ยน default_bucket ภายใต้ get_pipeline เป็นชื่อเดียวกับที่ระบุในขั้นตอนที่ 1

ปรับใช้โซลูชันด้วย AWS CDK

ประการแรก กำหนดค่า AWS CLI ของคุณ ด้วยบัญชีและภูมิภาคที่คุณต้องการปรับใช้ จากนั้นรันคำสั่งต่อไปนี้เพื่อเปลี่ยนเป็นไดเร็กทอรีการปรับใช้ สร้างสภาพแวดล้อมเสมือน เปิดใช้งาน ติดตั้งแพ็คเกจ pip ที่จำเป็นซึ่งระบุไว้ใน setup.pyและเรียกใช้ไฟล์ deploy.sh:

cd deployment
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
pre-commit install
chmod u+x deploy.sh
./deploy.sh

deploy.sh ดำเนินการดังต่อไปนี้:

1. สร้างสภาพแวดล้อมเสมือนจริงใน Python
2. จัดหาสคริปต์การเปิดใช้งานสภาพแวดล้อมเสมือน
3. ติดตั้ง AWS CDK และข้อกำหนดที่ระบุไว้ใน setup.py.
4. บูตสแตรป สิ่งแวดล้อม.
5. ซิปและคัดลอกไฟล์ที่จำเป็นที่คุณพัฒนา เช่น ไฟล์ของคุณ mllib ไฟล์ลงในโฟลเดอร์ที่เกี่ยวข้องซึ่งจำเป็นต้องใช้เนื้อหาเหล่านี้
6. วิ่ง cdk deploy —require-approval never.
7. สร้างและ การก่อตัวของ AWS Cloud สแต็กผ่าน AWS CDK

ขั้นตอนเริ่มต้นของการปรับใช้ควรใช้เวลาน้อยกว่า 5 นาที ตอนนี้คุณควรมีที่เก็บสี่แห่งใน CodeCommit ในภูมิภาคที่คุณระบุผ่าน AWS CLI ดังที่แสดงไว้ในไดอะแกรมสถาปัตยกรรม เดอะ AWS CodePipeline ท่อทำงานพร้อมกัน เดอะ modelbuild และ modeldeploy ไปป์ไลน์ขึ้นอยู่กับการดำเนินการสร้างอิมเมจการฝึกอบรมและการประมวลผลที่ประสบความสำเร็จ เดอะ modeldeploy ไปป์ไลน์ขึ้นอยู่กับการสร้างแบบจำลองที่ประสบความสำเร็จ การปรับใช้โมเดลควรเสร็จสิ้นภายในเวลาน้อยกว่า 1.5 ชั่วโมง

โคลนที่เก็บโมเดลใน Studio

หากต้องการปรับแต่งไปป์ไลน์ SageMaker ที่สร้างขึ้นผ่านการปรับใช้ AWS CDK ใน Studio UI คุณต้องโคลนที่เก็บลงใน Studio ก่อน เรียกใช้เทอร์มินัลระบบใน Studio และรันคำสั่งต่อไปนี้หลังจากระบุชื่อโปรเจ็กต์และ ID:

git clone https://git-codecommit.REGION.amazonaws.com/v1/repos/sagemaker-PROJECT_NAME-PROJECT_ID-modelbuild
git clone https://git-codecommit.REGION.amazonaws.com/v1/repos/sagemaker-PROJECT_NAME-PROJECT_ID-modeldeploy
git clone https://git-codecommit.REGION.amazonaws.com/v1/repos/sagemaker-PROJECT_NAME-PROJECT_ID-processing-imagebuild
git clone https://git-codecommit.REGION.amazonaws.com/v1/repos/sagemaker-PROJECT_NAME-PROJECT_ID-training-imagebuild

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

คุณยังสามารถปรับโซลูชันบนเครื่องโลคัลของคุณและทำงานกับ IDE ที่คุณต้องการได้อีกด้วย

นำทาง SageMaker Pipeline และ SageMaker Experiments UI

ไปป์ไลน์ของ SageMaker เป็นชุดของขั้นตอนที่เชื่อมต่อกันซึ่งกำหนดโดยใช้ Amazon SageMaker Python SDK. คำจำกัดความไปป์ไลน์นี้เข้ารหัสไปป์ไลน์โดยใช้ Directed Acyclic Graph (DAG) ที่สามารถส่งออกเป็นคำจำกัดความ JSON หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโครงสร้างของไปป์ไลน์ดังกล่าว โปรดดูที่ ภาพรวมไปป์ไลน์ของ SageMaker.

นำทางไปยัง แหล่งข้อมูล SageMaker บานหน้าต่างและเลือกทรัพยากรไปป์ไลน์เพื่อดู ภายใต้ Nameคุณควรเห็น PROJECT_NAME-PROJECT_ID. ใน UI การรัน ควรมีการรันที่สำเร็จซึ่งคาดว่าจะใช้เวลามากกว่า 1 ชั่วโมงเล็กน้อย ไปป์ไลน์ควรมีลักษณะดังที่แสดงในภาพหน้าจอต่อไปนี้

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

อย่าลังเลที่จะเริ่มไปป์ไลน์อื่นที่รันด้วยพารามิเตอร์ของคุณตามต้องการ หลังจากนั้นให้ไปที่ แหล่งข้อมูล SageMaker บานหน้าต่างอีกครั้งแล้วเลือก การทดลองและการทดลอง. คุณควรเห็นบรรทัดที่มีชื่อเช่น PROJECT_NAME-PROJECT_ID. ไปที่การทดสอบและเลือกการทดสอบเดียวที่มี ID แบบสุ่ม จากนั้น เลือกงานฝึกอบรมของ SageMaker เพื่อสำรวจเมตริกที่เกี่ยวข้องกับงานฝึกอบรม

เป้าหมายของ SageMaker Experiments คือการทำให้มันง่ายที่สุดเท่าที่จะเป็นไปได้ในการสร้างการทดลอง เติมข้อมูลการทดลอง และเรียกใช้การวิเคราะห์ระหว่างการทดลองและการทดลองต่างๆ ไปป์ไลน์ของ SageMaker ถูกรวมเข้ากับ SageMaker Experiments อย่างใกล้ชิด และตามค่าเริ่มต้นสำหรับการเรียกใช้แต่ละครั้ง จะสร้างการทดสอบ การทดลอง และส่วนประกอบการทดลอง ในกรณีที่ไม่มีอยู่จริง

อนุมัติการปรับใช้ Lambda ในรีจิสทรีของโมเดล

ในขั้นตอนถัดไป ให้ไปที่รีจิสทรีของโมเดลภายใต้ แหล่งข้อมูล SageMaker. ที่นี่คุณสามารถค้นหาบรรทัดที่มีชื่อเช่น PROJECT_NAME-PROJECT_ID. นำทางไปยังโมเดลเดียวที่มีอยู่และอนุมัติ สิ่งนี้ปรับใช้สิ่งประดิษฐ์โมเดลโดยอัตโนมัติในคอนเทนเนอร์ในแลมบ์ดา

หลังจากที่คุณอนุมัติโมเดลของคุณในรีจีสทรีโมเดลแล้ว อเมซอน EventBridge กฎเหตุการณ์ถูกทริกเกอร์ กฎนี้เรียกใช้ไปป์ไลน์ CodePipeline โดยสิ้นสุด *-modeldeploy. ในส่วนนี้ เราจะหารือเกี่ยวกับวิธีที่โซลูชันนี้ใช้โมเดลที่ได้รับอนุมัติและโฮสต์ในฟังก์ชัน Lambda CodePipeline นำที่เก็บ CodeCommit ที่มีอยู่และลงท้ายด้วย *-modeldeploy และใช้รหัสนั้นเพื่อทำงานใน CodeBuild รายการหลักสำหรับ CodeBuild คือ buildspec.yml ไฟล์. ลองดูที่นี้ก่อน:

version: 0.2

env:
  shell: bash

phases:
  install:
    runtime_versions:
      python: 3.8
    commands:
      - python3 -m ensurepip --upgrade
      - python3 -m pip install --upgrade pip
      - python3 -m pip install --upgrade virtualenv
      - python3 -m venv .venv
      - source .venv/bin/activate
      - npm install -g aws-cdk@2.26.0
      - pip install -r requirements.txt
      - cdk bootstrap
  build:
    commands:
      - python build.py --model-package-group-name "$SOURCE_MODEL_PACKAGE_GROUP_NAME"
      - tar -xf model.tar.gz
      - cp model.joblib lambda/digital_twin
      - rm model.tar.gz
      - rm model.joblib
      - cdk deploy --require-approval never

ในระหว่างขั้นตอนการติดตั้ง เราตรวจสอบให้แน่ใจว่าไลบรารี Python เป็นเวอร์ชันล่าสุด สร้างสภาพแวดล้อมเสมือนจริง ติดตั้ง AWS CDK v2.26.0 และติดตั้ง aws-cdk ไลบรารี Python พร้อมกับไฟล์อื่น ๆ โดยใช้ไฟล์ข้อกำหนด เรายัง เริ่มต้นระบบบัญชี AWS. ในขั้นตอนการสร้าง เราเรียกใช้ build.pyซึ่งเราจะหารือกันต่อไป ไฟล์นั้นดาวน์โหลดสิ่งประดิษฐ์โมเดล SageMaker ที่ได้รับการอนุมัติล่าสุดจาก บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ไปยังอินสแตนซ์ CodeBuild ในเครื่องของคุณ นี้ .tar.gz ไฟล์จะถูกคลายซิปและเนื้อหาจะถูกคัดลอกไปยังโฟลเดอร์ที่มีโค้ดแลมบ์ดาหลักของเราด้วย มีการปรับใช้ฟังก์ชัน Lambda โดยใช้ AWS CDK และโค้ดหมดจากคอนเทนเนอร์ Docker จาก Amazon ECR สิ่งนี้ดำเนินการโดยอัตโนมัติโดย AWS CDK

พื้นที่ build.py ไฟล์เป็นไฟล์ Python ที่ส่วนใหญ่ใช้ AWS SDK สำหรับ Python (Boto3) เพื่อแสดงรายการแพ็คเกจรุ่นที่ใช้ได้

ฟังก์ชั่น get_approved_package ส่งคืน Amazon S3 URI ของอาร์ติแฟกต์ที่ดาวน์โหลดแล้ว ตามที่อธิบายไว้ก่อนหน้านี้

หลังจากปรับใช้โมเดลของคุณสำเร็จแล้ว คุณสามารถทำได้ ทดสอบ โดยตรงบนคอนโซล Lambda ในภูมิภาคที่คุณเลือกปรับใช้ ชื่อของฟังก์ชันควรมี DigitalTwinStack-DigitalTwin*. เปิดฟังก์ชั่นและไปที่ ทดสอบ แท็บ คุณสามารถใช้เหตุการณ์ต่อไปนี้เพื่อเรียกใช้การทดสอบ:

{
  "flow": "[280, 300]",
  "pressure": "[69, 70]",
  "simulations": "10",
  "no_of_trials": "10",
  "train_error_weight": "1.0"
}

หลังจากรันเหตุการณ์การทดสอบ คุณจะได้รับคำตอบคล้ายกับที่แสดงในภาพหน้าจอต่อไปนี้

หากคุณต้องการเรียกใช้การจำลองหรือการทดลองเพิ่มเติม คุณสามารถเพิ่มขีดจำกัดการหมดเวลาของแลมบ์ดาและทดลองโค้ดได้! หรือคุณอาจต้องการรับข้อมูลที่สร้างขึ้นและแสดงภาพเดียวกันใน อเมซอน QuickSight. ด้านล่างนี้คือตัวอย่าง ถึงตาคุณแล้ว!

ทำความสะอาด

หากต้องการหลีกเลี่ยงการเรียกเก็บเงินเพิ่มเติม ให้ทำตามขั้นตอนต่อไปนี้:

• บนคอนโซล AWS CloudFormation ให้ลบไฟล์ EnergyOptimization กอง
  สิ่งนี้จะลบโซลูชันทั้งหมด
• ลบสแต็ก DigitalTwinStackซึ่งปรับใช้ฟังก์ชันแลมบ์ดาของคุณ

สรุป

ในโพสต์นี้ เราแสดงไปป์ไลน์ MLOps ที่ขับเคลื่อนด้วย CI/CD ของโซลูชันการจัดการพลังงานที่เราแยกแต่ละขั้นตอนออกจากกัน คุณสามารถติดตามไปป์ไลน์ ML และการทดสอบได้ใน Studio UI นอกจากนี้ เรายังสาธิตวิธีการปรับใช้ที่แตกต่างกัน: เมื่อได้รับอนุมัติโมเดลในการลงทะเบียนโมเดล ฟังก์ชัน Lambda ที่โฮสต์โมเดลที่ได้รับอนุมัติจะถูกสร้างขึ้นโดยอัตโนมัติผ่าน CodePipeline

หากคุณสนใจที่จะสำรวจไปป์ไลน์ MLOps บน AWS หรือโซลูชันการจัดการพลังงานอย่างยั่งยืน โปรดดูที่ พื้นที่เก็บข้อมูล GitHub และปรับใช้สแตกในสภาพแวดล้อม AWS ของคุณเอง!

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

ลอเรนส์ ฟาน เดอร์ มาส เป็นนักวิทยาศาสตร์ข้อมูลที่ AWS Professional Services เขาทำงานอย่างใกล้ชิดกับลูกค้าในการสร้างโซลูชันแมชชีนเลิร์นนิงบน AWS และมีความกระตือรือร้นว่าแมชชีนเลิร์นนิงกำลังเปลี่ยนแปลงโลกอย่างที่เราทราบได้อย่างไร

กังกังวัง เป็นที่ปรึกษาด้าน AI/ML กับ AWS Professional Services เธอมีประสบการณ์มากมายในการปรับใช้โซลูชัน AI/ML ในธุรกิจด้านสุขภาพและวิทยาศาสตร์เพื่อชีวิต เธอยังสนุกกับการช่วยลูกค้าองค์กรสร้างแพลตฟอร์ม AI/ML ที่ปรับขนาดได้เพื่อเร่งการเดินทางบนคลาวด์ของนักวิทยาศาสตร์ข้อมูล

เซเลน่า ทับบาร่า เป็นนักวิทยาศาสตร์ข้อมูลที่ AWS Professional Services เธอทำงานทุกวันร่วมกับลูกค้าเพื่อให้บรรลุผลลัพธ์ทางธุรกิจโดยการสร้างนวัตกรรมบนแพลตฟอร์ม AWS ในเวลาว่าง เซเลนาชอบเล่นเปียโน เดินป่า และดูบาสเก็ตบอล

ไมเคิล วอลล์เนอร์ เป็นที่ปรึกษาอาวุโสที่ให้ความสำคัญกับ AI/ML ด้วย AWS Professional Services Michael มีความกระตือรือร้นในการช่วยให้ลูกค้าบนเส้นทางคลาวด์กลายเป็น AWSome เขาตื่นเต้นกับการผลิตและสนุกกับการช่วยเปลี่ยนพื้นที่การผลิตผ่านข้อมูล