Crea un flusso di lavoro MLOps su più account utilizzando il registro dei modelli di Amazon SageMaker

Una pipeline CI/CD ben progettata è essenziale per scalare efficacemente qualsiasi flusso di lavoro di sviluppo software. Durante la progettazione di pipeline CI/CD di produzione, AWS consiglia di sfruttare più account per isolare le risorse, contenere le minacce alla sicurezza e semplificare la fatturazione e le pipeline di data science non sono diverse. In AWS, continuiamo a innovare per semplificare il flusso di lavoro MLOps.

In questo post, discutiamo alcune delle più recenti funzionalità cross-account per Amazon Sage Maker che consentono di condividere e gestire meglio i gruppi di modelli e le versioni dei modelli. Per un esempio di struttura dell'account da seguire best practice dell'unità organizzativa per ospitare modelli che utilizzano endpoint SageMaker tra account, fare riferimento a Orchestratore del carico di lavoro MLOps.

Panoramica della soluzione

Il diagramma seguente illustra l'architettura del registro del modello condiviso.

Alcune cose da notare nell'architettura precedente:

I seguenti passaggi corrispondono al diagramma:

1. Un data scientist registra un modello dall'account di data science nel registro dei modelli SageMaker dei servizi condivisi in a PendingManualApproval stato. L'artefatto del modello viene creato nell'account dei servizi condivisi Servizio di archiviazione semplice Amazon (Amazon S3) secchio.
2. Al momento della registrazione di una nuova versione del modello, qualcuno con l'autorità di approvare il modello in base alle metriche dovrebbe approvare o rifiutare il modello.
3. Dopo che il modello è stato approvato, la pipeline CI/CD nell'account di distribuzione lo è attivato per la distribuzione i dettagli del modello aggiornato nell'account QA e aggiornare la fase come QA.
4. Dopo aver superato il processo di test, puoi scegliere di avere una fase di approvazione manuale all'interno del tuo processo CI/CD o fare in modo che la tua pipeline CI/CD distribuisca direttamente il modello alla produzione e aggiorni la fase come Prod.
5. L'ambiente di produzione fa riferimento al modello e al codice approvati, magari facendo un Test A/B in produzione. In caso di audit o qualsiasi problema con il modello, è possibile utilizzare Monitoraggio del lignaggio di Amazon SageMaker ML. Crea e archivia informazioni sui passaggi di un flusso di lavoro di machine learning (ML) dalla preparazione dei dati alla distribuzione del modello. Con le informazioni di tracciamento, puoi riprodurre i passaggi del flusso di lavoro, tracciare la derivazione del modello e del set di dati e stabilire standard di controllo e governance del modello.

Durante l'intero processo, il registro del modello condiviso conserva le versioni del modello precedente. Ciò consente al team di ripristinare le modifiche o persino di ospitare varianti di produzione.

Prerequisiti

Assicurati di avere i seguenti prerequisiti:

• Una struttura multi-account con provisioning – Per le istruzioni, vedere Best practice per le unità organizzative con AWS Organizations. Per gli scopi di questo blog stiamo sfruttando i seguenti account:
  • Conto di scienza dei dati – Un account in cui i data scientist hanno accesso ai dati di addestramento e creano i modelli.
  • Account di servizi condivisi – Un account centrale per l'archiviazione degli artefatti del modello (come mostrato nel diagramma dell'architettura) a cui accedere attraverso i diversi account del carico di lavoro.
  • Account di distribuzione – Un account responsabile della distribuzione delle modifiche ai vari account.
  • Account del carico di lavoro – Si tratta comunemente di ambienti QA e di produzione in cui gli ingegneri del software sono in grado di creare applicazioni per utilizzare il modello ML.
• Un account di distribuzione con autorizzazioni appropriate – Per ulteriori informazioni sulle best practice con una struttura UO multi-account, fare riferimento a UO Distribuzioni. Questo account è responsabile del puntamento degli account del carico di lavoro al modello desiderato nel registro del modello dell'account dei servizi condivisi.

Definisci criteri per più account

Seguendo il principio del privilegio minimo, per prima cosa dobbiamo aggiungere criteri di risorse tra account alle risorse dei servizi condivisi per concedere l'accesso dagli altri account.

Poiché gli artefatti del modello sono archiviati nel bucket S3 dell'account dei servizi condivisi, l'account di data science necessita dell'accesso in lettura/scrittura di Amazon S3 per eseguire il push dei modelli addestrati in Amazon S3. Il codice seguente illustra questo criterio, ma non aggiungerlo ancora all'account dei servizi condivisi:

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

All'account di distribuzione deve essere concesso solo l'accesso in lettura al bucket S3, in modo che possa utilizzare gli artefatti del modello per la distribuzione agli endpoint SageMaker. Dobbiamo anche allegare la seguente policy al bucket S3 dei servizi condivisi:

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

Combiniamo entrambe le politiche per ottenere la seguente politica finale. Crea questo criterio nell'account dei servizi condivisi dopo aver sostituito gli ID account appropriati:

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

Per poter distribuire un modello creato in un altro account, l'utente deve disporre di un ruolo che abbia accesso alle azioni SageMaker, ad esempio un ruolo con il AmazonSageMakerFullAccess politica gestita. Fare riferimento a Distribuisci una versione del modello da un account diverso per ulteriori dettagli.

Dobbiamo definire il gruppo di modelli che contiene le versioni del modello che vogliamo distribuire. Inoltre, vogliamo concedere le autorizzazioni all'account data science. Questo può essere realizzato nei seguenti passaggi. Ci riferiamo ai conti come segue:

• shared_services_account_id – L'account in cui si trova il registro del modello e dove vogliamo che sia il modello
• data_science_account_id – L'account in cui ci alleneremo e quindi creeremo l'artefatto del modello effettivo
• ID_account_distribuzione – L'account in cui vogliamo ospitare l'endpoint per questo modello

Per prima cosa dobbiamo assicurarci che i gruppi di pacchetti modello esistano. È possibile utilizzare le API Boto3 come mostrato nell'esempio seguente oppure è possibile utilizzare il file Console di gestione AWS per creare il pacchetto modello. Fare riferimento a Crea gruppo pacchetto modello per ulteriori dettagli. Ciò presuppone che tu abbia installato 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']))

Per le autorizzazioni per questo gruppo di pacchetti modello, puoi creare un documento JSON simile al codice seguente. Sostituisci gli ID account effettivi e il nome del gruppo di pacchetti modello con i tuoi 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//*"    
    }
  ]
}

Infine, applica la policy al gruppo di pacchetti modello. Non puoi associare questo criterio al gruppo di pacchetti tramite la console. Hai bisogno dell'SDK o Interfaccia della riga di comando di AWS (AWS CLI). Ad esempio, il codice seguente utilizza 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)

Abbiamo anche bisogno di un'abitudine Servizio di gestione delle chiavi AWS (AWS KMS) per crittografare il modello durante l'archiviazione in Amazon S3. Questo deve essere fatto utilizzando l'account data science. Nella console AWS KMS, vai al file Definire le autorizzazioni di utilizzo delle chiavi pagina. Nel Altri account AWS sezione, scegliere Aggiungi un altro account AWS. Inserisci il numero di account AWS per l'account di distribuzione. Utilizzi questa chiave KMS per il lavoro di formazione SageMaker. Se non specifichi una chiave KMS per il processo di addestramento, SageMaker utilizza per impostazione predefinita una chiave di crittografia lato server Amazon S3. Una chiave di crittografia lato server Amazon S3 predefinita non può essere condivisa o utilizzata da un altro account AWS.

La politica e le autorizzazioni seguono questo schema:

• La policy Amazon S3 specificata in shared_services_account concede le autorizzazioni all'account di data science e all'account di implementazione
• La policy della chiave KMS specificata in shared_services_account concede le autorizzazioni all'account di data science e all'account di implementazione

Dobbiamo assicurarci che l'account dei servizi condivisi e l'account di distribuzione abbiano accesso alle immagini Docker utilizzate per l'addestramento del modello. Queste immagini sono generalmente ospitate negli account AWS e l'amministratore del tuo account può aiutarti a ottenere l'accesso, se non l'hai già fatto. Per questo post, non creiamo alcuna immagine Docker personalizzata dopo aver addestrato il modello e pertanto non abbiamo bisogno di policy Amazon ECR specifiche per le immagini.

Negli account del carico di lavoro (QA o prod), dobbiamo crearne due Gestione dell'identità e dell'accesso di AWS (IAM) simili alle seguenti. Questi sono politiche in linea, il che significa che sono incorporati in un'identità IAM. Ciò consente a questi account di accedere al registro dei modelli.

La prima policy inline consente a un ruolo di accedere alla risorsa Amazon S3 nell'account dei servizi condivisi che contiene l'artefatto del modello. Fornisci il nome del bucket S3 e il tuo modello:

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

La seconda policy inline consente a un ruolo, che creeremo in seguito, di utilizzare la chiave KMS nell'account dei servizi condivisi. Specifica l'ID account per l'account dei servizi condivisi e l'ID chiave 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}"
            ]
        }
    ]
}

Infine, dobbiamo creare un ruolo IAM per SageMaker. Questo ruolo ha il AmazonSageMakerFullAccess politica allegata. Quindi alleghiamo queste due policy inline al ruolo che abbiamo creato. Se stai utilizzando un ruolo di esecuzione SageMaker esistente, collega queste due policy a quel ruolo. Per le istruzioni, fare riferimento a Creazione di ruoli e collegamento di policy (console).

Ora che abbiamo definito le politiche di ciascun account, usiamo un esempio per vederlo in azione.

Crea e addestra un modello utilizzando una pipeline SageMaker

Per prima cosa creiamo una pipeline SageMaker nell'account di data science per eseguire l'elaborazione dei dati, l'addestramento del modello e la valutazione. Utilizziamo il set di dati sulle abitazioni della California ottenuto dalla libreria StatLib. Nel seguente frammento di codice, utilizziamo uno script di preelaborazione personalizzato preprocess.py per eseguire alcune semplici trasformazioni di funzionalità come il ridimensionamento delle funzionalità, che può essere generato utilizzando quanto segue taccuino. Questo script suddivide anche il set di dati in set di dati di addestramento e test.

Creiamo un file SKLearnProcessor oggetto per eseguire questo script di pre-elaborazione. Nella pipeline SageMaker, creiamo una fase di elaborazione (ProcessingStep) per eseguire il codice di elaborazione utilizzando SKLearnProcessor. Questo codice di elaborazione viene chiamato quando viene inizializzata la pipeline SageMaker. Il codice che crea il file SKLearnProcessor ed ProcessingStep sono mostrati nel codice seguente. Si noti che tutto il codice in questa sezione viene eseguito nell'account data science.

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

Abbiamo bisogno di una chiave KMS personalizzata per crittografare il modello durante l'archiviazione su Amazon S3. Vedere il seguente codice:

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

Per addestrare il modello, creiamo un oggetto stimatore TensorFlow. Gli passiamo l'ID chiave KMS insieme al nostro script di formazione train.py, tipo di istanza di addestramento e conteggio. Creiamo anche un TrainingStep da aggiungere alla nostra pipeline e aggiungervi lo stimatore TensorFlow. Vedere il seguente codice:

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

Oltre all'addestramento, dobbiamo eseguire la valutazione del modello, per la quale in questo esempio utilizziamo l'errore quadratico medio (MSE) come metrica. Il taccuino precedente genera anche evaluate.py, che utilizziamo per valutare il nostro modello utilizzando MSE. Creiamo anche un ProcessingStep per inizializzare lo script di valutazione del modello utilizzando a SKLearnProcessor oggetto. Il codice seguente crea questo passaggio:

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

Dopo la valutazione del modello, abbiamo anche bisogno di un passaggio per registrare il nostro modello con il registro dei modelli, se le prestazioni del modello soddisfano i requisiti. Questo è mostrato nel codice seguente usando il RegisterModel fare un passo. Qui dobbiamo specificare il pacchetto modello che avevamo dichiarato nell'account dei servizi condivisi. Sostituisci la regione, l'account e il pacchetto modello con i tuoi valori. Il nome del modello qui utilizzato è modeltest, ma puoi utilizzare qualsiasi nome di tua scelta.

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

Dobbiamo anche creare gli artefatti del modello in modo che possano essere distribuiti (utilizzando l'altro account). Per creare il modello, creiamo a CreateModelStep, come mostrato nel codice seguente:

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'aggiunta di condizioni alla pipeline viene eseguita con a ConditionStep. In questo caso, vogliamo solo registrare la nuova versione del modello con il registro del modello se il nuovo modello soddisfa una condizione di accuratezza. Vedere il seguente codice:

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

Infine, vogliamo orchestrare tutti i passaggi della pipeline in modo che la pipeline possa essere inizializzata:

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

Distribuisci una versione del modello da un altro account

Ora che il modello è stato registrato nell'account dei servizi condivisi, dobbiamo eseguire la distribuzione nei nostri account del carico di lavoro utilizzando la pipeline CI/CD nell'account di distribuzione. Abbiamo già configurato il ruolo e la policy in un passaggio precedente. Utilizziamo l'ARN del pacchetto modello per distribuire il modello dal registro dei modelli. Il seguente codice viene eseguito nell'account di distribuzione e viene utilizzato per distribuire i modelli approvati a QA e 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')

Conclusione

In questo post, abbiamo dimostrato come configurare le policy necessarie per una configurazione multi-account per ML basata sul principio del privilegio minimo. Quindi abbiamo mostrato il processo di creazione e addestramento dei modelli nell'account di data science. Infine, abbiamo utilizzato la pipeline CI/CD nell'account di distribuzione per distribuire l'ultima versione dei modelli approvati agli account QA e di produzione. Inoltre, puoi visualizzare la cronologia della distribuzione dei modelli ed costruire trigger in AWSCodeBuild.

Puoi ridimensionare i concetti in questo post per ospitare i modelli Cloud di calcolo elastico di Amazon (Amazon EC2) o Servizio Amazon Elastic Kubernetes (Amazon EKS), oltre a creare una pipeline di inferenza batch.

Per ulteriori informazioni su come avere account separati che creano modelli ML in AWS, consulta Best practice per le unità organizzative con AWS Organizations ed Aggiorna in modo sicuro i modelli in produzione.

Informazioni sugli autori

Sandep Verma è un Senior Prototyping Architect con AWS. Gli piace approfondire le sfide dei clienti e costruire prototipi per i clienti per accelerare l'innovazione. Ha un background in AI/ML, fondatore di New Knowledge e generalmente appassionato di tecnologia. Nel tempo libero ama viaggiare e sciare con la sua famiglia.

 Mani Khanuja è una SA specializzata in intelligenza artificiale e apprendimento automatico presso Amazon Web Services (AWS). Aiuta i clienti che utilizzano l'apprendimento automatico a risolvere le sfide aziendali utilizzando AWS. Trascorre la maggior parte del suo tempo immergendosi in profondità e insegnando ai clienti su progetti AI/ML relativi a visione artificiale, elaborazione del linguaggio naturale, previsioni, ML ai margini e altro ancora. Appassionata di ML al limite, ha creato il suo laboratorio con kit di guida autonoma e linea di produzione di prototipi, dove trascorre molto del suo tempo libero.

Saumitra Vikram è uno sviluppatore di software nel team di Amazon SageMaker e ha sede a Chennai, in India. Al di fuori del lavoro, ama passare il tempo correndo, facendo trekking e andando in moto attraverso l'Himalaya.

Sreedevi Srinivasan è un leader ingegneristico in AWS SageMaker. È appassionata ed entusiasta di abilitare il machine learning come piattaforma destinata a trasformare la vita di tutti i giorni. Attualmente si concentra su SageMaker Feature Store. Nel tempo libero le piace trascorrere del tempo con la sua famiglia.

Rupinder Grewal è un Senior Specialist Solutions Architect di Ai/ML con AWS. Attualmente si concentra sulla pubblicazione di modelli e MLOp su SageMaker. Prima di questo ruolo ha lavorato come Machine Learning Engineer, costruendo e ospitando modelli. Al di fuori del lavoro gli piace giocare a tennis e andare in bicicletta sui sentieri di montagna.

Farooq Sabir è Senior Artificial Intelligence and Machine Learning Specialist Solutions Architect presso AWS. Ha conseguito un dottorato di ricerca e un master in ingegneria elettrica presso l'Università del Texas ad Austin e un master in informatica presso il Georgia Institute of Technology. In AWS, aiuta i clienti a formulare e risolvere i loro problemi aziendali in data science, machine learning, visione artificiale, intelligenza artificiale, ottimizzazione numerica e domini correlati. Ha oltre 16 anni di esperienza lavorativa ed è anche membro aggiunto della facoltà presso l'Università del Texas a Dallas, dove insegna in un corso di laurea in Apprendimento automatico applicato. Con sede a Dallas, in Texas, lui e la sua famiglia amano viaggiare e fare lunghi viaggi.