Zelfstudie: Een model trainen in Python met geautomatiseerde machine learning (afgeschaft)
Azure Machine Learning is een cloudomgeving die u kunt gebruiken voor het trainen, implementeren, automatiseren, beheren en volgen van machine learning-modellen.
In deze zelfstudie gebruikt u geautomatiseerde machine learning in Azure Machine Learning om een regressiemodel te maken om de ritprijzen van taxi’s te voorspellen. Dit proces gebruikt trainingsgegevens en configuratie-instellingen en doorloopt automatisch combinaties van verschillende methoden voor het normaliseren/standaardiseren van functies, modellen en instellingen van hyperparameters om het beste model te bepalen.
In deze zelfstudie leert u het volgende:
- De gegevens downloaden met behulp van Apache Spark en Azure Open Datasets.
- Gegevens transformeren en opschonen met behulp van Apache Spark DataFrames.
- Een regressiemodel trainen in geautomatiseerde machine learning.
- De nauwkeurigheid van een model berekenen.
Voordat u begint
- Maak een serverloze Apache Spark 2.4-pool door de quickstart een serverloze Apache Spark-pool maken te volgen.
- Voltooi de zelfstudie Azure Machine Learning-werkruimte instellen als u niet beschikt over een bestaande Azure Machine Learning-werkruimte.
Waarschuwing
- Vanaf 29 september 2023 wordt de officiële ondersteuning voor Spark 2.4 Runtimes stopgezet in Azure Synapse. Na 29 september 2023 behandelen we geen ondersteuningstickets met betrekking tot Spark 2.4. Er is geen release-pijplijn aanwezig voor bug- of beveiligingsoplossingen voor Spark 2.4. Het gebruik van Spark 2.4 na de datum waarop de ondersteuning wordt afgekapt, wordt op eigen risico uitgevoerd. We raden het gebruik ervan sterk af vanwege mogelijke beveiligings- en functionaliteitsproblemen.
- Als onderdeel van het afschaffingsproces voor Apache Spark 2.4 willen we u laten weten dat AutoML in Azure Synapse Analytics ook wordt afgeschaft. Dit omvat zowel de interface met weinig code als de API's die worden gebruikt voor het maken van AutoML-proefversies via code.
- Houd er rekening mee dat de AutoML-functionaliteit uitsluitend beschikbaar is via de Spark 2.4-runtime.
- Voor klanten die gebruik willen blijven maken van AutoML-mogelijkheden, raden we u aan om uw gegevens op te slaan in uw ADLSg2-account (Azure Data Lake Storage Gen2). Van daaruit hebt u naadloos toegang tot de AutoML-ervaring via Azure Machine Learning (AzureML). Meer informatie over deze tijdelijke oplossing vindt u hier.
Regressiemodellen begrijpen
Regressiemodellen voorspellen numerieke uitvoerwaarden op basis van onafhankelijke voorspellingen. In regressie is het doel om te helpen de relatie tot stand te brengen tussen deze onafhankelijke voorspellingsvariabelen door te schatten hoe één variabele de andere beïnvloedt.
Voorbeeld op basis van taxigegevens in New York City
In dit voorbeeld gebruikt u Spark om een analyse uit te voeren op taxirittipgegevens uit New York City (NYC). De gegevens zijn beschikbaar via Azure Open Datasets. Deze subset van de gegevensset bevat informatie over taxiritten, waaronder informatie over elke rit, de begin- en eindtijd en locaties en de kosten.
Belangrijk
Er kunnen extra kosten gelden voor het ophalen van deze gegevens uit de opslaglocatie. In de volgende stappen ontwikkelt u een model om de ritprijzen voor NYC-taxi’s te voorspellen.
De gegevens downloaden en voorbereiden
U doet dit als volgt:
Maak een notebook met behulp van de PySpark-kernel. Zie Een notebook maken voor instructies.
Notitie
Vanwege de PySpark-kernel hoeft u niet expliciet contexten te maken. De Spark-context wordt automatisch voor u gemaakt wanneer u de eerste codecel uitvoert.
Omdat de onbewerkte gegevens een Parquet-indeling hebben, kunt u de Spark-context gebruiken om het bestand rechtstreeks in het geheugen op te halen als een DataFrame. Maak een Spark DataFrame door de gegevens op te halen via de Open Datasets-API. Hier gebruikt u de Spark DataFrame-eigenschappen
schema on readom de gegevenstypen en het schema af te leiden.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)Afhankelijk van de grootte van de Spark-pool kan de hoeveelheid onbewerkte gegevens te groot zijn, of kan het bewerken ervan te veel tijd in beslag nemen. U kunt deze gegevens filteren op iets kleiners, zoals een maand aan gegevens, met behulp van de
start_dateenend_datefilters. Nadat u een DataFrame hebt gefilterd, voert u dedescribe()functie ook uit op het nieuwe DataFrame om overzichtsstatistieken voor elk veld weer te geven.Op basis van de samenvattingsstatistieken ziet u dat er sprake is van wat onregelmatigheden in de gegevens. De statistieken laten bijvoorbeeld zien dat de minimale reisafstand kleiner is dan 0. Deze onregelmatige gegevenspunten moeten worden uitgefilterd.
# 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()Genereer functies uit de gegevensset door een set kolommen te selecteren en verschillende functies op basis van tijd te maken in het ophaalveld
datetime. Filter de uitbijters uit de vorige stap en verwijder vervolgens de laatste paar kolommen omdat ze niet nodig zijn voor training.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)Zoals u kunt zien, maakt u een nieuw DataFrame met extra kolommen voor de dag van de maand, het ophaaluur, de weekdag en de totale reistijd.
Gegevens genereren voor test en validatie
Zodra u beschikt over de definitieve gegevensset, kunt u de gegevens splitsen in trainings- en testsets, met behulp van de functie random_ split in Spark. Met behulp van de opgegeven gewichten splitst deze functie de gegevens willekeurig op in de trainingsgegevensset voor modeltraining en de validatiegegevensset voor testen.
# Random split dataset using Spark; convert Spark to pandas
training_data, validation_data = taxi_df.randomSplit([0.8,0.2], 223)
Met deze stap zorgt u ervoor dat de gegevenspunten die worden gebruikt om het voltooide model te testen, niet ook zijn gebruikt om het model te trainen.
Verbinding maken met een Azure Machine Learning-werkruimte
In Azure Machine Learning is een werkruimte een klasse die de gegevens over uw Azure-abonnement en -resources accepteert. Hier wordt ook een cloudresource gemaakt om de uitvoeringen van uw model te controleren en bij te houden. In deze stap maakt u een werkruimteobject op basis van de bestaande Azure Machine Learning-werkruimte.
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)
Een DataFrame converteren naar een Azure Machine Learning-gegevensset
Als u een extern experiment wilt verzenden, converteert u uw gegevensset naar een Azure Machine Learning-exemplaar TabularDatset . TabularDataset vertegenwoordigt gegevens in tabelvorm door de opgegeven bestanden te parseren.
Met de volgende code worden de bestaande werkruimte en het standaardgegevensarchief van Azure Machine Learning opgehaald. Vervolgens worden de gegevensopslag- en bestandslocaties doorgegeven aan de padparameter om een nieuw TabularDataset exemplaar te maken.
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')])
Een geautomatiseerd experiment verzenden
In de volgende secties wordt stapsgewijs uitgelegd hoe u een geautomatiseerd machine learning-experiment verzendt.
Trainingsinstellingen definiëren
U moet de experimentparameter en modelinstellingen voor training definiëren om een experiment te verzenden. Zie geautomatiseerde machine learning-experimenten configureren in Python voor een volledige lijst met instellingen.
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}Geef de gedefinieerde trainingsinstellingen door als
kwargs-parameter voor eenAutoMLConfig-object. Omdat u Spark gebruikt, moet u ook de Spark-context doorgeven die automatisch toegankelijk is voor de variabelesc. Daarnaast geeft u de trainingsgegevens en het modeltype op. In dit geval is dat regressie.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)
Notitie
De stappen voor vooraf bewerken van geautomatiseerde machine learning worden onderdeel van het onderliggende model. Deze stappen omvatten functienormalisatie, het verwerken van ontbrekende gegevens en het converteren van tekst naar numerieke waarden. Wanneer u het model voor voorspellingen gebruikt, worden dezelfde voorverwerkingsstappen die tijdens de training zijn toegepast, automatisch toegepast op uw invoergegevens.
Het automatische regressiemodel trainen
Vervolgens maakt u een experimentobject in uw Azure Machine Learning-werkruimte. Een experiment fungeert als een container voor uw afzonderlijke uitvoeringen.
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()
Wanneer het experiment is voltooid, retourneert de uitvoer details over de voltooide iteraties. Voor elke iteratie ziet u het modeltype, de uitvoeringsduur en de nauwkeurigheid van de training. In BEST het veld wordt de best uitgevoerde trainingsscore bijgehouden op basis van uw metrische type.
Notitie
Nadat u het geautomatiseerde machine learning-experiment hebt verzonden, worden verschillende iteraties en modeltypen uitgevoerd. Deze uitvoering duurt doorgaans 60 tot 90 minuten.
Het beste model ophalen
Om het beste model uit uw iteraties te selecteren, gebruiken we de functie get_output om het model te retourneren dat het beste is uitgevoerd en aangepast. Met de volgende code wordt het model opgehaald dat het beste is uitgevoerd en aangepast voor alle geregistreerde metrische gegevens of voor een bepaalde iteratie.
# Get best model
best_run, fitted_model = local_run.get_output()
Modelnauwkeurigheid testen
Als u de nauwkeurigheid van het model wilt testen, gebruikt u het beste model om de ritprijzen van taxi’s te voorspellen in de testgegevensset. De
predictfunctie maakt gebruik van het beste model en voorspelt de waarden vany(tariefhoeveelheid) uit de validatiegegevensset.# 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)De wortel van de gemiddelde kwadratische fout is een veelgebruikte meting van de verschillen tussen voorbeeldwaarden die zijn voorspeld met een model, en de waargenomen waarden. U berekent de wortel-gemiddelde-kwadratische fout van de resultaten door het
y_testDataFrame te vergelijken met de waarden die door het model worden voorspeld.Met de functie
mean_squared_errorwordt de gemiddelde gekwadrateerde fout berekend tussen twee matrices. Vervolgens neemt u de vierkantswortel uit het resultaat. Deze metrische waarde geeft ongeveer aan hoe ver de voorspellingen van taxiritten van de werkelijke tariefwaarden liggen.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.309997102577151De wortel van de gemiddelde kwadratische fout is een goede meting van hoe nauwkeurig het model het antwoord voorspelt. In de resultaten ziet u dat het model redelijk goed is in het voorspellen van de ritprijzen van taxi’s op basis van de functies van de gegevensset, met een afwijking van maximaal $2,00.
Voer de volgende code uit om het gemiddelde absolute foutpercentage te berekenen. Deze metrische waarde toont nauwkeurigheid als een percentage van de fout. Dit gebeurt door een absoluut verschil tussen elke voorspelde en werkelijke waarde te berekenen, en alle verschillen vervolgens op te tellen. Vervolgens wordt die som weergegeven als een percentage van het totaal van de werkelijke waarden.
# 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.9634492896151263In de twee metrische gegevens voor de nauwkeurigheid van de voorspellingen ziet u dat het model redelijk goed is in het voorspellen van de ritprijzen van taxi’s op basis van de functies van de gegevensset.
Na het aanpassen van een lineair regressiemodel moet u nu bepalen hoe goed het model past bij de gegevens. Hiervoor tekent u de werkelijke ritprijs ten opzichte van de voorspelde uitvoer. Daarnaast berekent u ook de R-kwadraatsmeting om te begrijpen hoe dicht de gegevens zich bij de aangepaste regressieregel bevinden.
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()
Uit de resultaten blijkt dat de R-kwadraatsmeting geldt voor 95 procent van de variantie. Dit wordt ook gevalideerd door de werkelijke grafiek versus de waargenomen grafiek. Hoe groter de variantie van het regressiemodel is, hoe dichter de gegevenspunten bij de aangepaste regressielijn vallen.
Het model registreren bij Azure Machine Learning
Nadat u het beste model hebt gevalideerd, kunt u dit registreren bij Azure Machine Learning. Vervolgens kunt u het geregistreerde model downloaden of implementeren, en alle bestanden ontvangen die u hebt geregistreerd.
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
Resultaten bekijken in Azure Machine Learning
U kunt ook toegang krijgen tot de resultaten van de iteraties door naar het experiment in uw Azure Machine Learning-werkruimte te gaan. Hier kunt u aanvullende informatie krijgen over de status van uw uitvoering, pogingsmodellen en andere metrische modelgegevens.
