Creați un flux de lucru MLOps pe mai multe conturi folosind registrul de modele Amazon SageMaker

O conductă CI/CD bine concepută este esențială pentru a scala în mod eficient orice flux de lucru de dezvoltare software. La proiectarea conductelor CI/CD de producție, AWS recomandă utilizarea mai multor conturi pentru a izola resursele, a limita amenințările de securitate și a simplifica facturarea, iar conductele de știință a datelor nu sunt diferite. La AWS, continuăm să inovăm pentru a simplifica fluxul de lucru MLOps.

În această postare, discutăm câteva dintre funcțiile mai noi pentru mai multe conturi Amazon SageMaker care vă permit să partajați și să gestionați mai bine grupurile de modele, precum și să gestionați versiunile de modele. Pentru un exemplu de structură a contului de urmat cele mai bune practici ale unității organizaționale pentru a găzdui modele folosind puncte finale SageMaker în toate conturile, consultați MLOps Workload Orchestrator.

Prezentare generală a soluțiilor

Următoarea diagramă ilustrează arhitectura noastră de registry de model partajată.

Câteva lucruri de remarcat în arhitectura precedentă:

Următorii pași corespund diagramei:

1. Un om de știință de date înregistrează un model din contul de știință a datelor în registrul de modele SageMaker de servicii partajate într-un PendingManualApproval stat. Artefactul model este creat în contul de servicii partajate Serviciul Amazon de stocare simplă Găleată (Amazon S3)
2. La înregistrarea unei noi versiuni de model, cineva cu autoritatea de a aproba modelul pe baza valorilor ar trebui să aprobe sau să respingă modelul.
3. După ce modelul este aprobat, conducta CI/CD în contul de implementare este declanșat să se desfășoare detaliile actualizate ale modelului în contul QA și actualizați etapa ca QA.
4. După trecerea procesului de testare, puteți alege fie să aveți un pas de aprobare manuală în cadrul procesului CI/CD, fie să solicitați canalului dumneavoastră CI/CD să implementeze direct modelul în producție și să actualizeze etapa ca Prod.
5. Mediul de producție face referire la modelul și codul aprobat, poate făcând un Test A/B în producție. În cazul unui audit sau al oricărei probleme cu modelul, puteți utiliza Urmărirea liniei Amazon SageMaker ML. Acesta creează și stochează informații despre pașii unui flux de lucru de învățare automată (ML), de la pregătirea datelor până la implementarea modelului. Cu informațiile de urmărire, puteți reproduce pașii fluxului de lucru, puteți urmări modelul și descendența setului de date și puteți stabili standarde de guvernanță și audit ale modelului.

Pe parcursul întregului proces, registrul de model partajat păstrează versiunile modelului mai vechi. Acest lucru permite echipei să anuleze modificările sau chiar să găzduiască variante de productie.

Cerințe preliminare

Asigurați-vă că aveți următoarele cerințe preliminare:

• O structură prevăzută cu mai multe conturi – Pentru instrucțiuni, vezi Cele mai bune practici pentru unitățile organizaționale cu organizații AWS. În scopul acestui blog, folosim următoarele conturi:
  • Cont pentru știința datelor – Un cont în care oamenii de știință au acces la datele de antrenament și creează modelele.
  • Cont de servicii partajate – Un cont central pentru stocarea artefactelor modelului (așa cum se arată în diagrama arhitecturii) pentru a fi accesat în diferitele conturi de sarcină de lucru.
  • Cont de implementare – Un cont responsabil pentru implementarea modificărilor la diferitele conturi.
  • Conturi de sarcină de muncă – Acestea sunt de obicei medii QA și prod în care inginerii de software sunt capabili să creeze aplicații pentru a consuma modelul ML.
• Un cont de implementare cu permisiunile corespunzătoare – Pentru mai multe informații despre cele mai bune practici cu o structură OU cu mai multe conturi, consultați Implementări OU. Acest cont este responsabil pentru direcționarea conturilor de sarcină de lucru către modelul dorit în registrul de modele al contului de servicii partajate.

Definiți politicile pentru mai multe conturi

Urmând principiul cel mai mic privilegiu, mai întâi trebuie să adăugăm politici de resurse pentru mai multe conturi la resursele de servicii partajate pentru a acorda acces de la celelalte conturi.

Deoarece artefactele modelului sunt stocate în compartimentul S3 al contului de servicii partajate, contul de știință a datelor are nevoie de acces de citire/scriere Amazon S3 pentru a împinge modele instruite către Amazon S3. Următorul cod ilustrează această politică, dar nu o adăugați încă la contul de servicii partajate:

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

Contului de implementare trebuie să i se acorde doar acces de citire la compartimentul S3, astfel încât să poată utiliza artefactele modelului pentru a le implementa pe punctele finale SageMaker. De asemenea, trebuie să atașăm următoarea politică la compartimentul S3 de servicii partajate:

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

Combinăm ambele politici pentru a obține următoarea politică finală. Creați această politică în contul de servicii partajate după înlocuirea ID-urilor de cont corespunzătoare:

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

Pentru a putea implementa un model creat într-un cont diferit, utilizatorul trebuie să aibă un rol care are acces la acțiunile SageMaker, cum ar fi un rol cu AmazonSageMakerFullAccess politică gestionată. A se referi la Implementați o versiune de model dintr-un cont diferit pentru detalii suplimentare.

Trebuie să definim grupul de modele care conține versiunile de model pe care dorim să le implementăm. De asemenea, dorim să acordăm permisiuni pentru contul de știință a datelor. Acest lucru poate fi realizat în următorii pași. Ne referim la conturi după cum urmează:

• shared_services_account_id – Contul în care se află registrul modelului și unde dorim să fie modelul
• data_science_account_id – Contul în care ne vom antrena și, prin urmare, vom crea artefactul propriu-zis al modelului
• deployment_account_id – Contul în care dorim să găzduim punctul final pentru acest model

Mai întâi trebuie să ne asigurăm că există grupurile de pachete model. Puteți utiliza API-urile Boto3, așa cum se arată în exemplul următor, sau puteți utiliza Consola de administrare AWS pentru a crea pachetul model. A se referi la Creați un grup de pachete de modele pentru mai multe detalii. Aceasta presupune că aveți Boto3 instalat.

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

Pentru permisiunile pentru acest grup de pachete model, puteți crea un document JSON asemănător cu următorul cod. Înlocuiți ID-urile contului real și numele grupului de pachete model cu propriile valori.

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

În cele din urmă, aplicați politica grupului de pachete model. Nu puteți asocia această politică cu grupul de pachete prin consolă. Aveți nevoie de SDK-ul sau Interfața liniei de comandă AWS acces (AWS CLI). De exemplu, următorul cod folosește 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)

Avem nevoie și de un obicei AWS Service Management Service (AWS KMS) pentru a cripta modelul în timp ce îl stocați în Amazon S3. Acest lucru trebuie făcut folosind contul de știință a datelor. În consola AWS KMS, navigați la Definiți permisiunile de utilizare a cheilor pagină. În Alte conturi AWS secțiune, pentru a alege Adăugați un alt cont AWS. Introduceți numărul contului AWS pentru contul de implementare. Utilizați această cheie KMS pentru munca de formare SageMaker. Dacă nu specificați o cheie KMS pentru jobul de instruire, SageMaker folosește implicit o cheie de criptare Amazon S3 pe server. O cheie de criptare implicită pe partea serverului Amazon S3 nu poate fi partajată sau utilizată de un alt cont AWS.

Politica și permisiunile urmează acest model:

• Politica Amazon S3 specificată în shared_services_account oferă permisiuni pentru contul de știință a datelor și contul de implementări
• Politica cheii KMS specificată în shared_services_account oferă permisiuni pentru contul de știință a datelor și contul de implementări

Trebuie să ne asigurăm că contul de servicii partajate și contul de implementare au acces la imaginile Docker care au fost folosite pentru antrenarea modelului. Aceste imagini sunt în general găzduite în conturi AWS, iar administratorul contului vă poate ajuta să obțineți acces, dacă nu aveți deja acces. Pentru această postare, nu creăm imagini Docker personalizate după antrenarea modelului și, prin urmare, nu avem nevoie de politici Amazon ECR specifice pentru imagini.

În conturile de volum de lucru (QA sau prod), trebuie să creăm două Gestionarea identității și accesului AWS (IAM) politici similare cu următoarele. Acestea sunt politici inline, ceea ce înseamnă că sunt încorporate într-o identitate IAM. Acest lucru oferă acestor conturi acces la modelul de registru.

Prima politică în linie permite unui rol să acceseze resursa Amazon S3 în contul de servicii partajate care conține artefactul model. Furnizați numele găleții S3 și modelul dvs.:

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

A doua politică inline permite unui rol, pe care îl creăm ulterior, să folosească cheia KMS în contul de servicii partajate. Specificați ID-ul contului pentru contul de servicii partajate și ID-ul cheii 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}"
            ]
        }
    ]
}

În sfârșit, trebuie creați un rol IAM pentru SageMaker. Acest rol are AmazonSageMakerFullAccess politica atasata. Apoi atașăm aceste două politici inline la rolul pe care l-am creat. Dacă utilizați un rol de execuție SageMaker existent, atașați aceste două politici la acel rol. Pentru instrucțiuni, consultați Crearea de roluri și atașarea politicilor (consolă).

Acum că am definit politicile fiecărui cont, să folosim un exemplu pentru a-l vedea în acțiune.

Construiți și antrenați un model folosind o conductă SageMaker

Mai întâi creăm o conductă SageMaker în contul de știință a datelor pentru efectuarea prelucrării datelor, a pregătirii modelelor și a evaluării. Folosim setul de date privind locuințele din California, obținut din biblioteca StatLib. În următorul fragment de cod, folosim un script personalizat de preprocesare preprocess.py pentru a efectua o transformare simplă a caracteristicilor, cum ar fi scalarea caracteristicilor, care poate fi generată folosind următoarele caiet. De asemenea, acest script împarte setul de date în seturi de date de antrenament și de testare.

Creăm un SKLearnProcessor obiect pentru a rula acest script de preprocesare. În conducta SageMaker, creăm o etapă de procesare (ProcessingStep) pentru a rula codul de procesare folosind SKLearnProcessor. Acest cod de procesare este apelat atunci când conducta SageMaker este inițializată. Codul care creează SKLearnProcessor și ProcessingStep sunt prezentate în codul următor. Rețineți că tot codul din această secțiune este rulat în contul de știință a datelor.

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

Avem nevoie de o cheie KMS personalizată pentru a cripta modelul în timp ce îl stocăm pe Amazon S3. Vezi următorul cod:

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

Pentru a antrena modelul, creăm un obiect estimator TensorFlow. Îi transmitem ID-ul cheii KMS împreună cu scriptul nostru de antrenament train.py, tipul instanței de antrenament și numărul. De asemenea, creăm un TrainingStep să fie adăugată la pipeline și adăugați estimatorul TensorFlow la acesta. Vezi următorul cod:

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

Pe lângă antrenament, trebuie să efectuăm evaluarea modelului, pentru care folosim eroarea pătrată medie (MSE) ca metrică în acest exemplu. The caietul anterior generează de asemenea evaluate.py, pe care îl folosim pentru a evalua modelul nostru folosind MSE. De asemenea, creăm un ProcessingStep pentru a inițializa scriptul de evaluare a modelului folosind a SKLearnProcessor obiect. Următorul cod creează acest pas:

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

După evaluarea modelului, avem nevoie și de un pas pentru a ne înregistra modelul în registrul modelului, dacă performanța modelului îndeplinește cerințele. Acest lucru este afișat în codul următor folosind RegisterModel Etapa. Aici trebuie să specificăm pachetul model pe care l-am declarat în contul de servicii partajate. Înlocuiți pachetul Regiune, cont și model cu valorile dvs. Numele modelului folosit aici este modeltest, dar poți folosi orice nume la alegere.

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

De asemenea, trebuie să creăm artefactele modelului, astfel încât să poată fi implementat (folosind celălalt cont). Pentru crearea modelului, creăm un CreateModelStep, așa cum se arată în următorul cod:

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

Adăugarea de condiții la conductă se face cu a ConditionStep. În acest caz, dorim să înregistrăm noua versiune a modelului în registrul modelului numai dacă noul model îndeplinește o condiție de acuratețe. Vezi următorul cod:

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

În cele din urmă, dorim să orchestrăm toți pașii conductei astfel încât conducta să poată fi inițializată:

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

Implementați o versiune de model dintr-un cont diferit

Acum că modelul a fost înregistrat în contul de servicii partajate, trebuie să ne implementăm în conturile noastre de sarcină de lucru utilizând conducta CI/CD din contul de implementare. Am configurat deja rolul și politica într-un pas anterior. Folosim pachetul de model ARN pentru a implementa modelul din registrul modelului. Următorul cod rulează în contul de implementare și este utilizat pentru a implementa modele aprobate pentru QA și produs:

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

Concluzie

În această postare, am demonstrat cum să configurați politicile necesare pentru o configurare cu mai multe conturi pentru ML pe baza principiului cel mai mic privilegiu. Apoi am arătat procesul de construire și antrenare a modelelor în contul de știință a datelor. În cele din urmă, am folosit conducta CI/CD din contul de implementare pentru a implementa cea mai recentă versiune a modelelor aprobate în conturile de QA și de producție. În plus, poți vizualizați istoricul implementării modelelor și construi declanșatoare in AWS CodeBuild.

Puteți scala conceptele din această postare pentru a găzdui modele Cloud Elastic de calcul Amazon (Amazon EC2) sau Serviciul Amazon Elastic Kubernetes (Amazon EKS), precum și să construiți o conductă de inferență pe lot.

Pentru a afla mai multe despre a avea conturi separate care construiesc modele ML în AWS, consultați Cele mai bune practici pentru unitățile organizaționale cu organizații AWS și Actualizați în siguranță modelele în producție.

Despre Autori

Sandeep Verma este un arhitect senior de prototipare cu AWS. Îi place să se scufunde adânc în provocările clienților și să construiască prototipuri pentru clienți pentru a accelera inovația. Are o experiență în AI/ML, fondator al New Knowledge și, în general, este pasionat de tehnologie. În timpul liber, îi place să călătorească și să schieze împreună cu familia.

 Mani Khanuja este un specialist SA în inteligență artificială și învățare automată la Amazon Web Services (AWS). Ea ajută clienții care folosesc învățarea automată pentru a-și rezolva provocările de afaceri folosind AWS. Ea își petrece cea mai mare parte a timpului scufundându-se adânc și învățând clienții cu privire la proiecte AI/ML legate de viziunea computerizată, procesarea limbajului natural, prognoza, ML la margine și multe altele. Este pasionată de ML at edge, prin urmare, și-a creat propriul laborator cu kit de auto-conducere și linie de producție de prototipuri, unde își petrece mult timp liber.

Saumitra Vikram este un dezvoltator de software în echipa Amazon SageMaker și are sediul în Chennai, India. În afara serviciului, îi place să petreacă timpul alergând, trekking și plimbându-se cu motocicleta prin Himalaya.

Sreedevi Srinivasan este un lider în inginerie în AWS SageMaker. Este pasionată și încântată de activarea ML ca o platformă care este setat să transforme viața de zi cu zi. În prezent, se concentrează pe SageMaker Feature Store. În timpul liber, îi place să petreacă timp cu familia.

Rupinder Grewal este un arhitect specializat în soluții Sr Ai/ML cu AWS. În prezent, se concentrează pe servirea modelelor și a MLOps-ului pe SageMaker. Înainte de acest rol, a lucrat ca inginer de învățare automată, construind și găzduind modele. În afara serviciului, îi place să joace tenis și să meargă cu bicicleta pe traseele montane.

Farooq Sabir este arhitect senior de soluții specializat în inteligență artificială și învățare automată la AWS. El deține diplome de doctorat și master în inginerie electrică de la Universitatea din Texas din Austin și un master în informatică de la Georgia Institute of Technology. La AWS, el ajută clienții să-și formuleze și să-și rezolve problemele de afaceri în știința datelor, învățarea automată, viziunea computerizată, inteligența artificială, optimizarea numerică și domeniile conexe. Are peste 16 ani de experiență de lucru și este, de asemenea, membru adjunct al facultății la Universitatea din Texas din Dallas, unde predă un curs absolvent de învățare automată aplicată. Cu sediul în Dallas, Texas, lui și familia lui le place să călătorească și să facă călătorii lungi.