Buat alur kerja MLOps lintas akun menggunakan registri model Amazon SageMaker

Pipeline CI/CD yang dirancang dengan baik sangat penting untuk menskalakan setiap alur kerja pengembangan perangkat lunak secara efektif. Saat merancang pipeline CI/CD produksi, AWS merekomendasikan untuk memanfaatkan beberapa akun untuk mengisolasi sumber daya, mengatasi ancaman keamanan, dan menyederhanakan penagihan—dan pipeline ilmu data juga demikian. Di AWS, kami terus berinovasi untuk menyederhanakan alur kerja MLOps.

Dalam postingan ini, kami membahas beberapa fitur lintas akun yang lebih baru Amazon SageMaker yang memungkinkan Anda berbagi dan mengelola grup model serta mengelola versi model dengan lebih baik. Untuk contoh struktur akun yang akan diikuti praktik terbaik unit organisasi untuk menghosting model menggunakan titik akhir SageMaker di seluruh akun, lihat Pengatur Beban Kerja MLOps.

Ikhtisar solusi

Diagram berikut mengilustrasikan arsitektur registri model bersama kami.

Beberapa hal yang perlu diperhatikan dalam arsitektur sebelumnya:

Langkah-langkah berikut sesuai dengan diagram:

1. Ilmuwan data mendaftarkan model dari akun ilmu data ke dalam registri model SageMaker layanan bersama di a PendingManualApproval negara. Artefak model dibuat di akun layanan bersama Layanan Penyimpanan Sederhana Amazon (Amazon S3).
2. Setelah pendaftaran versi model baru, seseorang dengan wewenang untuk menyetujui model berdasarkan metrik harus menyetujui atau menolak model tersebut.
3. Setelah model disetujui, saluran pipa CI/CD di akun penerapan dipicu untuk menyebarkan perbarui detail model di akun QA dan perbarui tahapan sebagai QA.
4. Setelah melewati proses pengujian, Anda dapat memilih untuk memiliki langkah persetujuan manual dalam proses CI/CD Anda atau meminta pipeline CI/CD Anda secara langsung menerapkan model ke produksi dan memperbarui tahapan sebagai Prod.
5. Lingkungan produksi mereferensikan model dan kode yang disetujui, mungkin melakukan Uji A/B dalam produksi. Jika terjadi audit atau masalah apa pun dengan model, Anda dapat menggunakannya Pelacakan Silsilah Amazon SageMaker ML. Ini membuat dan menyimpan informasi tentang langkah-langkah alur kerja pembelajaran mesin (ML) dari persiapan data hingga penerapan model. Dengan informasi pelacakan, Anda dapat mereproduksi langkah-langkah alur kerja, melacak silsilah model dan dataset, serta menetapkan tata kelola model dan standar audit.

Sepanjang seluruh proses, registri model bersama mempertahankan versi model lama. Ini memungkinkan tim untuk mengembalikan perubahan, atau bahkan menjadi tuan rumah varian produksi.

Prasyarat

Pastikan Anda memiliki prasyarat berikut:

• Struktur multi-akun yang disediakan – Untuk instruksi, lihat Praktik Terbaik untuk Unit Organisasi dengan Organisasi AWS. Untuk keperluan blog ini kami memanfaatkan akun berikut:
  • akun ilmu data – Akun tempat ilmuwan data memiliki akses ke data pelatihan dan membuat model.
  • Akun layanan bersama – Akun pusat untuk menyimpan artefak model (seperti yang ditunjukkan pada diagram arsitektur) untuk diakses di berbagai akun beban kerja.
  • Akun penerapan – Akun yang bertanggung jawab untuk menyebarkan perubahan ke berbagai akun.
  • Akun beban kerja – Ini umumnya adalah lingkungan QA dan prod tempat insinyur perangkat lunak dapat membangun aplikasi untuk menggunakan model ML.
• Akun penerapan dengan izin yang sesuai – Untuk informasi selengkapnya tentang praktik terbaik dengan struktur OU multi-akun, lihat Penerapan OU. Akun ini bertanggung jawab untuk mengarahkan akun beban kerja ke model yang diinginkan di registri model akun layanan bersama.

Tetapkan kebijakan lintas akun

Dalam mengikuti prinsip hak istimewa terkecil, pertama-tama kita perlu menambahkan kebijakan sumber daya lintas akun ke sumber daya layanan bersama untuk memberikan akses dari akun lain.

Karena artefak model disimpan di bucket S3 akun layanan bersama, akun sains data memerlukan akses baca/tulis Amazon S3 untuk mendorong model terlatih ke Amazon S3. Kode berikut mengilustrasikan kebijakan ini, tetapi belum menambahkannya ke akun layanan bersama:

#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:::/*'
    }]
}

Akun penerapan hanya perlu diberi akses baca ke bucket S3, sehingga dapat menggunakan artefak model untuk menerapkan ke titik akhir SageMaker. Kami juga perlu melampirkan kebijakan berikut ke bucket S3 layanan bersama:

#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:::/*'
    }]
}

Kami menggabungkan kedua kebijakan untuk mendapatkan kebijakan akhir berikut. Buat kebijakan ini di akun layanan bersama setelah mengganti ID akun yang sesuai:

{
  "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:::/*"    
    }
  ]
}

Agar dapat menerapkan model yang dibuat di akun berbeda, pengguna harus memiliki peran yang memiliki akses ke tindakan SageMaker, seperti peran dengan AmazonSageMakerFullAccess kebijakan yang dikelola. Mengacu pada Terapkan Versi Model dari Akun Berbeda untuk detail tambahan.

Kita perlu menentukan grup model yang berisi versi model yang ingin kita terapkan. Selain itu, kami ingin memberikan izin ke akun sains data. Ini dapat dicapai dalam langkah-langkah berikut. Kami merujuk ke akun sebagai berikut:

• shared_services_account_id – Akun tempat registri model berada dan tempat model yang kita inginkan
• data_science_account_id – Akun tempat kita akan berlatih dan karenanya membuat artefak model yang sebenarnya
• deployment_account_id – Akun tempat kami ingin menghosting titik akhir untuk model ini

Pertama kita perlu memastikan grup paket model ada. Anda dapat menggunakan API Boto3 seperti yang ditunjukkan pada contoh berikut, atau Anda dapat menggunakan Konsol Manajemen AWS untuk membuat paket model. Mengacu pada Buat Grup Paket Model untuk lebih jelasnya. Ini mengasumsikan Anda telah menginstal 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']))

Untuk izin grup paket model ini, Anda dapat membuat dokumen JSON yang menyerupai kode berikut. Ganti ID akun aktual dan nama grup paket model dengan nilai Anda sendiri.

{
  "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//*"    
    }
  ]
}

Terakhir, terapkan kebijakan ke grup paket model. Anda tidak dapat mengaitkan kebijakan ini dengan grup paket melalui konsol. Anda memerlukan SDK atau Antarmuka Baris Perintah AWS (AWS CLI) akses. Misalnya, kode berikut menggunakan 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)

Kami juga membutuhkan kebiasaan Layanan Manajemen Kunci AWS (AWS KMS) untuk mengenkripsi model saat menyimpannya di Amazon S3. Ini perlu dilakukan dengan menggunakan akun sains data. Di konsol AWS KMS, navigasikan ke Tentukan izin penggunaan kunci halaman. Dalam Akun AWS lainnya bagian, pilih Tambahkan akun AWS lain. Masukkan nomor akun AWS untuk akun penerapan. Anda menggunakan kunci KMS ini untuk tugas pelatihan SageMaker. Jika Anda tidak menentukan kunci KMS untuk tugas pelatihan, SageMaker secara default menggunakan kunci enkripsi sisi server Amazon S3. Kunci enkripsi sisi server Amazon S3 default tidak dapat dibagikan dengan atau digunakan oleh akun AWS lain.

Kebijakan dan izin mengikuti pola ini:

• Kebijakan Amazon S3 yang ditentukan di shared_services_account memberikan izin ke akun sains data dan akun penyebaran
• Kebijakan kunci KMS yang ditentukan di shared_services_account memberikan izin ke akun sains data dan akun penyebaran

Kami perlu memastikan bahwa akun layanan bersama dan akun penerapan memiliki akses ke image Docker yang digunakan untuk melatih model. Gambar ini umumnya dihosting di akun AWS, dan admin akun Anda dapat membantu Anda mendapatkan akses, jika Anda belum memiliki akses. Untuk posting ini, kami tidak membuat gambar Docker khusus apa pun setelah melatih model dan oleh karena itu kami tidak memerlukan kebijakan khusus Amazon ECR untuk gambar tersebut.

Di akun beban kerja (QA atau prod), kita perlu membuat dua Identitas AWS dan Manajemen Akses (IAM) mirip dengan yang berikut ini. Ini adalah kebijakan sebaris, yang berarti mereka disematkan dalam identitas IAM. Ini memberi akun ini akses ke registri model.

Kebijakan sebaris pertama memungkinkan peran untuk mengakses sumber daya Amazon S3 di akun layanan bersama yang berisi artefak model. Berikan nama bucket S3 dan model Anda:

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

Kebijakan sebaris kedua memungkinkan peran, yang kami buat nanti, untuk menggunakan kunci KMS di akun layanan bersama. Tentukan ID akun untuk akun layanan bersama dan ID kunci 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}"
            ]
        }
    ]
}

Akhirnya, kita perlu membuat peran IAM untuk SageMaker. Peran ini memiliki AmazonSageMakerFullAccess kebijakan terlampir. Kami kemudian melampirkan dua kebijakan sebaris ini ke peran yang kami buat. Jika Anda menggunakan peran eksekusi SageMaker yang sudah ada, lampirkan kedua kebijakan ini ke peran tersebut. Untuk instruksi, lihat Membuat peran dan melampirkan kebijakan (konsol).

Sekarang setelah kita menentukan kebijakan setiap akun, mari gunakan contoh untuk melihatnya dalam tindakan.

Build dan latih model menggunakan pipeline SageMaker

Pertama-tama, kami membuat pipeline SageMaker di akun ilmu data untuk melakukan pemrosesan data, pelatihan model, dan evaluasi. Kami menggunakan dataset perumahan California yang diperoleh dari perpustakaan StatLib. Dalam cuplikan kode berikut, kami menggunakan skrip prapemrosesan khusus preprocess.py untuk melakukan beberapa transformasi fitur sederhana seperti penskalaan fitur, yang dapat dihasilkan menggunakan berikut ini buku catatan. Skrip ini juga membagi dataset menjadi dataset pelatihan dan pengujian.

Kami membuat SKLearnProcessor objek untuk menjalankan skrip preprocessing ini. Di pipeline SageMaker, kami membuat langkah pemrosesan (ProcessingStep) untuk menjalankan kode pemrosesan menggunakan SKLearnProcessor. Kode pemrosesan ini dipanggil saat pipeline SageMaker diinisialisasi. Kode menciptakan SKLearnProcessor dan ProcessingStep ditunjukkan pada kode berikut. Perhatikan bahwa semua kode di bagian ini dijalankan di akun sains data.

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

Kami memerlukan kunci KMS khusus untuk mengenkripsi model sambil menyimpannya di Amazon S3. Lihat kode berikut:

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

Untuk melatih model, kami membuat objek estimator TensorFlow. Kami memberikannya ID kunci KMS bersama dengan skrip pelatihan kami train.py, jenis instans pelatihan, dan jumlah. Kami juga membuat TrainingStep untuk ditambahkan ke pipeline kami, dan menambahkan estimator TensorFlow ke dalamnya. Lihat kode berikut:

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",
        ),
    },
)

Selain pelatihan, kami perlu melakukan evaluasi model, yang kami gunakan mean squared error (MSE) sebagai metrik dalam contoh ini. Itu buku catatan sebelumnya juga menghasilkan evaluate.py, yang kami gunakan untuk mengevaluasi model kami menggunakan MSE. Kami juga membuat ProcessingStep untuk menginisialisasi skrip evaluasi model menggunakan a SKLearnProcessor obyek. Kode berikut membuat langkah ini:

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],
)

Setelah evaluasi model, kami juga memerlukan langkah untuk mendaftarkan model kami ke registri model, jika kinerja model memenuhi persyaratan. Ini ditunjukkan dalam kode berikut menggunakan RegisterModel melangkah. Di sini kita perlu menentukan paket model yang telah kita nyatakan di akun layanan bersama. Ganti Region, akun, dan paket model dengan nilai Anda. Nama model yang digunakan di sini adalah modeltest, tetapi Anda dapat menggunakan nama apa pun pilihan Anda.

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

Kita juga perlu membuat artefak model agar dapat diterapkan (menggunakan akun lain). Untuk membuat model, kami membuat a CreateModelStep, seperti yang ditunjukkan pada kode berikut:

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"),
 )

Penambahan kondisi pada pipeline dilakukan dengan a ConditionStep. Dalam hal ini, kami hanya ingin mendaftarkan versi model baru dengan model registry jika model baru memenuhi kondisi akurasi. Lihat kode berikut:

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],
)

Terakhir, kami ingin mengatur semua langkah pipeline sehingga pipeline dapat diinisialisasi:

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],
)

Terapkan versi model dari akun yang berbeda

Sekarang model telah terdaftar di akun layanan bersama, kami perlu menerapkan ke akun beban kerja menggunakan pipa CI/CD di akun penerapan. Kami telah mengonfigurasi peran dan kebijakan di langkah sebelumnya. Kami menggunakan paket model ARN untuk menerapkan model dari registri model. Kode berikut berjalan di akun penerapan dan digunakan untuk menerapkan model yang disetujui ke QA dan prod:

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

Kesimpulan

Dalam postingan ini, kami mendemonstrasikan cara menyiapkan kebijakan yang diperlukan untuk penyiapan multi-akun untuk ML berdasarkan prinsip hak istimewa terkecil. Kemudian kami menunjukkan proses pembuatan dan pelatihan model di akun sains data. Terakhir, kami menggunakan pipeline CI/CD di akun penerapan untuk menerapkan versi terbaru dari model yang disetujui ke QA dan akun produksi. Selain itu, Anda bisa melihat sejarah penyebaran model dan membangun pemicu in Pembuatan Kode AWS.

Anda dapat menskalakan konsep dalam postingan ini untuk menghosting model Cloud komputasi elastis Amazon (Amazon EC2) atau Layanan Amazon Elastic Kubernetes (Amazon EKS), serta membangun pipa inferensi batch.

Untuk mempelajari selengkapnya tentang memiliki akun terpisah yang membuat model ML di AWS, lihat Praktik Terbaik untuk Unit Organisasi dengan Organisasi AWS dan Perbarui model dengan aman dalam produksi.

Tentang Penulis

Sandeep Verma adalah Sr. Prototyping Architect dengan AWS. Dia senang mendalami tantangan pelanggan dan membangun prototipe bagi pelanggan untuk mempercepat inovasi. Dia memiliki latar belakang AI/ML, pendiri Pengetahuan Baru, dan secara umum sangat menyukai teknologi. Di waktu luangnya, dia suka bepergian dan bermain ski bersama keluarganya.

 Mani Khanuja adalah Spesialis Artificial Intelligence dan Machine Learning SA di Amazon Web Services (AWS). Dia membantu pelanggan menggunakan pembelajaran mesin untuk memecahkan tantangan bisnis mereka menggunakan AWS. Dia menghabiskan sebagian besar waktunya untuk menyelam lebih dalam dan mengajar pelanggan tentang proyek AI/ML yang terkait dengan visi komputer, pemrosesan bahasa alami, perkiraan, ML di edge, dan banyak lagi. Dia sangat menyukai ML di edge, oleh karena itu, dia telah membuat labnya sendiri dengan kit self-driving dan lini produksi manufaktur prototipe, di mana dia menghabiskan banyak waktu luangnya.

Saumitra Vikram adalah Pengembang Perangkat Lunak di tim Amazon SageMaker dan berbasis di Chennai, India. Di luar pekerjaan, ia suka menghabiskan waktu dengan berlari, trekking, dan mengendarai sepeda motor melintasi Himalaya.

Sreedevi Srinivasan adalah pemimpin teknik di AWS SageMaker. Dia bersemangat dan bersemangat untuk mengaktifkan ML sebagai platform yang akan mengubah kehidupan sehari-hari. Dia saat ini berfokus pada SageMaker Feature Store. Di waktu luangnya, dia suka menghabiskan waktu bersama keluarganya.

Rupinder Grewal adalah Arsitek Solusi Spesialis Sr Ai/ML dengan AWS. Dia saat ini berfokus pada penyajian model dan MLOps di SageMaker. Sebelum peran ini, ia telah bekerja sebagai Insinyur Pembelajaran Mesin yang membangun dan menjadi model hosting. Di luar pekerjaan ia menikmati bermain tenis dan bersepeda di jalur gunung.

Farooq Sabir adalah Arsitek Solusi Spesialis Kecerdasan Buatan dan Pembelajaran Mesin Senior di AWS. Dia memegang gelar PhD dan MS di bidang Teknik Elektro dari The University of Texas di Austin dan MS di bidang Ilmu Komputer dari Georgia Institute of Technology. Di AWS, dia membantu pelanggan merumuskan dan memecahkan masalah bisnis mereka dalam ilmu data, pembelajaran mesin, visi komputer, kecerdasan buatan, pengoptimalan numerik, dan domain terkait. Dia memiliki lebih dari 16 tahun pengalaman kerja dan juga anggota fakultas tambahan di The University of Texas di Dallas, di mana dia mengajar kursus pascasarjana tentang Pembelajaran Mesin Terapan. Berbasis di Dallas, Texas, dia dan keluarganya suka bepergian dan melakukan perjalanan jauh.