Erstellen Sie mithilfe der Amazon SageMaker-Modellregistrierung einen kontoübergreifenden MLOps-Workflow

Eine gut konzipierte CI/CD-Pipeline ist unerlässlich, um jeden Softwareentwicklungs-Workflow effektiv zu skalieren. Beim Entwerfen von CI/CD-Pipelines für die Produktion empfiehlt AWS, mehrere Konten zu nutzen, um Ressourcen zu isolieren, Sicherheitsbedrohungen einzudämmen und die Abrechnung zu vereinfachen – und Data-Science-Pipelines sind nicht anders. Bei AWS arbeiten wir weiterhin an Innovationen, um den MLOps-Workflow zu vereinfachen.

In diesem Beitrag diskutieren wir einige der neueren kontoübergreifenden Funktionen Amazon Sage Maker die es Ihnen ermöglichen, Modellgruppen besser zu teilen und zu verwalten sowie Modellversionen zu verwalten. Eine beispielhafte Kontostruktur folgt Best Practices der Organisationseinheit Informationen zum Hosten von Modellen mit kontenübergreifenden SageMaker-Endpunkten finden Sie unter MLOps Workload Orchestrator.

Lösungsüberblick

Das folgende Diagramm veranschaulicht unsere gemeinsam genutzte Modellregistrierungsarchitektur.

Einige Dinge, die bei der vorhergehenden Architektur zu beachten sind:

Die folgenden Schritte entsprechen dem Diagramm:

1. Ein Data Scientist registriert ein Modell aus dem Data Science-Konto in der SageMaker-Modellregistrierung für gemeinsam genutzte Dienste in a PendingManualApproval Zustand. Das Modellartefakt wird im Konto für gemeinsame Dienste erstellt Amazon Simple Storage-Service (Amazon S3) Eimer.
2. Bei einer Registrierung einer neuen Modellversion sollte jemand mit der Berechtigung, das Modell basierend auf den Metriken zu genehmigen, das Modell genehmigen oder ablehnen.
3. Nachdem das Modell genehmigt wurde, ist die CI/CD-Pipeline im Bereitstellungskonto zur Bereitstellung ausgelöst die aktualisierten Modelldetails im QA-Konto und aktualisieren Sie die Phase als QA.
4. Nachdem Sie den Testprozess bestanden haben, können Sie entweder einen manuellen Genehmigungsschritt in Ihrem CI/CD-Prozess durchführen oder Ihre CI/CD-Pipeline das Modell direkt in der Produktion bereitstellen und die Phase als Prod aktualisieren.
5. Die Produktionsumgebung verweist auf das genehmigte Modell und den genehmigten Code und tut dies möglicherweise A/B-Test in der Produktion. Im Falle einer Prüfung oder eines Problems mit dem Modell können Sie verwenden Amazon SageMaker ML-Herkunftsverfolgung. Es erstellt und speichert Informationen über die Schritte eines Arbeitsablaufs für maschinelles Lernen (ML) von der Datenvorbereitung bis zur Modellbereitstellung. Mit den Tracking-Informationen können Sie die Workflow-Schritte reproduzieren, die Modell- und Dataset-Herkunft verfolgen und Modell-Governance- und Audit-Standards festlegen.

Während des gesamten Prozesses behält die gemeinsam genutzte Modellregistrierung die älteren Modellversionen bei. Dies ermöglicht dem Team, Änderungen rückgängig zu machen oder sogar zu hosten Produktionsvarianten.

Voraussetzungen:

Stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:

• Eine bereitgestellte Struktur mit mehreren Konten – Anweisungen finden Sie unter Best Practices für Organisationseinheiten mit AWS Organizations. Für die Zwecke dieses Blogs nutzen wir die folgenden Konten:
  • Data-Science-Konto – Ein Konto, in dem Data Scientists Zugriff auf die Trainingsdaten haben und die Modelle erstellen.
  • Shared-Services-Konto – Ein zentrales Konto zum Speichern der Modellartefakte (wie im Architekturdiagramm gezeigt), auf die über die verschiedenen Workload-Konten zugegriffen werden kann.
  • Bereitstellungskonto – Ein Konto, das für die Bereitstellung von Änderungen an den verschiedenen Konten verantwortlich ist.
  • Workload-Konten – Dies sind in der Regel QA- und Produktionsumgebungen, in denen Softwareentwickler Anwendungen erstellen können, um das ML-Modell zu nutzen.
• Ein Bereitstellungskonto mit entsprechenden Berechtigungen – Weitere Informationen zu Best Practices mit einer OU-Struktur mit mehreren Konten finden Sie unter Bereitstellungen OU. Dieses Konto ist dafür verantwortlich, die Workload-Konten auf das gewünschte Modell in der Modellregistrierung des Kontos für gemeinsame Dienste zu verweisen.

Definieren Sie kontoübergreifende Richtlinien

Gemäß dem Prinzip der geringsten Rechte müssen wir zuerst kontenübergreifende Ressourcenrichtlinien zu den Ressourcen der gemeinsam genutzten Dienste hinzufügen, um den Zugriff von den anderen Konten zu gewähren.

Da die Modellartefakte im S3-Bucket des Shared-Services-Kontos gespeichert sind, benötigt das Data Science-Konto Amazon S3-Lese-/Schreibzugriff, um trainierte Modelle an Amazon S3 zu übertragen. Der folgende Code veranschaulicht diese Richtlinie, aber fügen Sie sie noch nicht dem Konto für gemeinsame Dienste hinzu:

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

Dem Bereitstellungskonto muss lediglich Lesezugriff auf den S3-Bucket gewährt werden, damit es die Modellartefakte für die Bereitstellung auf SageMaker-Endpunkten verwenden kann. Wir müssen auch die folgende Richtlinie an den S3-Bucket für gemeinsame Dienste anhängen:

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

Wir kombinieren beide Richtlinien, um die folgende endgültige Richtlinie zu erhalten. Erstellen Sie diese Richtlinie im Konto für gemeinsame Dienste, nachdem Sie die entsprechenden Konto-IDs ersetzt haben:

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

Um ein in einem anderen Konto erstelltes Modell bereitstellen zu können, muss der Benutzer über eine Rolle verfügen, die Zugriff auf SageMaker-Aktionen hat, z. B. eine Rolle mit der AmazonSageMakerFullAccess verwaltete Richtlinie. Beziehen auf Stellen Sie eine Modellversion von einem anderen Konto bereit für weitere Details.

Wir müssen die Modellgruppe definieren, die die Modellversionen enthält, die wir bereitstellen möchten. Außerdem möchten wir dem Data Science-Konto Berechtigungen erteilen. Dies kann in den folgenden Schritten erreicht werden. Wir beziehen uns auf die Konten wie folgt:

• shared_services_account_id – Das Konto, in dem sich die Modellregistrierung befindet und in dem wir das Modell haben möchten
• data_science_account_id – Das Konto, in dem wir trainieren und daher das eigentliche Modellartefakt erstellen
• Bereitstellungskonto-ID – Das Konto, in dem wir den Endpunkt für dieses Modell hosten möchten

Zuerst müssen wir sicherstellen, dass die Modellpaketgruppen vorhanden sind. Sie können Boto3-APIs verwenden, wie im folgenden Beispiel gezeigt, oder Sie können die AWS-Managementkonsole um das Modellpaket zu erstellen. Beziehen auf Modellpaketgruppe erstellen für mehr Details. Dies setzt voraus, dass Sie Boto3 installiert haben.

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 die Berechtigungen für diese Modellpaketgruppe können Sie ein JSON-Dokument erstellen, das dem folgenden Code ähnelt. Ersetzen Sie die tatsächlichen Konto-IDs und den Namen der Modellpaketgruppe durch Ihre eigenen Werte.

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

Wenden Sie abschließend die Richtlinie auf die Modellpaketgruppe an. Sie können diese Richtlinie nicht über die Konsole mit der Paketgruppe verknüpfen. Sie benötigen das SDK bzw AWS-Befehlszeilenschnittstelle (AWS CLI)-Zugriff. Der folgende Code verwendet beispielsweise 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)

Wir brauchen auch einen Brauch AWS-Schlüsselverwaltungsservice (AWS KMS)-Schlüssel, um das Modell zu verschlüsseln, während es in Amazon S3 gespeichert wird. Dies muss mit dem Data Science-Konto erfolgen. Navigieren Sie in der AWS KMS-Konsole zu der Definieren Sie Schlüsselnutzungsberechtigungen Seite. In dem Andere AWS-Konten Wählen Sie im Abschnitt Fügen Sie ein weiteres AWS-Konto hinzu. Geben Sie die AWS-Kontonummer für das Bereitstellungskonto ein. Sie verwenden diesen KMS-Schlüssel für den SageMaker-Trainingsjob. Wenn Sie keinen KMS-Schlüssel für den Trainingsauftrag angeben, verwendet SageMaker standardmäßig einen serverseitigen Amazon S3-Verschlüsselungsschlüssel. Ein standardmäßiger serverseitiger Amazon S3-Verschlüsselungsschlüssel kann nicht mit einem anderen AWS-Konto geteilt oder von diesem verwendet werden.

Die Richtlinie und Berechtigungen folgen diesem Muster:

• Die Amazon S3-Richtlinie, die in angegeben ist shared_services_account erteilt Berechtigungen für das Data Science-Konto und das Bereitstellungskonto
• Die KMS-Schlüsselrichtlinie, die in angegeben ist shared_services_account erteilt Berechtigungen für das Data Science-Konto und das Bereitstellungskonto

Wir müssen sicherstellen, dass das Konto für gemeinsame Dienste und das Bereitstellungskonto Zugriff auf die Docker-Images haben, die zum Trainieren des Modells verwendet wurden. Diese Bilder werden im Allgemeinen in AWS-Konten gehostet, und Ihr Kontoadministrator kann Ihnen helfen, Zugriff zu erhalten, falls Sie noch keinen Zugriff haben. Für diesen Beitrag erstellen wir nach dem Training des Modells keine benutzerdefinierten Docker-Images und benötigen daher keine spezifischen Amazon ECR-Richtlinien für die Images.

In den Workload-Konten (QA oder prod) müssen wir zwei erstellen AWS Identity and Access Management and (IAM)-Richtlinien, die den folgenden ähneln. Diese sind Inline-Richtlinien, was bedeutet, dass sie in eine IAM-Identität eingebettet sind. Dadurch erhalten diese Konten Zugriff auf die Modellregistrierung.

Die erste Inline-Richtlinie ermöglicht einer Rolle den Zugriff auf die Amazon S3-Ressource im Shared-Services-Konto, das das Modellartefakt enthält. Geben Sie den Namen des S3-Buckets und Ihr Modell an:

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

Die zweite Inline-Richtlinie erlaubt einer Rolle, die wir später erstellen, den KMS-Schlüssel im Konto für gemeinsame Dienste zu verwenden. Geben Sie die Konto-ID für das Konto für gemeinsame Dienste und die KMS-Schlüssel-ID an:

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

Schließlich müssen wir Erstellen Sie eine IAM-Rolle für SageMaker. Diese Rolle hat die AmazonSageMakerFullAccess Richtlinie beigefügt. Anschließend hängen wir diese beiden Inline-Richtlinien an die von uns erstellte Rolle an. Wenn Sie eine vorhandene SageMaker-Ausführungsrolle verwenden, hängen Sie diese beiden Richtlinien an diese Rolle an. Anweisungen finden Sie unter Rollen erstellen und Richtlinien anhängen (Konsole).

Nachdem wir nun die Richtlinien für jedes Konto definiert haben, sehen wir uns ein Beispiel an, um es in Aktion zu sehen.

Erstellen und trainieren Sie ein Modell mithilfe einer SageMaker-Pipeline

Wir erstellen zunächst eine SageMaker-Pipeline im Data-Science-Konto, um die Datenverarbeitung, das Modelltraining und die Bewertung durchzuführen. Wir verwenden den kalifornischen Wohnungsdatensatz aus der StatLib-Bibliothek. Im folgenden Codeausschnitt verwenden wir ein benutzerdefiniertes Vorverarbeitungsskript preprocess.py um einige einfache Feature-Transformationen wie Feature-Skalierung durchzuführen, die mit dem Folgenden generiert werden können Notizbuch. Dieses Skript teilt das Dataset auch in Trainings- und Test-Datasets auf.

Wir schaffen eine SKLearnProcessor -Objekt, um dieses Vorverarbeitungsskript auszuführen. In der SageMaker-Pipeline erstellen wir einen Verarbeitungsschritt (ProcessingStep), um den Verarbeitungscode mit auszuführen SKLearnProcessor. Dieser Verarbeitungscode wird aufgerufen, wenn die SageMaker-Pipeline initialisiert wird. Der Code, der die erstellt SKLearnProcessor und ProcessingStep sind im folgenden Code dargestellt. Beachten Sie, dass der gesamte Code in diesem Abschnitt im Data Science-Konto ausgeführt wird.

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

Wir benötigen einen benutzerdefinierten KMS-Schlüssel, um das Modell zu verschlüsseln, während wir es in Amazon S3 speichern. Siehe folgenden Code:

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

Um das Modell zu trainieren, erstellen wir ein TensorFlow-Estimator-Objekt. Wir übergeben ihm die KMS-Schlüssel-ID zusammen mit unserem Trainingsskript train.py, Trainingsinstanztyp und Anzahl. Wir erstellen auch eine TrainingStep zu unserer Pipeline hinzuzufügen, und fügen Sie den TensorFlow-Schätzer hinzu. Siehe folgenden Code:

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

Zusätzlich zum Training müssen wir eine Modellbewertung durchführen, für die wir in diesem Beispiel den mittleren quadratischen Fehler (MSE) als Metrik verwenden. Das früheres Notizbuch erzeugt auch evaluate.py, die wir verwenden, um unser a-Modell mit MSE zu evaluieren. Wir erstellen auch eine ProcessingStep um das Modellauswertungsskript mit a zu initialisieren SKLearnProcessor Objekt. Der folgende Code erstellt diesen Schritt:

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

Nach der Modellbewertung benötigen wir auch einen Schritt, um unser Modell bei der Modellregistrierung zu registrieren, wenn die Modellleistung den Anforderungen entspricht. Dies wird im folgenden Code mithilfe von gezeigt RegisterModel Schritt. Hier müssen wir das Modellpaket angeben, das wir im Konto für gemeinsame Dienste deklariert hatten. Ersetzen Sie das Paket „Region“, „Konto“ und „Modell“ durch Ihre Werte. Der hier verwendete Modellname lautet modeltest, aber Sie können einen beliebigen Namen Ihrer Wahl verwenden.

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

Wir müssen auch die Modellartefakte erstellen, damit sie bereitgestellt werden können (unter Verwendung des anderen Kontos). Zum Erstellen des Modells erstellen wir a CreateModelStep, wie im folgenden Code gezeigt:

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

Das Hinzufügen von Bedingungen zur Pipeline erfolgt mit a ConditionStep. In diesem Fall möchten wir die neue Modellversion nur dann bei der Modellregistrierung registrieren, wenn das neue Modell eine Genauigkeitsbedingung erfüllt. Siehe folgenden Code:

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

Schließlich wollen wir alle Pipeline-Schritte orchestrieren, damit die Pipeline initialisiert werden kann:

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

Stellen Sie eine Modellversion von einem anderen Konto bereit

Nachdem das Modell im Shared-Services-Konto registriert wurde, müssen wir es mithilfe der CI/CD-Pipeline im Bereitstellungskonto in unseren Workload-Konten bereitstellen. Wir haben die Rolle und die Richtlinie bereits in einem früheren Schritt konfiguriert. Wir verwenden den Modellpaket-ARN, um das Modell aus der Modellregistrierung bereitzustellen. Der folgende Code wird im Bereitstellungskonto ausgeführt und zum Bereitstellen genehmigter Modelle für QA und Produktion verwendet:

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

Zusammenfassung

In diesem Beitrag haben wir gezeigt, wie die Richtlinien eingerichtet werden, die für eine Multi-Account-Einrichtung für ML auf der Grundlage des Prinzips der geringsten Rechte erforderlich sind. Dann haben wir den Prozess zum Erstellen und Trainieren der Modelle im Data Science-Konto gezeigt. Schließlich haben wir die CI/CD-Pipeline im Bereitstellungskonto verwendet, um die neueste Version genehmigter Modelle für QA- und Produktionskonten bereitzustellen. Darüber hinaus können Sie Zeigen Sie den Bereitstellungsverlauf von Modellen an und Auslöser bauen in AWS CodeBuild.

Sie können die Konzepte in diesem Beitrag skalieren, um Modelle darin zu hosten Amazon Elastic Compute-Cloud (Amazon EC2) oder Amazon Elastic Kubernetes-Service (Amazon EKS) sowie den Aufbau einer Batch-Inferenz-Pipeline.

Um mehr über separate Konten zu erfahren, die ML-Modelle in AWS erstellen, siehe Best Practices für Organisationseinheiten mit AWS Organizations und Aktualisieren Sie Modelle in der Produktion sicher.

Über die Autoren

Sandeep Verma ist Senior Prototyping Architect bei AWS. Er taucht gerne tief in die Herausforderungen der Kunden ein und baut Prototypen für Kunden, um Innovationen zu beschleunigen. Er hat einen Hintergrund in KI/ML, Gründer von New Knowledge, und generell eine Leidenschaft für Technik. In seiner Freizeit reist er gerne und fährt mit seiner Familie Ski.

 Mani Chanuja ist Spezialist für künstliche Intelligenz und maschinelles Lernen SA bei Amazon Web Services (AWS). Sie hilft Kunden, maschinelles Lernen einzusetzen, um ihre geschäftlichen Herausforderungen mit AWS zu lösen. Sie verbringt die meiste Zeit damit, tief einzutauchen und Kunden in KI/ML-Projekten im Zusammenhang mit Computer Vision, natürlicher Sprachverarbeitung, Prognosen, ML am Edge und mehr zu unterrichten. Sie hat eine Leidenschaft für ML at Edge, daher hat sie ihr eigenes Labor mit selbstfahrenden Kits und einer Produktionslinie für die Prototypenfertigung geschaffen, in dem sie viel Freizeit verbringt.

Saumitra Vikram ist Softwareentwickler im Amazon SageMaker-Team und lebt in Chennai, Indien. Außerhalb der Arbeit verbringt er seine Zeit gerne mit Laufen, Trekking und Motorradfahren durch den Himalaya.

Sreedevi Srinivasan ist ein führendes technisches Unternehmen bei AWS SageMaker. Sie ist leidenschaftlich und begeistert davon, ML als Plattform zu ermöglichen, die das tägliche Leben verändern wird. Sie konzentriert sich derzeit auf den SageMaker Feature Store. In ihrer Freizeit verbringt sie gerne Zeit mit ihrer Familie.

Rupinder Grewal ist ein Sr Ai/ML Specialist Solutions Architect bei AWS. Derzeit konzentriert er sich auf die Bereitstellung von Modellen und MLOps auf SageMaker. Vor dieser Funktion hat er als Machine Learning Engineer gearbeitet und Modelle erstellt und gehostet. Außerhalb der Arbeit spielt er gerne Tennis und radelt auf Bergpfaden.

Farooq Sabir ist ein leitender Lösungsarchitekt für künstliche Intelligenz und maschinelles Lernen bei AWS. Er hat einen PhD- und MS-Abschluss in Elektrotechnik von der University of Texas at Austin und einen MS in Informatik vom Georgia Institute of Technology. Bei AWS hilft er Kunden bei der Formulierung und Lösung ihrer Geschäftsprobleme in den Bereichen Data Science, maschinelles Lernen, Computer Vision, künstliche Intelligenz, numerische Optimierung und verwandte Bereiche. Er verfügt über mehr als 16 Jahre Berufserfahrung und ist außerdem außerordentliches Fakultätsmitglied an der University of Texas in Dallas, wo er einen Graduiertenkurs über angewandtes maschinelles Lernen unterrichtet. Er lebt in Dallas, Texas, und seine Familie liebt es zu reisen und lange Autofahrten zu unternehmen.