Organisez votre parcours d'apprentissage automatique avec Amazon SageMaker Experiments et Amazon SageMaker Pipelines

Le processus de création d'un modèle d'apprentissage automatique (ML) est itératif jusqu'à ce que vous trouviez le modèle candidat qui fonctionne bien et est prêt à être déployé. Au fur et à mesure que les scientifiques des données parcourent ce processus, ils ont besoin d'une méthode fiable pour suivre facilement les expériences afin de comprendre comment chaque version de modèle a été construite et comment elle a fonctionné.

Amazon Sage Maker permet aux équipes de tirer parti d'un large éventail de fonctionnalités pour préparer, créer, former, déployer et surveiller rapidement des modèles ML. Pipelines Amazon SageMaker fournit un processus reproductible pour itérer à travers les activités de construction de modèles, et est intégré à Expériences Amazon SageMaker. Par défaut, chaque pipeline SageMaker est associé à une expérience, et chaque exécution de ce pipeline est suivie en tant qu'essai dans cette expérience. Ensuite, vos itérations sont automatiquement suivies sans aucune étape supplémentaire.

Dans cet article, nous examinons de plus près la motivation derrière un processus automatisé pour suivre les expériences avec Experiments et les capacités natives intégrées dans Pipelines.

Pourquoi est-il important de garder vos expériences organisées ?

Prenons un peu de recul et essayons de comprendre pourquoi il est important d'organiser des expériences pour l'apprentissage automatique. Lorsque les scientifiques des données abordent un nouveau problème de ML, ils doivent répondre à de nombreuses questions différentes, de la disponibilité des données à la manière dont ils mesureront les performances du modèle.

Au départ, le processus est plein d'incertitudes et très itératif. Par conséquent, cette phase d'expérimentation peut produire plusieurs modèles, chacun créé à partir de ses propres entrées (ensembles de données, scripts de formation et hyperparamètres) et produisant ses propres sorties (artefacts de modèle et métriques d'évaluation). Le défi consiste alors à garder une trace de toutes ces entrées et sorties de chaque itération.

Les scientifiques des données forment généralement de nombreuses versions de modèles différentes jusqu'à ce qu'ils trouvent la combinaison de transformation de données, d'algorithme et d'hyperparamètres qui se traduit par la version la plus performante d'un modèle. Chacune de ces combinaisons uniques est une expérience unique. Avec un enregistrement traçable des entrées, des algorithmes et des hyperparamètres utilisés par cet essai, l'équipe de science des données peut facilement reproduire ses étapes.

La mise en place d'un processus automatisé pour suivre les expériences améliore la capacité à reproduire et à déployer des versions de modèles spécifiques qui fonctionnent bien. L'intégration native de Pipelines avec Experiments facilite le suivi et la gestion automatiques des expériences à travers les exécutions de pipeline.

Avantages des expériences SageMaker

SageMaker Experiments permet aux data scientists d'organiser, de suivre, de comparer et d'évaluer leurs itérations de formation.

Commençons par un aperçu de ce que vous pouvez faire avec les tests :

• Organiser des expériences – Experiments structure l'expérimentation avec une entité de niveau supérieur appelée expérience qui contient un ensemble de essais cliniques. Chaque essai contient un ensemble d'étapes appelées composants d'essai. Chaque composant d'essai est une combinaison d'ensembles de données, d'algorithmes et de paramètres. Vous pouvez imaginer les expériences comme le dossier de niveau supérieur pour organiser vos hypothèses, vos essais comme les sous-dossiers pour chaque exécution de test de groupe et vos composants d'essai comme vos fichiers pour chaque instance d'une exécution de test.
• Suivre les expériences – Experiments permet aux data scientists de suivre les expériences. Il offre la possibilité d'affecter automatiquement des jobs SageMaker à un essai via des configurations simples et via les SDK de suivi.
• Comparer et évaluer des expériences – L'intégration des Expériences avec Amazon SageMakerStudio facilite la production de visualisations de données et la comparaison de différents essais. Vous pouvez également accéder aux données d'essai via le SDK Python pour générer votre propre visualisation à l'aide de vos bibliothèques de traçage préférées.

Pour en savoir plus sur les API et les SDK Experiments, nous vous recommandons de consulter la documentation suivante : CréerExpérience ainsi que le Amazon SageMaker expérimente le SDK Python.

Si vous voulez plonger plus profondément, nous vous recommandons de regarder dans le référentiel GitHub amazon-sagemaker-examples/sagemaker-experiments pour d'autres exemples.

Intégration entre pipelines et expérimentations

Les pipelines de création de modèles qui font partie de Pipelines sont spécialement conçus pour ML et vous permettent d'orchestrer vos tâches de création de modèles à l'aide d'un outil de pipeline qui inclut des intégrations natives avec d'autres fonctionnalités SageMaker ainsi que la flexibilité d'étendre votre pipeline avec des étapes exécutées en dehors de SageMaker. . Chaque étape définit une action effectuée par le pipeline. Les dépendances entre les étapes sont définies par un graphe acyclique direct (DAG) construit à l'aide du SDK Pipelines Python. Vous pouvez créer un pipeline SageMaker par programmation via le même SDK. Une fois qu'un pipeline est déployé, vous pouvez éventuellement visualiser son workflow dans Studio.

Les pipelines s'intègrent automatiquement aux expériences en créant automatiquement une expérience et un essai pour chaque exécution. Les pipelines créent automatiquement une expérience et un essai pour chaque exécution du pipeline avant d'exécuter les étapes, sauf si l'une de ces entrées ou les deux sont spécifiées. Lors de l'exécution de la tâche SageMaker du pipeline, le pipeline associe l'essai à l'expérience et associe à l'essai chaque composant d'essai créé par la tâche. Spécifier votre propre expérience ou essai par programmation vous permet d'affiner la façon d'organiser vos expériences.

Le flux de travail que nous présentons dans cet exemple consiste en une série d'étapes : une étape de prétraitement pour diviser notre ensemble de données d'entrée en ensembles de données d'apprentissage, de test et de validation ; une étape de réglage pour régler nos hyperparamètres et lancer des tâches de formation pour former un modèle à l'aide de Algorithme intégré XGBoost; et enfin une étape de modèle pour créer un modèle SageMaker à partir de l'artefact de modèle le mieux formé. Pipelines propose également plusieurs types d'étapes en dehors de ce qui est discuté dans ce post. Nous illustrons également comment vous pouvez suivre le flux de travail de votre pipeline et générer des métriques et des tableaux de comparaison. De plus, nous montrons comment associer le nouvel essai généré à une expérience existante qui aurait pu être créée avant la définition du pipeline.

Code SageMaker Pipelines

Vous pouvez consulter et télécharger le bloc-notes à partir du GitHub référentiel associé à ce poste. Nous examinons le code spécifique à Pipelines pour mieux le comprendre.

Les pipelines vous permettent de transmettre des paramètres au moment de l'exécution. Ici, nous définissons les types et le nombre d'instances de traitement et de formation au moment de l'exécution avec des valeurs par défaut prédéfinies :

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

Ensuite, nous mettons en place un script de traitement qui télécharge et divise l'ensemble de données d'entrée en parties d'apprentissage, de test et de validation. Nous utilisons SKLearnProcessor pour exécuter cette étape de prétraitement. Pour ce faire, nous définissons un objet processeur avec le type d'instance et le nombre nécessaires pour exécuter la tâche de traitement.

Les pipelines nous permettent de réaliser le versionnage des données de manière programmatique en utilisant des variables spécifiques à l'exécution telles que ExecutionVariables.PIPELINE_EXECUTION_ID, qui est l'ID unique d'une exécution de pipeline. Nous pouvons, par exemple, créer une clé unique pour stocker les jeux de données de sortie dans Service de stockage simple Amazon (Amazon S3) qui les lie à une exécution de pipeline spécifique. Pour la liste complète des variables, reportez-vous à Variables d'exécution.

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

Ensuite, nous passons à la création d'un objet estimateur pour former un modèle XGBoost. Nous définissons quelques hyperparamètres statiques couramment utilisés avec 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
)

Nous effectuons un réglage hyperparamétrique des modèles que nous créons en utilisant un ContinuousParameter gamme pour lambda. Le choix d'une métrique comme métrique objective indique au tuner (l'instance qui exécute les tâches de réglage des hyperparamètres) que vous évaluerez la tâche d'entraînement en fonction de cette métrique spécifique. Le tuner renvoie la meilleure combinaison basée sur la meilleure valeur pour cette métrique objective, c'est-à-dire la meilleure combinaison qui minimise la meilleure erreur quadratique moyenne (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",
        ),
    } 
)

L'étape de réglage exécute plusieurs essais dans le but de déterminer le meilleur modèle parmi les plages de paramètres testées. Avec la méthode get_top_model_s3_uri, nous classons les 50 versions les plus performantes de l'URI S3 de l'artefact de modèle et extrayons uniquement la version la plus performante (nous spécifions k=0 pour le mieux) pour créer un modèle 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"),
)

Lorsque le pipeline s'exécute, il crée des composants d'essai pour chaque tâche de réglage d'hyperparamètres et chaque tâche SageMaker créée par les étapes du pipeline.

Vous pouvez configurer davantage l'intégration des pipelines avec Experiments en créant un PipelineExperimentConfig objet et transmettez-le à l'objet pipeline. Les deux paramètres définissent le nom de l'expérience qui sera créée et l'essai qui fera référence à l'ensemble de l'exécution du pipeline.

Si vous souhaitez associer une exécution de pipeline à une expérience existante, vous pouvez transmettre son nom, et Pipelines y associera la nouvelle épreuve. Vous pouvez empêcher la création d'une expérience et d'un essai pour une exécution de pipeline en définissant pipeline_experiment_config à None.

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

Nous transmettons les types d'instances et les décomptes en tant que paramètres, et enchaînons les étapes précédentes dans l'ordre suivant. Le flux de travail du pipeline est implicitement défini par les sorties d'une étape étant les entrées d'une autre étape.

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

Le pipeline à part entière est maintenant créé et prêt à fonctionner. Nous ajoutons un rôle d'exécution au pipeline et le démarrons. De là, nous pouvons accéder à la console SageMaker Studio Pipelines et suivre visuellement chaque étape. Vous pouvez également accéder aux journaux liés à partir de la console pour déboguer un pipeline.

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

La capture d'écran précédente montre en vert un pipeline exécuté avec succès. Nous obtenons les métriques d'un essai à partir d'une exécution du pipeline avec le code suivant :

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

Comparez les métriques pour chaque composant d'essai

Vous pouvez tracer les résultats du réglage des hyperparamètres dans Studio ou via d'autres bibliothèques de traçage Python. Nous montrons les deux manières de procéder.

Explorer les métriques de formation et d'évaluation dans Studio

Studio fournit une interface utilisateur interactive dans laquelle vous pouvez générer des tracés interactifs. Les étapes sont les suivantes:

1. Selectionnez Expériences et essais du Ressources SageMaker icône dans la barre latérale gauche.
2. Choisissez votre expérience pour l'ouvrir.
3. Choisissez (clic droit) l'essai qui vous intéresse.
4. Selectionnez Ouvrir dans la liste des composants d'essai.
5. Presse Shift pour sélectionner les composants d'essai représentant les tâches d'apprentissage.
6. Selectionnez Ajouter un graphique.
7. Selectionnez Nouveau graphique et personnalisez-le pour tracer les métriques collectées que vous souhaitez analyser. Pour notre cas d'utilisation, choisissez ce qui suit :
   1. Pour Type de donnéessélectionner Statistiques récapitulatives.
   2. Pour Type de graphiquesélectionner Nuage de points.
   3. Pour Axe X, choisissez lambda.
   4. Pour Axe Y, choisissez validation:rmse_last.

Le nouveau graphique apparaît au bas de la fenêtre, étiqueté comme « 8 ».

Vous pouvez inclure plus ou moins de tâches d'entraînement en appuyant sur Shift et en choisissant l'icône de l'œil pour une expérience plus interactive.

Analytique avec SageMaker Experiments

Lorsque l'exécution du pipeline est terminée, nous pouvons rapidement visualiser comment différentes variantes du modèle se comparent en termes de métriques collectées pendant la formation. Auparavant, nous exportions toutes les métriques d'essai vers un Pandas DataFrame en utilisant ExperimentAnalytics. Nous pouvons reproduire le tracé obtenu dans Studio en utilisant la bibliothèque Matplotlib.

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

Conclusion

L'intégration native entre SageMaker Pipelines et SageMaker Experiments permet aux data scientists d'organiser, de suivre et de visualiser automatiquement les expériences pendant les activités de développement de modèles. Vous pouvez créer des expériences pour organiser l'ensemble de votre travail de développement de modèle, par exemple :

• Un cas d'utilisation commerciale auquel vous vous adressez, comme la création d'une expérience pour prédire l'attrition des clients
• Une expérience appartenant à l'équipe de science des données concernant l'analyse marketing, par exemple
• Un projet spécifique data science et ML

Dans cet article, nous avons plongé dans Pipelines pour montrer comment vous pouvez l'utiliser en tandem avec Experiments pour organiser un flux de travail de bout en bout entièrement automatisé.

Dans une prochaine étape, vous pouvez utiliser ces trois fonctionnalités SageMaker - Studio, Experiments et Pipelines - pour votre prochain projet ML.

Lectures suggérées

À propos des auteurs

Paul DiFrancesco est architecte de solutions chez AWS. Il a de l'expérience dans les télécommunications et le génie logiciel. Il est passionné par l'apprentissage automatique et se concentre actuellement sur l'utilisation de son expérience pour aider les clients à atteindre leurs objectifs sur AWS, en particulier dans les discussions autour des MLOps. En dehors du travail, il aime jouer au football et lire.

Mario Bourgoin est un architecte de solutions partenaire principal pour AWS, un spécialiste de l'IA/ML et le responsable technologique mondial pour MLOps. Il travaille avec des entreprises clientes et des partenaires qui déploient des solutions d'IA dans le cloud. Il a plus de 30 ans d'expérience dans l'apprentissage automatique et l'IA dans des startups et des entreprises, en commençant par créer l'un des premiers systèmes commerciaux d'apprentissage automatique pour le Big Data. Mario passe son temps libre à jouer avec ses trois Tervurens belges, à préparer le dîner pour sa famille et à apprendre les mathématiques et la cosmologie.

Ganapathi Krishnamoorthi est architecte senior de solutions ML chez AWS. Ganapathi fournit des conseils normatifs aux startups et aux entreprises clientes en les aidant à concevoir et à déployer des applications cloud à grande échelle. Il est spécialisé dans l'apprentissage automatique et s'attache à aider les clients à tirer parti de l'IA/ML pour leurs résultats commerciaux. Lorsqu'il n'est pas au travail, il aime explorer le plein air et écouter de la musique.

Valérie Sounthakith est un architecte de solutions pour AWS, travaillant dans l'industrie du jeu et avec des partenaires déployant des solutions d'IA. Elle vise à bâtir sa carrière autour de la vision par ordinateur. Pendant son temps libre, Valérie le consacre à voyager, découvrir de nouvelles adresses gourmandes et changer l'intérieur de sa maison.