Bygg ett MLOps-arbetsflöde över flera konton med hjälp av Amazon SageMaker-modellregistret

En väldesignad CI/CD-pipeline är avgörande för att effektivt skala alla arbetsflöden för mjukvaruutveckling. När man utformar produktions-CI/CD-pipelines rekommenderar AWS att man använder flera konton för att isolera resurser, innehålla säkerhetshot och förenkla fakturerings- och datavetenskapliga pipelines. På AWS fortsätter vi att förnya oss för att förenkla MLOps arbetsflöde.

I det här inlägget diskuterar vi några av de nyare funktionerna för flera konton Amazon SageMaker som gör att du bättre kan dela och hantera modellgrupper samt hantera modellversioner. För ett exempel på kontostruktur att följa organisationsenhets bästa praxis för att vara värd för modeller som använder SageMaker-slutpunkter över konton, se MLOps Workload Orchestrator.

Lösningsöversikt

Följande diagram illustrerar vår delade modellregisterarkitektur.

Några saker att notera i den föregående arkitekturen:

Följande steg motsvarar diagrammet:

1. En datavetare registrerar en modell från datavetenskapskontot till SageMakers modellregister för delade tjänster i ett PendingManualApproval stat. Modellartefakten skapas i kontot för delade tjänster Amazon enkel lagringstjänst (Amazon S3) hink.
2. Vid en ny modellversionsregistrering bör någon med behörighet att godkänna modellen baserat på måtten godkänna eller förkasta modellen.
3. Efter att modellen har godkänts är CI/CD-pipeline i distributionskontot utlöstes att distribuera den uppdaterade modellinformationen i QA-kontot och uppdatera scenen som QA.
4. När du har klarat testprocessen kan du antingen välja att ha ett manuellt godkännandesteg inom din CI/CD-process eller låta din CI/CD-pipeline direkt distribuera modellen till produktion och uppdatera scenen som Prod.
5. Produktionsmiljön refererar till den godkända modellen och koden, kanske gör en A/B-test i produktion. I händelse av en revision eller något problem med modellen kan du använda Amazon SageMaker ML Lineage Tracking. Den skapar och lagrar information om stegen i ett arbetsflöde för maskininlärning (ML) från dataförberedelse till modellimplementering. Med spårningsinformationen kan du återskapa arbetsflödesstegen, spåra modellen och datauppsättningens linje och upprätta modellstyrning och revisionsstandarder.

Under hela processen behåller det delade modellregistret de äldre modellversionerna. Detta gör att teamet kan återställa ändringar, eller till och med vara värd produktionsvarianter.

Förutsättningar

Se till att du har följande förutsättningar:

• En tillhandahållen struktur för flera konton – För instruktioner, se Bästa praxis för organisationsenheter med AWS-organisationer. För den här bloggens syften använder vi följande konton:
  • Datavetenskap konto – Ett konto där datavetare har tillgång till utbildningsdata och skapar modellerna.
  • Konto för delade tjänster – Ett centralt konto för lagring av modellartefakter (som visas i arkitekturdiagrammet) för åtkomst över de olika arbetsbelastningskontona.
  • Implementeringskonto – Ett konto som ansvarar för att implementera ändringar på de olika kontona.
  • Arbetsbelastningskonton – Dessa är vanligtvis QA- och prod-miljöer där mjukvaruingenjörer kan bygga applikationer för att konsumera ML-modellen.
• Ett distributionskonto med lämpliga behörigheter – För mer information om bästa praxis med en struktur för flera konton, se Distributions OU. Detta konto är ansvarigt för att peka arbetsbelastningskontona till den önskade modellen i kontots delade tjänsters modellregister.

Definiera policyer för flera konton

Genom att följa principen om minsta privilegium måste vi först lägga till resurspolicyer över flera konton till de delade tjänsternas resurser för att ge åtkomst från de andra kontona.

Eftersom modellartefakterna lagras i kontot för delade tjänsterna S3, behöver datavetenskapskontot Amazon S3 läs/skrivåtkomst för att pusha tränade modeller till Amazon S3. Följande kod illustrerar denna policy, men lägg inte till den i kontot för delade tjänster ännu:

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

Distributionskontot behöver bara ges läsåtkomst till S3-bucket, så att det kan använda modellartefakterna för att distribuera till SageMaker-slutpunkter. Vi måste också bifoga följande policy till S3-segmentet för delade tjänster:

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

Vi kombinerar båda policyerna för att få följande slutgiltiga policy. Skapa denna policy i kontot för delade tjänster efter att ha ersatt lämpliga konto-ID:n:

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

För att kunna distribuera en modell som skapats i ett annat konto måste användaren ha en roll som har åtkomst till SageMaker-åtgärder, till exempel en roll med AmazonSageMakerFullAccess hanterad politik. Hänvisa till Distribuera en modellversion från ett annat konto för ytterligare information.

Vi måste definiera modellgruppen som innehåller modellversionerna vi vill distribuera. Vi vill också ge behörigheter till datavetenskapskontot. Detta kan åstadkommas i följande steg. Vi hänvisar till räkenskaperna enligt följande:

• shared_services_account_id – Kontot där modellregistret finns och var vi vill att modellen ska vara
• data_science_account_id – Kontot där vi kommer att träna och därför skapa själva modellartefakten
• deployment_account_id – Kontot där vi vill vara värd för slutpunkten för denna modell

Först måste vi säkerställa att modellpaketgrupperna finns. Du kan använda Boto3 API:er som visas i följande exempel, eller så kan du använda AWS Management Console för att skapa modellpaketet. Hänvisa till Skapa modellpaketgrupp för mer detaljer. Detta förutsätter att du har Boto3 installerad.

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

För behörigheterna för denna modellpaketgrupp kan du skapa ett JSON-dokument som liknar följande kod. Ersätt de faktiska konto-ID:n och modellpaketgruppens namn med dina egna värden.

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

Till sist, tillämpa policyn på modellpaketgruppen. Du kan inte koppla denna policy till paketgruppen via konsolen. Du behöver SDK eller AWS-kommandoradsgränssnitt (AWS CLI) åtkomst. Till exempel använder följande kod 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)

Vi behöver också en anpassad AWS nyckelhanteringstjänst (AWS KMS)-nyckel för att kryptera modellen medan den lagras i Amazon S3. Detta måste göras med hjälp av datavetenskapskontot. På AWS KMS-konsolen, navigera till Definiera behörigheter för nyckelanvändning sida. I Andra AWS-konton avsnitt väljer Lägg till ytterligare ett AWS-konto. Ange AWS-kontonumret för distributionskontot. Du använder denna KMS-nyckel för SageMaker-utbildningsjobbet. Om du inte anger en KMS-nyckel för utbildningsjobbet, använder SageMaker som standard en Amazon S3-krypteringsnyckel på serversidan. En standardkrypteringsnyckel på Amazon S3-serversidan kan inte delas med eller användas av ett annat AWS-konto.

Policyn och behörigheterna följer detta mönster:

• Amazon S3-policyn som anges i shared_services_account ger behörigheter till datavetenskapskontot och distributionskontot
• KMS-nyckelpolicyn som anges i shared_services_account ger behörigheter till datavetenskapskontot och distributionskontot

Vi måste se till att kontot för delade tjänster och distributionskontot har tillgång till Docker-avbildningarna som användes för att träna modellen. Dessa bilder finns vanligtvis på AWS-konton, och din kontoadministratör kan hjälpa dig att få åtkomst, om du inte redan har åtkomst. För det här inlägget skapar vi inga anpassade Docker-bilder efter att ha tränat modellen och därför behöver vi inga specifika Amazon ECR-policyer för bilderna.

I arbetsbelastningskontona (QA eller prod) måste vi skapa två AWS identitets- och åtkomsthantering (IAM) policyer som liknar följande. Dessa är inline policyer, vilket betyder att de är inbäddade i en IAM-identitet. Detta ger dessa konton tillgång till modellregistret.

Den första inline-policyn tillåter en roll att komma åt Amazon S3-resursen i kontot för delade tjänster som innehåller modellartefakten. Ange namnet på S3-skopan och din modell:

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

Den andra inline-policyn tillåter en roll, som vi skapar senare, att använda KMS-nyckeln i kontot för delade tjänster. Ange konto-ID för kontot för delade tjänster och KMS-nyckel-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}"
            ]
        }
    ]
}

Äntligen måste vi skapa en IAM-roll för SageMaker. Denna roll har AmazonSageMakerFullAccess policy bifogas. Vi kopplar sedan dessa två integrerade policyer till den roll vi skapade. Om du använder en befintlig SageMaker exekveringsroll, bifoga dessa två policyer till den rollen. För instruktioner, se Skapa roller och bifoga policyer (konsol).

Nu när vi har definierat policyerna för varje konto, låt oss använda ett exempel för att se hur det fungerar.

Bygg och träna en modell med hjälp av en SageMaker-pipeline

Vi skapar först en SageMaker-pipeline i datavetenskapskontot för att utföra databearbetning, modellutbildning och utvärdering. Vi använder Kaliforniens bostadsdataset som erhållits från StatLib-biblioteket. I följande kodavsnitt använder vi ett anpassat förbearbetningsskript preprocess.py för att utföra några enkla funktionstransformationer såsom funktionsskalning, som kan genereras med hjälp av följande anteckningsbok. Detta skript delar också upp datauppsättningen i tränings- och testdatauppsättningar.

Vi skapar en SKLearnProcessor objekt för att köra detta förbearbetningsskript. I SageMaker pipeline skapar vi ett bearbetningssteg (ProcessingStep) för att köra bearbetningskoden med SKLearnProcessor. Denna bearbetningskod anropas när SageMaker-pipelinen initieras. Koden som skapar SKLearnProcessor och ProcessingStep visas i följande kod. Observera att all kod i det här avsnittet körs i datavetenskapskontot.

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

Vi behöver en anpassad KMS-nyckel för att kryptera modellen medan vi lagrar den på Amazon S3. Se följande kod:

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

För att träna modellen skapar vi ett TensorFlow estimatorobjekt. Vi skickar det KMS nyckel-ID tillsammans med vårt träningsskript train.py, typ av träningsinstans och antal. Vi skapar också en TrainingStep som ska läggas till vår pipeline och lägga till TensorFlow-estimatorn till den. Se följande kod:

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

Förutom utbildning behöver vi utföra modellutvärdering, för vilken vi använder medelkvadratfel (MSE) som måttenhet i detta exempel. De tidigare anteckningsbok också genererar evaluate.py, som vi använder för att utvärdera vår modell med hjälp av MSE. Vi skapar också en ProcessingStep för att initiera modellutvärderingsskriptet med hjälp av en SKLearnProcessor objekt. Följande kod skapar detta steg:

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

Efter modellutvärdering behöver vi också ett steg för att registrera vår modell i modellregistret, om modellens prestanda uppfyller kraven. Detta visas i följande kod med hjälp av RegisterModel steg. Här måste vi specificera modellpaketet som vi hade deklarerat i kontot för delade tjänster. Ersätt region-, konto- och modellpaketet med dina värden. Modellnamnet som används här är modeltest, men du kan använda valfritt namn.

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

Vi måste också skapa modellartefakter så att de kan distribueras (med det andra kontot). För att skapa modellen skapar vi en CreateModelStep, som visas i följande kod:

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

Lägga till villkor till rörledningen görs med en ConditionStep. I det här fallet vill vi bara registrera den nya modellversionen med modellregistret om den nya modellen uppfyller ett noggrannhetsvillkor. Se följande kod:

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

Slutligen vill vi orkestrera alla pipeline-stegen så att pipelinen kan initieras:

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

Implementera en modellversion från ett annat konto

Nu när modellen har registrerats i kontot för delade tjänster måste vi distribuera till våra arbetsbelastningskonton med hjälp av CI/CD-pipeline i distributionskontot. Vi har redan konfigurerat rollen och policyn i ett tidigare steg. Vi använder modellpaketet ARN för att distribuera modellen från modellregistret. Följande kod körs i distributionskontot och används för att distribuera godkända modeller till QA och 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')

Slutsats

I det här inlägget demonstrerade vi hur man ställer in de policyer som behövs för en multi-account setup för ML baserat på principen om minsta privilegium. Sedan visade vi processen att bygga och träna modellerna i datavetenskapskontot. Slutligen använde vi CI/CD-pipelinen i distributionskontot för att distribuera den senaste versionen av godkända modeller till QA- och produktionskonton. Dessutom kan du visa distributionshistoriken för modeller och bygga utlösare in AWS CodeBuild.

Du kan skala begreppen i det här inlägget för att vara värdmodeller i Amazon Elastic Compute Cloud (Amazon EC2) eller Amazon Elastic Kubernetes-tjänst (Amazon EKS), samt bygga ut en batch-inferenspipeline.

För att lära dig mer om att ha separata konton som bygger ML-modeller i AWS, se Bästa praxis för organisationsenheter med AWS-organisationer och Säker uppdatera modeller i produktion.

Om författarna

Sandeep Verma är en Sr. Prototyping Architect med AWS. Han gillar att dyka djupt in i kundernas utmaningar och bygga prototyper för kunder för att påskynda innovation. Han har en bakgrund inom AI/ML, grundare av New Knowledge och brinner generellt för teknik. På fritiden älskar han att resa och åka skidor med familjen.

 Mani Khanuja är en artificiell intelligens och maskininlärningsspecialist SA på Amazon Web Services (AWS). Hon hjälper kunder som använder maskininlärning för att lösa sina affärsutmaningar med hjälp av AWS. Hon tillbringar större delen av sin tid med att dyka djupt och lära kunder på AI / ML-projekt relaterade till datorsyn, bearbetning av naturligt språk, prognoser, ML vid kanten och mer. Hon brinner för ML i framkant, därför har hon skapat sitt eget laboratorium med självkörningssats och produktionslinje för tillverkning av prototyp, där hon tillbringar mycket av sin fritid.

Saumitra Vikram är en mjukvaruutvecklare på Amazon SageMaker-teamet och är baserad i Chennai, Indien. Utanför jobbet älskar han att tillbringa tid med att springa, vandra och cykla genom Himalaya.

Sreedevi Srinivasan är ingenjörsledare i AWS SageMaker. Hon är passionerad och entusiastisk över att möjliggöra ML som en plattform som kommer att förändra vardagens liv. Hon fokuserar för närvarande på SageMaker Feature Store. På fritiden umgås hon gärna med sin familj.

Rupinder Grewal är en Sr Ai/ML Specialist Solutions Architect med AWS. Han fokuserar för närvarande på servering av modeller och MLOps på SageMaker. Innan denna roll har han arbetat som Machine Learning Engineer med att bygga och hosta modeller. Utanför jobbet tycker han om att spela tennis och cykla på bergsstigar.

Farooq Sabir är Senior Artificiell Intelligens och Machine Learning Specialist Solutions Architect på AWS. Han har doktorsexamen och MS-examen i elektroteknik från University of Texas i Austin och en MS i datavetenskap från Georgia Institute of Technology. På AWS hjälper han kunder att formulera och lösa sina affärsproblem inom datavetenskap, maskininlärning, datorseende, artificiell intelligens, numerisk optimering och relaterade domäner. Han har över 16 års arbetslivserfarenhet och är också adjungerad fakultetsmedlem vid University of Texas i Dallas, där han undervisar i en forskarutbildning i tillämpad maskininlärning. Baserad i Dallas, Texas, älskar han och hans familj att resa och göra långa vägresor.