Organisera din maskininlärningsresa med Amazon SageMaker Experiments och Amazon SageMaker Pipelines

Processen att bygga en maskininlärningsmodell (ML) är iterativ tills du hittar en kandidatmodell som fungerar bra och är redo att användas. När dataforskare itererar genom den processen behöver de en pålitlig metod för att enkelt spåra experiment för att förstå hur varje modellversion byggdes och hur den presterade.

Amazon SageMaker tillåter team att dra nytta av ett brett utbud av funktioner för att snabbt förbereda, bygga, träna, distribuera och övervaka ML-modeller. Amazon SageMaker-rörledningar ger en repeterbar process för att iterera genom modellbyggande aktiviteter och är integrerad med Amazon SageMaker-experiment. Som standard är varje SageMaker-pipeline associerad med ett experiment, och varje körning av den pipeline spåras som en test i det experimentet. Sedan spåras dina iterationer automatiskt utan några ytterligare steg.

I det här inlägget tar vi en närmare titt på motivationen bakom att ha en automatiserad process för att spåra experiment med experiment och de inbyggda funktionerna inbyggda i Pipelines.

Varför är det viktigt att hålla dina experiment organiserade?

Låt oss ta ett steg tillbaka ett ögonblick och försöka förstå varför det är viktigt att ha experiment organiserade för maskininlärning. När datavetare närmar sig ett nytt ML-problem måste de svara på många olika frågor, från datatillgänglighet till hur de ska mäta modellprestanda.

I början är processen full av osäkerhet och mycket iterativ. Som ett resultat kan denna experimentfas producera flera modeller, var och en skapad från sina egna indata (dataset, träningsskript och hyperparametrar) och producera sina egna utdata (modellartefakter och utvärderingsmått). Utmaningen är då att hålla reda på alla dessa ingångar och utgångar för varje iteration.

Dataforskare tränar vanligtvis många olika modellversioner tills de hittar kombinationen av datatransformation, algoritm och hyperparametrar som resulterar i den bäst presterande versionen av en modell. Var och en av dessa unika kombinationer är ett enda experiment. Med en spårbar registrering av indata, algoritmer och hyperparametrar som användes av försöket, kan datavetenskapsteamet hitta det lätt att återskapa sina steg.

Att ha en automatiserad process på plats för att spåra experiment förbättrar förmågan att reproducera och distribuera specifika modellversioner som presterar bra. Pipelines-integreringen med Experiment gör det enkelt att automatiskt spåra och hantera experiment över pipelinekörningar.

Fördelar med SageMaker-experiment

SageMaker Experiments låter datavetare organisera, spåra, jämföra och utvärdera deras träningsupprepningar.

Låt oss börja med en översikt över vad du kan göra med Experiment:

• Organisera experiment – Experiment strukturerar experiment med en enhet på toppnivå som kallas an experimentera som innehåller en uppsättning av försök. Varje provversion innehåller en uppsättning steg som kallas provkomponenter. Varje testkomponent är en kombination av datamängder, algoritmer och parametrar. Du kan se experiment som översta mapp för att organisera dina hypoteser, dina försök som undermappar för varje grupptestkörning och dina testkomponenter som dina filer för varje instans av en testkörning.
• Spåra experiment – Experiment tillåter dataforskare att spåra experiment. Det erbjuder möjligheten att automatiskt tilldela SageMaker-jobb till en testversion via enkla konfigurationer och via spårnings-SDK:erna.
• Jämför och utvärdera experiment – Integreringen av Experiment med Amazon SageMaker Studio gör det enkelt att producera datavisualiseringar och jämföra olika försök. Du kan också komma åt testdata via Python SDK för att generera din egen visualisering med hjälp av dina föredragna ritningsbibliotek.

Om du vill veta mer om Experiment API:er och SDK:er rekommenderar vi följande dokumentation: SkapaExperiment och Amazon SageMaker Experiment Python SDK.

Om du vill dyka djupare rekommenderar vi att du tittar in amazon-sagemaker-examples/sagemaker-experiments GitHub-arkiv för ytterligare exempel.

Integration mellan pipelines och experiment

De modellbyggande pipelines som ingår i Pipelines är specialbyggda för ML och låter dig orkestrera dina modellbyggande uppgifter med hjälp av ett pipelineverktyg som inkluderar inbyggda integrationer med andra SageMaker-funktioner samt flexibiliteten att utöka din pipeline med steg som körs utanför SageMaker . Varje steg definierar en åtgärd som pipelinen vidtar. Beroendena mellan stegen definieras av en direkt acyklisk graf (DAG) byggd med Pipelines Python SDK. Du kan bygga en SageMaker-pipeline programmatiskt via samma SDK. Efter att en pipeline har distribuerats kan du valfritt visualisera dess arbetsflöde i Studio.

Pipelines integreras automatiskt med Experiment genom att automatiskt skapa ett experiment och test för varje körning. Pipelines skapar automatiskt ett experiment och en test för varje körning av pipelinen innan stegen körs, såvida inte en eller båda av dessa indata anges. När pipelinens SageMaker-jobb körs associerar pipelinen försöket med experimentet och associerar varje testkomponent som skapas av jobbet till försöket. Genom att specificera ditt eget experiment eller testversion programmatiskt kan du finjustera hur du organiserar dina experiment.

Arbetsflödet som vi presenterar i det här exemplet består av en serie steg: ett förbearbetningssteg för att dela upp vår indatauppsättning i tåg-, test- och valideringsdatauppsättningar; ett inställningssteg för att ställa in våra hyperparametrar och starta träningsjobb för att träna en modell med hjälp av XGBoost inbyggd algoritm; och slutligen ett modellsteg för att skapa en SageMaker-modell från den bäst utbildade modellartefakten. Pipelines erbjuder också flera inbyggt stödda stegtyper utanför det som diskuteras i detta inlägg. Vi illustrerar också hur du kan spåra ditt pipeline-arbetsflöde och generera mätvärden och jämförelsediagram. Dessutom visar vi hur man associerar den nya testversionen som genereras till ett befintligt experiment som kan ha skapats innan pipelinen definierades.

SageMaker Pipelines-kod

Du kan granska och ladda ner anteckningsboken från GitHub repository kopplat till detta inlägg. Vi tittar på den Pipelines-specifika koden för att förstå den bättre.

Pipelines gör att du kan skicka parametrar vid körning. Här definierar vi bearbetnings- och träningsinstanstyperna och antalet vid körning med förinställda standardvärden:

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

Därefter ställer vi upp ett bearbetningsskript som laddar ner och delar upp indatauppsättningen i tåg-, test- och valideringsdelar. Vi använder SKLearnProcessor för att köra detta förbearbetningssteg. För att göra det definierar vi ett processorobjekt med den instanstyp och det antal som behövs för att köra bearbetningsjobbet.

Pipelines tillåter oss att uppnå dataversionering på ett programmatiskt sätt genom att använda exekveringsspecifika variabler som ExecutionVariables.PIPELINE_EXECUTION_ID, vilket är det unika ID:t för en pipelinekörning. Vi kan till exempel skapa en unik nyckel för att lagra utdatauppsättningarna i Amazon enkel lagringstjänst (Amazon S3) som binder dem till en specifik pipelinekörning. För hela listan över variabler, se Exekveringsvariabler.

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

Sedan går vi vidare för att skapa ett estimatorobjekt för att träna en XGBoost-modell. Vi ställer in några statiska hyperparametrar som vanligtvis används med 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
)

Vi gör hyperparameterjustering av modellerna vi skapar genom att använda en ContinuousParameter intervall för lambda. Att välja ett mått för att vara det objektiva värdet talar om för tunern (instansen som kör hyperparametrarnas tuningjobb) att du kommer att utvärdera träningsjobbet baserat på detta specifika mått. Tunern returnerar den bästa kombinationen baserat på det bästa värdet för detta objektiva mått, vilket betyder den bästa kombinationen som minimerar det bästa RMSE-felet.

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

Trimningssteget kör flera försök med målet att bestämma den bästa modellen bland de testade parameterområdena. Med metoden get_top_model_s3_uri, rankar vi de 50 bästa versionerna av modellartefakten S3 URI och extraherar bara den version som ger bäst resultat (vi specificerar k=0 för det bästa) för att skapa en SageMaker-modell.

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

När pipelinen körs skapar den testkomponenter för varje hyperparameterjusteringsjobb och varje SageMaker-jobb som skapas av pipelinestegen.

Du kan ytterligare konfigurera integreringen av pipelines med Experiment genom att skapa en PipelineExperimentConfig objektet och skicka det till pipelineobjektet. De två parametrarna definierar namnet på experimentet som kommer att skapas, och försöket som kommer att hänvisa till hela pipelinen.

Om du vill koppla en pipelinekörning till ett befintligt experiment kan du skicka dess namn, och Pipelines kommer att associera den nya testversionen till den. Du kan förhindra skapandet av ett experiment och en testversion av en pipeline som körs genom inställning pipeline_experiment_config till None.

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

Vi vidarebefordrar instanstyperna och räknas som parametrar, och kedjar de föregående stegen i ordning enligt följande. Pipeline-arbetsflödet definieras implicit av att utdata från ett steg är indata från ett annat steg.

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

Den fullfjädrade pipelinen är nu skapad och redo att gå. Vi lägger till en exekveringsroll i pipelinen och startar den. Härifrån kan vi gå till SageMaker Studio Pipelines-konsolen och visuellt spåra varje steg. Du kan också komma åt de länkade loggarna från konsolen för att felsöka en pipeline.

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

Den föregående skärmdumpen visar i grönt en framgångsrik pipeline. Vi hämtar mätvärdena för ett försök från en run of the pipeline med följande kod:

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

Jämför mätvärdena för varje testkomponent

Du kan plotta resultaten av hyperparameterinställning i Studio eller via andra Python-plotningsbibliotek. Vi visar båda sätten att göra detta.

Utforska utbildnings- och utvärderingsstatistiken i Studio

Studio tillhandahåller ett interaktivt användargränssnitt där du kan skapa interaktiva plotter. Stegen är som följer:

1. Välja Experiment och försök från SageMaker-resurser ikonen på vänster sidofält.
2. Välj ditt experiment för att öppna det.
3. Välj (högerklicka) provversionen av intresse.
4. Välja Öppna i testkomponentlistan.
5. Presse shift för att välja de provkomponenter som representerar utbildningsjobben.
6. Välja Lägg till diagram.
7. Välja Nytt diagram och anpassa den för att plotta de insamlade mätvärdena som du vill analysera. Välj följande för vårt användningsfall:
   1. För Data typVälj Sammanfattande statistik.
   2. För DiagramtypVälj Scatter tomt.
   3. För X-axelväljer lambda.
   4. För Y-axelväljer validation:rmse_last.

Det nya diagrammet visas längst ner i fönstret, märkt som '8'.

Du kan ta med fler eller färre utbildningsjobb genom att trycka shift och att välja ögonikonen för en mer interaktiv upplevelse.

Analys med SageMaker Experiment

När pipelinekörningen är klar kan vi snabbt visualisera hur olika varianter av modellen står sig i förhållande till de mätvärden som samlats in under utbildningen. Tidigare exporterade vi alla testvärden till en pandas DataFrame med hjälp av ExperimentAnalytics. Vi kan reproducera handlingen som erhållits i Studio genom att använda Matplotlib-biblioteket.

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

Slutsats

Den inbyggda integrationen mellan SageMaker Pipelines och SageMaker Experiments tillåter datavetare att automatiskt organisera, spåra och visualisera experiment under modellutvecklingsaktiviteter. Du kan skapa experiment för att organisera allt ditt modellutvecklingsarbete, till exempel följande:

• Ett affärsanvändningsfall du tar upp, till exempel att skapa ett experiment för att förutsäga kundförlust
• Ett experiment som ägs av datavetenskapsteamet angående marknadsföringsanalys, till exempel
• Ett specifikt datavetenskap- och ML-projekt

I det här inlägget dyker vi in ​​i Pipelines för att visa hur du kan använda det tillsammans med Experiment för att organisera ett helt automatiserat end-to-end-arbetsflöde.

Som nästa steg kan du använda dessa tre SageMaker-funktioner – Studio, Experiment och Pipelines – för ditt nästa ML-projekt.

Föreslagna läsningar

Om författarna

Paolo Di Francesco är lösningsarkitekt på AWS. Han har erfarenhet av telekommunikation och mjukvaruteknik. Han brinner för maskininlärning och fokuserar för närvarande på att använda sin erfarenhet för att hjälpa kunder att nå sina mål på AWS, särskilt i diskussioner kring MLOps. Utanför jobbet tycker han om att spela fotboll och läsa.

Mario Bourgoin är en Senior Partner Solutions Architect för AWS, en AI/ML-specialist och den globala tekniska ledaren för MLOps. Han arbetar med företagskunder och partners som distribuerar AI-lösningar i molnet. Han har mer än 30 års erfarenhet av maskininlärning och AI vid startups och i företag, till att börja med att skapa ett av de första kommersiella maskininlärningssystemen för big data. Mario tillbringar sin fritid med att leka med sina tre belgiska Tervurens, laga middag till sin familj och lära sig om matematik och kosmologi.

Ganapathi Krishnamoorthi är Senior ML Solutions Architect på AWS. Ganapathi tillhandahåller föreskrivande vägledning till startup- och företagskunder och hjälper dem att designa och distribuera molnapplikationer i stor skala. Han är specialiserad på maskininlärning och är fokuserad på att hjälpa kunder att utnyttja AI/ML för sina affärsresultat. När han inte är på jobbet tycker han om att utforska utomhus och lyssna på musik.

Valerie Sounthakith är en lösningsarkitekt för AWS, som arbetar i spelindustrin och med partners som distribuerar AI-lösningar. Hon siktar på att bygga sin karriär kring Computer Vision. På fritiden ägnar Valerie den åt att resa, upptäcka nya matställen och förändra sitt hus.