Expériences Amazon SageMaker de nouvelle génération – Organisez, suivez et comparez vos formations de machine learning à grande échelle

Aujourd'hui, nous sommes heureux d'annoncer les mises à jour de notre Expériences Amazon SageMaker capacité de Amazon Sage Maker qui vous permet d'organiser, de suivre, de comparer et d'évaluer des expériences d'apprentissage automatique (ML) et des versions de modèles à partir de n'importe quel environnement de développement intégré (IDE) à l'aide du SDK Python SageMaker ou de boto3, y compris les blocs-notes Jupyter locaux.

L'apprentissage automatique (ML) est un processus itératif. Lors de la résolution d'un nouveau cas d'utilisation, les scientifiques des données et les ingénieurs ML parcourent divers paramètres pour trouver les meilleures configurations de modèle (c'est-à-dire les hyperparamètres) pouvant être utilisées en production pour résoudre le défi commercial identifié. Au fil du temps, après avoir expérimenté plusieurs modèles et hyperparamètres, il devient difficile pour les équipes ML de gérer efficacement les exécutions de modèles pour trouver le modèle optimal sans outil pour suivre les différentes expériences. Les systèmes de suivi des expériences rationalisent les processus pour comparer différentes itérations et aident à simplifier la collaboration et la communication au sein d'une équipe, augmentant ainsi la productivité et permettant de gagner du temps. Ceci est réalisé en organisant et en gérant les expériences ML de manière simple pour en tirer des conclusions, par exemple, en trouvant la course d'entraînement avec la meilleure précision.

Pour résoudre ce défi, SageMaker fournit SageMaker Experiments, une fonctionnalité SageMaker entièrement intégrée. Il offre la possibilité de consigner les métriques, paramètres, fichiers, artefacts de votre modèle, de tracer des graphiques à partir des différentes métriques, de capturer diverses métadonnées, de les parcourir et de prendre en charge la reproductibilité du modèle. Les scientifiques des données peuvent comparer rapidement les performances et les hyperparamètres pour l'évaluation du modèle via des graphiques et des tableaux visuels. Ils peuvent également utiliser SageMaker Experiments pour télécharger les graphiques créés et partager l'évaluation du modèle avec leurs parties prenantes.

Avec les nouvelles mises à jour de SageMaker Experiments, il fait désormais partie du SDK SageMaker, simplifiant le travail des data scientists et éliminant le besoin d'installer une bibliothèque supplémentaire pour gérer plusieurs exécutions de modèles. Nous introduisons les nouveaux concepts de base suivants :

• Expérience: une collection d'exécutions qui sont regroupées. Une expérience comprend des exécutions pour plusieurs types qui peuvent être lancées de n'importe où à l'aide du SDK SageMaker Python.
• Courir: Chaque étape d'exécution d'un processus de formation de modèle. Une exécution se compose de toutes les entrées, paramètres, configurations et résultats pour une itération de la formation du modèle. Les paramètres et métriques personnalisés peuvent être enregistrés à l'aide du log_parameter, log_parameterset log_metric les fonctions. L'entrée et la sortie personnalisées peuvent être enregistrées à l'aide du log_file la fonction.

Les concepts mis en œuvre dans le cadre d'un Run sont disponibles à partir de n'importe quel IDE sur lequel le SDK Python SageMaker est installé. Pour la formation SageMaker, le traitement et

Transform Jobs, l'exécution expérimentale de SageMaker est automatiquement transmise au travail si celui-ci est appelé dans un contexte d'exécution. Vous pouvez récupérer l'objet d'exécution à l'aide de load_run() de votre travail. Enfin, avec l'intégration des nouvelles fonctionnalités, les scientifiques des données peuvent également enregistrer automatiquement une matrice de confusion, des graphiques de précision et de rappel, et une courbe ROC pour les cas d'utilisation de classification en utilisant le run.log_confusion_matrix, run.log_precision_recallet run.log_roc_curve fonctions, respectivement.

Dans cet article de blog, nous fournirons des exemples d'utilisation des nouvelles fonctionnalités SageMaker Experiments dans un notebook Jupyter via le SDK SageMaker. Nous démontrerons ces capacités à l'aide d'un PyTorch exemple pour former un exemple de classification de chiffres manuscrits MNIST. L'expérimentation sera organisée comme suit :

1. Création des exécutions de l'expérience et des paramètres de journalisation : Nous allons d'abord créer une nouvelle expérience, démarrer une nouvelle exécution pour cette expérience et y enregistrer des paramètres.
2. Métriques de performances du modèle de journalisation: Nous enregistrerons les métriques de performance du modèle et tracerons des graphiques de métriques.
3. Comparaison des exécutions de modèles: Nous comparerons différentes exécutions du modèle en fonction des hyperparamètres du modèle. Nous verrons comment comparer ces exécutions et comment utiliser SageMaker Experiments pour sélectionner le meilleur modèle.
4. Exécution d'expériences à partir de tâches SageMaker: Nous fournirons également un exemple de partage automatique du contexte de votre expérience avec une tâche de traitement, d'entraînement ou de transformation par lots SageMaker. Cela vous permet de récupérer automatiquement votre contexte d'exécution avec le load_run fonction à l'intérieur de votre travail.
5. Intégration des rapports SageMaker Clarify: Nous montrerons comment nous pouvons maintenant intégrer SageMaker Clarifier rapports sur les biais et l'explicabilité dans une seule vue avec votre rapport de modèle entraîné.

Pré-requis

Pour cet article de blog, nous utiliserons Amazon SageMakerStudio pour montrer comment consigner des métriques à partir d'un bloc-notes Studio à l'aide des fonctionnalités SageMaker Experiments mises à jour. Pour exécuter les commandes présentées dans notre exemple, vous avez besoin des prérequis suivants :

• Domaine SageMaker Studio
• Profil utilisateur SageMaker Studio avec accès complet à SageMaker
• Un bloc-notes SageMaker Studio avec au moins un ml.t3.medium type d'instance

Si vous ne disposez pas d'un domaine SageMaker et d'un profil utilisateur, vous pouvez en créer un à l'aide de cette guide d'installation rapide.

Paramètres de journalisation

Pour cet exercice, nous utiliserons vision aux flambeaux, un package PyTorch qui fournit des ensembles de données, des architectures de modèles et des transformations d'images courantes pour la vision par ordinateur. SageMaker Studio fournit un ensemble de Images Docker pour les cas d'utilisation courants de la science des données qui sont mis à disposition dans Amazon ECR. Pour PyTorch, vous avez la possibilité de sélectionner des images optimisées pour la formation CPU ou GPU. Pour cet exemple, nous allons sélectionner l'image PyTorch 1.12 Python 3.8 CPU Optimized et par Python 3 noyau. Les exemples décrits ci-dessous se concentreront sur les fonctionnalités de SageMaker Experiments et ne sont pas complets.

Téléchargeons les données avec le torchvision empaquetez et suivez le nombre d'échantillons de données pour les ensembles de données d'entraînement et de test en tant que paramètres avec SageMaker Experiments. Pour cet exemple, supposons train_set ainsi que test_set comme déjà téléchargé torchvision jeux de données.

from sagemaker.session import Session
from sagemaker.experiments.run import Run
import os

# create an experiment and start a new run
experiment_name = "local-experiment-example"
run_name = "experiment-run"

with Run(experiment_name=experiment_name, sagemaker_session=Session(), run_name=run_name) as run:
    run.log_parameters({
        "num_train_samples": len(train_set.data),
        "num_test_samples": len(test_set.data)
    })
    for f in os.listdir(train_set.raw_folder):
        print("Logging", train_set.raw_folder+"/"+f)
        run.log_file(train_set.raw_folder+"/"+f, name=f, is_output=False)

Dans cet exemple, nous utilisons le run.log_parameters pour enregistrer le nombre d'échantillons de données d'entraînement et de test et run.log_file pour télécharger les ensembles de données brutes sur Amazon S3 et les enregistrer en tant qu'entrées de notre expérience.

Entraînement d'un modèle et journalisation des métriques du modèle

Maintenant que nous avons téléchargé notre ensemble de données MNIST, formons un Modèle CNN reconnaître les chiffres. Lors de la formation du modèle, nous souhaitons charger notre exécution d'expérience existante, y enregistrer de nouveaux paramètres et suivre les performances du modèle en enregistrant les métriques du modèle.

Nous pouvons utiliser le load_run fonction pour charger notre exécution précédente et l'utiliser pour enregistrer notre formation de modèle

with load_run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=Session()) as run:
    train_model(
        run=run,
        train_set=train_set,
        test_set=test_set,
        epochs=10,
        hidden_channels=5,
        optimizer="adam"
    )

On peut alors utiliser run.log_parameter ainsi que run.log_parameters pour enregistrer un ou plusieurs paramètres de modèle dans notre exécution.

# log the parameters of your model
run.log_parameter("device", "cpu")
run.log_parameters({
    "data_dir": data_dir,
    "optimizer": optimizer,
    "epochs": epochs,
    "hidden_channels": hidden_channels
})

Et nous pouvons utiliser run.log_metric pour consigner les mesures de performance dans notre expérience.

run.log_metric(name=metric_type+":loss", value=loss, step=epoch)
run.log_metric(name=metric_type+":accuracy", value=accuracy, step=epoch)

Pour les modèles de classification, vous pouvez également utiliser run.log_confusion_matrix, run.log_precision_recallet run.log_roc_curve, pour tracer automatiquement la matrice de confusion, le graphique de rappel de précision et la courbe ROC de votre modèle. Puisque notre modèle résout un problème de classification multiclasse, enregistrons uniquement la matrice de confusion pour celui-ci.

# log confusion matrix
with torch.no_grad():
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.max(1, keepdim=True)[1] 
        run.log_confusion_matrix(target, pred, "Confusion-Matrix-Test-Data")

Lorsque nous examinons les détails de notre exécution, nous pouvons maintenant voir les métriques générées, comme indiqué dans la capture d'écran ci-dessous :

La page des détails de l'exécution fournit des informations supplémentaires sur les métriques.

Et les nouveaux paramètres du modèle sont suivis sur la page de présentation des paramètres.

Vous pouvez également analyser les performances de votre modèle par classe à l'aide de la matrice de confusion tracée automatiquement, qui peut également être téléchargée et utilisée pour différents rapports. Et vous pouvez tracer des graphiques supplémentaires pour analyser les performances de votre modèle en fonction des métriques enregistrées.

Comparaison de plusieurs paramètres de modèle

En tant que data scientist, vous souhaitez trouver le meilleur modèle possible. Cela inclut la formation d'un modèle plusieurs fois avec différents hyperparamètres et la comparaison des performances du modèle avec ces hyperparamètres. Pour ce faire, SageMaker Experiments nous permet de créer plusieurs exécutions dans la même expérience. Explorons ce concept en entraînant notre modèle avec différents num_hidden_channels ainsi que optimizers.

# define the list of parameters to train the model with
num_hidden_channel_param = [5, 10, 20]
optimizer_param = ["adam", "sgd"]
run_id = 0
# train the model using SageMaker Experiments to track the model parameters, 
# metrics and performance
sm_session = Session()
for i, num_hidden_channel in enumerate(num_hidden_channel_param):
    for k, optimizer in enumerate(optimizer_param):
        run_id += 1
        run_name = "experiment-run-"+str(run_id)
        print(run_name)
        print(f"Training model with: {num_hidden_channel} hidden channels and {optimizer} as optimizer")
        # Defining an experiment run for each model training run
        with Run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=sm_session) as run:
            train_model(
                run=run, 
                train_set=train_set,
                test_set=test_set,
                epochs=10, 
                hidden_channels=num_hidden_channel,
                optimizer=optimizer
            )

Nous créons maintenant six nouvelles séries pour notre expérience. Chacun enregistrera les paramètres du modèle, les métriques et la matrice de confusion. Nous pouvons ensuite comparer les exécutions pour sélectionner le modèle le plus performant pour le problème. Lors de l'analyse des exécutions, nous pouvons tracer les graphiques métriques pour les différentes exécutions sous la forme d'un seul tracé, en comparant les performances des exécutions à travers les différentes étapes d'entraînement (ou époques).

Utilisation des expériences SageMaker avec les tâches de formation, de traitement et de transformation par lots SageMaker

Dans l'exemple ci-dessus, nous avons utilisé SageMaker Experiments pour enregistrer les performances du modèle à partir d'un bloc-notes SageMaker Studio où le modèle a été formé localement dans le bloc-notes. Nous pouvons faire de même pour consigner les performances du modèle à partir des tâches de traitement, de formation et de transformation par lots de SageMaker. Avec les nouvelles fonctionnalités de passage automatique de contexte, nous n'avons pas besoin de partager spécifiquement la configuration de l'expérience avec le travail SageMaker, car elle sera automatiquement capturée.

L'exemple ci-dessous se concentrera sur les fonctionnalités de SageMaker Experiments et n'est pas complet.

from sagemaker.pytorch import PyTorch
from sagemaker.experiments.run import Run
from sagemaker.session import Session
from sagemaker import get_execution_role
role = get_execution_role()

# set new experiment configuration
exp_name = "training-job-experiment-example"
run_name = "experiment-run-example"

# Start training job with experiment setting
with Run(experiment_name=exp_name, run_name=run_name, sagemaker_session=Session()) as run:
    est = PyTorch(
        entry_point="",
        dependencies=[""],
        role=role,
        model_dir=False,
        framework_version="1.12",
        py_version="py38",
        instance_type='ml.c5.xlarge',
        instance_count=1,
            hyperparameters={
            "epochs": 10,
            "hidden_channels":5,
            "optimizer": "adam",
        },
        keep_alive_period_in_seconds=3600
    )
    
    est.fit()

Dans notre fichier de script de modèle, nous pouvons obtenir le contexte d'exécution en utilisant load_run(). Dans les tâches de traitement et de formation SageMaker, nous n'avons pas besoin de fournir la configuration d'expérience pour charger la configuration. Pour les tâches de transformation par lots, nous devons fournir experiment_name ainsi que run_name pour charger la configuration de l'expérience.

with load_run() as run:
    run.log_parameters({...})
    train_model(run, ...)

En plus des informations que nous obtenons lors de l'exécution des expériences SageMaker à partir d'un script de bloc-notes, l'exécution à partir d'un travail SageMaker remplira automatiquement les paramètres et les sorties du travail.

Le nouveau SDK SageMaker Experiments assure également la rétrocompatibilité avec la version précédente en utilisant les concepts d'essais et de composants d'essai. Toute expérience déclenchée à l'aide de la version précédente de SageMaker Experiments sera automatiquement mise à disposition dans la nouvelle interface utilisateur, pour l'analyse des expériences.

Intégration de SageMaker Clarify et modèles de rapports de formation

SageMaker Clarify aide à améliorer nos modèles ML en détectant biais potentiel et aider expliquer comment ces modèles font des prédictions. Clarify fournit des conteneurs prédéfinis qui s'exécutent en tant que tâches de traitement SageMaker après la formation de votre modèle, en utilisant des informations sur vos données (configuration des données), votre modèle (configuration du modèle) et les colonnes de données sensibles que nous souhaitons analyser pour détecter d'éventuels biais (biais configuration). Jusqu'à présent, SageMaker Experiments affichait nos rapports de formation de modèle et Clarify en tant que composants d'essai individuels connectés via un essai.

Avec les nouvelles expériences SageMaker, nous pouvons également intégrer les rapports SageMaker Clarify à notre formation de modèle ayant une source de vérité qui nous permet de mieux comprendre notre modèle. Pour un rapport intégré, tout ce que nous devons faire est d'avoir le même nom d'exécution pour nos tâches de formation et de clarification. L'exemple suivant montre comment nous pouvons intégrer les rapports à l'aide d'un Modèle XGBoost pour prédire le revenu des adultes à travers les États-Unis. Le modèle utilise le Ensemble de données UCI pour adultes. Pour cet exercice, nous supposons que le modèle a déjà été formé et que nous avons déjà calculé les configurations de données, de modèle et de biais.

with Run(
    experiment_name='clarify-experiment',
    run_name="joint-run",
    sagemaker_session=sagemaker_session,
) as run:
    xgb.fit({"train": train_input}, logs=False)
    clarify_processor.run_bias(
        data_config=bias_data_config,
        bias_config=bias_config,
        model_config=model_config,
        model_predicted_label_config=predictions_config,
        pre_training_methods="all",
        post_training_methods="all",
    )
    clarify_processor.run_explainability(
        data_config=explainability_data_config,
        model_config=model_config,
        explainability_config=shap_config,
    )

Avec cette configuration, nous obtenons une vue combinée qui inclut les métriques du modèle, les entrées et les sorties conjointes, et les rapports Clarify pour le biais statistique et l'explicabilité du modèle.

Conclusion

Dans cet article, nous avons exploré la nouvelle génération d'expériences SageMaker, une partie intégrée du SDK SageMaker. Nous avons montré comment enregistrer vos flux de travail ML de n'importe où avec la nouvelle classe Run. Nous avons présenté la nouvelle interface utilisateur des expériences qui vous permet de suivre vos expériences et de tracer des graphiques pour une seule métrique d'exécution, ainsi que de comparer plusieurs exécutions avec la nouvelle capacité d'analyse. Nous avons fourni des exemples d'expériences de journalisation à partir d'un bloc-notes SageMaker Studio et d'une tâche de formation SageMaker Studio. Enfin, nous avons montré comment intégrer la formation de modèle et les rapports SageMaker Clarify dans une vue unifiée, vous permettant de mieux comprendre votre modèle.

Nous vous encourageons à essayer les nouvelles fonctionnalités des expériences et à vous connecter avec le Communauté d'apprentissage automatique et d'IA si vous avez des questions ou des commentaires!

À propos des auteurs

Maira Ladeira Tanké est un spécialiste de l'apprentissage automatique chez AWS. Avec une formation en science des données, elle a 9 ans d'expérience dans l'architecture et la création d'applications ML avec des clients de tous les secteurs. En tant que responsable technique, elle aide les clients à accélérer la réalisation de leur valeur commerciale grâce aux technologies émergentes et aux solutions innovantes. Dans ses temps libres, Maira aime voyager et passer du temps avec sa famille dans un endroit chaleureux.

Mani Khanouja est un spécialiste de l'intelligence artificielle et de l'apprentissage automatique SA chez Amazon Web Services (AWS). Elle aide les clients utilisant l'apprentissage automatique à résoudre leurs défis commerciaux à l'aide d'AWS. Elle passe la plupart de son temps à approfondir et à enseigner aux clients des projets d'IA/ML liés à la vision par ordinateur, au traitement du langage naturel, aux prévisions, au ML à la périphérie, etc. Elle est passionnée par le ML à la pointe, c'est pourquoi elle a créé son propre laboratoire avec un kit d'auto-conduite et une ligne de production de fabrication de prototypes, où elle passe beaucoup de son temps libre.

Dewen Qi est ingénieur en développement logiciel chez AWS. Elle participe actuellement à la création d'une collection de services et d'outils de plate-forme dans AWS SageMaker pour aider les clients à réussir leurs projets ML. Elle est également passionnée par l'idée d'apporter le concept de MLOps à un public plus large. En dehors du travail, Dewen aime pratiquer le violoncelle.

Abishek Agarwal est chef de produit senior pour Amazon SageMaker. Il est passionné par le travail avec les clients et rend l'apprentissage automatique plus accessible. Dans ses temps libres, Abhishek aime peindre, faire du vélo et apprendre des technologies innovantes.

Dana Benson est un ingénieur logiciel travaillant dans l'équipe d'expériences, de lignage et de recherche d'Amazon SageMaker. Avant de rejoindre AWS, Dana a passé du temps à activer la fonctionnalité de maison intelligente dans Alexa et la commande mobile chez Starbucks.