สร้างโมเดล Amazon SageMaker โดยใช้ PyTorch Model Zoo

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

บล็อกโพสต์นี้สาธิตวิธีการอนุมาน ML โดยใช้โมเดลการตรวจจับวัตถุจาก PyTorch Model Zoo ภายใน SageMaker โมเดล ML ที่ผ่านการฝึกอบรมล่วงหน้าจาก PyTorch Model Zoo เป็นโมเดลสำเร็จรูปและสามารถใช้เป็นส่วนหนึ่งของแอปพลิเคชัน ML ได้อย่างง่ายดาย การตั้งค่าโมเดล ML เหล่านี้เป็นจุดสิ้นสุดของ SageMaker หรือ การแปลงเป็นชุดของ SageMaker งานสำหรับการอนุมานแบบออนไลน์หรือออฟไลน์ทำได้ง่ายด้วยขั้นตอนที่ระบุไว้ในบล็อกโพสต์นี้ เราจะใช้ R-CNN ที่เร็วขึ้น แบบจำลองการตรวจจับวัตถุเพื่อทำนายกล่องขอบเขตสำหรับคลาสวัตถุที่กำหนดไว้ล่วงหน้า

เราอธิบายตัวอย่างแบบ end-to-end ตั้งแต่การโหลดน้ำหนักแบบจำลองการตรวจจับวัตถุ Faster R-CNN ไปจนถึงการบันทึกลงใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ที่ฝากข้อมูล และเพื่อเขียนไฟล์จุดเริ่มต้นและทำความเข้าใจกับพารามิเตอร์หลักใน PyTorchModel API สุดท้าย เราจะปรับใช้โมเดล ML ทำการอนุมานโดยใช้ SageMaker Batch Transform และตรวจสอบผลลัพธ์ของโมเดล ML และเรียนรู้วิธีตีความผลลัพธ์ โซลูชันนี้สามารถนำไปใช้กับโมเดลที่ผ่านการฝึกอบรมล่วงหน้าอื่นๆ บน PyTorch Model Zoo สำหรับรายการรุ่นที่มี โปรดดูที่ เอกสาร PyTorch Model Zoo.

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

โพสต์บล็อกนี้จะแนะนำขั้นตอนต่อไปนี้ สำหรับขั้นตอนการทำงานฉบับเต็ม โปรดดูที่ create_pytorch_model_sagemaker.ipynb

• ขั้นตอนที่ 1: ตั้งค่า
• ขั้นตอนที่ 2: กำลังโหลดโมเดล ML จาก PyTorch Model Zoo
• ขั้นตอนที่ 3 บันทึกและอัปโหลดสิ่งประดิษฐ์โมเดล ML ไปยัง Amazon S3
• ขั้นตอนที่ 4: สร้างสคริปต์การอนุมานแบบจำลอง ML
• ขั้นตอนที่ 5: เรียกใช้งานการแปลงเป็นชุดของ SageMaker
• ขั้นตอนที่ 6: การแสดงผลลัพธ์

แผนภาพสถาปัตยกรรม

โครงสร้างไดเร็กทอรี

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

นี่คือเวิร์กโฟลว์ที่เราใช้ ขั้นตอนทั้งหมดต่อไปนี้จะอ้างถึงโมดูลในโครงสร้างนี้

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

พื้นที่ sagemaker_torch_model_zoo โฟลเดอร์ควรมี inference.py เป็นไฟล์จุดเริ่มต้น และ create_pytorch_model_sagemaker.ipynb เพื่อโหลดและบันทึกน้ำหนักของโมเดล สร้างอ็อบเจ็กต์โมเดล SageMaker และส่งต่อไปยังงานการแปลงเป็นชุดของ SageMaker หากต้องการนำโมเดล ML ของคุณเอง ให้เปลี่ยนพาธในส่วนขั้นตอนที่ 1: การตั้งค่าของโน้ตบุ๊ก และโหลดโมเดลใหม่ในขั้นตอนที่ 2: การโหลดโมเดล ML จากส่วน PyTorch Model Zoo ขั้นตอนที่เหลือด้านล่างจะยังคงเหมือนเดิม

ขั้นตอนที่ 1: ตั้งค่า

บทบาท IAM

SageMaker ดำเนินการบนโครงสร้างพื้นฐานที่จัดการโดย SageMaker SageMaker สามารถดำเนินการตามที่ได้รับอนุญาตตามที่กำหนดไว้ในบทบาทการดำเนินการ IAM ที่มาพร้อมกับโน้ตบุ๊กสำหรับ SageMaker เท่านั้น สำหรับเอกสารรายละเอียดเพิ่มเติมเกี่ยวกับการสร้างบทบาท IAM และการจัดการสิทธิ์ IAM โปรดดูที่ เอกสารประกอบบทบาทของ AWS SageMaker. เราสามารถสร้างบทบาทใหม่หรือได้รับ สมุดบันทึก SageMaker (สตูดิโอ)บทบาทการดำเนินการเริ่มต้นของโดยการเรียกใช้บรรทัดของรหัสต่อไปนี้:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

โค้ดด้านบนได้รับบทบาทการดำเนินการของ SageMaker สำหรับอินสแตนซ์โน้ตบุ๊ก นี่คือบทบาท IAM ที่เราสร้างขึ้นสำหรับอินสแตนซ์โน้ตบุ๊ก SageMaker หรือ SageMaker Studio

ผู้ใช้กำหนดพารามิเตอร์

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

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

ขั้นตอนที่ 2: กำลังโหลดโมเดล ML จาก PyTorch Model Zoo

ต่อไป เราจะระบุโมเดลการตรวจจับวัตถุจาก PyTorch Model Zoo และบันทึกน้ำหนักโมเดล ML โดยทั่วไป เราจะบันทึกโมเดล PyTorch โดยใช้นามสกุลไฟล์ .pt หรือ .pth ข้อมูลโค้ดด้านล่างดาวน์โหลดโมเดล Faster R-CNN ResNet50 ML ที่ผ่านการฝึกอบรมล่วงหน้าจาก PyTorch Model Zoo:

model = torchvision.models.detection.fasterrcnn_resnet50_fpn (ฝึกล่วงหน้า = True)

การแปลงเป็นชุดของ SageMaker ต้องใช้น้ำหนักของโมเดลเป็นอินพุต ดังนั้นเราจะบันทึกโมเดล ML ที่ฝึกไว้ล่วงหน้าเป็น model.pt หากเราต้องการโหลดโมเดลที่กำหนดเอง เราสามารถบันทึกน้ำหนักโมเดลจากโมเดล PyTorch อื่นเป็น model.pt แทน

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

ขั้นตอนที่ 3: บันทึกและอัปโหลดสิ่งประดิษฐ์โมเดล ML ไปยัง Amazon S3

เนื่องจากเราจะใช้ SageMaker สำหรับการอนุมาน ML เราจึงจำเป็นต้องอัปโหลดน้ำหนักแบบจำลองไปยังบัคเก็ต S3 เราสามารถทำได้โดยใช้คำสั่งต่อไปนี้ หรือดาวน์โหลดและเพียงแค่ลากและวางไฟล์ลงใน S3 โดยตรง คำสั่งต่อไปนี้จะบีบอัดกลุ่มไฟล์ภายในก่อน model.pt ไปยัง tarball และคัดลอกน้ำหนักแบบจำลองจากเครื่องในพื้นที่ของเราไปยังบัคเก็ต S3

หมายเหตุ: ในการเรียกใช้คำสั่งต่อไปนี้ คุณต้องมีไฟล์ อินเทอร์เฟซบรรทัดคำสั่ง AWS (AWS CLI) การติดตั้ง

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

ต่อไป เราคัดลอกภาพอินพุตของเราไปยัง S3 ด้านล่างนี้คือเส้นทาง S3 แบบเต็มสำหรับรูปภาพ

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

เราสามารถคัดลอกภาพนี้ไปยัง S3 ด้วยคำสั่ง aws s3 cp อื่น

aws s3 cp cars.jpg $car_image_path

ขั้นตอนที่ 4: สร้างสคริปต์การอนุมานแบบจำลอง ML

ตอนนี้เราจะพูดถึงไฟล์จุดเข้าใช้งานของเรา inference.py โมดูล. เราสามารถปรับใช้โมเดล PyTorch ที่ฝึกภายนอก SageMaker โดยใช้คลาส PyTorchModel ขั้นแรก เรายกตัวอย่างวัตถุ PyTorchModelZoo จากนั้น เราจะสร้างไฟล์จุดเข้าใช้งาน inference.py เพื่อดำเนินการอนุมาน ML โดยใช้การแปลงเป็นชุดของ SageMaker บนข้อมูลตัวอย่างที่โฮสต์ใน Amazon S3

ทำความเข้าใจกับวัตถุ PyTorchModel

พื้นที่ PyTorchรุ่น คลาสภายใน SageMaker Python API ช่วยให้เราสามารถทำการอนุมาน ML โดยใช้โมเดลอาร์ติแฟกต์ที่ดาวน์โหลดมา

ในการเริ่มคลาส PyTorchModel เราต้องเข้าใจพารามิเตอร์อินพุตต่อไปนี้:

• name: ชื่อรุ่น; ขอแนะนำให้ใช้ชื่อรุ่น + วันที่เวลา หรือสตริงสุ่ม + วันที่เวลาเพื่อความไม่ซ้ำกัน
• model_data: S3 URI ของสิ่งประดิษฐ์โมเดล ML ที่บรรจุ
• entry_point: ไฟล์ Python ที่ผู้ใช้กำหนดเพื่อใช้โดยอิมเมจ Docker การอนุมานเพื่อกำหนดตัวจัดการสำหรับคำขอที่เข้ามา โค้ดกำหนดการโหลดโมเดล การประมวลผลล่วงหน้าอินพุต ตรรกะการคาดการณ์ และเอาต์พุตหลังการประมวลผล
• framework_version: ต้องตั้งค่าเป็นเวอร์ชัน 1.2 หรือสูงกว่าเพื่อเปิดใช้งานการบรรจุโมเดล PyTorch ใหม่โดยอัตโนมัติ
• source_dir: ไดเร็กทอรีของไฟล์ entry_point
• role: บทบาท IAM เพื่อส่งคำขอบริการ AWS
• image_uri: ใช้อิมเมจคอนเทนเนอร์ Amazon ECR Docker นี้เป็นฐานสำหรับสภาพแวดล้อมการประมวลผลแบบจำลอง ML
• sagemaker_session: เซสชั่น SageMaker
• py_version: เวอร์ชัน Python ที่จะใช้

ข้อมูลโค้ดต่อไปนี้ยกตัวอย่างคลาส PyTorchModel เพื่อดำเนินการอนุมานโดยใช้โมเดล PyTorch ที่ผ่านการฝึกอบรมมาแล้ว:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

ทำความเข้าใจไฟล์จุดเข้าใช้งาน (inference.py)

พารามิเตอร์ entry_point ชี้ไปที่ไฟล์ Python ชื่อ inference.py. จุดเริ่มต้นนี้กำหนดการโหลดโมเดล การประมวลผลล่วงหน้าของอินพุต ตรรกะการคาดการณ์ และเอาต์พุตหลังการประมวลผล มันเสริมโค้ดที่ให้บริการโมเดล ML ใน PyTorch ที่สร้างไว้ล่วงหน้า คอนเทนเนอร์การเรียนรู้เชิงลึกของ SageMaker ภาพ.

Inference.py จะมีฟังก์ชั่นดังต่อไปนี้ ในตัวอย่างของเรา เราใช้ model_fn, input_fn, predict_fn และ output_fn ฟังก์ชั่นที่จะแทนที่ ตัวจัดการการอนุมาน PyTorch เริ่มต้น.

1. model_fn: รับในไดเร็กทอรีที่มีจุดตรวจสอบโมเดลแบบสแตติกในภาพการอนุมาน เปิดและโหลดโมเดลจากเส้นทางที่ระบุและส่งคืนโมเดล PyTorch
2. input_fn: รับในส่วนของข้อมูลของคำขอที่เข้ามา (request_body) และประเภทเนื้อหาของคำขอที่เข้ามา (request_content_type) เป็นอินพุต จัดการกับการถอดรหัสข้อมูล จำเป็นต้องปรับฟังก์ชันนี้สำหรับอินพุตที่โมเดลต้องการ
3. predict_fn: เรียกใช้โมเดลบนข้อมูลที่แยกซีเรียลไลซ์แล้วใน input_fn ทำการคาดคะเนบนอ็อบเจกต์ deserialized ด้วยโมเดล ML ที่โหลด
4. output_fn: เรียงลำดับผลการคาดคะเนเป็นประเภทเนื้อหาการตอบสนองที่ต้องการ แปลงการคาดคะเนที่ได้รับจากฟังก์ชัน Predict_fn เป็นรูปแบบ JSON, CSV หรือ NPY

ขั้นตอนที่ 5: เรียกใช้งานการแปลงเป็นชุดของ SageMaker

สำหรับตัวอย่างนี้ เราจะได้ผลการอนุมาน ML ผ่านงานการแปลงเป็นชุดของ SageMaker งานการแปลงเป็นชุดมีประโยชน์มากที่สุดเมื่อเราต้องการรับการอนุมานจากชุดข้อมูลเพียงครั้งเดียว โดยไม่จำเป็นต้องมีปลายทางถาวร เรายกตัวอย่าง ก sagemaker.transformer.หม้อแปลงไฟฟ้า วัตถุสำหรับสร้างและโต้ตอบกับงานการแปลงเป็นชุดของ SageMaker

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

ดูเอกสารประกอบการสร้างงานการแปลงเป็นชุดได้ที่ สร้าง TransformJob.

ขั้นตอนที่ 6: การแสดงภาพการทดสอบ

เมื่องานการแปลงเป็นชุดของ SageMaker เสร็จสิ้น เราสามารถโหลดเอาต์พุตการอนุมาน ML จาก Amazon S3 สำหรับสิ่งนี้ ให้ไปที่ คอนโซลการจัดการ AWS แล้วค้นหา Amazon SageMaker ที่แผงด้านซ้าย ภายใต้ การอนุมานโปรดดูที่ งานแปลงเป็นชุด.

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

อย่างแรก งานจะมีสถานะเป็น “กำลังดำเนินการ” เมื่อเสร็จแล้ว ดูสถานะเปลี่ยนเป็นเสร็จสมบูรณ์

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

ภายใต้ การกำหนดค่าข้อมูลเอาต์พุตเราจะเห็นเส้นทางเอาต์พุต S3 ที่นี่เราจะพบผลลัพธ์การอนุมาน ML ของเรา

เลือกเส้นทางเอาต์พุต S3 และดูไฟล์ [image_name].[file_type].out พร้อมข้อมูลเอาต์พุตของเรา ไฟล์เอาต์พุตของเราจะมีรายการการแมป ตัวอย่างเอาต์พุต:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

เพื่อให้เห็นภาพการคาดการณ์เหล่านี้ ก่อนอื่นเราจะอ่านเส้นทางเอาต์พุตจากวัตถุหม้อแปลงของเรา

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

ต่อไป เราจะประมวลผลไฟล์เอาต์พุตนี้และแสดงภาพการคาดการณ์ของเรา ด้านล่างระบุเกณฑ์ความเชื่อมั่นของเรา เราได้รับรายชื่อชั้นเรียนจาก การแมปวัตถุชุดข้อมูล COCO ในระหว่างการอนุมาน แบบจำลองต้องการเพียงเทนเซอร์อินพุตและส่งคืนการคาดคะเนหลังการประมวลผลเป็นรายการ[Dict[Tensor]] หนึ่งรายการสำหรับแต่ละภาพที่ป้อนเข้า ฟิลด์ของ Dict มีดังนี้ โดยที่ N คือจำนวนการตรวจจับ:

1. กล่อง (FloatTensor[N, 4]): กล่องที่คาดการณ์ไว้ [x1, y1, x2, y2] รูปแบบด้วย 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= Hที่นี่มี W คือความกว้างของภาพและ H คือความสูงของภาพ
2. ป้ายกำกับ (Int64Tensor[N]): ป้ายกำกับที่คาดการณ์สำหรับการตรวจจับแต่ละครั้ง
3. คะแนน (Tensor[N]): คะแนนการทำนายสำหรับการตรวจจับแต่ละครั้ง

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับเอาต์พุต โปรดดูที่ PyTorch เอกสาร R-CNN FPN ที่เร็วขึ้น.

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

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

สุดท้าย เราแสดงภาพการแมปเหล่านี้เพื่อทำความเข้าใจผลลัพธ์ของเรา

หมายเหตุ: ถ้ารูปภาพไม่แสดงในสมุดบันทึกของคุณ โปรดค้นหารูปภาพนั้นในโครงสร้างไดเร็กทอรีทางด้านซ้ายของ JupyterLab และเปิดจากที่นั่น

รันโค้ดตัวอย่าง

สำหรับตัวอย่างการทำงานเต็มรูปแบบ ให้โคลนโค้ดใน amazon-sagemaker-ตัวอย่าง GitHub และเรียกใช้เซลล์ใน create_pytorch_model_sagemaker.ipynb สมุดบันทึก.

สรุป

ในบล็อกโพสต์นี้ เราแสดงตัวอย่างแบบ end-to-end ของการดำเนินการอนุมาน ML โดยใช้โมเดลการตรวจจับวัตถุจาก PyTorch Model Zoo โดยใช้การแปลงเป็นชุดของ SageMaker เราครอบคลุมการโหลดน้ำหนักแบบจำลองการตรวจจับวัตถุ R-CNN ที่เร็วขึ้น การบันทึกลงในบัคเก็ต S3 การเขียนไฟล์จุดเข้าใช้งาน และการทำความเข้าใจพารามิเตอร์หลักใน PyTorchModel API สุดท้าย เราปรับใช้โมเดลและทำการอนุมานโมเดล ML แสดงภาพผลลัพธ์ของโมเดล และเรียนรู้วิธีตีความผลลัพธ์

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

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

มาร์เซโล อาแบร์เล่ เป็นวิศวกร ML ในองค์กร AWS AI เขาเป็นผู้นำความพยายามของ MLOps ที่ ห้องปฏิบัติการโซลูชัน Amazon MLช่วยลูกค้าออกแบบและใช้งานระบบ ML ที่ปรับขนาดได้ ภารกิจของเขาคือการแนะนำลูกค้าเกี่ยวกับเส้นทาง ML สำหรับองค์กร และเร่งเส้นทาง ML ไปสู่การผลิต

นินาด กุลการี เป็นนักวิทยาศาสตร์ประยุกต์ใน ห้องปฏิบัติการโซลูชัน Amazon ML. เขาช่วยลูกค้าปรับใช้ ML และ AI โดยสร้างโซลูชันเพื่อแก้ไขปัญหาทางธุรกิจของพวกเขา ล่าสุด เขาได้สร้างโมเดลคาดการณ์สำหรับลูกค้ากีฬา ยานยนต์ และสื่อ

ยัชชาห์ เป็นผู้จัดการวิทยาศาสตร์ใน แล็บโซลูชัน Amazon ML เขาและทีมนักวิทยาศาสตร์ประยุกต์และวิศวกร ML ทำงานในกรณีการใช้งาน ML ที่หลากหลายตั้งแต่การดูแลสุขภาพ กีฬา ยานยนต์ และการผลิต