Organisieren Sie Ihre Reise zum maschinellen Lernen mit Amazon SageMaker-Experimenten und Amazon SageMaker-Pipelines

Der Prozess zum Erstellen eines Modells für maschinelles Lernen (ML) ist iterativ, bis Sie das Kandidatenmodell gefunden haben, das gut funktioniert und bereitgestellt werden kann. Während Data Scientists diesen Prozess durchlaufen, benötigen sie eine zuverlässige Methode, um Experimente einfach nachzuverfolgen und zu verstehen, wie jede Modellversion erstellt wurde und wie sie funktioniert.

Amazon Sage Maker ermöglicht es Teams, eine breite Palette von Funktionen zu nutzen, um ML-Modelle schnell vorzubereiten, zu erstellen, zu trainieren, bereitzustellen und zu überwachen. Amazon SageMaker-Pipelines bietet einen wiederholbaren Prozess zum Durchlaufen von Modellerstellungsaktivitäten und ist in integriert Amazon SageMaker-Experimente. Standardmäßig ist jede SageMaker-Pipeline einem Experiment zugeordnet, und jede Ausführung dieser Pipeline wird in diesem Experiment als Testversion nachverfolgt. Dann werden Ihre Iterationen automatisch ohne zusätzliche Schritte verfolgt.

In diesem Beitrag werfen wir einen genaueren Blick auf die Motivation hinter einem automatisierten Prozess zum Verfolgen von Experimenten mit Experimenten und den in Pipelines integrierten nativen Funktionen.

Warum ist es wichtig, Ihre Experimente organisiert zu halten?

Lassen Sie uns für einen Moment einen Schritt zurücktreten und versuchen zu verstehen, warum es wichtig ist, Experimente für maschinelles Lernen zu organisieren. Wenn Datenwissenschaftler sich einem neuen ML-Problem nähern, müssen sie viele verschiedene Fragen beantworten, von der Datenverfügbarkeit bis hin zur Messung der Modellleistung.

Zu Beginn ist der Prozess voller Unsicherheiten und stark iterativ. Infolgedessen kann diese Experimentierphase mehrere Modelle produzieren, die jeweils aus ihren eigenen Eingaben (Datensätze, Trainingsskripts und Hyperparameter) und eigenen Ausgaben (Modellartefakte und Bewertungsmetriken) erstellt werden. Die Herausforderung besteht dann darin, all diese Eingaben und Ausgaben jeder Iteration im Auge zu behalten.

Data Scientists trainieren in der Regel viele verschiedene Modellversionen, bis sie die Kombination aus Datentransformation, Algorithmus und Hyperparametern gefunden haben, die zur leistungsstärksten Version eines Modells führt. Jede dieser einzigartigen Kombinationen ist ein einzelnes Experiment. Mit einer nachvollziehbaren Aufzeichnung der Eingaben, Algorithmen und Hyperparameter, die in dieser Studie verwendet wurden, kann das Data-Science-Team seine Schritte leicht reproduzieren.

Ein automatisierter Prozess zum Verfolgen von Experimenten verbessert die Fähigkeit, bestimmte Modellversionen mit guter Leistung zu reproduzieren und bereitzustellen. Die native Pipeline-Integration mit Experimenten erleichtert die automatische Nachverfolgung und Verwaltung von Experimenten über Pipeline-Ausführungen hinweg.

Vorteile von SageMaker-Experimenten

Mit SageMaker Experiments können Datenwissenschaftler ihre Trainingsiterationen organisieren, verfolgen, vergleichen und auswerten.

Beginnen wir zunächst mit einem Überblick darüber, was Sie mit Experimenten tun können:

• Experimente organisieren – Experimente strukturiert das Experimentieren mit einer übergeordneten Entität namens an Experiment das enthält eine Reihe von Studien. Jeder Versuch enthält eine Reihe von Schritten, die als Testkomponenten. Jede Versuchskomponente ist eine Kombination aus Datensätzen, Algorithmen und Parametern. Sie können sich Experimente als Ordner der obersten Ebene zum Organisieren Ihrer Hypothesen, Ihre Versuche als Unterordner für jeden Gruppentestlauf und Ihre Versuchskomponenten als Ihre Dateien für jede Instanz eines Testlaufs vorstellen.
• Experimente verfolgen – Mit Experimenten können Data Scientists Experimente nachverfolgen. Es bietet die Möglichkeit, SageMaker-Jobs über einfache Konfigurationen und über die Tracking-SDKs automatisch einer Testversion zuzuweisen.
• Experimente vergleichen und auswerten – Die Integration von Experimenten mit Amazon SageMaker-Studio macht es einfach, Datenvisualisierungen zu erstellen und verschiedene Studien zu vergleichen. Sie können auch über das Python SDK auf die Testdaten zugreifen, um Ihre eigene Visualisierung mit Ihren bevorzugten Plotbibliotheken zu erstellen.

Um mehr über Experiments-APIs und -SDKs zu erfahren, empfehlen wir die folgende Dokumentation: ErstellenExperiment und Python-SDK für Amazon SageMaker-Experimente.

Wer tiefer eintauchen möchte, dem empfehlen wir einen Blick in die amazon-sagemaker-examples/sagemaker-experiments GitHub-Repository für weitere Beispiele.

Integration zwischen Pipelines und Experimenten

Die Modellerstellungs-Pipelines, die Teil von Pipelines sind, wurden speziell für ML entwickelt und ermöglichen es Ihnen, Ihre Modellerstellungsaufgaben mit einem Pipeline-Tool zu orchestrieren, das native Integrationen mit anderen SageMaker-Funktionen sowie die Flexibilität zur Erweiterung Ihrer Pipeline mit Schritten enthält, die außerhalb von SageMaker ausgeführt werden . Jeder Schritt definiert eine Aktion, die die Pipeline ausführt. Die Abhängigkeiten zwischen den Schritten werden durch einen direkten azyklischen Graphen (DAG) definiert, der mit dem Python-SDK von Pipelines erstellt wurde. Sie können eine SageMaker-Pipeline programmgesteuert über dasselbe SDK erstellen. Nachdem eine Pipeline bereitgestellt wurde, können Sie ihren Workflow optional in Studio visualisieren.

Pipelines lassen sich automatisch in Experimente integrieren, indem für jede Ausführung automatisch ein Experiment und eine Testversion erstellt werden. Pipelines erstellen automatisch ein Experiment und einen Test für jede Ausführung der Pipeline, bevor die Schritte ausgeführt werden, es sei denn, eine oder beide dieser Eingaben sind angegeben. Während der SageMaker-Auftrag der Pipeline ausgeführt wird, ordnet die Pipeline die Testversion dem Experiment zu und ordnet der Testversion jede Testkomponente zu, die durch den Job erstellt wird. Durch die programmgesteuerte Angabe Ihres eigenen Experiments oder Versuchs können Sie die Organisation Ihrer Experimente optimieren.

Der in diesem Beispiel vorgestellte Arbeitsablauf besteht aus einer Reihe von Schritten: einem Vorverarbeitungsschritt, um unseren Eingabedatensatz in Trainings-, Test- und Validierungsdatensätze aufzuteilen; ein Tuning-Schritt, um unsere Hyperparameter zu optimieren und Trainingsjobs zu starten, um ein Modell mit dem zu trainieren Integrierter XGBoost-Algorithmus; und schließlich ein Modellschritt zum Erstellen eines SageMaker-Modells aus dem am besten trainierten Modellartefakt. Pipelines bietet auch mehrere nativ unterstützte Schrittarten außerhalb dessen, was in diesem Beitrag besprochen wird. Wir veranschaulichen auch, wie Sie Ihren Pipeline-Workflow verfolgen und Metriken und Vergleichsdiagramme generieren können. Darüber hinaus zeigen wir, wie Sie die neu generierte Studie mit einem vorhandenen Experiment verknüpfen, das möglicherweise erstellt wurde, bevor die Pipeline definiert wurde.

SageMaker-Pipelines-Code

Sie können das Notizbuch von überprüfen und herunterladen GitHub-Repository mit diesem Beitrag verbunden. Wir sehen uns den Pipelines-spezifischen Code an, um ihn besser zu verstehen.

Mit Pipelines können Sie Parameter zur Laufzeit übergeben. Hier definieren wir die Typen und Anzahl der Verarbeitungs- und Trainingsinstanzen zur Laufzeit mit voreingestellten Standardwerten:

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

Als Nächstes richten wir ein Verarbeitungsskript ein, das den Eingabedatensatz herunterlädt und in Trainings-, Test- und Validierungsteile aufteilt. Wir gebrauchen SKLearnProcessor zum Ausführen dieses Vorverarbeitungsschritts. Dazu definieren wir ein Prozessorobjekt mit dem Instanztyp und der Anzahl, die zum Ausführen des Verarbeitungsjobs erforderlich sind.

Pipelines ermöglichen es uns, Datenversionierung auf programmatische Weise zu erreichen, indem wir ausführungsspezifische Variablen wie verwenden ExecutionVariables.PIPELINE_EXECUTION_ID, die die eindeutige ID einer Pipelineausführung ist. Wir können beispielsweise einen eindeutigen Schlüssel zum Speichern der Ausgabedatensätze erstellen Amazon Simple Storage-Service (Amazon S3), das sie an einen bestimmten Pipeline-Lauf bindet. Die vollständige Liste der Variablen finden Sie unter Ausführungsvariablen.

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

Anschließend erstellen wir ein Estimator-Objekt zum Trainieren eines XGBoost-Modells. Wir setzen einige statische Hyperparameter, die häufig mit XGBoost verwendet werden:

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
)

Wir führen ein Hyperparameter-Tuning der von uns erstellten Modelle durch, indem wir a verwenden ContinuousParameter Bereich für lambda. Die Auswahl einer Metrik als objektive Metrik teilt dem Tuner (der Instanz, die die Hyperparameter-Optimierungsjobs ausführt) mit, dass Sie den Trainingsjob basierend auf dieser spezifischen Metrik bewerten werden. Der Tuner gibt die beste Kombination basierend auf dem besten Wert für diese objektive Metrik zurück, d. h. die beste Kombination, die den besten quadratischen Mittelwertfehler (RMSE) minimiert.

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

Der Abstimmungsschritt führt mehrere Versuche durch, mit dem Ziel, das beste Modell unter den getesteten Parameterbereichen zu ermitteln. Mit der Methode get_top_model_s3_uri, stufen wir die 50 leistungsstärksten Versionen des S3-URI des Modellartefakts ein und extrahieren nur die leistungsstärkste Version (wir spezifizieren k=0 für die Besten), um ein SageMaker-Modell zu erstellen.

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

Wenn die Pipeline ausgeführt wird, erstellt sie Testkomponenten für jeden Hyperparameter-Tuning-Job und jeden SageMaker-Job, der von den Pipeline-Schritten erstellt wird.

Sie können die Integration von Pipelines mit Experimenten weiter konfigurieren, indem Sie eine PipelineExperimentConfig -Objekt und übergeben Sie es an das Pipeline-Objekt. Die beiden Parameter definieren den Namen des Experiments, das erstellt wird, und die Testversion, die sich auf die gesamte Ausführung der Pipeline bezieht.

Wenn Sie eine Pipelineausführung einem vorhandenen Experiment zuordnen möchten, können Sie seinen Namen übergeben, und Pipelines ordnet ihm die neue Testversion zu. Sie können die Erstellung eines Experiments und einer Testversion für eine Pipelineausführung durch Einstellung verhindern pipeline_experiment_config zu None.

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

Wir übergeben die Instanztypen und Zählwerte als Parameter und verketten die vorangegangenen Schritte der Reihe nach wie folgt. Der Pipeline-Workflow wird implizit dadurch definiert, dass die Ausgaben eines Schritts die Eingaben eines anderen Schritts sind.

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

Die vollwertige Pipeline ist jetzt erstellt und einsatzbereit. Wir fügen der Pipeline eine Ausführungsrolle hinzu und starten sie. Von hier aus können wir zur SageMaker Studio Pipelines-Konsole gehen und jeden Schritt visuell verfolgen. Sie können auch über die Konsole auf die verknüpften Protokolle zugreifen, um eine Pipeline zu debuggen.

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

Der vorherige Screenshot zeigt in Grün eine erfolgreich ausgeführte Pipeline. Wir erhalten die Metriken eines Versuchs aus einem Lauf der Pipeline mit dem folgenden Code:

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

Vergleichen Sie die Metriken für jede Testkomponente

Sie können die Ergebnisse der Hyperparameter-Abstimmung in Studio oder über andere Python-Plot-Bibliotheken darstellen. Wir zeigen beide Möglichkeiten, dies zu tun.

Erkunden Sie die Schulungs- und Bewertungsmetriken in Studio

Studio bietet eine interaktive Benutzeroberfläche, auf der Sie interaktive Diagramme erstellen können. Die Schritte sind wie folgt:

1. Auswählen Experimente und Versuche von dem SageMaker-Ressourcen Symbol in der linken Seitenleiste.
2. Wählen Sie Ihr Experiment aus, um es zu öffnen.
3. Wählen Sie (Rechtsklick) die gewünschte Studie aus.
4. Auswählen In Testkomponentenliste öffnen.
5. Öffentlichkeitsarbeit/Presse Shift um die Testkomponenten auszuwählen, die die Trainingsjobs repräsentieren.
6. Auswählen Diagramm hinzufügen.
7. Auswählen Neue Karte und passen Sie es an, um die gesammelten Metriken zu zeichnen, die Sie analysieren möchten. Wählen Sie für unseren Anwendungsfall Folgendes:
   1. Aussichten für Datentypwählen Zusammengefasste Statistiken.
   2. Aussichten für Diagrammtypwählen Streudiagramm.
   3. Aussichten für X-Achse, wählen lambda.
   4. Aussichten für Y-Achse, wählen validation:rmse_last.

Das neue Diagramm wird am unteren Rand des Fensters mit der Bezeichnung „8“ angezeigt.

Durch Drücken von können Sie mehr oder weniger Ausbildungsberufe hinzufügen Shift und wählen Sie das Augensymbol für ein interaktiveres Erlebnis.

Analytics mit SageMaker-Experimenten

Wenn der Pipeline-Lauf abgeschlossen ist, können wir schnell visualisieren, wie verschiedene Variationen des Modells in Bezug auf die während des Trainings gesammelten Metriken verglichen werden. Zuvor haben wir alle Testmetriken in a exportiert Pandas DataFrame Verwendung von ExperimentAnalytics. Wir können den in Studio erhaltenen Plot reproduzieren, indem wir die Matplotlib-Bibliothek verwenden.

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

Zusammenfassung

Die native Integration zwischen SageMaker-Pipelines und SageMaker-Experimenten ermöglicht es Data Scientists, Experimente während der Modellentwicklungsaktivitäten automatisch zu organisieren, zu verfolgen und zu visualisieren. Sie können Experimente erstellen, um Ihre gesamte Modellentwicklungsarbeit zu organisieren, wie z. B. die folgenden:

• Ein Geschäftsanwendungsfall, den Sie ansprechen, z. B. das Erstellen eines Experiments zur Vorhersage der Kundenabwanderung
• Ein Experiment im Besitz des Data-Science-Teams zum Beispiel zu Marketinganalysen
• Ein spezifisches Data Science- und ML-Projekt

In diesem Beitrag haben wir uns mit Pipelines befasst, um zu zeigen, wie Sie es zusammen mit Experiments verwenden können, um einen vollständig automatisierten End-to-End-Workflow zu organisieren.

Als nächsten Schritt können Sie diese drei SageMaker-Funktionen – Studio, Experimente und Pipelines – für Ihr nächstes ML-Projekt verwenden.

Empfohlene Lesungen

Über die Autoren

Paolo di Francesco ist Lösungsarchitekt bei AWS. Er hat Erfahrung in der Telekommunikation und im Software-Engineering. Er interessiert sich leidenschaftlich für maschinelles Lernen und konzentriert sich derzeit darauf, seine Erfahrung einzusetzen, um Kunden dabei zu helfen, ihre Ziele auf AWS zu erreichen, insbesondere in Diskussionen über MLOps. Außerhalb der Arbeit spielt er gerne Fußball und liest.

Mario Bourgoin ist Senior Partner Solutions Architect für AWS, KI/ML-Spezialist und globaler technischer Leiter für MLOps. Er arbeitet mit Unternehmenskunden und Partnern zusammen, die KI-Lösungen in der Cloud bereitstellen. Er verfügt über mehr als 30 Jahre Erfahrung mit maschinellem Lernen und KI in Startups und Unternehmen, beginnend mit der Entwicklung eines der ersten kommerziellen maschinellen Lernsysteme für Big Data. Mario verbringt seine Freizeit damit, mit seinen drei belgischen Tervurens zu spielen, Abendessen für seine Familie zu kochen und etwas über Mathematik und Kosmologie zu lernen.

Ganapathi Krishnamoorthi ist Senior ML Solutions Architect bei AWS. Ganapathi bietet Start-up- und Unternehmenskunden vorschreibende Anleitungen, die ihnen helfen, Cloud-Anwendungen in großem Maßstab zu entwerfen und bereitzustellen. Er ist auf maschinelles Lernen spezialisiert und konzentriert sich darauf, Kunden dabei zu helfen, KI/ML für ihre Geschäftsergebnisse zu nutzen. Wenn er nicht bei der Arbeit ist, erkundet er gerne die Natur und hört Musik.

Valerie Soundhakith ist ein Lösungsarchitekt für AWS, der in der Gaming-Branche und mit Partnern arbeitet, die KI-Lösungen bereitstellen. Sie möchte ihre Karriere rund um Computer Vision aufbauen. In ihrer Freizeit verbringt Valerie sie damit, zu reisen, neue Essensorte zu entdecken und die Inneneinrichtung ihres Hauses zu verändern.