Hozzon létre egy több fiókra kiterjedő MLOps munkafolyamatot az Amazon SageMaker modellnyilvántartás használatával

A jól megtervezett CI/CD folyamat elengedhetetlen bármely szoftverfejlesztési munkafolyamat hatékony méretezéséhez. Az éles CI/CD-folyamatok tervezésekor az AWS több fiók igénybevételét javasolja az erőforrások elkülönítése, a biztonsági fenyegetések visszaszorítása és a számlázás egyszerűsítése érdekében – az adattudományi folyamatok sem különböznek egymástól. Az AWS-nél folytatjuk az innovációt az MLOps munkafolyamat egyszerűsítése érdekében.

Ebben a bejegyzésben néhány újabb, több fiókra kiterjedő funkciót tárgyalunk Amazon SageMaker amelyek lehetővé teszik a modellcsoportok jobb megosztását és kezelését, valamint a modellverziók kezelését. A követendő számlastruktúra példaként szervezeti egység legjobb gyakorlatai A SageMaker-végpontokat használó modellek több fiókon keresztüli üzemeltetéséhez lásd: MLOps Workload Orchestrator.

Megoldás áttekintése

Az alábbi ábra szemlélteti megosztott rendszerleíró adatbázis-architektúránkat.

Néhány dolog, amit meg kell jegyezni az előző architektúrában:

A következő lépések megfelelnek a diagramnak:

1. Egy adattudós regisztrál egy modellt az adattudományi fiókból a megosztott szolgáltatások SageMaker modellnyilvántartásába a PendingManualApproval állapot. A modell melléktermék a megosztott szolgáltatások fiókjában jön létre Amazon egyszerű tárolási szolgáltatás (Amazon S3) vödör.
2. Új modellverzió regisztrálásakor valakinek, aki jogosult a modellt a mérőszámok alapján jóváhagyni, jóvá kell hagynia vagy el kell utasítania a modellt.
3. A modell jóváhagyása után a CI/CD folyamat a telepítési fiókban kiváltotta a telepítést a frissített modell részleteit a minőségbiztosítási fiókban, és frissítse a szakaszt minőségbiztosításként.
4. A tesztelési folyamat sikeres befejezése után választhat egy manuális jóváhagyási lépést a CI/CD folyamaton belül, vagy a CI/CD folyamatban közvetlenül telepíti a modellt a termelésbe, és frissítheti a szakaszt Prod-ként.
5. Az éles környezet hivatkozik a jóváhagyott modellre és kódra, esetleg egy A/B teszt a gyártásban. Ellenőrzés vagy a modellel kapcsolatos bármilyen probléma esetén használhatja Amazon SageMaker ML Lineage Tracking. Információkat hoz létre és tárol a gépi tanulási (ML) munkafolyamat lépéseiről az adatok előkészítésétől a modell üzembe helyezéséig. A nyomon követési információk segítségével reprodukálhatja a munkafolyamat lépéseit, nyomon követheti a modell és az adatkészlet vonalát, valamint modellirányítási és ellenőrzési szabványokat hozhat létre.

A teljes folyamat során a megosztott modell-nyilvántartás megtartja a régebbi modellverziókat. Ez lehetővé teszi a csapat számára, hogy visszaállítsa a változtatásokat, vagy akár házigazdát is hajtson végre gyártási változatok.

Előfeltételek

Győződjön meg arról, hogy rendelkezik a következő előfeltételekkel:

• Kiépített többfiókos struktúra – Az utasításokat lásd Bevált gyakorlatok az AWS-szervezetekkel működő szervezeti egységekhez. A blog céljaira a következő fiókokat használjuk:
  • Adattudományi beszámoló – Egy fiók, ahol az adatkutatók hozzáférhetnek a képzési adatokhoz, és létrehozhatják a modelleket.
  • Megosztott szolgáltatások fiókja – Központi fiók a modellműtermékek tárolására (az architektúra diagramon látható módon), amely a különböző munkaterhelési fiókokon keresztül elérhető.
  • Telepítési fiók – Egy fiók, amely a különböző fiókok módosításaiért felelős.
  • Munkaterhelési fiókok – Ezek általában minőségbiztosítási és termékkörnyezetek, ahol a szoftvermérnökök olyan alkalmazásokat tudnak készíteni, amelyek felhasználják az ML modellt.
• Telepítési fiók megfelelő jogosultságokkal – A többfiókos szervezeti egység struktúrájával kapcsolatos bevált gyakorlatokkal kapcsolatos további információkért lásd: Telepítések OU. Ez a fiók felelős azért, hogy a munkaterhelési fiókokat a kívánt modellre irányítsa az osztott szolgáltatások fiókjának modellnyilvántartásában.

Határozza meg a több számlára vonatkozó irányelveket

A legkisebb jogosultság elvét követve először több fiókra kiterjedő erőforrás-házirendeket kell hozzáadnunk a megosztott szolgáltatások erőforrásaihoz, hogy hozzáférést biztosíthassunk a többi fiókból.

Mivel a modelltermékek a megosztott szolgáltatások fiókjának S3 tárolójában vannak tárolva, az adattudományi fióknak Amazon S3 olvasási/írási hozzáférésre van szüksége ahhoz, hogy a betanított modelleket az Amazon S3-ra küldje. A következő kód illusztrálja ezt a házirendet, de még ne adja hozzá a megosztott szolgáltatások fiókjához:

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

A telepítési fióknak csak olvasási hozzáférést kell biztosítania az S3 tárolóhoz, hogy a modell melléktermékeit felhasználhassa a SageMaker végpontokhoz való üzembe helyezéshez. A következő házirendet is csatolnunk kell a megosztott szolgáltatások S3 tárolójához:

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

Mindkét irányelvet egyesítjük, így a következő végső szabályzatot kapjuk. A megfelelő fiókazonosítók cseréje után hozza létre ezt a házirendet a megosztott szolgáltatások fiókjában:

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

Egy másik fiókban létrehozott modell üzembe helyezéséhez a felhasználónak rendelkeznie kell egy szerepkörrel, amely hozzáfér a SageMaker-műveletekhez, például a AmazonSageMakerFullAccess kezelt politika. Hivatkozni Telepítsen egy modellverziót egy másik fiókból további részletekért.

Meg kell határoznunk azt a modellcsoportot, amely tartalmazza a telepíteni kívánt modellverziókat. Ezenkívül engedélyeket szeretnénk adni az adattudományi fiókhoz. Ez a következő lépésekkel valósítható meg. A beszámolókra a következőképpen hivatkozunk:

• share_services_account_id – A fiók, ahol a modellnyilvántartás található, és ahol a modellt szeretnénk
• data_science_account_id – A fiók, ahol edzünk, és így létrehozzuk a tényleges modellműterméket
• telepítési_fiókazonosító – A fiók, ahol a modell végpontját szeretnénk tárolni

Először meg kell győződnünk a modellcsomag-csoportok létezéséről. Használhatja a Boto3 API-kat a következő példa szerint, vagy használhatja a AWS felügyeleti konzol a modellcsomag létrehozásához. Hivatkozni Modellcsomag-csoport létrehozása további részletekért. Ez feltételezi, hogy telepítve van a 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']))

A modellcsomag-csoport engedélyeihez létrehozhat egy JSON-dokumentumot, amely hasonlít a következő kódra. Cserélje ki a tényleges fiókazonosítókat és a modellcsomag-csoport nevét a saját értékeivel.

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

Végül alkalmazza a házirendet a modellcsomag-csoportra. Ez a házirend nem társítható a csomagcsoporthoz a konzolon keresztül. Szüksége van az SDK ill AWS parancssori interfész (AWS CLI) hozzáférést. Például a következő kód a Boto3-at használja:

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

Szükségünk van egy szokásra is AWS kulcskezelési szolgáltatás (AWS KMS) kulcs a modell titkosításához, miközben azt az Amazon S3-ban tárolja. Ezt az adattudományi fiók használatával kell megtenni. Az AWS KMS konzolon navigáljon a Határozza meg a kulcshasználati engedélyeket oldalon. Ban,-ben Egyéb AWS-fiókok szakaszban válassza Adjon hozzá egy másik AWS-fiókot. Adja meg a telepítési fiók AWS-fiókszámát. Ezt a KMS-kulcsot a SageMaker képzési munkához használja. Ha nem ad meg KMS-kulcsot a betanítási feladathoz, a SageMaker alapértelmezés szerint egy Amazon S3 szerveroldali titkosítási kulcsot használ. Az alapértelmezett Amazon S3 szerveroldali titkosítási kulcs nem osztható meg másik AWS-fiókkal, és nem használható más AWS-fiókkal.

A szabályzat és az engedélyek a következő mintát követik:

• pontban meghatározott Amazon S3 szabályzat shared_services_account engedélyeket ad a Data Science-fiókhoz és a telepítési fiókhoz
• pontban meghatározott KMS-kulcs házirendje shared_services_account engedélyeket ad a Data Science-fiókhoz és a telepítési fiókhoz

Biztosítanunk kell, hogy a megosztott szolgáltatások fiókja és a telepítési fiók hozzáférjen a modell betanításához használt Docker-képekhez. Ezeket a képeket általában AWS-fiókok tárolják, és a fiókadminisztrátor segíthet a hozzáférésben, ha még nem rendelkezik hozzáféréssel. Ehhez a bejegyzéshez nem hozunk létre egyéni Docker-képeket a modell betanítása után, ezért nincs szükségünk speciális Amazon ECR-szabályzatra a képekhez.

A munkaterhelési fiókokban (QA vagy prod) kettőt kell létrehoznunk AWS Identity and Access Management (IAM) irányelvei hasonlóak az alábbiakhoz. Ezek inline szabályzatok, ami azt jelenti, hogy egy IAM identitásba vannak beágyazva. Ez hozzáférést biztosít ezeknek a fiókoknak a modellnyilvántartáshoz.

Az első soron belüli házirend lehetővé teszi, hogy egy szerepkör hozzáférjen az Amazon S3 erőforráshoz a modellműterméket tartalmazó megosztott szolgáltatások fiókjában. Adja meg az S3 kanál nevét és modelljét:

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

A második soron belüli házirend lehetővé teszi, hogy egy szerepkör, amelyet később hozunk létre, használja a KMS-kulcsot a megosztott szolgáltatások fiókjában. Adja meg a megosztott szolgáltatások fiókjának fiókazonosítóját és a KMS-kulcs azonosítóját:

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

Végül is kell hozzon létre egy IAM-szerepet a SageMaker számára. Ennek a szerepnek a AmazonSageMakerFullAccess szabályzat csatolva. Ezután ezt a két soron belüli szabályzatot csatoljuk az általunk létrehozott szerepkörhöz. Ha meglévő SageMaker végrehajtási szerepkört használ, csatolja ezt a két szabályzatot ehhez a szerepkörhöz. Az utasításokat lásd Szerepkörök létrehozása és házirendek csatolása (konzol).

Most, hogy meghatároztuk az egyes fiókokhoz tartozó irányelveket, nézzük meg egy példán keresztül működésüket.

Modellek készítése és betanítása SageMaker csővezeték segítségével

Először létrehozunk egy SageMaker-folyamatot az adattudományi fiókban az adatfeldolgozás, a modellképzés és az értékelés végrehajtásához. A StatLib könyvtárból származó kaliforniai lakhatási adatkészletet használjuk. A következő kódrészletben egyéni előfeldolgozási szkriptet használunk preprocess.py néhány egyszerű jellemző transzformáció végrehajtásához, mint például a funkcióskálázás, amelyet a következő módon lehet előállítani jegyzetfüzet. Ez a szkript az adatkészletet képzési és tesztadatkészletekre is felosztja.

Létrehozunk egy SKLearnProcessor objektumot az előfeldolgozó szkript futtatásához. A SageMaker folyamatban létrehozunk egy feldolgozási lépést (ProcessingStep) a feldolgozási kód futtatásához SKLearnProcessor. Ez a feldolgozási kód a SageMaker folyamat inicializálásakor hívódik meg. A kód létrehozza a SKLearnProcessor és a ProcessingStep a következő kódban jelennek meg. Vegye figyelembe, hogy az ebben a szakaszban szereplő összes kód a Data Science fiókban fut.

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

Egyéni KMS-kulcsra van szükségünk a modell titkosításához, miközben az Amazon S3-on tároljuk. Lásd a következő kódot:

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

A modell betanításához létrehozunk egy TensorFlow becslő objektumot. Átadjuk neki a KMS-kulcsazonosítót a képzési szkriptünkkel együtt train.py, képzési példány típusa és száma. Létrehozunk továbbá a TrainingStep hozzá kell adni a folyamatunkhoz, és hozzá kell adni a TensorFlow becslőt. Lásd a következő kódot:

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

A betanításon kívül el kell végeznünk a modellértékelést is, amelyhez ebben a példában az átlagos négyzetes hibát (MSE) használjuk mérőszámként. Az korábbi notebook is generál evaluate.py, amelyet a modellünk MSE segítségével történő kiértékelésére használunk. Létrehozunk továbbá a ProcessingStep a modell kiértékelő szkriptjének inicializálásához a SKLearnProcessor tárgy. A következő kód hozza létre ezt a lépést:

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

A modell kiértékelése után szükségünk van egy lépésre, hogy regisztráljuk a modellünket a modellnyilvántartásba, ha a modell teljesítménye megfelel a követelményeknek. Ez a következő kódban látható a RegisterModel lépés. Itt meg kell adnunk a modellcsomagot, amelyet a megosztott szolgáltatások fiókjában deklaráltunk. Cserélje ki a Régió, fiók és modellcsomagot saját értékeivel. Az itt használt modellnév: modeltest, de tetszőleges nevet használhat.

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

Létre kell hoznunk a modell melléktermékeit is, hogy telepíthető legyen (a másik fiók használatával). A modell létrehozásához létrehozunk a CreateModelStep, ahogy az a következő kódban látható:

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

A feltételek hozzáadása a csővezetékhez a ConditionStep. Ebben az esetben csak akkor szeretnénk az új modellverziót regisztrálni a modellnyilvántartásba, ha az új modell megfelel a pontossági feltételnek. Lásd a következő kódot:

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

Végül meg akarjuk hangolni a folyamat összes lépését, hogy a folyamat inicializálható legyen:

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

Telepítsen egy modellverziót egy másik fiókból

Most, hogy a modell regisztrálva van a megosztott szolgáltatások fiókjában, a telepítési fiókban lévő CI/CD-folyamat használatával telepítenünk kell a munkaterhelési fiókjainkra. Egy korábbi lépésben már konfiguráltuk a szerepet és a házirendet. Az ARN modellcsomagot használjuk a modell telepítéséhez a modellnyilvántartásból. A következő kód fut a telepítési fiókban, és a jóváhagyott modellek minőségbiztosítási és gyártási rendszerbe történő telepítéséhez használható:

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

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan állíthatjuk be az ML többfiókos beállításához szükséges házirendeket a legkisebb jogosultság elve alapján. Ezután bemutattuk a modellek felépítésének és betanításának folyamatát az adattudományi fiókban. Végül a telepítési fiókban a CI/CD folyamatot használtuk a jóváhagyott modellek legújabb verziójának üzembe helyezéséhez a minőségbiztosítási és éles fiókokban. Ezenkívül megteheti megtekintheti a modellek telepítési előzményeit és a triggereket épít in AWS CodeBuild.

Az ebben a bejegyzésben szereplő fogalmakat méretezheti a modellek befogadására Amazon rugalmas számítási felhő (Amazon EC2) ill Amazon Elastic Kubernetes szolgáltatás (Amazon EKS), valamint építsen ki egy kötegelt következtetési folyamatot.

Ha többet szeretne megtudni arról, hogy az AWS-ben ML-modelleket készítő külön fiókok legyenek, lásd: Bevált gyakorlatok az AWS-szervezetekkel működő szervezeti egységekhez és a A gyártásban lévő modellek biztonságos frissítése.

A szerzőkről

Sandeep Verma idősebb prototípus-készítő építész az AWS-vel. Élvezi, hogy mélyen belemerüljön az ügyfelek kihívásaiba, és prototípusokat építsen az ügyfelek számára az innováció felgyorsítása érdekében. AI/ML háttérrel rendelkezik, a New Knowledge alapítója, és általában szenvedélyes a technológia iránt. Szabadidejében szeret utazni és családjával síelni.

 Mani Khanuja az Amazon Web Services (AWS) mesterséges intelligencia és gépi tanulás szakértője. Segít a gépi tanulást használó ügyfeleknek üzleti kihívásaik megoldásában az AWS segítségével. Ideje nagy részét azzal tölti, hogy mélyre merül, és ügyfeleit olyan AI/ML projektekre oktatja, amelyek a számítógépes látással, a természetes nyelvi feldolgozással, az előrejelzéssel, az ML szélén és még sok mással kapcsolatosak. Szenvedélye az ML szélén, ezért létrehozta saját laborját önvezető készlettel és prototípus gyártósorral, ahol szabadidejének nagy részét tölti.

Saumitra Vikram az Amazon SageMaker csapat szoftverfejlesztője, székhelye az indiai Chennaiban található. Munkán kívül szeret futni, túrázni és motorozni a Himalájában.

Sreedevi Srinivasan az AWS SageMaker mérnöki vezetője. Szenvedélyes és izgatott, hogy lehetővé tegye az ML-t olyan platformként, amely megváltoztatja a mindennapi életet. Jelenleg a SageMaker Feature Store-ra összpontosít. Szabadidejében szívesen tölt időt a családjával.

Rupinder Grewal Sr Ai/ML Specialist Solutions Architect, az AWS-vel. Jelenleg a SageMaker modellek és MLOp-k kiszolgálására összpontosít. Ezt megelőzően gépi tanulási mérnökként dolgozott modellek építésében és üzemeltetésében. Munkán kívül szeret teniszezni és hegyi ösvényeken kerékpározni.

Farooq Sabir az AWS mesterséges intelligenciával és gépi tanulással foglalkozó megoldásokkal foglalkozó vezető építésze. Az austini Texasi Egyetemen szerzett PhD és MS fokozatot villamosmérnöki szakon, valamint MS fokozatot számítástechnikából a Georgia Institute of Technology-n. Az AWS-nél segít az ügyfeleknek üzleti problémáik megfogalmazásában és megoldásában az adattudomány, a gépi tanulás, a számítógépes látás, a mesterséges intelligencia, a numerikus optimalizálás és a kapcsolódó területeken. Több mint 16 éves munkatapasztalattal rendelkezik, és adjunktus a dallasi Texasi Egyetemen, ahol posztgraduális kurzust tart az alkalmazott gépi tanulásról. A texasi Dallasban él, családjával együtt szeretnek utazni és hosszú utakat tenni.