Zgradite potek dela MLOps za več računov z uporabo registra modelov Amazon SageMaker

Dobro zasnovan cevovod CI/CD je bistvenega pomena za učinkovito prilagajanje delovnega toka razvoja programske opreme. Pri načrtovanju produkcijskih cevovodov CI/CD AWS priporoča uporabo več računov za izolacijo virov, zajezitev varnostnih groženj in poenostavitev zaračunavanja in podatkovnih cevovodov ni nič drugače. Pri AWS nadaljujemo z inovacijami, da bi poenostavili potek dela MLOps.

V tej objavi razpravljamo o nekaterih novejših funkcijah med računi Amazon SageMaker ki vam omogočajo boljšo skupno rabo in upravljanje skupin modelov ter upravljanje različic modelov. Sledi primer strukture računa najboljše prakse organizacijskih enot za gostovanje modelov, ki uporabljajo končne točke SageMaker v računih, glejte MLOps Workload Orchestrator.

Pregled rešitev

Naslednji diagram ponazarja našo arhitekturo registra modela v skupni rabi.

Nekaj ​​stvari, ki jih je treba upoštevati pri prejšnji arhitekturi:

Naslednji koraki ustrezajo diagramu:

1. Podatkovni znanstvenik registrira model iz računa podatkovne znanosti v register modelov SageMaker za skupne storitve v a PendingManualApproval država. Artefakt modela je ustvarjen v računu storitev v skupni rabi Preprosta storitev shranjevanja Amazon (Amazon S3) vedro.
2. Ob registraciji nove različice modela mora nekdo s pooblastilom za odobritev modela na podlagi meritev odobriti ali zavrniti model.
3. Ko je model odobren, je cevovod CI/CD v računu za uvedbo sprožil za namestitev posodobljene podrobnosti modela v računu QA in posodobite stopnjo kot QA.
4. Ko uspešno opravite postopek testiranja, se lahko odločite za ročni korak odobritve v procesu CI/CD ali pa vaš cevovod CI/CD neposredno uvede model v proizvodnjo in posodobi stopnjo kot Prod.
5. Proizvodno okolje se sklicuje na odobren model in kodo, morda izvaja A/B test v proizvodnji. V primeru revizije ali kakršne koli težave z modelom lahko uporabite Sledenje rodu Amazon SageMaker ML. Ustvarja in shranjuje informacije o korakih delovnega toka strojnega učenja (ML) od priprave podatkov do uvajanja modela. Z informacijami o sledenju lahko reproducirate korake poteka dela, sledite modelu in rodu nabora podatkov ter vzpostavite standarde upravljanja in revizije modela.

Skozi celoten postopek register modela v skupni rabi ohranja starejše različice modela. To ekipi omogoča povrnitev sprememb ali celo gostovanje proizvodne variante.

Predpogoji

Zagotovite, da imate naslednje predpogoje:

• Omogočena struktura z več računi – Za navodila gl Najboljše prakse za organizacijske enote z organizacijami AWS. Za namene tega bloga uporabljamo naslednje račune:
  • Račun podatkovne znanosti – Račun, kjer imajo podatkovni znanstveniki dostop do podatkov o usposabljanju in ustvarjajo modele.
  • Račun skupnih storitev – Osrednji račun za shranjevanje artefaktov modela (kot je prikazano v diagramu arhitekture), do katerega je mogoče dostopati prek različnih računov delovne obremenitve.
  • Račun za uvedbo – Račun, odgovoren za uvajanje sprememb v različne račune.
  • Računi delovne obremenitve – To so običajno QA in proizvodna okolja, kjer lahko programski inženirji izdelajo aplikacije za uporabo modela ML.
• Račun za uvajanje z ustreznimi dovoljenji – Za več informacij o najboljših praksah s strukturo OU z več računi glejte Razmestitve OU. Ta račun je odgovoren za usmerjanje računov delovne obremenitve na želeni model v registru modelov računa storitev v skupni rabi.

Določite politike med računi

Pri upoštevanju načela najmanjših privilegijev moramo virom storitev v skupni rabi najprej dodati pravilnike o virih med računi, da omogočimo dostop iz drugih računov.

Ker so artefakti modela shranjeni v vedru S3 računa za skupne storitve, račun podatkovne znanosti potrebuje dostop za branje/pisanje Amazon S3, da potisne usposobljene modele v Amazon S3. Naslednja koda ponazarja ta pravilnik, vendar ga še ne dodajte v račun storitev v skupni rabi:

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

Računu za uvajanje je treba odobriti le dostop za branje do vedra S3, tako da lahko uporablja artefakte modela za uvajanje v končne točke SageMaker. Vedru storitev S3 v skupni rabi moramo priložiti tudi naslednji pravilnik:

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

Združimo oba pravilnika, da dobimo naslednji končni pravilnik. Ustvarite ta pravilnik v računu storitev v skupni rabi, potem ko zamenjate ustrezne ID-je računa:

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

Da lahko uporabnik uvede model, ustvarjen v drugem računu, mora imeti vlogo, ki ima dostop do dejanj SageMaker, kot je vloga z AmazonSageMakerFullAccess upravljana politika. Nanašati se na Razmestite različico modela iz drugega računa za dodatne podrobnosti.

Določiti moramo skupino modelov, ki vsebuje različice modela, ki jih želimo razmestiti. Prav tako želimo podeliti dovoljenja za račun podatkovne znanosti. To je mogoče doseči v naslednjih korakih. Na račune se sklicujemo na naslednji način:

• shared_services_account_id – Račun, kjer je register modelov in kjer želimo, da je model
• data_science_account_id – Račun, kjer se bomo usposabljali in s tem ustvarjali dejanski artefakt modela
• deployment_account_id – Račun, kjer želimo gostiti končno točko za ta model

Najprej moramo zagotoviti, da modelne skupine paketov obstajajo. Uporabite lahko API-je Boto3, kot je prikazano v naslednjem primeru, ali pa uporabite Konzola za upravljanje AWS za ustvarjanje paketa modela. Nanašati se na Ustvari skupino paketov modela za več podrobnosti. To predvideva, da imate nameščen 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']))

Za dovoljenja za to skupino paketov modela lahko ustvarite dokument JSON, ki spominja na naslednjo kodo. Zamenjajte dejanske ID-je računa in ime skupine paketov modela s svojimi vrednostmi.

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

Na koncu uporabite pravilnik za skupino paketov modela. Tega pravilnika ne morete povezati s skupino paketov prek konzole. Potrebujete SDK oz Vmesnik ukazne vrstice AWS (AWS CLI) dostop. Naslednja koda na primer uporablja 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)

Potrebujemo tudi običaj AWS Service Key Management (AWS KMS) ključ za šifriranje modela med shranjevanjem v Amazon S3. To je treba storiti z računom data science. Na konzoli AWS KMS se pomaknite do Določite ključna dovoljenja za uporabo stran. V Drugi računi AWS oddelek, izberite Dodajte drug račun AWS. Vnesite številko računa AWS za račun za uvedbo. Ta ključ KMS uporabljate za nalogo usposabljanja SageMaker. Če za nalogo usposabljanja ne določite ključa KMS, SageMaker privzeto uporabi strežniški šifrirni ključ Amazon S3. Privzetega strežniškega šifrirnega ključa Amazon S3 ni mogoče deliti z drugim računom AWS ali ga uporabljati z njim.

Politika in dovoljenja sledijo temu vzorcu:

• Pravilnik Amazon S3, določen v shared_services_account daje dovoljenja za račun podatkovne znanosti in račun za uvedbe
• Politika ključa KMS, navedena v shared_services_account daje dovoljenja za račun podatkovne znanosti in račun za uvedbe

Zagotoviti moramo, da imata račun storitev v skupni rabi in račun za uvajanje dostop do slik Docker, ki so bile uporabljene za usposabljanje modela. Te slike običajno gostujejo v računih AWS in skrbnik računa vam lahko pomaga pridobiti dostop, če dostopa še nimate. Za to objavo po usposabljanju modela ne ustvarjamo nobenih slik Docker po meri, zato za slike ne potrebujemo posebnih pravilnikov Amazon ECR.

V računih delovne obremenitve (QA ali prod) moramo ustvariti dva AWS upravljanje identitete in dostopa (IAM) podobne politike. To so vgrajeni pravilniki, kar pomeni, da so vdelani v identiteto IAM. To tem računom omogoči dostop do registra modelov.

Prvi vgrajeni pravilnik omogoča vlogi dostop do vira Amazon S3 v računu storitev v skupni rabi, ki vsebuje artefakt modela. Navedite ime vedra S3 in svoj model:

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

Drugi vgrajeni pravilnik omogoča vlogi, ki jo ustvarimo pozneje, uporabo ključa KMS v računu storitev v skupni rabi. Podajte ID računa za račun storitev v skupni rabi in ID ključa 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}"
            ]
        }
    ]
}

Končno moramo ustvarite vlogo IAM za SageMaker. Ta vloga ima AmazonSageMakerFullAccess pravilnik priložen. Ta dva vgrajena pravilnika nato priložimo vlogi, ki smo jo ustvarili. Če uporabljate obstoječo izvršilno vlogo SageMaker, tej vlogi pripnite ta dva pravilnika. Za navodila glejte Ustvarjanje vlog in pripenjanje pravilnikov (konzola).

Zdaj, ko smo definirali politike vsakega računa, si oglejmo primer v akciji.

Zgradite in učite model z uporabo cevovoda SageMaker

Najprej ustvarimo cevovod SageMaker v računu podatkovne znanosti za izvajanje obdelave podatkov, usposabljanje modelov in vrednotenje. Uporabljamo nabor stanovanjskih podatkov v Kaliforniji, pridobljen iz knjižnice StatLib. V naslednjem delčku kode uporabljamo skript za predhodno obdelavo po meri preprocess.py za izvedbo preproste transformacije funkcij, kot je skaliranje funkcij, ki jo je mogoče ustvariti z naslednjim prenosnik. Ta skript tudi razdeli nabor podatkov na nabor podatkov za usposabljanje in test.

Ustvarimo a SKLearnProcessor objekt za zagon tega skripta za predprocesiranje. V cevovodu SageMaker ustvarimo korak obdelave (ProcessingStep), da zaženete kodo za obdelavo z uporabo SKLearnProcessor. Ta koda za obdelavo se pokliče, ko je cevovod SageMaker inicializiran. Koda, ki ustvarja SKLearnProcessor in ProcessingStep so prikazani v naslednji kodi. Upoštevajte, da se vsa koda v tem razdelku izvaja v računu podatkovne znanosti.

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

Za šifriranje modela med shranjevanjem v Amazon S3 potrebujemo ključ KMS po meri. Oglejte si naslednjo kodo:

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

Za usposabljanje modela ustvarimo objekt ocenjevalca TensorFlow. Posredujemo mu ID ključa KMS skupaj s skriptom za usposabljanje train.py, vrsto primerka usposabljanja in število. Ustvarjamo tudi a TrainingStep dodamo v naš cevovod, in mu dodamo ocenjevalec TensorFlow. Oglejte si naslednjo kodo:

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

Poleg usposabljanja moramo izvesti evalvacijo modela, za katero v tem primeru kot metriko uporabimo srednjo kvadratno napako (MSE). The prejšnji zvezek tudi ustvarja evaluate.py, ki ga uporabljamo za vrednotenje našega modela z uporabo MSE. Ustvarjamo tudi a ProcessingStep za inicializacijo skripta za vrednotenje modela z uporabo a SKLearnProcessor predmet. Naslednja koda ustvari ta korak:

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

Po oceni modela potrebujemo tudi korak za registracijo našega modela v registru modelov, če zmogljivost modela izpolnjuje zahteve. To je prikazano v naslednji kodi z uporabo RegisterModel korak. Tukaj moramo določiti paket modela, ki smo ga prijavili v računu storitev v skupni rabi. Zamenjajte paket regije, računa in modela s svojimi vrednostmi. Tukaj uporabljeno ime modela je modeltest, vendar lahko uporabite katero koli ime po vaši izbiri.

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

Prav tako moramo ustvariti artefakte modela, da ga bo mogoče razmestiti (z uporabo drugega računa). Za izdelavo modela izdelamo a CreateModelStep, kot je prikazano v naslednji kodi:

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

Dodajanje pogojev v cevovod se izvede z a ConditionStep. V tem primeru želimo novo različico modela registrirati samo v registru modelov, če novi model izpolnjuje pogoj točnosti. Oglejte si naslednjo kodo:

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

Končno želimo orkestrirati vse korake cevovoda, tako da je cevovod mogoče inicializirati:

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

Namestite različico modela iz drugega računa

Zdaj, ko je bil model registriran v računu storitev v skupni rabi, ga moramo uvesti v naše račune delovne obremenitve z uporabo cevovoda CI/CD v računu za uvajanje. Vlogo in pravilnik smo že konfigurirali v prejšnjem koraku. Za razmestitev modela iz registra modelov uporabljamo modelni paket ARN. Naslednja koda se izvaja v računu za uvajanje in se uporablja za uvajanje odobrenih modelov v QA in 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')

zaključek

V tej objavi smo pokazali, kako nastaviti pravilnike, potrebne za nastavitev več računov za ML, ki temelji na načelu najmanjših privilegijev. Nato smo prikazali postopek gradnje in usposabljanja modelov v računu podatkovne znanosti. Nazadnje smo uporabili cevovod CI/CD v uvedbenem računu za uvedbo najnovejše različice odobrenih modelov v QA in proizvodne račune. Poleg tega lahko ogled zgodovine uvajanja modelov in graditi sprožilce in AWS CodeBuild.

Koncepte v tej objavi lahko prilagodite tako, da v njih gostite modele Amazonski elastični računalniški oblak (Amazon EC2) oz Amazonski elastični kubernetes storitev (Amazon EKS), kot tudi zgraditi cevovod za serijsko sklepanje.

Če želite izvedeti več o ločenih računih, ki gradijo modele ML v AWS, glejte Najboljše prakse za organizacijske enote z organizacijami AWS in Varno posodobite modele v proizvodnji.

O avtorjih

Sandeep Verma je višji arhitekt za izdelavo prototipov pri AWS. Uživa v poglobljenem potapljanju v izzive strank in izdelavi prototipov za stranke, da pospešijo inovacije. Ima izkušnje z AI/ML, ustanovitelj New Knowledge in je na splošno strasten do tehnologije. V prostem času rad potuje in z družino smuča.

 Mani Khanuja je strokovnjak za umetno inteligenco in strojno učenje pri podjetju Amazon Web Services (AWS). Strankam, ki uporabljajo strojno učenje, pomaga pri reševanju njihovih poslovnih izzivov z uporabo AWS. Večino časa posveča potapljanju in poučevanju strank na projektih AI / ML, povezanih z računalniškim vidom, obdelavo naravnega jezika, napovedovanjem, ML na robu in še več. Navdušena je nad ML na robu, zato je ustvarila lasten laboratorij s samovozečim kompletom in proizvodno linijo za izdelavo prototipov, kjer preživi veliko svojega prostega časa.

Saumitra Vikram je razvijalec programske opreme v skupini Amazon SageMaker in ima sedež v Chennaiju v Indiji. Zunaj službe rad preživlja čas s tekom, trekingom in vožnjo z motorjem po Himalaji.

Sreedevi Srinivasan je vodja inženiringa v AWS SageMaker. Je strastna in navdušena nad omogočanjem ML kot platforme, ki bo spremenila vsakdanje življenje. Trenutno se osredotoča na SageMaker Feature Store. V prostem času se rada posveča družini.

Rupinder Grewal je Sr Ai/ML Specialist Solutions Architect pri AWS. Trenutno se osredotoča na streženje modelov in MLO na SageMakerju. Pred to vlogo je delal kot inženir strojnega učenja za gradnjo in gostovanje modelov. Izven službe rad igra tenis in kolesari po gorskih poteh.

Farooq Sabir je višji strokovnjak za rešitve za umetno inteligenco in strojno učenje pri AWS. Ima doktorat in magisterij iz elektrotehnike na Univerzi v Teksasu v Austinu ter magisterij iz računalništva na Georgia Institute of Technology. Pri AWS strankam pomaga oblikovati in reševati njihove poslovne probleme na področju podatkovne znanosti, strojnega učenja, računalniškega vida, umetne inteligence, numerične optimizacije in sorodnih domen. Ima več kot 16 let delovnih izkušenj in je tudi pomožni član fakultete na Teksaški univerzi v Dallasu, kjer poučuje podiplomski tečaj o uporabnem strojnem učenju. On in njegova družina s sedežem v Dallasu v Teksasu obožujejo potovanja in dolga potovanja.