Tutorial: Trainieren eines Modells in Python mit automatisiertem maschinellem Lernen (veraltet)

Artikel
03/06/2024

Azure Machine Learning ist eine cloudbasierte Umgebung, die Ihnen das Trainieren, Bereitstellen, Automatisieren, Verwalten und Nachverfolgen von Machine Learning-Modellen ermöglicht.

In diesem Tutorial verwenden Sie automatisiertes maschinelles Lernen in Azure Machine Learning, um ein Regressionsmodell für die Vorhersage der Preise für Taxifahrten zu erstellen. Dieser Prozess erzielt das beste Modell, indem Trainingsdaten und Konfigurationseinstellungen akzeptiert und automatisch Kombinationen der verschiedenen Methoden, Modelle und Hyperparametereinstellungen durchlaufen werden.

In diesem Tutorial lernen Sie Folgendes:

Herunterladen der Daten unter Verwendung von Apache Spark und Azure Open Datasets
Transformieren und Bereinigen von Daten unter Verwendung von Azure Spark-Datenrahmen
Trainieren eines Regressionsmodells mit automatisiertem maschinellem Lernen
Berechnen der Modellgenauigkeit

Voraussetzungen

Erstellen Sie anhand der Schnellstartanleitung zum Erstellen eines serverlosen Apache Spark-Pools einen serverlosen Apache Spark 2.4-Pool.
Absolvieren Sie das Tutorial für die Einrichtung des Azure Machine Learning-Arbeitsbereichs, falls Sie noch nicht über einen vorhandenen Azure Machine Learning-Arbeitsbereich verfügen.

Warnung

Ab dem 29. September 2023 wird Azure Synapse die offizielle Unterstützung für Spark 2.4 Runtimes einstellen. Nach dem 29. September 2023 werden wir keine Supporttickets im Zusammenhang mit Spark 2.4 mehr bearbeiten. Für Fehler- oder Sicherheitsfixes für Spark 2.4 ist keine Releasepipeline vorhanden. Die Nutzung von Spark 2.4 nach dem Ende der Unterstützung erfolgt auf eigenes Risiko. Aufgrund potenzieller Sicherheits- und Funktionalitätsbedenken raten wir dringend davon ab.
Im Rahmen der Einstellung von Apache Spark 2.4 möchten wir Sie darüber informieren, dass AutoML in Azure Synapse Analytics ebenfalls veraltet sein wird. Dies umfasst sowohl die Low-Code-Schnittstelle als auch die APIs, die zum Erstellen von AutoML-Testversionen über Code verwendet werden.
Bitte beachten Sie, dass die AutoML-Funktionalität ausschließlich über die Spark 2.4 Runtime verfügbar war.
Kundinnen und Kunden, die weiterhin AutoML-Funktionen nutzen möchten, empfehlen wir, Ihre Daten in Ihrem Azure Data Lake Storage Gen2 (ADLSg2)-Konto zu speichern. Von dort aus können Sie nahtlos über Azure Machine Learning (AzureML) auf die AutoML-Erfahrung zugreifen. Weitere Informationen zu dieser Problemumgehung finden Sie hier.

Grundlegendes zu logistischen Regressionsmodellen

Regressionsmodelle sagen numerische Ausgabewerte auf Grundlage unabhängiger Prädiktoren voraus. Bei der Regression besteht das Ziel darin, die Beziehung zwischen diesen unabhängigen Vorhersagevariablen herzustellen, indem geschätzt wird, wie eine Variable die anderen beeinflusst.

Beispiel auf der Grundlage von New York City-Taxidaten

In diesem Beispiel verwenden Sie Spark, um einige Analysen zu Trinkgelddaten von Taxifahrten in New York City (NYC) durchzuführen. Die Daten sind über Azure Open Datasets verfügbar. Diese Teilmenge des Datasets enthält Informationen zu Taxifahrten von Yellow Cabs, einschließlich Informationen zu jeder einzelnen Fahrt, den Start- und Endzeiten und Start- und Endorten sowie den Kosten.

Wichtig

Es können zusätzliche Gebühren für das Abrufen dieser Daten aus ihrem Speicherort anfallen. In den folgenden Schritten entwickeln Sie ein Modell zur Vorhersage der Preise für NYC-Taxifahren.

Herunterladen und Vorbereiten der Daten

Gehen Sie dabei folgendermaßen vor:

Erstellen Sie ein Notebook unter Verwendung des PySpark-Kernels. Eine entsprechende Anleitung finden Sie unter Erstellen eines Notebooks.

Hinweis

Durch den PySpark-Kernel müssen Sie keine Kontexte explizit erstellen. Der Spark-Kontext wird automatisch für Sie erstellt, wenn Sie die erste Codezelle ausführen.

Da die Rohdaten im Parquet-Format vorliegen, können Sie den Spark-Kontext verwenden, um die Datei als Datenrahmen direkt in den Arbeitsspeicher zu lesen. Erstellen Sie einen Spark-Datenrahmen, indem Sie die Daten über die Open Datasets-API abrufen. Hier verwenden Sie die Spark-Datenrahmeneigenschaften vom Typ schema on read, um die Datentypen und das Schema abzuleiten.

blob_account_name = "azureopendatastorage"
blob_container_name = "nyctlc"
blob_relative_path = "yellow"
blob_sas_token = r""

# Allow Spark to read from the blob remotely
wasbs_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name, blob_relative_path)
spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name),blob_sas_token)

# Spark read parquet; note that it won't load any data yet
df = spark.read.parquet(wasbs_path)

Je nach Größe Ihres Spark-Pools können die Rohdaten zu umfangreich sein oder zu viel Verarbeitungszeit in Anspruch nehmen. Sie können nach einer kleineren Menge dieser Daten filtern (etwa den Daten eines Monats), indem Sie die Filter start_date und end_date verwenden. Nach dem Filtern nach einem Datenrahmen führen Sie auch die describe()-Funktion für den neuen Datenrahmen aus, um zusammenfassende Statistiken für jedes Feld anzuzeigen.

Basierend auf den Zusammenfassungsstatistiken können Sie erkennen, dass es einige Unregelmäßigkeiten in den Daten gibt. Beispielsweise zeigt die Statistik, dass die minimale Fahrtstrecke kleiner als 0 ist. Diese unregelmäßigen Datenpunkte müssen herausgefiltert werden.
```
# Create an ingestion filter
start_date = '2015-01-01 00:00:00'
end_date = '2015-12-31 00:00:00'

filtered_df = df.filter('tpepPickupDateTime > "' + start_date + '" and tpepPickupDateTime< "' + end_date + '"')

filtered_df.describe().show()
```

Generieren Sie Merkmale aus dem Dataset, indem Sie eine Gruppe von Spalten auswählen und verschiedene zeitbasierte Merkmale aus dem Feld datetime für die Abholung erstellen. Filtern Sie die Ausreißer heraus, die im vorherigen Schritt identifiziert wurden, und entfernen Sie dann die letzten Spalten, da diese für das Training unnötig sind.

from datetime import datetime
from pyspark.sql.functions import *

# To make development easier, faster, and less expensive, downsample for now
sampled_taxi_df = filtered_df.sample(True, 0.001, seed=1234)

taxi_df = sampled_taxi_df.select('vendorID', 'passengerCount', 'tripDistance',  'startLon', 'startLat', 'endLon' \
                                , 'endLat', 'paymentType', 'fareAmount', 'tipAmount'\
                                , column('puMonth').alias('month_num') \
                                , date_format('tpepPickupDateTime', 'hh').alias('hour_of_day')\
                                , date_format('tpepPickupDateTime', 'EEEE').alias('day_of_week')\
                                , dayofmonth(col('tpepPickupDateTime')).alias('day_of_month')
                                ,(unix_timestamp(col('tpepDropoffDateTime')) - unix_timestamp(col('tpepPickupDateTime'))).alias('trip_time'))\
                        .filter((sampled_taxi_df.passengerCount > 0) & (sampled_taxi_df.passengerCount < 8)\
                                & (sampled_taxi_df.tipAmount >= 0)\
                                & (sampled_taxi_df.fareAmount >= 1) & (sampled_taxi_df.fareAmount <= 250)\
                                & (sampled_taxi_df.tipAmount < sampled_taxi_df.fareAmount)\
                                & (sampled_taxi_df.tripDistance > 0) & (sampled_taxi_df.tripDistance <= 200)\
                                & (sampled_taxi_df.rateCodeId <= 5)\
                                & (sampled_taxi_df.paymentType.isin({"1", "2"})))
taxi_df.show(10)

Wie Sie sehen können, wird dadurch ein neuer Datenrahmen mit zusätzlichen Spalten für den Tag des Monats, die Stunde der Abholung, den Wochentag und die Gesamtfahrtzeit erstellt.

Abbildung des Taxidatenrahmens

Generieren von Datasets für Test und Validierung

Nachdem Sie das endgültige Dataset haben, können Sie die Daten mithilfe der Funktion random_ split in Spark in Trainings- und Testsätze aufteilen. Unter Verwendung der bereitgestellten Gewichtungen teilt diese Funktion die Daten nach dem Zufallsprinzip in das Trainingsdataset für das Modelltraining und das Validierungsdataset zum Testen auf.

# Random split dataset using Spark; convert Spark to pandas
training_data, validation_data = taxi_df.randomSplit([0.8,0.2], 223)

Dieser Schritt stellt sicher, dass die Datenpunkte zum Testen des fertigen Modells nicht zum Trainieren des Modells verwendet wurden.

Herstellen einer Verbindung mit einem Azure Machine Learning-Arbeitsbereich

In Azure Machine Learning ist ein Arbeitsbereich eine Klasse, die Informationen zu Ihrem Azure-Abonnement und Ihren Azure-Ressourcen akzeptiert. Außerdem erstellt der Arbeitsbereich eine Cloudressource zur Überwachung und Nachverfolgung Ihrer Modellausführungen. In diesem Schritt erstellen Sie ein Arbeitsbereichsobjekt auf der Grundlage des vorhandenen Azure Machine Learning-Arbeitsbereichs.

from azureml.core import Workspace

# Enter your subscription id, resource group, and workspace name.
subscription_id = "<enter your subscription ID>" #you should be owner or contributor
resource_group = "<enter your resource group>" #you should be owner or contributor
workspace_name = "<enter your workspace name>" #your workspace name

ws = Workspace(workspace_name = workspace_name,
               subscription_id = subscription_id,
               resource_group = resource_group)

Konvertieren eines Datenrahmens in ein Azure Machine Learning-Dataset

Um ein Remoteexperiment zu übermitteln, müssen Sie das Dataset in eine Azure Machine Learning-Instanz vom Typ TabularDatset konvertieren. TabularDataset stellt Daten in einem tabellarischen Format dar, indem die bereitgestellten Dateien analysiert werden.

Mit dem folgenden Code werden der vorhandene Arbeitsbereich und der Azure Machine Learning-Standarddatenspeicher abgerufen. Anschließend werden der Datenspeicher und die Dateispeicherorte an den Pfadparameter übergeben, um eine neue TabularDataset-Instanz zu erstellen.

import pandas 
from azureml.core import Dataset

# Get the Azure Machine Learning default datastore
datastore = ws.get_default_datastore()
training_pd = training_data.toPandas().to_csv('training_pd.csv', index=False)

# Convert into an Azure Machine Learning tabular dataset
datastore.upload_files(files = ['training_pd.csv'],
                       target_path = 'train-dataset/tabular/',
                       overwrite = True,
                       show_progress = True)
dataset_training = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/training_pd.csv')])

Abbildung des hochgeladenen Datasets.

Übermitteln eines automatisierten Experiments

In den folgenden Abschnitten wird der Prozess zum Übermitteln eines Experiments mit automatisiertem maschinellem Lernen Schritt für Schritt beschrieben.

Definieren von Trainingseinstellungen

Zum Übermitteln eines Experiments müssen Sie die Experimentparameter und Modelleinstellungen für das Training definieren. Eine vollständige Liste der Einstellungen finden Sie unter Konfigurieren automatisierter ML-Experimente in Python.

import logging

automl_settings = {
    "iteration_timeout_minutes": 10,
    "experiment_timeout_minutes": 30,
    "enable_early_stopping": True,
    "primary_metric": 'r2_score',
    "featurization": 'auto',
    "verbosity": logging.INFO,
    "n_cross_validations": 2}

Übergeben Sie die definierten Trainingseinstellungen als Parameter kwargs für ein Objekt vom Typ AutoMLConfig. Da Sie Spark verwenden, müssen Sie auch den Spark-Kontext übergeben, der automatisch über die Variable sc zugänglich ist. Außerdem geben Sie die Trainingsdaten und den Typ des Modells an, der in diesem Fall „Regression“ ist.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task='regression',
                             debug_log='automated_ml_errors.log',
                             training_data = dataset_training,
                             spark_context = sc,
                             model_explainability = False, 
                             label_column_name ="fareAmount",**automl_settings)

Hinweis

Die Schritte zur Vorverarbeitung bei automatisiertem maschinellen Lernen werden Teil des zugrunde liegenden Modells. Diese Schritte umfassen Featurenormalisierung, Behandlung fehlender Daten und Umwandlung von Text in numerische Daten. Bei Verwendung des Modells für Vorhersagen werden die während des Trainings angewendeten Vorverarbeitungsschritte automatisch auf Ihre Eingabedaten angewendet.

Trainieren des automatischen Regressionsmodells

Als Nächstes erstellen Sie ein Experimentobjekt in Ihrem Azure Machine Learning-Arbeitsbereich. Ein Experiment fungiert als Container für die einzelnen Ausführungen.

from azureml.core.experiment import Experiment

# Start an experiment in Azure Machine Learning
experiment = Experiment(ws, "aml-synapse-regression")
tags = {"Synapse": "regression"}
local_run = experiment.submit(automl_config, show_output=True, tags = tags)

# Use the get_details function to retrieve the detailed output for the run.
run_details = local_run.get_details()

Wenn das Experiment beendet ist, gibt die Ausgabe Details zu den abgeschlossenen Iterationen zurück. Für die einzelnen Iterationen werden jeweils die Art des Modells, die Ausführungsdauer und die Trainingsgenauigkeit angezeigt. Im Feld BEST wird die beste Trainingsbewertung auf der Grundlage Ihres Metriktyps nachverfolgt.

Screenshot der Modellausgabe.

Hinweis

Nach der Übermittlung des Experiments mit automatisiertem maschinellem Lernen führt es verschiedene Iterationen und Modelltypen aus. Diese Ausführung dauert in der Regel 60 bis 90 Minuten

Abrufen des besten Modells

Um das beste Modell aus ihren Iterationen auszuwählen, verwenden Sie die get_output-Funktion, um das am besten ausgeführte und angepasste Modell zurückzugeben. Mit dem folgenden Code wird das am besten ausgeführte und angepasste Modell für eine beliebige protokollierte Metrik oder für eine bestimmte Iteration abgerufen:

# Get best model
best_run, fitted_model = local_run.get_output()

Testen der Modellgenauigkeit

Um die Modellgenauigkeit zu testen, verwenden Sie das beste Modell, um Vorhersagen für die Preise von Taxifahrten mit dem Testdataset auszuführen. Die Funktion predict verwendet das beste Modell und sagt die Werte von y (Fahrtkosten) aus dem Validierungsdataset voraus.
```
# Test best model accuracy
validation_data_pd = validation_data.toPandas()
y_test = validation_data_pd.pop("fareAmount").to_frame()
y_predict = fitted_model.predict(validation_data_pd)
```
Die mittlere quadratische Gesamtabweichung ist ein häufig verwendetes Maß für die Unterschiede zwischen den von einem Modell vorhergesagten Stichprobenwerten und den beobachteten Werten. Sie berechnen die mittlere quadratische Gesamtabweichung der Ergebnisse, indem Sie den y_test-Datenrahmen mit den vom Modell vorhergesagten Werten vergleichen.

Die Funktion mean_squared_error akzeptiert zwei Arrays und berechnet den durchschnittlichen quadratischen Fehler zwischen den Arrays. Danach ziehen Sie die Quadratwurzel aus dem Ergebnis. Diese Metrik gibt Aufschluss darüber, wie weit die Vorhersagen des Preises für Taxifahrten ungefähr von den tatsächlichen Werten der Preise entfernt sind.
```
from sklearn.metrics import mean_squared_error
from math import sqrt

# Calculate root-mean-square error
y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))

print("Root Mean Square Error:")
print(rmse)
```
```
Root Mean Square Error:
2.309997102577151
```
Die mittlere quadratische Gesamtabweichung ist ein gutes Maß für die Genauigkeit der Vorhersage der Antwort durch das Modell. Anhand der Ergebnisse sehen Sie, dass das Modell die Preise von Taxifahrten auf der Grundlage der Features des Datasets ziemlich gut vorhersagen kann (in der Regel mit einer Genauigkeit von +/-2,00 USD).
Führen Sie den folgenden Code aus, um den mittleren absoluten Fehler in Prozent zu berechnen. Diese Metrik drückt die Genauigkeit als Prozentsatz des Fehlers aus. Hierzu wird eine absolute Differenz zwischen jedem vorhergesagten und tatsächlichen Wert berechnet, und anschließend werden alle Differenzen summiert. Die Summe wird dann als Prozentsatz der gesamten tatsächlichen Werte ausgedrückt.
```
# Calculate mean-absolute-percent error and model accuracy 
sum_actuals = sum_errors = 0

for actual_val, predict_val in zip(y_actual, y_predict):
    abs_error = actual_val - predict_val
    if abs_error < 0:
        abs_error = abs_error * -1

    sum_errors = sum_errors + abs_error
    sum_actuals = sum_actuals + actual_val

mean_abs_percent_error = sum_errors / sum_actuals

print("Model MAPE:")
print(mean_abs_percent_error)
print()
print("Model Accuracy:")
print(1 - mean_abs_percent_error)
```
```
Model MAPE:
0.03655071038487368

Model Accuracy:
0.9634492896151263
```
Anhand der zwei Metriken für die Vorhersagegenauigkeit sehen Sie, dass das Modell die Preise von Taxifahrten auf der Grundlage der Datasetfeatures ziemlich gut vorhersagen kann.
Nachdem Sie ein lineares Regressionsmodell angepasst haben, müssen Sie nun bestimmen, wie gut das Modell auf die Daten passt. Zu diesem Zweck werden die tatsächlichen Fahrpreiswerte gegen die vorhergesagte Ausgabe gezeichnet. Zusätzlich berechnen Sie noch das Bestimmtheitsmaß (R²), um zu verstehen, wie nah die Daten an der angepassten Regressionslinie liegen.
```
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# Calculate the R2 score by using the predicted and actual fare prices
y_test_actual = y_test["fareAmount"]
r2 = r2_score(y_test_actual, y_predict)

# Plot the actual versus predicted fare amount values
plt.style.use('ggplot')
plt.figure(figsize=(10, 7))
plt.scatter(y_test_actual,y_predict)
plt.plot([np.min(y_test_actual), np.max(y_test_actual)], [np.min(y_test_actual), np.max(y_test_actual)], color='lightblue')
plt.xlabel("Actual Fare Amount")
plt.ylabel("Predicted Fare Amount")
plt.title("Actual vs Predicted Fare Amount R^2={}".format(r2))
plt.show()
```
Anhand der Ergebnisse können Sie sehen, dass das Bestimmtheitsmaß 95 Prozent der Varianz abdeckt. Dies wird auch durch den Plot der tatsächlichen gegen die beobachteten Werte bestätigt. Je mehr der Varianz durch das Regressionsmodell abgedeckt wird, desto näher werden die Datenpunkte an der angepassten Regressionslinie liegen.

Registrieren des Modells in Azure Machine Learning

Nachdem Sie das beste Modell überprüft haben, können Sie es bei Azure Machine Learning registrieren. Anschließend können Sie das registrierte Modell herunterladen oder bereitstellen und alle Dateien empfangen, die Sie registriert haben.

description = 'My automated ML model'
model_path='outputs/model.pkl'
model = best_run.register_model(model_name = 'NYCYellowTaxiModel', model_path = model_path, description = description)
print(model.name, model.version)

NYCYellowTaxiModel 1

Anzeigen von Ergebnissen in Azure Machine Learning

Sie können auch auf die Ergebnisse der Iterationen zugreifen, indem Sie in Ihrem Azure Machine Learning-Arbeitsbereich zu dem Experiment navigieren. Hier können Sie zusätzliche Details zum Status Ihrer Ausführung, zu ausprobierten Modellen und anderen Modellmetriken abrufen.

Screenshot: Azure Machine Learning-Arbeitsbereich

Freigeben über