Amazon SageMaker-Experimente der nächsten Generation – Organisieren, verfolgen und vergleichen Sie Ihre Schulungen zum maschinellen Lernen im großen Maßstab

Heute freuen wir uns, Aktualisierungen unserer anzukündigen Amazon SageMaker-Experimente Fähigkeit von Amazon Sage Maker Damit können Sie Machine Learning (ML)-Experimente und Modellversionen aus jeder integrierten Entwicklungsumgebung (IDE) mit dem SageMaker Python SDK oder boto3, einschließlich lokaler Jupyter-Notebooks, organisieren, verfolgen, vergleichen und bewerten.

Maschinelles Lernen (ML) ist ein iterativer Prozess. Bei der Lösung eines neuen Anwendungsfalls durchlaufen Data Scientists und ML-Ingenieure verschiedene Parameter, um die besten Modellkonfigurationen (auch bekannt als Hyperparameter) zu finden, die in der Produktion verwendet werden können, um die identifizierte geschäftliche Herausforderung zu lösen. Nach dem Experimentieren mit mehreren Modellen und Hyperparametern wird es für ML-Teams im Laufe der Zeit schwierig, Modellläufe effizient zu verwalten, um das optimale Modell zu finden, ohne ein Tool zur Nachverfolgung der verschiedenen Experimente. Experiment-Tracking-Systeme rationalisieren die Prozesse zum Vergleichen verschiedener Iterationen und helfen, die Zusammenarbeit und Kommunikation in einem Team zu vereinfachen, wodurch die Produktivität gesteigert und Zeit gespart wird. Dies wird erreicht, indem ML-Experimente mühelos organisiert und verwaltet werden, um daraus Schlussfolgerungen zu ziehen, z. B. den Trainingslauf mit der besten Genauigkeit zu finden.

Um diese Herausforderung zu lösen, bietet SageMaker SageMaker-Experimente, eine vollständig integrierte SageMaker-Funktion. Es bietet die Flexibilität, Ihre Modellmetriken, Parameter, Dateien, Artefakte zu protokollieren, Diagramme aus den verschiedenen Metriken zu zeichnen, verschiedene Metadaten zu erfassen, sie zu durchsuchen und die Reproduzierbarkeit des Modells zu unterstützen. Data Scientists können die Leistung und Hyperparameter für die Modellbewertung anhand von visuellen Diagrammen und Tabellen schnell vergleichen. Sie können SageMaker-Experimente auch verwenden, um die erstellten Diagramme herunterzuladen und die Modellbewertung mit ihren Stakeholdern zu teilen.

Mit den neuen Updates für SageMaker-Experimente ist es jetzt Teil des SageMaker-SDK, was die Arbeit des Datenwissenschaftlers vereinfacht und die Installation einer zusätzlichen Bibliothek zur Verwaltung mehrerer Modellausführungen überflüssig macht. Wir führen die folgenden neuen Kernkonzepte ein:

• Experiment: Eine Sammlung von Läufen, die gruppiert sind. Ein Experiment umfasst Ausführungen für mehrere Typen, die mit dem SageMaker Python SDK von überall initiiert werden können.
• Führen Sie: Jeder Ausführungsschritt eines Modelltrainingsprozesses. Ein Lauf besteht aus allen Eingaben, Parametern, Konfigurationen und Ergebnissen für eine Iteration des Modelltrainings. Benutzerdefinierte Parameter und Metriken können mit protokolliert werden log_parameter, log_parameters und log_metric Funktionen. Benutzerdefinierte Ein- und Ausgaben können mit protokolliert werden log_file Funktion.

Die Konzepte, die im Rahmen von a Run -Klasse werden von jeder IDE zur Verfügung gestellt, in der das SageMaker Python SDK installiert ist. Für SageMaker-Schulung, Verarbeitung und

Transformationsjobs wird der SageMaker-Experimentlauf automatisch an den Job übergeben, wenn der Job in einem Ausführungskontext aufgerufen wird. Sie können das ausgeführte Objekt mit wiederherstellen load_run() von deiner Arbeit. Schließlich können Data Scientists mit der Integration der neuen Funktionalitäten auch automatisch eine Konfusionsmatrix, Präzisions- und Recall-Graphen sowie eine ROC-Kurve für Anwendungsfälle der Klassifizierung protokollieren run.log_confusion_matrix, run.log_precision_recall und run.log_roc_curve Funktionen bzw.

In diesem Blogbeitrag stellen wir Beispiele für die Verwendung der neuen Funktionen von SageMaker Experiments in einem Jupyter-Notebook über das SageMaker SDK bereit. Wir demonstrieren diese Fähigkeiten mit a PyTorch Beispiel zum Trainieren eines MNIST-Klassifikationsbeispiels für handgeschriebene Ziffern. Der Versuch wird wie folgt organisiert:

1. Erstellen von Testläufen und Protokollierungsparametern: Wir erstellen zunächst ein neues Experiment, starten einen neuen Lauf für dieses Experiment und protokollieren Parameter dazu.
2. Protokollierungsmodellleistungsmetriken:Wir werden Modellleistungsmetriken protokollieren und Metrikdiagramme zeichnen.
3. Modellläufe vergleichen:Wir werden verschiedene Modellläufe anhand der Modellhyperparameter vergleichen. Wir werden besprechen, wie man diese Läufe vergleicht und wie man SageMaker-Experimente verwendet, um das beste Modell auszuwählen.
4. Ausführen von Experimenten aus SageMaker-Jobs: Wir stellen auch ein Beispiel bereit, wie Sie den Kontext Ihres Experiments automatisch mit einem SageMaker-Verarbeitungs-, Trainings- oder Batch-Transformationsjob teilen können. Auf diese Weise können Sie Ihren Ausführungskontext automatisch mit dem wiederherstellen load_run Funktion in Ihrem Job.
5. Integrieren von SageMaker Clarify-Berichten: Wir werden zeigen, wie wir jetzt integrieren können SageMaker klären Bias- und Erklärbarkeitsberichte in einer einzigen Ansicht mit Ihrem trainierten Modellbericht.

Voraussetzungen:

Für diesen Blogbeitrag werden wir verwenden Amazon SageMaker-Studio um zu zeigen, wie Metriken aus einem Studio-Notebook mit den aktualisierten Funktionen von SageMaker Experiments protokolliert werden. Um die in unserem Beispiel vorgestellten Befehle auszuführen, benötigen Sie folgende Voraussetzungen:

• SageMaker Studio-Domäne
• SageMaker Studio-Benutzerprofil mit SageMaker-Vollzugriff
• Ein SageMaker Studio-Notebook mit mindestens einer ml.t3.medium Instanztyp

Wenn Sie keine SageMaker-Domäne und kein Benutzerprofil zur Verfügung haben, können Sie eines mit diesem erstellen Kurzanleitung zur Einrichtung.

Protokollierungsparameter

Für diese Übung verwenden wir Fackelvision, ein PyTorch-Paket, das beliebte Datasets, Modellarchitekturen und gängige Bildtransformationen für Computer Vision bereitstellt. SageMaker Studio bietet eine Reihe von Docker-Bilder für gängige Data-Science-Anwendungsfälle, die in Amazon ECR verfügbar gemacht werden. Für PyTorch haben Sie die Möglichkeit, Bilder auszuwählen, die für CPU- oder GPU-Training optimiert sind. Für dieses Beispiel wählen wir das Bild aus PyTorch 1.12 Python 3.8 CPU Optimized und für Python 3 Kernel. Die unten beschriebenen Beispiele konzentrieren sich auf die Funktionalitäten von SageMaker Experiments und sind kein vollständiger Code.

Lassen Sie uns die Daten mit herunterladen torchvision Packen und verfolgen Sie die Anzahl der Datenbeispiele für die Zug- und Testdatensätze als Parameter mit SageMaker-Experimenten. Nehmen wir für dieses Beispiel an train_set und test_set wie bereits heruntergeladen torchvision Datensätze.

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)

In diesem Beispiel verwenden wir die run.log_parameters um die Anzahl der Zug- und Testdatenproben zu protokollieren und run.log_file um die Rohdatensätze auf Amazon S3 hochzuladen und sie als Eingaben für unser Experiment zu protokollieren.

Trainieren eines Modells und Protokollieren von Modellmetriken

Nachdem wir nun unseren MNIST-Datensatz heruntergeladen haben, trainieren wir a CNN-Modell um die Ziffern zu erkennen. Während wir das Modell trainieren, möchten wir unseren vorhandenen Experimentlauf laden, neue Parameter darin protokollieren und die Modellleistung durch Protokollieren von Modellmetriken verfolgen.

Wir können das benutzen load_run Funktion, um unseren vorherigen Lauf zu laden und damit unser Modelltraining zu protokollieren

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

Wir können dann verwenden run.log_parameter und run.log_parameters um einen oder mehrere Modellparameter in unserem Lauf zu protokollieren.

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

Und wir können verwenden run.log_metric um Leistungsmetriken für unser Experiment zu protokollieren.

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

Für Klassifizierungsmodelle können Sie auch verwenden run.log_confusion_matrix, run.log_precision_recall und run.log_roc_curve, um die Konfusionsmatrix, das Präzisions-Erinnerungsdiagramm und die ROC-Kurve Ihres Modells automatisch zu zeichnen. Da unser Modell ein Mehrklassen-Klassifikationsproblem löst, protokollieren wir nur die Konfusionsmatrix dafür.

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

Wenn wir uns unsere Laufdetails ansehen, können wir jetzt die generierten Metriken sehen, wie im folgenden Screenshot gezeigt:

Die Seite mit den Ausführungsdetails enthält weitere Informationen zu den Metriken.

Und die neuen Modellparameter werden auf der Parameterübersichtsseite verfolgt.

Sie können Ihre Modellleistung auch nach Klasse analysieren, indem Sie die automatisch gezeichnete Konfusionsmatrix verwenden, die auch heruntergeladen und für verschiedene Berichte verwendet werden kann. Und Sie können zusätzliche Diagramme zeichnen, um die Leistung Ihres Modells basierend auf den protokollierten Metriken zu analysieren.

Vergleich mehrerer Modellparameter

Als Data Scientist möchten Sie das bestmögliche Modell finden. Dazu gehört das mehrmalige Trainieren eines Modells mit unterschiedlichen Hyperparametern und das Vergleichen der Leistung des Modells mit diesen Hyperparametern. Dazu können wir mit SageMaker Experiments mehrere Läufe im selben Experiment erstellen. Lassen Sie uns dieses Konzept untersuchen, indem wir unser Modell mit verschiedenen trainieren num_hidden_channels und 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
            )

Wir erstellen jetzt sechs neue Läufe für unser Experiment. Jeder protokolliert die Modellparameter, Metriken und die Konfusionsmatrix. Wir können dann die Läufe vergleichen, um das leistungsstärkste Modell für das Problem auszuwählen. Bei der Analyse der Läufe können wir die Metrikdiagramme für die verschiedenen Läufe als ein einziges Diagramm darstellen und die Leistung der Läufe über die verschiedenen Trainingsschritte (oder Epochen) hinweg vergleichen.

Verwenden von SageMaker-Experimenten mit SageMaker-Trainings-, -Verarbeitungs- und -Batch-Transformationsaufträgen

Im obigen Beispiel haben wir SageMaker-Experimente verwendet, um die Modellleistung von einem SageMaker Studio-Notebook zu protokollieren, in dem das Modell lokal im Notebook trainiert wurde. Wir können dasselbe tun, um die Modellleistung von SageMaker-Verarbeitungs-, Trainings- und Batch-Transformationsaufträgen zu protokollieren. Mit den neuen Funktionen zur automatischen Kontextübergabe müssen wir die Experimentkonfiguration nicht speziell mit dem SageMaker-Job teilen, da sie automatisch erfasst wird.

Das folgende Beispiel konzentriert sich auf die Funktionalitäten von SageMaker Experiments und ist kein vollständiger Code.

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

In unserer Modellskriptdatei können wir den Ausführungskontext mit abrufen load_run(). In SageMaker-Verarbeitungs- und Trainingsjobs müssen wir die Experimentkonfiguration nicht zum Laden der Konfiguration bereitstellen. Für Batch-Transformationsaufträge müssen wir bereitstellen experiment_name und run_name um die Konfiguration des Experiments zu laden.

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

Zusätzlich zu den Informationen, die wir erhalten, wenn wir SageMaker-Experimente über ein Notebook-Skript ausführen, füllt die Ausführung eines SageMaker-Jobs automatisch die Jobparameter und -ausgaben.

Das neue SageMaker Experiments SDK stellt außerdem die Abwärtskompatibilität mit der vorherigen Version sicher, indem es die Konzepte von Testversionen und Testkomponenten verwendet. Jedes Experiment, das mit der vorherigen Version von SageMaker Experiments ausgelöst wurde, wird automatisch in der neuen Benutzeroberfläche zur Analyse der Experimente verfügbar gemacht.

Integration von SageMaker Clarify und Modelltrainingsberichten

SageMaker Clarify hilft bei der Verbesserung unserer ML-Modelle durch Erkennung mögliche Verzerrung und helfen erklären wie diese Modelle Vorhersagen treffen. Clarify stellt vorgefertigte Container bereit, die als SageMaker-Verarbeitungsaufträge ausgeführt werden, nachdem Ihr Modell trainiert wurde, wobei Informationen über Ihre Daten (Datenkonfiguration), Ihr Modell (Modellkonfiguration) und die sensiblen Datenspalten verwendet werden, die wir auf mögliche Verzerrungen (Bias Aufbau). Bisher zeigten SageMaker-Experimente unsere Modelltrainings- und Clarify-Berichte als einzelne Testkomponenten an, die über einen Test miteinander verbunden waren.

Mit den neuen SageMaker-Experimenten können wir auch SageMaker Clarify-Berichte in unser Modelltraining integrieren, um eine einzige Quelle der Wahrheit zu haben, die es uns ermöglicht, unser Modell besser zu verstehen. Für einen integrierten Bericht müssen wir lediglich denselben Laufnamen für unsere Schulungs- und Klärungsjobs verwenden. Das folgende Beispiel zeigt, wie wir die Berichte mit einer integrieren können XGBoost-Modell um das Einkommen von Erwachsenen in den Vereinigten Staaten vorherzusagen. Das Modell verwendet die UCI-Datensatz für Erwachsene. Für diese Übung gehen wir davon aus, dass das Modell bereits trainiert wurde und dass wir die Daten-, Modell- und Bias-Konfigurationen bereits berechnet haben.

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

Mit diesem Setup erhalten wir eine kombinierte Ansicht, die die Modellmetriken, gemeinsame Eingaben und Ausgaben sowie die Clarify-Berichte für statistische Verzerrungen und Erklärbarkeit des Modells enthält.

Zusammenfassung

In diesem Beitrag haben wir die neue Generation von SageMaker-Experimenten untersucht, die ein integrierter Bestandteil des SageMaker SDK sind. Wir haben gezeigt, wie Sie Ihre ML-Workflows mit der neuen Run-Klasse von überall aus protokollieren können. Wir haben die neue Benutzeroberfläche „Experimente“ vorgestellt, mit der Sie Ihre Experimente verfolgen und Diagramme für eine einzelne Laufmetrik zeichnen sowie mehrere Läufe mit der neuen Analysefunktion vergleichen können. Wir haben Beispiele für Protokollierungsexperimente aus einem SageMaker Studio-Notebook und aus einem SageMaker Studio-Schulungsjob bereitgestellt. Schließlich haben wir gezeigt, wie Sie Modelltraining und SageMaker Clarify-Berichte in einer einheitlichen Ansicht integrieren, sodass Sie Ihr Modell besser verstehen können.

Wir empfehlen Ihnen, die neuen Experiments-Funktionen auszuprobieren und sich mit dem zu verbinden Community für maschinelles Lernen und KI Wenn Sie Fragen oder Feedback haben!

Über die Autoren

Maira Ladeira Tanke ist Machine Learning Specialist bei AWS. Mit einem Hintergrund in Data Science verfügt sie über 9 Jahre Erfahrung in der Architektur und Erstellung von ML-Anwendungen mit Kunden aus allen Branchen. Als technische Leiterin hilft sie Kunden dabei, ihre geschäftliche Wertschöpfung durch neue Technologien und innovative Lösungen zu beschleunigen. In ihrer Freizeit reist Maira gerne und verbringt Zeit mit ihrer Familie an einem warmen Ort.

Mani Chanuja ist ein Artificial Intelligence and Machine Learning Specialist SA bei Amazon Web Services (AWS). Sie hilft Kunden, die maschinelles Lernen einsetzen, um ihre geschäftlichen Herausforderungen mit AWS zu lösen. Sie verbringt die meiste Zeit damit, tief einzutauchen und Kunden in KI/ML-Projekten im Zusammenhang mit Computer Vision, Verarbeitung natürlicher Sprache, Prognosen, ML am Rande und mehr zu unterrichten. Sie ist begeistert von ML at Edge, daher hat sie ihr eigenes Labor mit einem selbstfahrenden Kit und einer Produktionslinie für die Herstellung von Prototypen eingerichtet, wo sie viel Freizeit verbringt.

Dewen Qi ist Softwareentwicklungsingenieur bei AWS. Derzeit beteiligt sie sich am Aufbau einer Sammlung von Plattformdiensten und Tools in AWS SageMaker, um Kunden dabei zu helfen, ihre ML-Projekte erfolgreich zu machen. Sie setzt sich auch leidenschaftlich dafür ein, das Konzept von MLOps einem breiteren Publikum zugänglich zu machen. Außerhalb der Arbeit übt Dewen gerne Cello.

Abhishek Agarwal ist Senior Product Manager für Amazon SageMaker. Er arbeitet leidenschaftlich gerne mit Kunden zusammen und macht maschinelles Lernen zugänglicher. In seiner Freizeit malt Abhishek gerne, fährt Rad und lernt innovative Technologien kennen.

Dan Benson ist ein Software Engineer, der im Amazon SageMaker-Team für Experimente, Herkunft und Suche arbeitet. Bevor sie zu AWS kam, verbrachte Dana Zeit damit, Smart-Home-Funktionen in Alexa zu aktivieren und mobile Bestellungen bei Starbucks zu tätigen.