Organizza il tuo percorso di machine learning con Amazon SageMaker Experiments e Amazon SageMaker Pipelines

Il processo di creazione di un modello di machine learning (ML) è iterativo finché non trovi il modello candidato che funziona bene ed è pronto per essere distribuito. Mentre i data scientist ripetono questo processo, hanno bisogno di un metodo affidabile per tracciare facilmente gli esperimenti per capire come è stata costruita ogni versione del modello e come ha funzionato.

Amazon Sage Maker consente ai team di sfruttare un'ampia gamma di funzionalità per preparare, creare, addestrare, distribuire e monitorare rapidamente i modelli ML. Pipeline di Amazon SageMaker fornisce un processo ripetibile per l'iterazione attraverso le attività di costruzione del modello ed è integrato con Esperimenti Amazon SageMaker. Per impostazione predefinita, ogni pipeline SageMaker è associata a un esperimento e ogni esecuzione di tale pipeline viene registrata come prova in quell'esperimento. Quindi le tue iterazioni vengono automaticamente tracciate senza ulteriori passaggi.

In questo post, esaminiamo più da vicino la motivazione alla base di un processo automatizzato per tenere traccia degli esperimenti con gli esperimenti e le funzionalità native integrate in Pipelines.

Perché è importante mantenere organizzati i tuoi esperimenti?

Facciamo un passo indietro per un momento e cerchiamo di capire perché è importante organizzare esperimenti per l'apprendimento automatico. Quando i data scientist affrontano un nuovo problema di ML, devono rispondere a molte domande diverse, dalla disponibilità dei dati al modo in cui misureranno le prestazioni del modello.

All'inizio, il processo è pieno di incertezza ed è altamente iterativo. Di conseguenza, questa fase di sperimentazione può produrre più modelli, ciascuno creato dai propri input (set di dati, script di addestramento e iperparametri) e produrre i propri output (artefatti del modello e metriche di valutazione). La sfida quindi è tenere traccia di tutti questi input e output di ogni iterazione.

I data scientist in genere addestrano molte versioni differenti del modello finché non trovano la combinazione di trasformazione dei dati, algoritmo e iperparametri che si traduce nella versione di un modello con le migliori prestazioni. Ognuna di queste combinazioni uniche è un singolo esperimento. Con una registrazione tracciabile degli input, degli algoritmi e degli iperparametri utilizzati da quella prova, il team di data science può trovare facile riprodurre i propri passaggi.

Avere un processo automatizzato in atto per tenere traccia degli esperimenti migliora la capacità di riprodurre e distribuire versioni di modelli specifici che funzionano bene. L'integrazione nativa di Pipelines con Experiments semplifica il monitoraggio e la gestione automatica degli esperimenti tra le esecuzioni della pipeline.

Vantaggi degli esperimenti SageMaker

SageMaker Experiments consente ai data scientist di organizzare, monitorare, confrontare e valutare le loro iterazioni di addestramento.

Iniziamo innanzitutto con una panoramica di ciò che puoi fare con Esperimenti:

• Organizza esperimenti – Esperimenti struttura la sperimentazione con un'entità di primo livello chiamata an esperimento che contiene un insieme di studi clinici. Ogni prova contiene una serie di passaggi chiamati componenti di prova. Ogni componente di prova è una combinazione di set di dati, algoritmi e parametri. Puoi immaginare gli esperimenti come la cartella di primo livello per organizzare le tue ipotesi, le prove come sottocartelle per ogni esecuzione di test di gruppo e i componenti di prova come file per ogni istanza di un'esecuzione di prova.
• Tieni traccia degli esperimenti – Gli esperimenti consentono ai data scientist di tenere traccia degli esperimenti. Offre la possibilità di assegnare automaticamente i lavori SageMaker a una prova tramite semplici configurazioni e tramite gli SDK di monitoraggio.
• Confronta e valuta gli esperimenti – L'integrazione di Esperimenti con Amazon Sage Maker Studio semplifica la produzione di visualizzazioni di dati e il confronto di diverse prove. Puoi anche accedere ai dati di prova tramite Python SDK per generare la tua visualizzazione utilizzando le tue librerie di stampa preferite.

Per ulteriori informazioni sulle API e gli SDK di Experiments, consigliamo la seguente documentazione: Crea esperimento ed Amazon SageMaker sperimenta l'SDK Python.

Se vuoi immergerti più a fondo, ti consigliamo di esaminare il amazon-sagemaker-examples/sagemaker-experiments repository GitHub per ulteriori esempi.

Integrazione tra pipeline ed esperimenti

Le pipeline di creazione di modelli che fanno parte di Pipelines sono create appositamente per il ML e consentono di orchestrare le attività di creazione di modelli utilizzando uno strumento di pipeline che include integrazioni native con altre funzionalità di SageMaker, nonché la flessibilità di estendere la pipeline con passaggi eseguiti all'esterno di SageMaker . Ogni passaggio definisce un'azione intrapresa dalla pipeline. Le dipendenze tra i passaggi sono definite da un grafico aciclico diretto (DAG) creato utilizzando Pipelines Python SDK. Puoi creare una pipeline SageMaker a livello di codice tramite lo stesso SDK. Dopo che una pipeline è stata distribuita, puoi facoltativamente visualizzarne il flusso di lavoro all'interno di Studio.

Le pipeline si integrano automaticamente con Experiments creando automaticamente un esperimento e una prova per ogni esecuzione. Le pipeline creano automaticamente un esperimento e una prova per ogni esecuzione della pipeline prima di eseguire i passaggi, a meno che non vengano specificati uno o entrambi questi input. Durante l'esecuzione del lavoro SageMaker della pipeline, la pipeline associa la versione di prova all'esperimento e associa alla versione di prova ogni componente di prova creato dal lavoro. Specificando il tuo esperimento o prova a livello di codice, puoi perfezionare l'organizzazione degli esperimenti.

Il flusso di lavoro che presentiamo in questo esempio consiste in una serie di passaggi: un passaggio di preelaborazione per suddividere il nostro set di dati di input in set di dati di addestramento, test e convalida; una fase di ottimizzazione per ottimizzare i nostri iperparametri e avviare i processi di addestramento per addestrare un modello utilizzando il Algoritmo integrato di XGBoost; e infine un passaggio del modello per creare un modello SageMaker dal manufatto modello meglio addestrato. Pipelines offre anche diversi supportati in modo nativo tipi di passi al di fuori di quanto discusso in questo post. Illustriamo anche come monitorare il flusso di lavoro della pipeline e generare metriche e grafici di confronto. Inoltre, mostriamo come associare la nuova prova generata a un esperimento esistente che potrebbe essere stato creato prima della definizione della pipeline.

Codice tubazioni SageMaker

Puoi rivedere e scaricare il taccuino dal Repository GitHub associato a questo post. Esaminiamo il codice specifico di Pipelines per capirlo meglio.

Pipelines consente di passare i parametri in fase di esecuzione. Qui definiamo i tipi di istanza di elaborazione e addestramento e i conteggi in fase di esecuzione con impostazioni predefinite preimpostate:

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

Successivamente, impostiamo uno script di elaborazione che scarica e suddivide il set di dati di input in parti di training, test e validazione. Noi usiamo SKLearnProcessor per eseguire questa fase di preelaborazione. Per fare ciò, definiamo un oggetto processore con il tipo di istanza e il conteggio necessari per eseguire il processo di elaborazione.

Pipelines ci consente di ottenere il controllo delle versioni dei dati in modo programmatico utilizzando variabili specifiche dell'esecuzione come ExecutionVariables.PIPELINE_EXECUTION_ID, che è l'ID univoco di un'esecuzione della pipeline. Possiamo, ad esempio, creare una chiave univoca in cui archiviare i set di dati di output Servizio di archiviazione semplice Amazon (Amazon S3) che li collega a un percorso specifico della pipeline. Per l'elenco completo delle variabili, fare riferimento a Variabili di esecuzione.

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

Quindi si passa alla creazione di un oggetto stimatore per addestrare un modello XGBoost. Impostiamo alcuni iperparametri statici comunemente usati con 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
)

Eseguiamo l'ottimizzazione degli iperparametri dei modelli che creiamo utilizzando a ContinuousParameter gamma per lambda. La scelta di una metrica come metrica obiettivo indica al sintonizzatore (l'istanza che esegue i processi di ottimizzazione degli iperparametri) che valuterai il processo di addestramento in base a questa metrica specifica. Il sintonizzatore restituisce la migliore combinazione in base al valore migliore per questa metrica obiettivo, ovvero la migliore combinazione che riduce al minimo l'errore quadratico medio della radice migliore (RMSE).

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

La fase di ottimizzazione esegue più prove con l'obiettivo di determinare il modello migliore tra gli intervalli di parametri testati. Con il metodo get_top_model_s3_uri, classifichiamo le prime 50 versioni con le prestazioni migliori dell'URI S3 dell'artefatto del modello ed estraiamo solo la versione con le migliori prestazioni (specificiamo k=0 per il meglio) per creare un modello SageMaker.

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

Quando la pipeline viene eseguita, crea componenti di prova per ogni processo di ottimizzazione degli iperparametri e ogni processo SageMaker creato dai passaggi della pipeline.

Puoi configurare ulteriormente l'integrazione delle pipeline con Experiments creando a PipelineExperimentConfig oggetto e passarlo all'oggetto pipeline. I due parametri definiscono il nome dell'esperimento che verrà creato e la prova che farà riferimento all'intero percorso della pipeline.

Se vuoi associare un'esecuzione della pipeline a un esperimento esistente, puoi passarne il nome e Pipelines assocerà ad essa la nuova prova. È possibile impedire la creazione di un esperimento e una versione di prova per una pipeline eseguita tramite l'impostazione pipeline_experiment_config a None.

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

Passiamo i tipi di istanza e i conteggi come parametri e concateniamo i passaggi precedenti nell'ordine seguente. Il flusso di lavoro della pipeline è implicitamente definito dagli output di un passaggio come input di un altro passaggio.

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

La pipeline a tutti gli effetti è ora creata e pronta per l'uso. Aggiungiamo un ruolo di esecuzione alla pipeline e la avviamo. Da qui, possiamo andare alla console SageMaker Studio Pipelines e tracciare visivamente ogni passaggio. Puoi anche accedere ai log collegati dalla console per eseguire il debug di una pipeline.

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

La schermata precedente mostra in verde una pipeline eseguita correttamente. Otteniamo le metriche di una prova da un'esecuzione della pipeline con il codice seguente:

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

Confronta le metriche per ogni componente di prova

Puoi tracciare i risultati dell'ottimizzazione degli iperparametri in Studio o tramite altre librerie di stampa Python. Mostriamo entrambi i modi per farlo.

Esplora le metriche di formazione e valutazione in Studio

Studio fornisce un'interfaccia utente interattiva in cui è possibile generare grafici interattivi. I passi sono come segue:

1. Scegli Esperimenti e prove dal Risorse di SageMaker icona sulla barra laterale sinistra.
2. Scegli il tuo esperimento per aprirlo.
3. Scegli (tasto destro del mouse) la prova di interesse.
4. Scegli Apri nell'elenco dei componenti di prova.
5. Rassegna Stampa Shift per selezionare i componenti di prova che rappresentano i lavori di formazione.
6. Scegli Aggiungi grafico.
7. Scegli Nuovo grafico e personalizzalo per tracciare le metriche raccolte che desideri analizzare. Per il nostro caso d'uso, scegli quanto segue:
   1. Nel Tipo di datiSelezionare Statistiche riassuntive.
   2. Nel tipo di graficoSelezionare Grafico a dispersione.
   3. Nel Asse Xscegli lambda.
   4. Nel Asse Yscegli validation:rmse_last.

Il nuovo grafico viene visualizzato nella parte inferiore della finestra, etichettato come "8".

È possibile includere più o meno lavori di formazione premendo Shift e scegliendo l'icona dell'occhio per un'esperienza più interattiva.

Analisi con esperimenti SageMaker

Quando l'esecuzione della pipeline è completa, possiamo visualizzare rapidamente il confronto tra le diverse variazioni del modello in termini di metriche raccolte durante l'addestramento. In precedenza, abbiamo esportato tutte le metriche di prova in a Pandas DataFrame utilizzando ExperimentAnalytics. Possiamo riprodurre la trama ottenuta in Studio utilizzando la libreria Matplotlib.

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

Conclusione

L'integrazione nativa tra SageMaker Pipelines e SageMaker Experiments consente ai data scientist di organizzare, tracciare e visualizzare automaticamente gli esperimenti durante le attività di sviluppo del modello. È possibile creare esperimenti per organizzare tutto il lavoro di sviluppo del modello, ad esempio:

• Un caso d'uso aziendale che stai affrontando, come la creazione di un esperimento per prevedere l'abbandono dei clienti
• Ad esempio, un esperimento di proprietà del team di data science relativo all'analisi di marketing
• Un progetto specifico di data science e ML

In questo post, ci siamo tuffati in Pipelines per mostrare come puoi usarlo insieme a Experiments per organizzare un flusso di lavoro end-to-end completamente automatizzato.

Come passaggio successivo, puoi utilizzare queste tre funzionalità di SageMaker – Studio, Experiments e Pipelines – per il tuo prossimo progetto ML.

Letture suggerite

Circa gli autori

Paolo Di Francesco è un architetto di soluzioni in AWS. Ha esperienza nel settore delle telecomunicazioni e dell'ingegneria del software. È appassionato di machine learning e attualmente si sta concentrando sull'utilizzo della sua esperienza per aiutare i clienti a raggiungere i propri obiettivi su AWS, in particolare nelle discussioni sugli MLOps. Al di fuori del lavoro, gli piace giocare a calcio e leggere.

Mario Bourgoin è un Senior Partner Solutions Architect per AWS, uno specialista di AI/ML e leader tecnologico globale per MLOps. Lavora con clienti e partner aziendali che implementano soluzioni di intelligenza artificiale nel cloud. Ha più di 30 anni di esperienza nell'apprendimento automatico e nell'intelligenza artificiale nelle startup e nelle imprese, iniziando con la creazione di uno dei primi sistemi commerciali di apprendimento automatico per i big data. Mario trascorre il suo tempo libero giocando con i suoi tre Tervuren belgi, cucinando la cena per la sua famiglia e imparando matematica e cosmologia.

Ganapathi Krishnamoorthi è Senior ML Solutions Architect presso AWS. Ganapathi fornisce una guida prescrittiva alle startup e ai clienti aziendali, aiutandoli a progettare e distribuire applicazioni cloud su larga scala. È specializzato in machine learning e si concentra sull'aiutare i clienti a sfruttare AI/ML per i loro risultati di business. Quando non è al lavoro, gli piace esplorare la vita all'aria aperta e ascoltare musica.

Valerie Soundhakith è un Solutions Architect per AWS, che lavora nel settore dei giochi e con i partner che distribuiscono soluzioni di intelligenza artificiale. Mira a costruire la sua carriera attorno alla Computer Vision. Durante il suo tempo libero, Valerie lo trascorre per viaggiare, scoprire nuovi punti di ristoro e cambiare gli interni della sua casa.