Oktatóanyag: Modell betanítása Pythonban automatizált gépi tanulással (elavult)

Cikk
03/07/2024

Az Azure Machine Tanulás egy felhőalapú környezet, amely lehetővé teszi a gépi tanulási modellek betanítása, üzembe helyezése, automatizálása, kezelése és nyomon követése.

Ebben az oktatóanyagban az Azure Machine Tanulás automatizált gépi tanulását használva hoz létre regressziós modellt a taxidíjak előrejelzéséhez. Ez a folyamat a legjobb modellhez érkezik a betanítási adatok és a konfigurációs beállítások elfogadásával, valamint a különböző módszerek, modellek és hiperparaméter-beállítások kombinációjának automatikus iterálásával.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

Töltse le az adatokat az Apache Spark és az Azure Open Datasets használatával.
Adatok átalakítása és tisztítása Apache Spark DataFrame-ek használatával.
Regressziós modell betanítása automatizált gépi tanulásban.
Modell pontosságának kiszámítása.

Mielőtt elkezdené

Hozzon létre egy kiszolgáló nélküli Apache Spark 2.4-készletet a kiszolgáló nélküli Apache Spark-készlet gyorsútmutatójának követésével.
Ha nem rendelkezik meglévő Azure Machine-Tanulás-munkaterületével, végezze el az Azure Machine Tanulás munkaterület beállítási oktatóanyagát.

Figyelmeztetés

2023. szeptember 29-én az Azure Synapse megszünteti a Spark 2.4-futtatókörnyezetek hivatalos támogatását. 2023. szeptember 29-én nem foglalkozunk a Spark 2.4-hez kapcsolódó támogatási jegyekkel. A Spark 2.4 hiba- vagy biztonsági javításaihoz nem lesz kiadási folyamat. A Spark 2.4-et a támogatási leépítési dátum után saját felelősségre hajtjuk végre. A potenciális biztonsági és működési problémák miatt határozottan elriasztjuk a folyamatos használattól.
Az Apache Spark 2.4 elavulásának részeként értesíteni szeretnénk, hogy az Azure Synapse Analytics autoML-jének elavultsága is megszűnik. Ez magában foglalja az alacsony kódfelületet és az AutoML-próbaverziók kódon keresztüli létrehozásához használt API-kat is.
Vegye figyelembe, hogy az AutoML funkció kizárólag a Spark 2.4-es futtatókörnyezeten keresztül volt elérhető.
AzOknak az ügyfeleknek, akik továbbra is szeretnék kihasználni az AutoML képességeit, javasoljuk, hogy mentse az adatokat az Azure Data Lake Storage Gen2 (ADLSg2) fiókjába. Innen zökkenőmentesen elérheti az AutoML-felületet az Azure Machine Tanulás (AzureML) használatával. A kerülő megoldással kapcsolatos további információk itt érhetők el.

Regressziós modellek ismertetése

A regressziós modellek numerikus kimeneti értékeket jeleznek előre független prediktorok alapján. A regresszióban a cél az, hogy segítsünk a független prediktor változók közötti kapcsolat kialakításában azáltal, hogy megbecsüljük, hogy az egyik változó hogyan hat a többire.

Példa a New York-i taxiadatok alapján

Ebben a példában a Spark használatával végez elemzést a New York Cityből (NYC) származó taxiút-tippadatokról. Az adatok az Azure Open Datasetsen keresztül érhetők el. Az adatkészlet ezen részhalmaza információkat tartalmaz a sárga taxis utakról, beleértve az egyes utazásokról, a kezdési és befejezési időpontokról és helyekről, valamint a költségekről szóló információkat.

Fontos

Előfordulhat, hogy az adatok tárolási helyről való lekérése további költségekkel jár. A következő lépésekben egy modellt fejleszt a NYC taxiárak előrejelzéséhez.

Az adatok letöltése és előkészítése

Ennek módja az alábbi:

Hozzon létre egy jegyzetfüzetet a PySpark kernel használatával. Útmutatásért lásd: Jegyzetfüzet létrehozása.

Feljegyzés

A PySpark kernel miatt nem kell explicit módon létrehoznia a környezeteket. A Spark-környezet automatikusan létrejön az első kódcella futtatásakor.

Mivel a nyers adatok Parquet formátumúak, a Spark-környezettel dataFrame-ként közvetlenül lekérheti a fájlt a memóriába. Spark DataFrame létrehozása az adatok Open Datasets API-val történő beolvasásával. Itt a Spark DataFrame schema on read tulajdonságaival következtethet az adattípusokra és a sémára.

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)

A Spark-készlet méretétől függően előfordulhat, hogy a nyers adatok túl nagyok, vagy túl sok időt vesznek igénybe a működéshez. Ezeket az adatokat kisebbre, például egy hónapnyi adatra szűrheti a szűrők és end_date a start_date szűrők használatával. A DataFrame szűrése után az új DataFrame-en is futtatja a describe() függvényt az egyes mezők összesített statisztikáinak megtekintéséhez.

Az összefoglaló statisztikák alapján láthatja, hogy vannak szabálytalanságok az adatokban. A statisztikák például azt mutatják, hogy a minimális utazási távolság 0-nál kisebb. Ki kell szűrnie ezeket a szabálytalan adatpontokat.
```
# 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()
```

Az adathalmaz funkcióinak létrehozásához válasszon ki egy oszlopkészletet, és hozzon létre különböző időalapú szolgáltatásokat a felvételi datetime mezőből. Szűrje ki a korábbi lépésben azonosított kiugró értékeket, majd távolítsa el az utolsó néhány oszlopot, mert ezek nem szükségesek a betanításhoz.

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)

Mint látható, ez létrehoz egy új DataFrame-et, amely további oszlopokat tartalmaz a hónap napjára, a csomagfelvételi órára, a hétköznapra és a teljes utazási időre vonatkozóan.

A taxi DataFrame képe.

Teszt- és érvényesítési adathalmazok létrehozása

A végleges adathalmazt követően a Spark függvény használatával feloszthatja az adatokat betanítási és tesztelési random_ split csoportokra. A megadott súlyok használatával ez a függvény véletlenszerűen felosztja az adatokat a modell betanításához használt betanítási adatkészletre és a teszteléshez szükséges érvényesítési adatkészletre.

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

Ez a lépés biztosítja, hogy a kész modell teszteléséhez használt adatpontok nem lettek használva a modell betanítására.

Csatlakozás Azure Machine Tanulás-munkaterületre

Az Azure Machine Tanulás egy olyan osztály, amely elfogadja az Azure-előfizetést és az erőforrás-információkat. Emellett létrehoz egy felhőalapú erőforrást a modellfuttatások figyeléséhez és nyomon követéséhez. Ebben a lépésben egy munkaterület-objektumot hoz létre a meglévő Azure Machine Tanulás munkaterületről.

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)

DataFrame átalakítása Azure Machine-Tanulás-adatkészletté

Távoli kísérlet elküldéséhez konvertálja az adathalmazt egy Azure Machine Tanulás-példánysáTabularDatset. A TabularDataset táblázatos formátumban jeleníti meg az adatokat a megadott fájlok elemzésével.

Az alábbi kód lekéri a meglévő munkaterületet és az alapértelmezett Azure Machine-Tanulás adattárat. Ezután átadja az adattárat és a fájlhelyeket az elérési út paraméternek egy új TabularDataset példány létrehozásához.

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

A feltöltött adathalmaz képe.

Automatizált kísérlet elküldése

Az alábbi szakaszok végigvezetik egy automatizált gépi tanulási kísérlet beküldésének folyamatán.

Betanítási beállítások megadása

A kísérlet elküldéséhez meg kell határoznia a betanításhoz szükséges kísérletparamétert és modellbeállításokat. A beállítások teljes listájáért lásd : Automatizált gépi tanulási kísérletek konfigurálása a Pythonban.

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}

Adja át a megadott betanítási beállításokat paraméterként kwargs egy AutoMLConfig objektumnak. Mivel Sparkot használ, át kell adnia a Spark-környezetet is, amelyet a sc változó automatikusan elér. Emellett meg kell adnia a betanítási adatokat és a modell típusát, amely ebben az esetben regresszió.

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)

Feljegyzés

Az automatizált gépi tanulás előfeldolgozási lépései az alapul szolgáló modell részévé válnak. Ezek a lépések közé tartozik a funkció normalizálása, a hiányzó adatok kezelése és a szöveg numerikussá alakítása. Ha a modellt előrejelzésekhez használja, a betanítás során alkalmazott előfeldolgozási lépések automatikusan érvényesek lesznek a bemeneti adatokra.

Az automatikus regressziós modell betanítása

Ezután létrehoz egy kísérletobjektumot az Azure Machine Tanulás-munkaterületen. A kísérletek tárolóként szolgálnak az egyes futtatásokhoz.

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

Ha a kísérlet befejeződött, a kimenet a befejezett iterációk részleteit adja vissza. Minden iteráció esetében megjelenik a modell típusa, a futtatás időtartama és a betanítás pontossága. A BEST mező a metrikatípus alapján követi nyomon a legjobban futó betanítási pontszámot.

Képernyőkép a modell kimenetéről.

Feljegyzés

Az automatizált gépi tanulási kísérlet elküldése után különböző iterációkat és modelltípusokat futtat. Ez a futtatás általában 60–90 percet vesz igénybe.

A legjobb modell lekérése

Az iterációk közül a legjobb modell kiválasztásához használja a get_output függvényt a legjobb futtatási és illesztett modell visszaadásához. Az alábbi kód lekéri a legjobban futtatott és beszerelt modellt minden naplózott metrikához vagy egy adott iterációhoz.

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

Modell pontosságának tesztelése

A modell pontosságának teszteléséhez használja a legjobb modellt taxidíj-előrejelzések futtatásához a tesztadatkészleten. A predict függvény a legjobb modellt használja, és előrejelzi az érvényesítési adatkészletből származó (viteldíj-összeg) értékeket y .
```
# 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)
```
A gyökér-közép-négyzet hiba a modell által előrejelzett mintaértékek és a megfigyelt értékek közötti különbségek gyakran használt mértéke. Az eredmények gyökér-közép-négyzet hibájának kiszámításához hasonlítsa össze a y_test DataFrame-et a modell által előrejelzett értékekkel.

A függvény mean_squared_error két tömböt használ, és kiszámítja közöttük az átlagos négyzetes hibát. Ezután meg kell adnia az eredmény négyzetgyökét. Ez a metrika nagyjából azt jelzi, hogy a taxi viteldíj-előrejelzései milyen messze vannak a tényleges viteldíjértékektől.
```
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
```
A gyökér-közép-négyzet hiba jó mérték annak, hogy a modell milyen pontosan előrejelzi a választ. Az eredményekből látható, hogy a modell meglehetősen jó előrejelzést nyújt az adathalmaz jellemzőiből származó taxidíjakra, jellemzően 2,00 dolláron belül.

Futtassa a következő kódot a közép-abszolút százalékos hiba kiszámításához. Ez a metrika a hiba százalékában fejezi ki a pontosságot. Ezt úgy teszi, hogy kiszámít egy abszolút különbséget az egyes előrejelzett és a tényleges értékek között, majd összegzi az összes különbséget. Ezután ezt az összeget a tényleges értékek összegének százalékában fejezi ki.

# 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

A két előrejelzési pontossági metrika alapján láthatja, hogy a modell elég jó a taxidíjak előrejelzéséhez az adathalmaz funkcióitól.

A lineáris regressziós modell illesztése után meg kell határoznia, hogy a modell milyen jól illeszkedik az adatokhoz. Ehhez a tényleges viteldíjértékeket az előrejelzett kimenethez kell ábrázolnia. Emellett kiszámítja az R négyzetes mértéket, hogy megértse, milyen közel vannak az adatok a rögzített regressziós vonalhoz.

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

Regressziós diagram képernyőképe.

Az eredményekből láthatja, hogy az R négyzetes mérték a variancia 95 százalékát teszi ki. Ezt a tényleges diagram és a megfigyelt ábrázolás is ellenőrzi. Minél nagyobb eltérést mutat a regressziós modell, annál közelebb kerülnek az adatpontok a rögzített regressziós vonalhoz.

A modell regisztrálása az Azure Machine Tanulás

Miután ellenőrizte a legjobb modellt, regisztrálhatja azt az Azure Machine Tanulás. Ezután letöltheti vagy üzembe helyezheti a regisztrált modellt, és megkaphatja az összes regisztrált fájlt.

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

Eredmények megtekintése az Azure Machine Tanulás

Az iterációk eredményeihez az Azure Machine Tanulás munkaterületén található kísérlet megtekintésével is hozzáférhet. Itt további részleteket kaphat a futtatás állapotáról, a megkísérelt modellekről és más modellmetrikákról.

Képernyőkép egy Azure Machine Tanulás-munkaterületről.

Megosztás a következőn keresztül: