Oktatóanyag: Modell betanítás a Pythonban automatizált gépi tanulással

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

Ebben az oktatóanyagban automatizált gépi tanulást fog használni a Azure Machine Learning egy regressziós modell létrehozásához a taxik árának előrejelzése érdekében. Ez a folyamat úgy érkezik a legjobb modellhez, hogy elfogadja a betanítási adatokat és a konfigurációs beállításokat, és automatikusan iterál különböző metódusok, modellek és hiperparaméter-beállítások kombinációjával.

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

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

Előkészületek

  • Hozzon létre egy kiszolgáló nélküli Apache Spark a Kiszolgáló nélküli adatbázis létrehozása Apache Spark rövid útmutató alapján.
  • Ha még nem Azure Machine Learning meglévő munkaterülettel, Azure Machine Learning a munkaterület beállítását ismertető oktatóanyagot.

A regressziós modellek

A regressziós modellek numerikus kimeneti értékeket jeleznek előre független előrejelzők alapján. A regresszió célja, hogy segítsen a független prediktív változók közötti kapcsolat megállapításában azáltal, hogy megbecsüli, hogyan befolyásolja az egyik változó a többit.

New York-i taxiadatokon alapuló példa

Ebben a példában a Spark használatával fog elemzést végezni a New York-i (NYC) taxisofőr-tipp adatain. Az adatok a következőn keresztül Azure Open Datasets. Az adatkészlet ezen részkészlete információkat tartalmaz a sárga taxis utakról, beleértve az egyes utakkal, a kezdési és a záró időpontokkal és helyekkel kapcsolatos információkat, valamint a költségeket.

Fontos

Előfordulhat, hogy az adatok tárolási helyéről való lekért adatokért további díjakat kell fizetni. A következő lépésekben egy modellt fog kifejleszteni az NYC taxiárak előrejelzése érdekében.

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

Ezt a következőképpen teheti meg:

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

    Megjegyzés

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

  2. Mivel a nyers adatok Parquet formátumúak, a Spark-környezettel közvetlenül a memóriába is lekérte a fájlt DataFrame-ként. Hozzon létre egy Spark DataFrame-et az adatok a Open Datasets API-n keresztüli le Open Datasets le. Itt a Spark DataFrame tulajdonságaival kiveszi schema on read az adattípusokat és a sémát.

    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)
    
    
  3. A Spark-készlet méretétől függően előfordulhat, hogy a nyers adatok túl nagyok, vagy túl sok ideig tart a használat. Az és a szűrővel szűrheti az adatokat kisebbre, például egy hónap start_date end_date adatra. A DataFrame szűrése után a függvényt az új DataFrame-en is futtatja az egyes mezők összegző describe() statisztikáinak megtekintése érdekében.

    Az összefoglaló statisztikák alapján láthatja, hogy az adatokban vannak rendellenességek. A statisztikák például azt mutatják, hogy a minimális út távolsága 0-snál kisebb. Ezeket a szabálytalan adatpontokat ki kell szűrni.

    # 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()
    
  4. Az adatkészletből úgy hozhat létre szolgáltatásokat, hogy kiválaszt egy oszlopkészletet, és különböző időalapú funkciókat hoz létre a csomagfelvételi datetime mezőből. Szűrje ki az előző lépésben azonosított kiadatokat, majd távolítsa el az utolsó néhány oszlopot, mert nincs szükség betanításra.

    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)
    

    Amint látható, ezzel létrehoz egy új DataFrame-et, amely további oszlopokat tartalmaz a hónap napjával, a csomagfelvétel órájával, a hétköznapokkal és az utazás teljes időtartamával.

    A taxis adatkeret képe.

Teszt- és ellenőrzési adatkészletek létrehozása

A végső adathalmazt követően feloszthatja az adatokat betanítás és tesztelési készletekre a random_ split Spark függvényének használatával. A megadott súlyok használatával ez a függvény véletlenszerűen felosztja az adatokat a modell betanítása és az ellenőrzési adatkészlet betanítása céljából.

# 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ére használt adatpontok nem voltak használva a modell betanítása során.

Csatlakozás Azure Machine Learning munkaterülethez

A Azure Machine Learning munkaterület egy osztály, amely elfogadja az Azure-előfizetését és az erőforrás-adatait. Emellett létrehoz egy felhőerőforrást is a modell futtatásának figyelése és nyomon követése számára. Ebben a lépésben egy munkaterület-objektumot hoz létre a meglévő Azure Machine Learning munkaterületről.

from azureml.core import Workspace

# Enter your workspace subscription, resource group, name, and region.
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
workspace_region = "<enter workspace region>" #your region

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

Adatkeret átalakítása Azure Machine Learning adatkészletké

Távoli kísérlet elküldéhez alakítsa át az adatkészletet egy Azure Machine Learning TabularDatset példányká. A TabularDataset táblázatos formában jelöli az adatokat a megadott fájlok elemezve.

A következő kód lekérte a meglévő munkaterületet és az alapértelmezett Azure Machine Learning adattárat. Ezután továbbítja az adattár és a fájl helyét a path paraméternek egy új példány TabularDataset 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')])

Feltöltött adatkészlet képe.

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

A következő szakaszok végigkísérik egy automatizált gépi tanulási kísérlet beküldésének folyamatán.

Betanítás beállításainak megadása

  1. Kísérlet elküldéhez meg kell határoznia a kísérlet paramétereit és a modell beállításait a betanításhoz. A beállítások teljes listáját 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}
    
  2. Adja át paraméterként a megadott betanítási kwargs beállításokat egy AutoMLConfig objektumnak. Mivel a Sparkot használja, a Spark-környezetet is át kell adnia, amelyet a változó automatikusan sc elérhetővé fog tenni. Emellett meg kell adnia a betanítási adatokat és a modell típusát, ami 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)
    

Megjegyzés

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

Az automatikus regressziós modell betanítása

Ezután hozzon létre egy kísérletobjektumot a Azure Machine Learning munkaterületén. A kísérletek tárolóként is viselkednek az egyes futtatásokat tárolóként.

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 visszaadja a befejezett iterációk részleteit. Az egyes iterációkhoz láthatja a modell típusát, a futtatás időtartamát és a betanítási pontosságot. A mező a metrika típusa alapján követi nyomon a legjobban BEST futó betanítás pontszámát.

A modell kimenetének képernyőképe.

Megjegyzé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

Ha a legjobb modellt választja ki az iterációk közül, a függvény használatával adja vissza a get_output legjobb futtatási és illeszthető modellt. Az alábbi kód lekéri a legjobb futtatási és illesztett modellt bármely naplózott metrika vagy egy adott iteráció esetében.

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

Modell pontosságának tesztelése

  1. A modell pontosságának teszteléséhez használja a legjobb modellt a taxikra vonatkozó előrejelzések tesztadatkészleten való futtatásához. A függvény a legjobb modellt használja, és előrejelezni az érvényesítési adatkészletből származó predict y (viteldíj összege) értékeket.

    # 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)
    
  2. A gyökér-átlag-négyzet hiba a modell által előrejel jelzett mintaértékek és a megfigyelt értékek közötti különbségek gyakran használt mértéke. Az eredmények átlag-négyzetgyökének kiszámításához hasonlítsa össze a DataFrame-et a modell által előrejel y_test jelzett értékekkel.

    A függvény két tömböt vesz fel, és kiszámítja közöttük az mean_squared_error átlagos négyzetes hibát. Ezután vegyük az eredmény négyzetgyökét. Ez a metrika nagyjából azt jelzi, hogy a taxik ára milyen messze van a tényleges viteldíj értékeitő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-átlagos-négyzet hiba jól mérhető, hogy a modell milyen pontosan előrejelezik a választ. Az eredményekből láthatja, hogy a modell viszonylag jól előrejelezni tudja az adatkészlet jellemzőiből a taxik árának előrejelzését, jellemzően 2,00 dolláron belül.

  3. A következő kód futtatásával számítsa ki az átlag-abszolút-százalék hibát. Ez a metrika a hiba százalékában fejezi ki a pontosságot. Ezt úgy teszi meg, hogy kiszámítja az előrejel jelzett és a tényleges értékek közötti abszolút különbséget, majd összegezve 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 mérőszámból láthatja, hogy a modell viszonylag jól előrejelezni tudja a taxik által az adatkészlet jellemzőitől mérten mért árakat.

  4. A lineáris regressziós modell illesztése után meg kell határoznia, hogy a modell mennyire illeszkedik az adatokhoz. Ehhez a tényleges viteldíj értékeit kell ábrázolni az előrejel jelzett kimenethez. Emellett kiszámítja az R-négyzetes mértéket, hogy megértse, milyen közel vannak az adatok az illesztett 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 ábrázolás képernyőképe.

    Az eredményekből látható, hogy az R-négyzet alakú mérték a variancia 95 százalékát jelenti. Ezt a tényleges és a megfigyelt ábrázolás is ellenőrzi. Minél nagyobb a variancia, amely a regressziós modellhez tartozik, annál közelebb esnek az adatpontok az illesztott regressziós vonalhoz.

A modell regisztrálása Azure Machine Learning

A legjobb modell ellenőrzése után regisztrálhatja azt a Azure Machine Learning. Ezután letöltheti vagy üzembe helyezheti a regisztrált modellt, és fogadhatja az összes regisztrált fájlt.

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

Eredmények megtekintése a Azure Machine Learning

Az iterációk eredményeit úgy is elérheti, ha a saját munkaterületén található Azure Machine Learning meg. 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 Learning munkaterületről.

Következő lépések