Självstudie: Träna en modell i Python med automatiserad maskininlärning (inaktuell)

Artikel
03/10/2024

Azure Machine Learning är en molnbaserad miljö där du kan träna, distribuera, automatisera, hantera och spåra maskininlärningsmodeller.

I den här självstudien använder du automatiserad maskininlärning i Azure Machine Learning för att skapa en regressionsmodell för att förutsäga priser för taxipriser. Den här processen anländer till den bästa modellen genom att acceptera träningsdata och konfigurationsinställningar och automatiskt iterera genom kombinationer av olika metoder, modeller och hyperparameterinställningar.

I den här självstudien lär du dig att:

Ladda ned data med hjälp av Apache Spark och Azure Open Datasets.
Transformera och rensa data med hjälp av Apache Spark DataFrames.
Träna en regressionsmodell i automatiserad maskininlärning.
Beräkna modellnoggrannhet.

Innan du börjar

Skapa en serverlös Apache Spark 2.4-pool genom att följa snabbstarten Skapa en serverlös Apache Spark-pool .
Slutför installationsguiden för Azure Machine Learning-arbetsytan om du inte har någon befintlig Azure Machine Learning-arbetsyta.

Varning

Från och med den 29 september 2023 upphör Azure Synapse med det officiella stödet för Spark 2.4 Runtimes. Efter den 29 september 2023 kommer vi inte att ta upp några supportärenden relaterade till Spark 2.4. Det finns ingen versionspipeline för buggar eller säkerhetskorrigeringar för Spark 2.4. Användning av Spark 2.4 efter supportavstängningen sker på egen risk. Vi avråder starkt från fortsatt användning på grund av potentiella säkerhets- och funktionsproblem.
Som en del av utfasningsprocessen för Apache Spark 2.4 vill vi meddela dig att AutoML i Azure Synapse Analytics också kommer att bli inaktuellt. Detta omfattar både gränssnittet med låg kod och de API:er som används för att skapa AutoML-utvärderingsversioner via kod.
Observera att AutoML-funktionen var exklusivt tillgänglig via Spark 2.4-körningen.
För kunder som vill fortsätta använda AutoML-funktioner rekommenderar vi att du sparar dina data i ditt Azure Data Lake Storage Gen2-konto (ADLSg2). Därifrån kan du sömlöst komma åt AutoML-upplevelsen via Azure Machine Learning (AzureML). Mer information om den här lösningen finns här.

Förstå regressionsmodeller

Regressionsmodeller förutsäger numeriska utdatavärden baserat på oberoende prediktorer. I regression är målet att hjälpa till att upprätta relationen mellan dessa oberoende förutsägelsevariabler genom att uppskatta hur en variabel påverkar de andra.

Exempel baserat på taxidata i New York City

I det här exemplet använder du Spark för att utföra en analys av tipsdata för taxiresor från New York City (NYC). Data är tillgängliga via Azure Open Datasets. Den här delmängden av datamängden innehåller information om gula taxiresor, inklusive information om varje resa, start- och sluttid och platser samt kostnaden.

Viktigt!

Det kan tillkomma ytterligare avgifter för att hämta dessa data från lagringsplatsen. I följande steg utvecklar du en modell för att förutsäga priser för NYC-taxipriser.

Ladda ned och förbereda data

Så här gör du:

Skapa en notebook-fil med hjälp av PySpark-kerneln. Anvisningar finns i Skapa en notebook-fil.

Kommentar

På grund av PySpark-kerneln behöver du inte skapa några kontexter explicit. Spark-kontexten skapas automatiskt åt dig när du kör den första kodcellen.

Eftersom rådata är i Parquet-format kan du använda Spark-kontexten för att hämta filen direkt till minnet som en DataFrame. Skapa en Spark DataFrame genom att hämta data via API:et Open Datasets. Här använder du Spark DataFrame-egenskaperna schema on read för att härleda datatyperna och schemat.

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)

Beroende på storleken på Din Spark-pool kan rådata vara för stora eller ta för lång tid att arbeta med. Du kan filtrera ned dessa data till något mindre, till exempel en månad med data, med hjälp start_date av filtren och end_date . När du har filtrerat en DataFrame kör describe() du även funktionen på den nya DataFrame för att se sammanfattningsstatistik för varje fält.

Baserat på sammanfattningsstatistiken kan du se att det finns vissa oegentligheter i data. Statistiken visar till exempel att det minsta reseavståndet är mindre än 0. Du måste filtrera bort dessa oregelbundna datapunkter.
```
# 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()
```

Generera funktioner från datauppsättningen genom att välja en uppsättning kolumner och skapa olika tidsbaserade funktioner från upphämtningsfältet datetime . Filtrera bort avvikande värden som identifierades från det tidigare steget och ta sedan bort de sista kolumnerna eftersom de är onödiga för träning.

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)

Som du ser skapar detta en ny DataFrame med ytterligare kolumner för dagen i månaden, upphämtningstimmen, veckodagen och den totala restiden.

Bild av taxi DataFrame.

Generera test- och valideringsdatauppsättningar

När du har din slutliga datauppsättning kan du dela upp data i tränings- och testuppsättningar med hjälp random_ split av funktionen i Spark. Genom att använda de angivna vikterna delar den här funktionen slumpmässigt upp data i träningsdatauppsättningen för modellträning och valideringsdatauppsättningen för testning.

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

Det här steget säkerställer att datapunkterna för att testa den färdiga modellen inte har använts för att träna modellen.

Ansluta till en Azure Machine Learning-arbetsyta

I Azure Machine Learning är en arbetsyta en klass som accepterar din Azure-prenumeration och resursinformation. Den skapar också en molnresurs för att övervaka och spåra dina körningar i modellen. I det här steget skapar du ett arbetsyteobjekt från den befintliga Azure Machine Learning-arbetsytan.

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)

Konvertera en DataFrame till en Azure Machine Learning-datauppsättning

Om du vill skicka ett fjärrexperiment konverterar du datamängden till en Azure Machine Learning-instans TabularDatset . TabularDataset representerar data i tabellformat genom att parsa de angivna filerna.

Följande kod hämtar den befintliga arbetsytan och standarddatalagret för Azure Machine Learning. Den skickar sedan datalagrings- och filplatserna till sökvägsparametern för att skapa en ny TabularDataset instans.

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

Bild av uppladdad datamängd.

Skicka ett automatiserat experiment

Följande avsnitt beskriver hur du skickar ett automatiserat maskininlärningsexperiment.

Definiera träningsinställningar

Om du vill skicka ett experiment måste du definiera experimentparametern och modellinställningarna för träning. En fullständig lista över inställningar finns i Konfigurera automatiserade maskininlärningsexperiment i 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}

Skicka de definierade träningsinställningarna som en kwargs parameter till ett AutoMLConfig objekt. Eftersom du använder Spark måste du också skicka Spark-kontexten, som automatiskt kan nås av variabeln sc . Dessutom anger du träningsdata och typ av modell, vilket är regression i det här fallet.

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)

Kommentar

Förbearbetningssteg för automatiserad maskininlärning blir en del av den underliggande modellen. De här stegen omfattar funktionsnormalisering, hantering av data som saknas och konvertering av text till numerisk. När du använder modellen för förutsägelser tillämpas samma förbearbetningssteg som tillämpas under träningen på dina indata automatiskt.

Träna den automatiska regressionsmodellen

Sedan skapar du ett experimentobjekt på din Azure Machine Learning-arbetsyta. Ett experiment fungerar som en container för enskilda körningar.

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

När experimentet är klart returnerar utdata information om de slutförda iterationerna. För varje iteration ser du modelltypen, körningens varaktighet samt träningens noggrannhet. Fältet BEST spårar träningspoängen som körs bäst baserat på din måtttyp.

Skärmbild av modellutdata.

Kommentar

När du har skickat det automatiserade maskininlärningsexperimentet körs olika iterationer och modelltyper. Den här körningen tar vanligtvis 60 till 90 minuter.

Hämta den bästa modellen

Om du vill välja den bästa modellen från dina iterationer använder du get_output funktionen för att returnera den bästa körningsmodellen och den anpassade modellen. Följande kod hämtar den bästa körningsmodellen och den anpassade modellen för alla loggade mått eller en viss iteration.

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

Testmodellnoggrannhet

Om du vill testa modellens noggrannhet använder du den bästa modellen för att köra taxiprisförutsägelser på testdatauppsättningen. Funktionen predict använder den bästa modellen och förutsäger värdena y för (prisbelopp) från valideringsdatauppsättningen.
```
# 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)
```
Rot-medelvärde-kvadrat-felet är ett vanligt mått på skillnaderna mellan exempelvärden som förutsägs av en modell och de värden som observerats. Du beräknar rot-medelvärde-kvadrat-felet för resultaten genom att y_test jämföra DataFrame med de värden som förutsägs av modellen.

Funktionen mean_squared_error tar två matriser och beräknar det genomsnittliga kvadratfelet mellan dem. Sedan tar du kvadratroten för resultatet. Det här måttet anger ungefär hur långt taxiprisförutsägelserna är från de faktiska prisvärdena.
```
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
```
Rot-medelvärde-kvadrat-felet är ett bra mått på hur exakt modellen förutsäger svaret. Från resultaten ser du att modellen är ganska bra på att förutsäga taxipriser från datamängdens funktioner, vanligtvis inom 2,00 USD.

Kör följande kod för att beräkna felet mean-absolute-percent. Det här måttet uttrycker noggrannhet som en procentandel av felet. Det gör det genom att beräkna en absolut skillnad mellan varje förutsagt och faktiskt värde och sedan summera alla skillnader. Sedan uttrycker den summan som en procentandel av summan av de faktiska värdena.

# 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

Från de två förutsägelsenoggrannhetsmåtten ser du att modellen är ganska bra på att förutsäga taxipriser från datamängdens funktioner.

När du har monterat en linjär regressionsmodell måste du nu bestämma hur väl modellen passar data. För att göra detta ritar du de faktiska prisvärdena mot de förväntade utdata. Dessutom beräknar du R-kvadratmåttet för att förstå hur nära data är den anpassade regressionslinjen.

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

Skärmbild av ett regressionsdiagram.

Från resultaten kan du se att R-kvadratmåttet står för 95 procent av variansen. Detta verifieras också av det faktiska diagrammet jämfört med det observerade diagrammet. Ju mer varians som regressionsmodellen står för, desto närmare faller datapunkterna till den anpassade regressionslinjen.

Registrera modellen till Azure Machine Learning

När du har verifierat din bästa modell kan du registrera den i Azure Machine Learning. Sedan kan du ladda ned eller distribuera den registrerade modellen och ta emot alla filer som du har registrerat.

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

Visa resultat i Azure Machine Learning

Du kan också komma åt resultatet av iterationerna genom att gå till experimentet på din Azure Machine Learning-arbetsyta. Här kan du få ytterligare information om status för körningen, försök till modeller och andra modellmått.

Skärmbild av en Azure Machine Learning-arbetsyta.

Dela via