Looge Amazon SageMakeri mudeliregistri abil kontoülene MLOps-i töövoog

Hästi läbimõeldud CI/CD torujuhe on oluline mis tahes tarkvaraarenduse töövoo tõhusaks skaleerimiseks. Tootmis-CI/CD torujuhtmete kavandamisel soovitab AWS kasutada mitut kontot, et isoleerida ressursse, ohjeldada turvaohtusid ja lihtsustada arveldamist ning andmeteaduse torujuhtmed ei erine sellest. AWS-is jätkame uuenduste tegemist, et lihtsustada MLOps-i töövoogu.

Selles postituses käsitleme mõningaid uuemaid kontoüleseid funktsioone Amazon SageMaker mis võimaldavad teil paremini jagada ja hallata mudelirühmi ning hallata mudeliversioone. Konto struktuuri näide, mida järgida organisatsiooniüksuse parimad tavad SageMakeri lõpp-punkte kasutavate mudelite hostimiseks kontode lõikes vt MLOps Workload Orchestrator.

Lahenduse ülevaade

Järgmine diagramm illustreerib meie jagatud mudeliregistri arhitektuuri.

Mõned asjad, mida eelmises arhitektuuris tähele panna:

Järgmised sammud vastavad diagrammile:

1. Andmeteadlane registreerib mudeli andmeteaduse kontolt jagatud teenuste SageMakeri mudeliregistrisse a PendingManualApproval olek. Mudeli artefakt luuakse jagatud teenuste kontol Amazoni lihtne salvestusteenus (Amazon S3) kopp.
2. Uue mudeliversiooni registreerimisel peaks keegi, kellel on volitused mudelit mõõdikute põhjal kinnitada, mudeli heaks kiitma või tagasi lükkama.
3. Pärast mudeli kinnitamist on CI/CD konveier juurutuskontol käivitatud uuendatud mudeli üksikasjad QA kontol ja värskendage etappi kvaliteedikontrollina.
4. Pärast testimisprotsessi läbimist saate CI/CD protsessis käsitsi kinnitada või lasta CI/CD konveieril mudeli otse tootmisse juurutada ja etappi tootena värskendada.
5. Tootmiskeskkond viitab kinnitatud mudelile ja koodile, võib-olla teeb seda A/B test tootmises. Auditi või mudeliga seotud probleemide korral saate seda kasutada Amazon SageMaker ML Lineage Tracking. See loob ja salvestab teavet masinõppe (ML) töövoo etappide kohta andmete ettevalmistamisest mudeli juurutamiseni. Jälgiteabe abil saate reprodutseerida töövoo samme, jälgida mudelit ja andmestiku liini ning kehtestada mudeli juhtimis- ja auditistandardid.

Kogu protsessi vältel säilitab jagatud mudeliregister vanemad mudeliversioonid. See võimaldab meeskonnal muudatusi tagasi võtta või isegi korraldada tootmisvariandid.

Eeldused

Veenduge, et teil on järgmised eeltingimused:

• Ettevalmistatud mitme konto struktuur – Juhiseid vt AWS-i organisatsioonide organisatsiooniüksuste parimad tavad. Selle ajaveebi jaoks kasutame järgmisi kontosid:
  • Andmeteaduse konto – konto, kus andmeteadlastel on juurdepääs koolitusandmetele ja kus nad loovad mudeleid.
  • Ühisteenuste konto – Keskne konto mudeliartefaktide salvestamiseks (nagu on näidatud arhitektuuriskeemil), millele pääseb juurde erinevatel töökoormuse kontodel.
  • Juurutuskonto – konto, mis vastutab erinevate kontode muudatuste juurutamise eest.
  • Töökoormuse kontod – Need on tavaliselt kvaliteedikontrolli- ja tootekeskkonnad, kus tarkvarainsenerid saavad luua rakendusi ML-mudeli tarbimiseks.
• Asjakohaste õigustega juurutuskonto – Lisateavet mitme kontoga OU-struktuuri parimate tavade kohta leiate aadressilt Deployments OU. See konto vastutab töökoormuse kontode suunamise eest soovitud mudelile jagatud teenuste konto mudeliregistris.

Määratlege kontoülesed eeskirjad

Väiksemate privileegide põhimõtet järgides peame esmalt lisama jagatud teenuste ressurssidele kontoülesed ressursipoliitikad, et anda juurdepääs teistelt kontodelt.

Kuna mudeli artefaktid on salvestatud jagatud teenuste konto S3 ämbrisse, vajab andmeteaduse konto Amazon S3 lugemis-/kirjutusjuurdepääsu, et koolitatud mudelid Amazon S3-sse suunata. Järgmine kood illustreerib seda reeglit, kuid ärge lisage seda veel jagatud teenuste kontole:

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

Juurutuskontole tuleb anda ainult lugemisõigus S3 ämbrile, et see saaks mudeliartefakte kasutada SageMakeri lõpp-punktidesse juurutamiseks. Samuti peame ühisteenuste S3 ämbrile lisama järgmise poliitika:

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

Kombineerime mõlemad eeskirjad, et saada järgmine lõplik poliitika. Looge see reegel jagatud teenuste kontol pärast sobivate konto ID-de asendamist:

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

Teisel kontol loodud mudeli juurutamiseks peab kasutajal olema roll, millel on juurdepääs SageMakeri toimingutele, näiteks roll AmazonSageMakerFullAccess juhitud poliitika. Viitama Mudeli versiooni juurutamine erinevalt kontolt täiendavaid üksikasju.

Peame määratlema mudelirühma, mis sisaldab mudeliversioone, mida soovime juurutada. Samuti tahame anda andmeteaduse kontole load. Seda saab teha järgmiste sammudega. Arvestustele viitame järgmiselt:

• jagatud_teenuste_konto_id – Konto, kus asub mudeliregister ja kuhu tahame mudelit paigutada
• data_science_account_id – Konto, kus me treenime ja loome seega tegeliku mudeliartefakti
• juurutamise_konto_id – Konto, kuhu tahame selle mudeli lõpp-punkti majutada

Kõigepealt peame tagama mudelpaketirühmade olemasolu. Saate kasutada Boto3 API-sid, nagu on näidatud järgmises näites, või kasutada AWS-i juhtimiskonsool mudelipaketi loomiseks. Viitama Loo mudelipaketi rühm lisateabe saamiseks. See eeldab, et olete installinud 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']))

Selle mudelipakettide rühma lubade saamiseks saate luua JSON-dokumendi, mis meenutab järgmist koodi. Asendage tegelikud konto ID-d ja mudelipaketi rühma nimi oma väärtustega.

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

Lõpuks rakendage poliitika mudelpaketi rühmale. Te ei saa seda poliitikat konsooli kaudu paketirühmaga seostada. Teil on vaja SDK-d või AWS-i käsurea liides (AWS CLI) juurdepääs. Näiteks järgmine kood kasutab 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)

Vajame ka tava AWS-i võtmehaldusteenus (AWS KMS) võti mudeli krüptimiseks, säilitades selle Amazon S3-s. Seda tuleb teha andmeteaduse konto abil. Navigeerige AWS KMS-i konsoolis Määratlege võtmekasutusõigused lehel. Aastal Muud AWS-i kontod Valige jaotises Lisage veel üks AWS-i konto. Sisestage juurutuskonto AWS-i kontonumber. Seda KMS-võtit kasutate SageMakeri koolitustöö jaoks. Kui te ei määra koolitustöö jaoks KMS-võtit, kasutab SageMaker vaikimisi Amazon S3 serveripoolset krüpteerimisvõtit. Amazon S3 serveripoolset vaikekrüpteerimisvõtit ei saa teise AWS-i kontoga jagada ega kasutada.

Eeskirjad ja load järgivad järgmist mustrit:

• punktis määratletud Amazon S3 poliitika shared_services_account annab load andmeteaduse kontole ja juurutuste kontole
• punktis määratletud KMS-i võtmepoliitika shared_services_account annab load andmeteaduse kontole ja juurutuste kontole

Peame tagama, et jagatud teenuste kontol ja juurutamise kontol on juurdepääs Dockeri piltidele, mida mudeli väljaõpetamiseks kasutati. Neid pilte majutatakse tavaliselt AWS-i kontodel ja teie konto administraator võib aidata teil juurdepääsu hankida, kui teil seda veel pole. Selle postituse jaoks ei loo me pärast mudeli treenimist kohandatud Dockeri pilte ja seetõttu ei vaja me piltide jaoks mingeid konkreetseid Amazoni ECR-eeskirju.

Töökoormuse kontodel (QA või prod) peame looma kaks AWS-i identiteedi- ja juurdepääsuhaldus (IAM) poliitikad, mis on sarnased järgmistega. Need on tekstisisesed poliitikad, mis tähendab, et need on manustatud IAM-identiteedi. See annab neile kontodele juurdepääsu mudeliregistrile.

Esimene tekstisisene poliitika võimaldab rollil juurdepääsu Amazon S3 ressursile jagatud teenuste kontol, mis sisaldab mudeli artefakti. Esitage S3 kopa nimi ja mudel:

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

Teine tekstisisene reegel lubab rollil, mille loome hiljem, kasutada KMS-i võtit jagatud teenuste kontol. Määrake jagatud teenuste konto konto ID ja KMS-i võtme ID:

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

Lõpuks peame luua IAM-i roll SageMakeri jaoks. Sellel rollil on AmazonSageMakerFullAccess lisatud poliitika. Seejärel lisame need kaks tekstisisest poliitikat loodud rollile. Kui kasutate olemasolevat SageMakeri täitmisrolli, lisage sellele rollile need kaks poliitikat. Juhiste saamiseks vaadake Rollide loomine ja poliitikate lisamine (konsool).

Nüüd, kui oleme määratlenud iga konto eeskirjad, kasutame näidet, et näha seda toimimas.

Ehitage ja koolitage mudel SageMakeri torujuhtme abil

Esmalt loome andmeteaduse kontol SageMakeri konveieri andmetöötluse, mudelikoolituse ja hindamise läbiviimiseks. Kasutame StatLibi raamatukogust saadud California eluasemeandmestikku. Järgmises koodilõigul kasutame kohandatud eeltöötlusskripti preprocess.py mõne lihtsa funktsiooni teisenduse tegemiseks, nagu funktsiooni skaleerimine, mille saab luua järgmise abil märkmik. See skript jagab andmestiku ka koolitus- ja katseandmekogumiteks.

Loome a SKLearnProcessor objekt selle eeltöötlusskripti käitamiseks. SageMakeri torujuhtmes loome töötlemisetapi (ProcessingStep), et käitada töötlemiskoodi kasutades SKLearnProcessor. Seda töötlemiskoodi kutsutakse välja SageMakeri konveieri initsialiseerimisel. Kood, mis loob SKLearnProcessor ja ProcessingStep on näidatud järgmises koodis. Pange tähele, et kogu selles jaotises olevat koodi käitatakse andmeteaduse kontol.

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

Mudeli krüpteerimiseks vajame kohandatud KMS-võtit selle Amazon S3-sse salvestamiseks. Vaadake järgmist koodi:

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

Mudeli koolitamiseks loome TensorFlow hinnanguobjekti. Edastame sellele KMS-i võtme ID koos koolitusskriptiga train.py, koolituseksemplari tüüp ja arv. Samuti loome a TrainingStep lisada meie konveierile ja lisada sellele TensorFlow hindaja. Vaadake järgmist koodi:

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

Lisaks koolitusele peame läbi viima mudeli hindamise, mille puhul kasutame selles näites mõõdikuna keskmist ruudu viga (MSE). The varasem märkmik genereerib ka evaluate.py, mida kasutame oma mudeli hindamiseks MSE abil. Samuti loome a ProcessingStep mudeli hindamise skripti lähtestamiseks, kasutades a SKLearnProcessor objektiks. Selle sammu loob järgmine kood:

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

Pärast mudeli hindamist vajame ka sammu oma mudeli registreerimiseks mudeliregistris, kui mudeli jõudlus vastab nõuetele. Seda näidatakse järgmises koodis, kasutades RegisterModel samm. Siin peame täpsustama mudelpaketi, mille olime ühisteenuste kontol deklareerinud. Asendage piirkond, konto ja mudelipakett oma väärtustega. Siin kasutatav mudeli nimi on modeltest, kuid võite kasutada mis tahes enda valitud nime.

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

Peame looma ka mudeli artefaktid, et seda saaks juurutada (kasutades teist kontot). Mudeli loomiseks loome a CreateModelStep, nagu on näidatud järgmises koodis:

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

Tingimuste lisamine torujuhtmele toimub a ConditionStep. Sel juhul soovime registreerida mudeli registris uue mudeliversiooni ainult juhul, kui uus mudel vastab täpsuse tingimusele. Vaadake järgmist koodi:

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

Lõpuks tahame kõik konveieri etapid korraldada, et konveier saaks lähtestada:

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

Juurutage mudeli versioon teiselt kontolt

Nüüd, kui mudel on jagatud teenuste kontol registreeritud, peame juurutama oma töökoormuse kontodele, kasutades juurutuskonto CI/CD konveieri. Oleme rolli ja poliitika juba varasemas etapis konfigureerinud. Mudeli juurutamiseks mudeliregistrist kasutame mudelipaketti ARN. Juurutuskontol töötab järgmine kood ja seda kasutatakse heakskiidetud mudelite juurutamiseks kvaliteedikontrollile ja tootele:

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

Järeldus

Selles postituses näitasime, kuidas seadistada ML-i jaoks mitme konto seadistamiseks vajalikke eeskirju, lähtudes vähima privileegi põhimõttest. Seejärel näitasime andmeteaduse kontol mudelite loomise ja koolitamise protsessi. Lõpuks kasutasime juurutuskontol CI/CD konveieri, et juurutada kinnitatud mudelite uusim versioon kvaliteedikontrolli- ja tootmiskontodele. Lisaks saate vaadata mudelite juurutamise ajalugu ja luua käivitajaid in AWS CodeBuild.

Saate selles postituses olevaid kontseptsioone mudelite majutamiseks skaleerida Amazon Elastic Compute Cloud (Amazon EC2) või Amazoni elastse Kubernetese teenus (Amazon EKS), samuti ehitada välja partii järelduse torujuhe.

Lisateavet AWS-is ML-mudeleid loovate eraldi kontode omamise kohta vt AWS-i organisatsioonide organisatsiooniüksuste parimad tavad ja Uuendage ohutult tootmises olevaid mudeleid.

Autoritest

Sandeep Verma on AWS-iga prototüüpide loomise arhitekt. Talle meeldib sukelduda sügavale klientide väljakutsetesse ja luua klientidele prototüüpe, et kiirendada innovatsiooni. Tal on AI/ML-i taust, New Knowledge'i asutaja ja üldiselt kirglik tehnoloogia. Vabal ajal armastab ta perega reisida ja suusatada.

 Mani Khanuja on tehisintellekti ja masinõppe spetsialist ettevõttes Amazon Web Services (AWS). Ta aitab masinõpet kasutavatel klientidel AWS-i abil oma äriprobleeme lahendada. Ta veedab suurema osa ajast sukeldudes sügavuti ja õpetades kliente AI/ML projektidele, mis on seotud arvutinägemise, loomuliku keele töötlemise, prognoosimise, ML-i äärealade ja muuga. Ta on kirglik ML-i vastu, seetõttu on ta loonud oma labori koos isejuhtiva komplekti ja prototüüpide valmistamise tootmisliiniga, kus veedab suure osa oma vabast ajast.

Saumitra Vikram on Amazon SageMakeri meeskonna tarkvaraarendaja ja asub Indias Chennais. Väljaspool tööd meeldib talle veeta aega joostes, matkates ja mootorrattaga Himaalajas sõites.

Sreedevi Srinivasan on AWS SageMakeri insenerijuht. Ta on kirglik ja põnevil, et võimaldada ML-il platvormina, mis peaks muutma igapäevaelu. Praegu keskendub ta SageMakeri funktsioonipoele. Vabal ajal meeldib talle perega aega veeta.

Rupinder Grewal on AWS-iga Sr Ai/ML spetsialistide lahenduste arhitekt. Praegu keskendub ta mudelite ja MLO-de teenindamisele SageMakeris. Enne seda rolli on ta töötanud masinõppeinsenerina mudelite ehitamise ja hostimise kohta. Töövälisel ajal meeldib talle tennist mängida ja mägiradadel jalgrattaga sõita.

Farooq Sabir on AWS-i tehisintellekti ja masinõppe lahenduste vanemarhitekt. Tal on doktori- ja magistrikraad elektrotehnika alal Texase ülikoolist Austinis ning magistrikraadi arvutiteaduses Georgia Tehnoloogiainstituudist. AWS-is aitab ta klientidel sõnastada ja lahendada äriprobleeme andmeteaduse, masinõppe, arvutinägemise, tehisintellekti, numbrilise optimeerimise ja sellega seotud valdkondades. Tal on üle 16-aastane töökogemus ja ta on ka täiendav õppejõud Texase ülikoolis Dallases, kus ta õpetab rakendusliku masinõppe kursust. Teksases Dallases asuv talle ja ta perele meeldib reisida ja pikki autoreise teha.