สร้างเวิร์กโฟลว์ MLOps ข้ามบัญชีโดยใช้การลงทะเบียนโมเดล Amazon SageMaker

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

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

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

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมรีจีสทรีแบบจำลองที่ใช้ร่วมกันของเรา

สิ่งที่ควรทราบในสถาปัตยกรรมก่อนหน้านี้:

ขั้นตอนต่อไปนี้สอดคล้องกับแผนภาพ:

1. นักวิทยาศาสตร์ข้อมูลลงทะเบียนแบบจำลองจากบัญชีวิทยาศาสตร์ข้อมูลลงในการลงทะเบียนแบบจำลองบริการ SageMaker ที่ใช้ร่วมกันใน PendingManualApproval สถานะ. สิ่งประดิษฐ์แบบจำลองถูกสร้างขึ้นในบัญชีบริการที่ใช้ร่วมกัน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) ถัง
2. เมื่อลงทะเบียนเวอร์ชันโมเดลใหม่ ผู้ที่มีอำนาจในการอนุมัติโมเดลตามเมตริกควรอนุมัติหรือปฏิเสธโมเดล
3. หลังจากโมเดลได้รับการอนุมัติ ไปป์ไลน์ CI/CD ในบัญชีการปรับใช้จะเป็น ทริกเกอร์เพื่อปรับใช้ รายละเอียดโมเดลที่อัปเดตในบัญชี QA และอัปเดตสเตจเป็น QA
4. เมื่อผ่านขั้นตอนการทดสอบแล้ว คุณสามารถเลือกให้มีขั้นตอนการอนุมัติด้วยตนเองภายในกระบวนการ CI/CD ของคุณ หรือให้ไปป์ไลน์ CI/CD ปรับใช้โมเดลกับการผลิตโดยตรงและอัปเดตสเตจเป็น Prod
5. สภาพแวดล้อมการผลิตอ้างอิงถึงรุ่นและรหัสที่ได้รับอนุมัติ บางทีอาจทำ การทดสอบ A/B ในการผลิต. ในกรณีที่มีการตรวจสอบหรือมีปัญหาใดๆ กับโมเดล คุณสามารถใช้ การติดตามเชื้อสายของ Amazon SageMaker ML. สร้างและจัดเก็บข้อมูลเกี่ยวกับขั้นตอนของเวิร์กโฟลว์แมชชีนเลิร์นนิง (ML) ตั้งแต่การเตรียมข้อมูลไปจนถึงการปรับใช้โมเดล ด้วยข้อมูลการติดตาม คุณสามารถจำลองขั้นตอนเวิร์กโฟลว์ ติดตามโมเดลและสายเลือดของชุดข้อมูล และสร้างการกำกับดูแลโมเดลและมาตรฐานการตรวจสอบได้

ตลอดกระบวนการทั้งหมด รีจีสทรีโมเดลที่ใช้ร่วมกันจะรักษาเวอร์ชันของโมเดลที่เก่ากว่าไว้ สิ่งนี้ทำให้ทีมสามารถย้อนกลับการเปลี่ยนแปลงหรือโฮสต์ได้ สายพันธุ์การผลิต.

เบื้องต้น

ตรวจสอบให้แน่ใจว่าคุณมีข้อกำหนดเบื้องต้นดังต่อไปนี้:

• โครงสร้างหลายบัญชีที่จัดเตรียมไว้ - ดูคำแนะนำได้ที่ แนวทางปฏิบัติที่ดีที่สุดสำหรับหน่วยขององค์กรกับองค์กร AWS. สำหรับวัตถุประสงค์ของบล็อกนี้ เราใช้ประโยชน์จากบัญชีต่อไปนี้:
  • บัญชีวิทยาศาสตร์ข้อมูล – บัญชีที่นักวิทยาศาสตร์ข้อมูลสามารถเข้าถึงข้อมูลการฝึกอบรมและสร้างแบบจำลองได้
  • บัญชีบริการที่ใช้ร่วมกัน – บัญชีกลางสำหรับจัดเก็บสิ่งประดิษฐ์แบบจำลอง (ตามที่แสดงในไดอะแกรมสถาปัตยกรรม) เพื่อให้เข้าถึงได้ในบัญชีปริมาณงานต่างๆ
  • บัญชีการปรับใช้ – บัญชีที่รับผิดชอบในการปรับใช้การเปลี่ยนแปลงกับบัญชีต่างๆ
  • บัญชีภาระงาน – สิ่งเหล่านี้โดยทั่วไปคือสภาพแวดล้อม QA และผลิตภัณฑ์ที่วิศวกรซอฟต์แวร์สามารถสร้างแอปพลิเคชันเพื่อใช้โมเดล ML
• บัญชีการปรับใช้ที่มีสิทธิ์ที่เหมาะสม – สำหรับข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติที่ดีที่สุดเกี่ยวกับโครงสร้าง OU หลายบัญชี โปรดดูที่ OU. บัญชีนี้มีหน้าที่ในการชี้บัญชีภาระงานไปยังแบบจำลองที่ต้องการในการลงทะเบียนแบบจำลองของบัญชีบริการที่ใช้ร่วมกัน

กำหนดนโยบายข้ามบัญชี

ในการปฏิบัติตามหลักการสิทธิ์ขั้นต่ำ ก่อนอื่นเราต้องเพิ่มนโยบายทรัพยากรข้ามบัญชีให้กับทรัพยากรบริการที่ใช้ร่วมกันเพื่อให้สิทธิ์การเข้าถึงจากบัญชีอื่นๆ

เนื่องจากอาร์ติแฟกต์โมเดลถูกจัดเก็บไว้ในบัคเก็ต S3 ของบัญชีบริการที่ใช้ร่วมกัน บัญชีวิทยาศาสตร์ข้อมูลจึงต้องการการเข้าถึงแบบอ่าน/เขียนของ Amazon S3 เพื่อพุชโมเดลที่ผ่านการฝึกอบรมไปยัง Amazon S3 โค้ดต่อไปนี้แสดงนโยบายนี้ แต่ยังไม่ได้เพิ่มลงในบัญชีบริการที่ใช้ร่วมกัน:

#Data Science account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        }, 
        "Action": [ 
            's3:PutObject', 
            's3:PutObjectAcl',
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read/write
        'Resource': 'arn:aws:s3:::/*'
    }]
}

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

#Deployment account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        },
        'Action': [ 
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read
        'Resource': 'arn:aws:s3:::/*'
    }]
}

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

{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "AddPerm",
    "Effect": "Allow",
    "Principal": {
      "AWS": "arn:aws:iam:::root"    
    },
    "Action": [
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:GetObject",
      "s3:GetObjectVersion"    ],
    "Resource": "arn:aws:s3:::/*"  
    },
    {
      "Sid": "AddPermDeployment",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "s3:GetObject",
        "s3:GetObjectVersion"      ], 
      "Resource": "arn:aws:s3:::/*"    
    }
  ]
}

ในการปรับใช้โมเดลที่สร้างขึ้นในบัญชีอื่น ผู้ใช้ต้องมีบทบาทที่มีสิทธิ์เข้าถึงการดำเนินการของ SageMaker เช่น บทบาทกับ AmazonSageMakerFullAccess นโยบายที่ได้รับการจัดการ อ้างถึง ปรับใช้รุ่นของโมเดลจากบัญชีอื่น สำหรับรายละเอียดเพิ่มเติม

เราจำเป็นต้องกำหนดกลุ่มโมเดลที่มีเวอร์ชันของโมเดลที่เราต้องการปรับใช้ นอกจากนี้ เราต้องการให้สิทธิ์แก่บัญชีวิทยาศาสตร์ข้อมูล สามารถทำได้ตามขั้นตอนต่อไปนี้ เราอ้างถึงบัญชีดังต่อไปนี้:

• shared_services_account_id – บัญชีที่มีการลงทะเบียนโมเดลและตำแหน่งที่เราต้องการให้โมเดลอยู่
• data_science_account_id – บัญชีที่เราจะฝึกฝนและสร้างสิ่งประดิษฐ์แบบจำลองจริง
• การปรับใช้_account_id – บัญชีที่เราต้องการโฮสต์ปลายทางสำหรับโมเดลนี้

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

model_package_group_name = "cross-account-example-model"
sm_client = boto3.Session().client("sagemaker")

create_model_package_group_response = sm_client.create_model_package_group(
    ModelPackageGroupName=model_package_group_name,
    ModelPackageGroupDescription="Cross account model package group",
    Tags=[
          {
              'Key': 'Name',
              'Value': 'cross_account_test'
          },
      ]

)

print('ModelPackageGroup Arn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))

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

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AddPermModelPackageGroupCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackageGroup"      
        ],
      "Resource": "arn:aws:sagemaker:::model-package-group/"    
    },
    {
      "Sid": "AddPermModelPackageVersionCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackage",
        "sagemaker:ListModelPackages",
        "sagemaker:UpdateModelPackage",
        "sagemaker:CreateModelPackage",
        "sagemaker:CreateModel"      
      ],
      "Resource": "arn:aws:sagemaker:::model-package//*"    
    }
  ]
}

สุดท้าย ใช้นโยบายกับกลุ่มแพคเกจแบบจำลอง คุณไม่สามารถเชื่อมโยงนโยบายนี้กับกลุ่มแพ็คเกจผ่านทางคอนโซล คุณต้องมี SDK หรือ อินเทอร์เฟซบรรทัดคำสั่ง AWS AWS การเข้าถึง (AWS CLI) ตัวอย่างเช่น รหัสต่อไปนี้ใช้ Boto3:

# Convert the policy from JSON dict to string
model_package_group_policy = dict( )
model_package_group_policy = json.dumps(model_package_group_policy)

# Set the new policy
sm_client = boto3.Session().client("sagemaker")
response = sm_client.put_model_package_group_policy(
    ModelPackageGroupName = model_package_group_name,
    ResourcePolicy = model_package_group_policy)

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

นโยบายและการอนุญาตเป็นไปตามรูปแบบนี้:

• นโยบาย Amazon S3 ที่ระบุไว้ใน shared_services_account ให้สิทธิ์แก่บัญชีวิทยาศาสตร์ข้อมูลและบัญชีการปรับใช้
• นโยบายคีย์ KMS ที่ระบุใน shared_services_account ให้สิทธิ์แก่บัญชีวิทยาศาสตร์ข้อมูลและบัญชีการปรับใช้

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

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

นโยบายแบบอินไลน์แรกอนุญาตให้บทบาทเข้าถึงทรัพยากร Amazon S3 ในบัญชีบริการที่ใช้ร่วมกันที่มีอาร์ติแฟกต์โมเดล ระบุชื่อบัคเก็ต S3 และรุ่นของคุณ:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::/sagemaker//output/model.tar.gz"
        }
    ]
}

นโยบายแบบอินไลน์ที่สองอนุญาตให้บทบาทซึ่งเราสร้างในภายหลังใช้คีย์ KMS ในบัญชีบริการที่ใช้ร่วมกัน ระบุรหัสบัญชีสำหรับบัญชีบริการที่ใช้ร่วมกันและรหัสคีย์ KMS:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "AllowUseOfTheKey",
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": [
                "arn:aws:kms:us-east-1::key/{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"
            ]
        }
    ]
}

สุดท้ายเราต้อง สร้างบทบาท IAM สำหรับ SageMaker บทบาทนี้มี AmazonSageMakerFullAccess แนบนโยบาย จากนั้นเราจะแนบนโยบายแบบอินไลน์ทั้งสองนี้กับบทบาทที่เราสร้างขึ้น หากคุณกำลังใช้บทบาทการดำเนินการของ SageMaker ที่มีอยู่ ให้แนบนโยบายทั้งสองนี้กับบทบาทนั้น สำหรับคำแนะนำ โปรดดูที่ การสร้างบทบาทและการแนบนโยบาย (คอนโซล).

ตอนนี้เราได้กำหนดนโยบายของแต่ละบัญชีแล้ว ลองใช้ตัวอย่างเพื่อดูการทำงาน

สร้างและฝึกโมเดลโดยใช้ไปป์ไลน์ของ SageMaker

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

เราสร้างไฟล์ SKLearnProcessor คัดค้านการรันสคริปต์การประมวลผลล่วงหน้านี้ ในไปป์ไลน์ SageMaker เราสร้างขั้นตอนการประมวลผล (ProcessingStep) เพื่อเรียกใช้รหัสการประมวลผลโดยใช้ SKLearnProcessor. รหัสการประมวลผลนี้ถูกเรียกเมื่อเริ่มต้นไปป์ไลน์ SageMaker รหัสที่สร้าง SKLearnProcessor และ ProcessingStep แสดงในรหัสต่อไปนี้ โปรดทราบว่าโค้ดทั้งหมดในส่วนนี้รันในบัญชีวิทยาศาสตร์ข้อมูล

# Useful SageMaker variables - Create a Pipeline session which will lazy init resources
session = PipelineSession()

framework_version = "0.23-1"

# Create SKlearn processor object,
# The object contains information about what instance type to use, the IAM role to use etc.
# A managed processor comes with a preconfigured container, so only specifying version is required.
sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    role=role,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-processing-job",
    sagemaker_session=session
)

# Use the sklearn_processor in a SageMaker pipelines ProcessingStep
step_preprocess_data = ProcessingStep(
    name="Preprocess-California-Housing-Data",
    processor=sklearn_processor,
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="preprocess.py",
)

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

kms_client = boto3.client('kms')
response = kms_client.describe_key(
    KeyId='alias/sagemaker/outkey',
)
key_id = response['KeyMetadata']['KeyId']

ในการฝึกโมเดล เราสร้างออบเจกต์ตัวประมาณค่า TensorFlow เราส่งรหัสคีย์ KMS พร้อมกับสคริปต์การฝึกอบรมของเรา train.pyประเภทอินสแตนซ์การฝึก และจำนวน เรายังสร้าง TrainingStep เพื่อเพิ่มลงในไปป์ไลน์ของเรา และเพิ่มตัวประมาณค่า TensorFlow เข้าไป ดูรหัสต่อไปนี้:

model_path = f"s3://{bucket}/{prefix}/model/"

hyperparameters = {"epochs": training_epochs}
tensorflow_version = "2.4.1"
python_version = "py37"

tf2_estimator = TensorFlow(
    source_dir="code",
    entry_point="train.py",
    instance_type=training_instance_type,
    instance_count=1,
    framework_version=tensorflow_version,
    role=role,
    base_job_name="tf2-california-housing-train",
    output_path=model_path,
    output_kms_key=key_id,
    hyperparameters=hyperparameters,
    py_version=python_version,
    sagemaker_session=session
)

# Use the tf2_estimator in a SageMaker pipelines ProcessingStep.
# NOTE how the input to the training job directly references the output of the previous step.
step_train_model = TrainingStep(
    name="Train-California-Housing-Model",
    estimator=tf2_estimator,
    inputs={
        "train": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "test": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    },
)

นอกจากการฝึกอบรมแล้ว เราจำเป็นต้องดำเนินการประเมินแบบจำลอง ซึ่งเราใช้ค่าเฉลี่ยกำลังสอง (Mean Squared Error - MSE) เป็นเมตริกในตัวอย่างนี้ เดอะ โน๊ตบุ๊คก่อนหน้านี้ ยังสร้าง evaluate.pyซึ่งเราใช้ประเมินโมเดลของเราโดยใช้ MSE เรายังสร้าง ProcessingStep เพื่อเริ่มต้นสคริปต์การประเมินแบบจำลองโดยใช้ a SKLearnProcessor วัตถุ. รหัสต่อไปนี้สร้างขั้นตอนนี้:

from sagemaker.workflow.properties import PropertyFile

# Create SKLearnProcessor object.
# The object contains information about what container to use, what instance type etc.
evaluate_model_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-evaluate",
    role=role,
    sagemaker_session=session
)

# Create a PropertyFile
# A PropertyFile is used to be able to reference outputs from a processing step, for instance to use in a condition step.
# For more information, visit https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html
evaluation_report = PropertyFile(
    name="EvaluationReport", output_name="evaluation", path="evaluation.json"
)

# Use the evaluate_model_processor in a SageMaker pipelines ProcessingStep.
step_evaluate_model = ProcessingStep(
    name="Evaluate-California-Housing-Model",
    processor=evaluate_model_processor,
    inputs=[
        ProcessingInput(
            source=step_train_model.properties.ModelArtifacts.S3ModelArtifacts,
            destination="/opt/ml/processing/model",
        ),
        ProcessingInput(
            source=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            destination="/opt/ml/processing/test",
        ),
    ],
    outputs=[
        ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
    ],
    code="evaluate.py",
    property_files=[evaluation_report],
)

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

# Create ModelMetrics object using the evaluation report from the evaluation step
# A ModelMetrics object contains metrics captured from a model.
model_metrics = ModelMetrics(
    model_statistics=MetricsSource(
        s3_uri=evaluation_s3_uri,
        content_type="application/json",
    )
)

# Create a RegisterModel step, which registers the model with SageMaker Model Registry.
model = Model(
    image_uri=tf2_estimator.training_image_uri(),
    model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir=tf2_estimator.source_dir,
    entry_point=tf2_estimator.entry_point,
    role=role_arn,
    sagemaker_session=session
)

model_registry_args = model.register(
    content_types=['text/csv'],
    response_types=['application/json'],
    inference_instances=['ml.t2.medium', 'ml.m5.xlarge'],
    transform_instances=['ml.m5.xlarge'],
    model_package_group_name=model_package_group_name,
    approval_status='PendingManualApproval',
    model_metrics=model_metrics
)

 step_register_model= ModelStep(
    name='RegisterModel',
    step_args=model_registry_args
)

เรายังจำเป็นต้องสร้างแบบจำลองสิ่งประดิษฐ์เพื่อให้สามารถปรับใช้ (โดยใช้บัญชีอื่น) สำหรับการสร้างแบบจำลอง เราสร้าง CreateModelStepดังแสดงในรหัสต่อไปนี้:

from sagemaker.inputs import CreateModelInput 
from sagemaker.workflow.model_step import ModelStep 
step_create_model = ModelStep( 
    name="Create-California-Housing-Model", 
    step_args=model.create(instance_type="ml.m5.large",accelerator_type="ml.eia1.medium"),
 )

การเพิ่มเงื่อนไขไปยังไปป์ไลน์ทำได้ด้วย ConditionStep. ในกรณีนี้ เราเพียงต้องการลงทะเบียนรุ่นใหม่กับการลงทะเบียนรุ่น ถ้ารุ่นใหม่ตรงตามเงื่อนไขความถูกต้อง ดูรหัสต่อไปนี้:

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import (
    ConditionStep,
    JsonGet,
)

# Create accuracy condition to ensure the model meets performance requirements.
# Models with a test accuracy lower than the condition will not be registered with the model registry.
cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step=step_evaluate_model,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",
    ),
    right=accuracy_mse_threshold,
)

# Create a SageMaker Pipelines ConditionStep, using the preceding condition.
# Enter the steps to perform if the condition returns True / False.
step_cond = ConditionStep(
    name="MSE-Lower-Than-Threshold-Condition",
    conditions=[cond_lte],
    if_steps=[step_register_model, step_create_model],
    else_steps=[step_higher_mse_send_email_lambda],
)

สุดท้าย เราต้องการจัดการขั้นตอนไปป์ไลน์ทั้งหมดเพื่อให้สามารถเริ่มต้นไปป์ไลน์ได้:

from sagemaker.workflow.pipeline import Pipeline

# Create a SageMaker Pipeline.
# Each parameter for the pipeline must be set as a parameter explicitly when the pipeline is created.
# Also pass in each of the preceding steps.
# Note that the order of execution is determined from each step's dependencies on other steps,
# not on the order they are passed in.
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        processing_instance_type,
        training_instance_type,
        input_data,
        training_epochs,
        accuracy_mse_threshold,
        endpoint_instance_type,
    ],
    steps=[step_preprocess_data, step_train_model, step_evaluate_model, step_cond],
)

ปรับใช้รุ่นโมเดลจากบัญชีอื่น

เมื่อโมเดลได้รับการลงทะเบียนในบัญชีบริการที่ใช้ร่วมกันแล้ว เราจำเป็นต้องปรับใช้ในบัญชีภาระงานของเราโดยใช้ไปป์ไลน์ CI/CD ในบัญชีการปรับใช้ เราได้กำหนดค่าบทบาทและนโยบายในขั้นตอนก่อนหน้าแล้ว เราใช้แพ็คเกจโมเดล ARN เพื่อปรับใช้โมเดลจากรีจิสตรีโมเดล รหัสต่อไปนี้ทำงานในบัญชีการปรับใช้และใช้เพื่อปรับใช้โมเดลที่ได้รับอนุมัติกับ QA และผลิตภัณฑ์:

from sagemaker import ModelPackage
from time import gmtime, strftime

sagemaker_session = sagemaker.Session(boto_session=sess)

model_package_arn = 'arn:aws:sagemaker:::/modeltest/version_number'
model = ModelPackage(role=role, 
                     model_package_arn=model_package_arn, 
                     sagemaker_session=sagemaker_session)
model.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')

สรุป

ในโพสต์นี้ เราได้สาธิตวิธีตั้งค่านโยบายที่จำเป็นสำหรับการตั้งค่าหลายบัญชีสำหรับ ML ตามหลักการของสิทธิ์ขั้นต่ำ จากนั้นเราได้แสดงกระบวนการสร้างและฝึกอบรมแบบจำลองในบัญชีวิทยาศาสตร์ข้อมูล สุดท้าย เราใช้ไปป์ไลน์ CI/CD ในบัญชีการปรับใช้เพื่อปรับใช้เวอร์ชันล่าสุดของโมเดลที่ได้รับอนุมัติไปยังบัญชี QA และบัญชีการผลิต นอกจากนี้ คุณสามารถ ดูประวัติการปรับใช้โมเดล และ สร้างทริกเกอร์ in AWS CodeBuild.

คุณสามารถปรับขนาดแนวคิดในโพสต์นี้เพื่อโฮสต์โมเดลใน อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (Amazon EC2) หรือ บริการ Amazon Elastic Kubernetes (Amazon EKS) และสร้างไปป์ไลน์การอนุมานแบบกลุ่ม

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการมีบัญชีแยกต่างหากที่สร้างโมเดล ML ใน AWS โปรดดู แนวทางปฏิบัติที่ดีที่สุดสำหรับหน่วยขององค์กรกับองค์กร AWS และ อัปเดตโมเดลในการผลิตอย่างปลอดภัย.

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

ซานดีป เวอร์มา เป็น Sr. Prototyping Architect กับ AWS เขาสนุกกับการดำดิ่งสู่ความท้าทายของลูกค้าและสร้างต้นแบบสำหรับลูกค้าเพื่อเร่งสร้างนวัตกรรม เขามีพื้นฐานด้าน AI/ML เป็นผู้ก่อตั้ง New Knowledge และมักหลงใหลในเทคโนโลยี ในเวลาว่าง เขาชอบท่องเที่ยวและเล่นสกีกับครอบครัว

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

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

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

รูพินเดอร์ กรีวาล เป็น Sr Ai/ML Specialist Solutions Architect กับ AWS ปัจจุบันเขามุ่งเน้นการให้บริการโมเดลและ MLOps บน SageMaker ก่อนหน้าจะรับตำแหน่งนี้ เขาเคยทำงานเป็นวิศวกรด้านการเรียนรู้ของเครื่องจักรในการสร้างและโฮสต์โมเดล นอกเวลางาน เขาชอบเล่นเทนนิสและขี่จักรยานบนเส้นทางบนภูเขา

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