Organiseer uw machine learning-reis met Amazon SageMaker Experiments en Amazon SageMaker Pipelines

Het proces van het bouwen van een machine learning (ML)-model is iteratief totdat u het kandidaat-model vindt dat goed presteert en klaar is om te worden geïmplementeerd. Terwijl datawetenschappers dat proces doorlopen, hebben ze een betrouwbare methode nodig om experimenten gemakkelijk te volgen om te begrijpen hoe elke modelversie is gebouwd en hoe deze heeft gepresteerd.

Amazon Sage Maker stelt teams in staat om te profiteren van een breed scala aan functies om ML-modellen snel voor te bereiden, te bouwen, te trainen, te implementeren en te bewaken. Amazon SageMaker-pijpleidingen biedt een herhaalbaar proces voor iteratie door middel van modelbouwactiviteiten en is geïntegreerd met Amazon SageMaker-experimenten. Elke SageMaker-pijplijn is standaard gekoppeld aan een experiment en elke uitvoering van die pijplijn wordt bijgehouden als een proef in dat experiment. Dan worden je iteraties automatisch bijgehouden zonder extra stappen.

In dit bericht gaan we dieper in op de motivatie achter het hebben van een geautomatiseerd proces om experimenten bij te houden met Experimenten en de ingebouwde mogelijkheden die in Pipelines zijn ingebouwd.

Waarom is het belangrijk om je experimenten georganiseerd te houden?

Laten we even een stapje terug doen en proberen te begrijpen waarom het belangrijk is om experimenten te organiseren voor machine learning. Wanneer datawetenschappers een nieuw ML-probleem benaderen, moeten ze veel verschillende vragen beantwoorden, van de beschikbaarheid van gegevens tot hoe ze de modelprestaties zullen meten.

In het begin is het proces vol onzekerheid en zeer iteratief. Als gevolg hiervan kan deze experimenteerfase meerdere modellen produceren, elk gemaakt op basis van hun eigen invoer (gegevenssets, trainingsscripts en hyperparameters) en hun eigen uitvoer produceren (modelartefacten en evaluatiestatistieken). De uitdaging is dan om al deze inputs en outputs van elke iteratie bij te houden.

Datawetenschappers trainen doorgaans veel verschillende modelversies totdat ze de combinatie van datatransformatie, algoritme en hyperparameters hebben gevonden die resulteert in de best presterende versie van een model. Elk van deze unieke combinaties is een enkel experiment. Met een traceerbaar overzicht van de invoer, algoritmen en hyperparameters die door die proef zijn gebruikt, kan het data science-team het gemakkelijk vinden om hun stappen te reproduceren.

Het hebben van een geautomatiseerd proces om experimenten bij te houden, verbetert het vermogen om te reproduceren en om specifieke modelversies te implementeren die goed presteren. De native integratie van Pipelines met Experiments maakt het eenvoudig om experimenten automatisch bij te houden en te beheren voor verschillende pijplijnuitvoeringen.

Voordelen van SageMaker-experimenten

Met SageMaker Experiments kunnen datawetenschappers hun trainingsiteraties organiseren, volgen, vergelijken en evalueren.

Laten we eerst beginnen met een overzicht van wat u kunt doen met Experimenten:

• Organiseer experimenten – Experimenten structureren experimenten met een entiteit op het hoogste niveau genaamd an experiment die een set van bevat proeven. Elke proef bevat een reeks stappen genaamd proefcomponenten. Elke proefcomponent is een combinatie van datasets, algoritmen en parameters. U kunt experimenten zien als de map op het hoogste niveau voor het organiseren van uw hypothesen, uw proeven als de submappen voor elke groepstestrun en uw proefcomponenten als uw bestanden voor elk exemplaar van een testrun.
• Experimenten volgen - Met experimenten kunnen datawetenschappers experimenten volgen. Het biedt de mogelijkheid om SageMaker jobs automatisch toe te wijzen aan een proef via eenvoudige configuraties en via de tracking SDK's.
• Vergelijk en evalueer experimenten – De integratie van Experimenten met Amazon SageMaker Studio maakt het gemakkelijk om datavisualisaties te maken en verschillende proeven te vergelijken. U hebt ook toegang tot de proefgegevens via de Python SDK om uw eigen visualisatie te genereren met behulp van uw favoriete plotbibliotheken.

Voor meer informatie over Experiments-API's en SDK's raden we de volgende documentatie aan: CreëerExperiment en Amazon SageMaker experimenteert met Python SDK.

Als je dieper wilt duiken, raden we je aan om de Amazon-sagemaker-voorbeelden/sagemaker-experimenten GitHub-repository voor meer voorbeelden.

Integratie tussen pijplijnen en experimenten

De modelbouwpijplijnen die deel uitmaken van pijplijnen zijn speciaal gebouwd voor ML en stellen u in staat uw modelbouwtaken te orkestreren met behulp van een pijplijntool die native integraties met andere SageMaker-functies omvat, evenals de flexibiliteit om uw pijplijn uit te breiden met stappen die buiten SageMaker worden uitgevoerd . Elke stap definieert een actie die de pijplijn onderneemt. De afhankelijkheden tussen stappen worden gedefinieerd door een directe acyclische grafiek (DAG) die is gebouwd met behulp van de Pipelines Python SDK. U kunt programmatisch een SageMaker-pijplijn bouwen via dezelfde SDK. Nadat een pijplijn is geïmplementeerd, kunt u desgewenst de workflow ervan in Studio visualiseren.

Pipelines worden automatisch geïntegreerd met Experiments door voor elke run automatisch een experiment en proefversie te maken. Pijplijnen maken automatisch een experiment en een proefversie voor elke uitvoering van de pijplijn voordat de stappen worden uitgevoerd, tenzij een of beide invoer is opgegeven. Tijdens het uitvoeren van de SageMaker-taak van de pijplijn, associeert de pijplijn de proef met het experiment en koppelt aan de proef elk proefonderdeel dat door de taak wordt gemaakt. Door uw eigen experiment of proefprogramma programmatisch op te geven, kunt u de organisatie van uw experimenten verfijnen.

De workflow die we in dit voorbeeld presenteren, bestaat uit een reeks stappen: een voorbewerkingsstap om onze invoergegevensset op te splitsen in trein-, test- en validatiegegevenssets; een afstemmingsstap om onze hyperparameters af te stemmen en trainingstaken te starten om een ​​model te trainen met behulp van de XGBoost ingebouwd algoritme; en tot slot een modelstap om een ​​SageMaker-model te maken van het best getrainde modelartefact. Pipelines biedt ook verschillende native ondersteunde stap typen buiten wat in dit bericht wordt besproken. We laten ook zien hoe u uw pijplijnworkflow kunt volgen en statistieken en vergelijkingsgrafieken kunt genereren. Verder laten we zien hoe de nieuwe proef die is gegenereerd, kan worden gekoppeld aan een bestaand experiment dat mogelijk is gemaakt voordat de pijplijn werd gedefinieerd.

SageMaker Pipelines-code

U kunt het notitieboekje bekijken en downloaden via de GitHub-repository gekoppeld aan dit bericht. We kijken naar de Pipelines-specifieke code om deze beter te begrijpen.

Met pijplijnen kunt u tijdens runtime parameters doorgeven. Hier definiëren we de typen verwerkings- en trainingsinstanties en tellingen tijdens runtime met vooraf ingestelde standaardwaarden:

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

Vervolgens stellen we een verwerkingsscript in dat de invoergegevensset downloadt en splitst in trein-, test- en validatiedelen. We gebruiken SKLearnProcessor voor het uitvoeren van deze voorbewerkingsstap. Om dit te doen, definiëren we een processorobject met het instantietype en het aantal dat nodig is om de verwerkingstaak uit te voeren.

Met pijplijnen kunnen we gegevensversiebeheer op een programmatische manier realiseren door gebruik te maken van uitvoeringsspecifieke variabelen zoals: ExecutionVariables.PIPELINE_EXECUTION_ID, wat de unieke ID is van een pijplijnuitvoering. We kunnen bijvoorbeeld een unieke sleutel maken om de output datasets in op te slaan Amazon eenvoudige opslagservice (Amazon S3) die ze binden aan een specifieke pijplijnrun. Voor de volledige lijst met variabelen, zie: Uitvoeringsvariabelen.

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

Daarna gaan we verder met het maken van een schatterobject om een ​​XGBoost-model te trainen. We hebben enkele statische hyperparameters ingesteld die vaak worden gebruikt met XGBoost:

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

We doen hyperparameter-afstemming van de modellen die we maken met behulp van a ContinuousParameter bereik voor lambda. Als u één metriek kiest als de objectieve metriek, vertelt de tuner (de instantie die de afstemmingstaken voor hyperparameters uitvoert) dat u de trainingstaak zult evalueren op basis van deze specifieke metriek. De tuner retourneert de beste combinatie op basis van de beste waarde voor deze objectieve metriek, dat wil zeggen de beste combinatie die de beste root mean square error (RMSE) minimaliseert.

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

tune_step = TuningStep(
    name="HPTuning",
    tuner=tuner_log,
    inputs={
        "train": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "validation": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "validation"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    } 
)

De afstemmingsstap voert meerdere proeven uit met als doel het bepalen van het beste model van de geteste parameterbereiken. Met de methode get_top_model_s3_uri, rangschikken we de 50 best presterende versies van het modelartefact S3 URI en extraheren we alleen de best presterende versie (we specificeren k=0 voor het beste) om een ​​SageMaker-model te maken.

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

Wanneer de pijplijn wordt uitgevoerd, worden proefcomponenten gemaakt voor elke hyperparameterafstemmingstaak en elke SageMaker-taak die door de pijplijnstappen is gemaakt.

U kunt de integratie van pijplijnen met Experimenten verder configureren door een PipelineExperimentConfig object en geef het door aan het pijplijnobject. De twee parameters definiëren de naam van het experiment dat wordt gemaakt en de proef die verwijst naar de hele uitvoering van de pijplijn.

Als u een pijplijnuitvoering wilt koppelen aan een bestaand experiment, kunt u de naam ervan doorgeven, waarna Pipelines de nieuwe proefperiode eraan zal koppelen. U kunt het maken van een experiment en proefversie voor een pijplijnuitvoering voorkomen door in te stellen: pipeline_experiment_config naar None.

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

We geven de instantietypes en tellingen door als parameters, en ketenen de voorgaande stappen in volgorde als volgt. De workflow van de pijplijn wordt impliciet gedefinieerd doordat de output van een stap de input is van een andere stap.

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

De volwaardige pijplijn is nu gemaakt en klaar voor gebruik. We voegen een uitvoeringsrol toe aan de pijplijn en starten deze. Vanaf hier kunnen we naar de SageMaker Studio Pipelines-console gaan en elke stap visueel volgen. U kunt vanuit de console ook toegang krijgen tot de gekoppelde logboeken om fouten in een pijplijn op te sporen.

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

De voorgaande schermafbeelding toont in het groen een succesvol uitgevoerde pijplijn. We verkrijgen de statistieken van één proef uit een uitvoering van de pijplijn met de volgende code:

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

Vergelijk de statistieken voor elk proefonderdeel

U kunt de resultaten van het afstemmen van hyperparameters plotten in Studio of via andere Python-plotbibliotheken. We laten beide manieren zien om dit te doen.

Verken de trainings- en evaluatiestatistieken in Studio

Studio biedt een interactieve gebruikersinterface waar u interactieve plots kunt genereren. De stappen zijn als volgt:

1. Kies Experimenten en proeven van het SageMaker-bronnen pictogram in de linkerzijbalk.
2. Kies uw experiment om het te openen.
3. Kies (klik met de rechtermuisknop) de proef van interesse.
4. Kies Open in proefcomponentenlijst.
5. Media Shift om de proefcomponenten te selecteren die de opleidingstaken vertegenwoordigen.
6. Kies Grafiek toevoegen.
7. Kies Nieuwe grafiek en pas het aan om de verzamelde statistieken die u wilt analyseren in kaart te brengen. Kies het volgende voor ons gebruik:
   1. Voor Data type¸ selecteren Samenvattende statistieken.
   2. Voor Type grafiek¸ selecteren Scatterplot.
   3. Voor X-as, kiezen lambda.
   4. Voor Y-as, kiezen validation:rmse_last.

De nieuwe grafiek verschijnt onderaan het venster, aangeduid als '8'.

U kunt meer of minder trainingstaken opnemen door op te drukken Shift en het oogpictogram te kiezen voor een meer interactieve ervaring.

Analyse met SageMaker-experimenten

Wanneer de pijplijnrun is voltooid, kunnen we snel visualiseren hoe verschillende variaties van het model zich verhouden in termen van de metrieken die tijdens de training zijn verzameld. Eerder exporteerden we alle proefstatistieken naar a Pandas DataFrame gebruik ExperimentAnalytics. We kunnen de in Studio verkregen plot reproduceren met behulp van de Matplotlib-bibliotheek.

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

Conclusie

Dankzij de native integratie tussen SageMaker Pipelines en SageMaker Experiments kunnen datawetenschappers experimenten automatisch organiseren, volgen en visualiseren tijdens modelontwikkelingsactiviteiten. U kunt experimenten maken om al uw modelontwikkelingswerk te organiseren, zoals:

• Een zakelijk gebruiksscenario dat u aanpakt, zoals het maken van een experiment om klantverloop te voorspellen
• Een experiment dat eigendom is van het data science-team met betrekking tot bijvoorbeeld marketinganalyse
• Een specifiek data science- en ML-project

In dit bericht zijn we in Pipelines gedoken om te laten zien hoe je het samen met Experiments kunt gebruiken om een ​​volledig geautomatiseerde end-to-end workflow te organiseren.

Als volgende stap kunt u deze drie SageMaker-functies - Studio, Experimenten en Pipelines - gebruiken voor uw volgende ML-project.

Voorgestelde metingen

Over de auteurs

Paul Di Francesco is oplossingsarchitect bij AWS. Hij heeft ervaring in de telecommunicatie en software engineering. Hij is gepassioneerd door machine learning en richt zich momenteel op het gebruik van zijn ervaring om klanten te helpen hun doelen op AWS te bereiken, met name in discussies over MLOps. Naast zijn werk houdt hij van voetballen en lezen.

Mario Bourgoin is Senior Partner Solutions Architect voor AWS, een AI/ML-specialist en de wereldwijde tech lead voor MLOps. Hij werkt met zakelijke klanten en partners die AI-oplossingen in de cloud implementeren. Hij heeft meer dan 30 jaar ervaring met machine learning en AI bij startups en in ondernemingen, te beginnen met het creëren van een van de eerste commerciële machine learning-systemen voor big data. Mario brengt zijn vrije tijd door met spelen met zijn drie Belgische Tervurens, koken voor zijn gezin en leren over wiskunde en kosmologie.

Ganapathi Krishnamoorthi is Senior ML Solutions Architect bij AWS. Ganapathi biedt prescriptieve begeleiding aan startende en zakelijke klanten en helpt hen bij het ontwerpen en implementeren van cloudapplicaties op grote schaal. Hij is gespecialiseerd in machine learning en is gericht op het helpen van klanten om AI/ML te gebruiken voor hun bedrijfsresultaten. Als hij niet aan het werk is, gaat hij graag buiten op ontdekkingstocht en luistert hij graag naar muziek.

Valerie Sounthakith is een Solutions Architect voor AWS, werkzaam in de gamingindustrie en met partners die AI-oplossingen implementeren. Ze wil haar carrière opbouwen rond Computer Vision. Tijdens haar vrije tijd besteedt Valerie het aan reizen, nieuwe eetplekken ontdekken en het interieur van haar huis veranderen.