Träna regressionsmodell med automatiserad ML och Python (SDK v1)

GÄLLER FÖR: Python SDK azureml v1

I den här artikeln får du lära dig hur du tränar en regressionsmodell med Azure Mašinsko učenje Python SDK med hjälp av Azure Mašinsko učenje Automatiserad ML. Regressionsmodellen förutsäger passagerarpriser för taxibilar som körs i New York City (NYC). Du skriver kod med Python SDK för att konfigurera en arbetsyta med förberedda data, träna modellen lokalt med anpassade parametrar och utforska resultaten.

Processen accepterar träningsdata och konfigurationsinställningar. Den itererar automatiskt genom kombinationer av olika metoder för funktionsnormalisering/standardisering, modeller och hyperparameterinställningar för att komma fram till den bästa modellen. Följande diagram illustrerar processflödet för regressionsmodellträningen:

Förutsättningar

• En Azure-prenumeration. Du kan skapa ett kostnadsfritt eller betalt konto för Azure Mašinsko učenje.

• En Azure Mašinsko učenje-arbetsyta eller beräkningsinstans. Information om hur du förbereder dessa resurser finns i Snabbstart: Kom igång med Azure Mašinsko učenje.

• Hämta förberedda exempeldata för självstudierna genom att läsa in en notebook-fil på din arbetsyta:

  1. Gå till din arbetsyta i Azure Mašinsko učenje Studio, välj Notebooks och välj sedan fliken Exempel.

  2. I listan över notebook-filer expanderar du självstudierna>för Samples>SDK v1>regression-automl-nyc-taxi-data.

  3. Välj notebook-filen regression-automated-ml.ipynb.

  4. Om du vill köra varje notebook-cell som en del av den här självstudien väljer du Klona den här filen.

  Alternativ metod: Om du vill kan du köra självstudierna i en lokal miljö. Självstudien är tillgänglig i Azure Mašinsko učenje Notebooks-lagringsplatsen på GitHub. Följ dessa steg för att hämta de paket som krävs för den här metoden:

  1. Installera den fullständiga automl klienten.

  2. pip install azureml-opendatasets azureml-widgets Kör kommandot på den lokala datorn för att hämta de paket som krävs.

Ladda ned och förbereda data

Paketet Öppna datauppsättningar innehåller en klass som representerar varje datakälla (till exempel NycTlcGreen) för att enkelt filtrera datumparametrar innan du laddar ned.

Följande kod importerar nödvändiga paket:

from azureml.opendatasets import NycTlcGreen
import pandas as pd
from datetime import datetime
from dateutil.relativedelta import relativedelta

Det första steget är att skapa en dataram för taxidata. När du arbetar i en icke-Spark-miljö tillåter Open Datasets-paketet endast nedladdning av en månads data i taget med vissa klasser. Den här metoden hjälper till att undvika det MemoryError problem som kan uppstå med stora datamängder.

Om du vill ladda ned taxidata hämtar du iterativt en månad i taget. Innan du lägger till nästa uppsättning data i dataramen green_taxi_df ska du slumpmässigt sampla 2 000 poster från varje månad och sedan förhandsgranska data. Den här metoden hjälper till att undvika att dataramen svälls upp.

Följande kod skapar dataramen, hämtar data och läser in dem i dataramen:

green_taxi_df = pd.DataFrame([])
start = datetime.strptime("1/1/2015","%m/%d/%Y")
end = datetime.strptime("1/31/2015","%m/%d/%Y")

for sample_month in range(12):
   temp_df_green = NycTlcGreen(start + relativedelta(months=sample_month), end + relativedelta(months=sample_month)) \
      .to_pandas_dataframe()
   green_taxi_df = green_taxi_df.append(temp_df_green.sample(2000))

green_taxi_df.head(10)

I följande tabell visas de många kolumnerna med värden i exempeltaxidata:

Det är bra att ta bort vissa kolumner som du inte behöver för träning eller andra funktioner. Du kan till exempel ta bort kolumnen lpepPickupDatetime eftersom automatiserad ML automatiskt hanterar tidsbaserade funktioner.

Följande kod tar bort 14 kolumner från exempeldata:

columns_to_remove = ["lpepDropoffDatetime", "puLocationId", "doLocationId", "extra", "mtaTax",
                "improvementSurcharge", "tollsAmount", "ehailFee", "tripType", "rateCodeID",
                "storeAndFwdFlag", "paymentType", "fareAmount", "tipAmount"
               ]
for col in columns_to_remove:
   green_taxi_df.pop(col)

green_taxi_df.head(5)

Rensa data

Nästa steg är att rensa data.

Följande kod kör describe() funktionen i den nya dataramen för att skapa sammanfattningsstatistik för varje fält:

green_taxi_df.describe()

Följande tabell visar sammanfattningsstatistik för de återstående fälten i exempeldata:

Sammanfattningsstatistiken visar flera fält som är extremvärden, vilket är värden som minskar modellens noggrannhet. För att åtgärda problemet filtrerar du fälten latitud/longitud (lat/long) så att värdena ligger inom gränserna för Manhattan-området. Den här metoden filtrerar bort längre taxiresor eller resor som är avvikande när det gäller deras relation till andra funktioner.

Filtrera sedan fältet tripDistance efter värden som är större än noll men mindre än 31 miles (haversinavståndet mellan de två lat/långa paren). Den här tekniken eliminerar långa avvikande resor som har inkonsekventa resekostnader.

Slutligen har fältet totalAmount negativa värden för taxipriser, vilket inte är meningsfullt i samband med modellen. Fältet passengerCount innehåller också felaktiga data där minimivärdet är noll.

Följande kod filtrerar bort dessa värdeavvikelser med hjälp av frågefunktioner. Koden tar sedan bort de sista kolumnerna som inte behövs för träning:

final_df = green_taxi_df.query("pickupLatitude>=40.53 and pickupLatitude<=40.88")
final_df = final_df.query("pickupLongitude>=-74.09 and pickupLongitude<=-73.72")
final_df = final_df.query("tripDistance>=0.25 and tripDistance<31")
final_df = final_df.query("passengerCount>0 and totalAmount>0")

columns_to_remove_for_training = ["pickupLongitude", "pickupLatitude", "dropoffLongitude", "dropoffLatitude"]
for col in columns_to_remove_for_training:
   final_df.pop(col)

Det sista steget i den här sekvensen describe() är att anropa funktionen igen på data för att säkerställa att rensningen fungerade som förväntat. Nu har du en förberedd och rensad uppsättning taxi-, semester- och väderdata som ska användas för maskininlärningsmodellträning:

final_df.describe()

Konfigurera arbetsyta

Skapa ett arbetsyteobjekt från den befintliga arbetsytan. En arbetsyta är 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.

Följande kod anropar Workspace.from_config() funktionen för att läsa config.json-filen och läsa in autentiseringsinformationen i ett objekt med namnet ws.

from azureml.core.workspace import Workspace
ws = Workspace.from_config()

Objektet ws används i resten av koden i den här självstudien.

Dela data till uppsättningar för träning och testning

Dela upp data i tränings- och testuppsättningar med hjälp train_test_split av funktionen i scikit-learn-biblioteket . Den här funktionen separerar data i datauppsättningen x (funktioner) för modellträning och datauppsättningen y (värden att förutsäga) för testning.

Parametern test_size anger procentandelen av data som ska allokeras till testning. Parametern random_state anger ett frö till den slumpmässiga generatorn, så att dina träningstestsplitter är deterministiska.

Följande kod anropar train_test_split funktionen för att läsa in x- och y-datauppsättningarna:

from sklearn.model_selection import train_test_split

x_train, x_test = train_test_split(final_df, test_size=0.2, random_state=223)

Syftet med det här steget är att förbereda datapunkter för att testa den färdiga modellen som inte används för att träna modellen. Dessa punkter används för att mäta sann noggrannhet. En vältränad modell är en modell som kan göra korrekta förutsägelser från osynliga data. Nu har du data som förberetts för automatisk träning av en maskininlärningsmodell.

Träna modell automatiskt

För att träna en modell automatiskt gör du följande:

1. Definiera inställningar för körningen av experimentet. Koppla dina träningsdata till konfigurationen och ändra de inställningar som styr träningsprocessen.

2. Skicka experimentet för modelljustering. När du har skickat experimentet itererar processen genom olika maskininlärningsalgoritmer och inställningar för hyperparameter, vilket följer dina definierade begränsningar. Den väljer den modell som passar bäst genom att optimera ett noggrannhetsmått.

Definiera träningsinställningar

Definiera experimentparametern och modellinställningarna för träning. Visa hela listan med inställningar. Det tar cirka 5–20 minuter att skicka experimentet med dessa standardinställningar. Minska parametern experiment_timeout_hours om du vill minska körningstiden.

Följande kod skickar experimentet:

import logging

automl_settings = {
   "iteration_timeout_minutes": 10,
   "experiment_timeout_hours": 0.3,
   "enable_early_stopping": True,
   "primary_metric": 'spearman_correlation',
   "featurization": 'auto',
   "verbosity": logging.INFO,
   "n_cross_validations": 5
}

Med följande kod kan du använda dina definierade träningsinställningar som en **kwargs parameter till ett AutoMLConfig objekt. Dessutom anger du dina träningsdata och typen 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=x_train,
                      label_column_name="totalAmount",
                      **automl_settings)

Träna automatisk regressionsmodell

Skapa ett experimentobjekt på din arbetsyta. Ett experiment fungerar som en container för dina enskilda jobb. Skicka det definierade automl_config objektet till experimentet och ange utdata till Sant för att visa förloppet under jobbet.

När du har startat experimentet uppdateras de utdata som visas live när experimentet körs. För varje iteration ser du modelltypen, körningens varaktighet och träningsnoggrannheten. Fältet BEST spårar den bästa träningspoängen baserat på din måtttyp:

from azureml.core.experiment import Experiment
experiment = Experiment(ws, "Tutorial-NYCTaxi")
local_run = experiment.submit(automl_config, show_output=True)

Så här ser utdata ut:

Running on local machine
Parent Run ID: AutoML_1766cdf7-56cf-4b28-a340-c4aeee15b12b
Current status: DatasetFeaturization. Beginning to featurize the dataset.
Current status: DatasetEvaluation. Gathering dataset statistics.
Current status: FeaturesGeneration. Generating features for the dataset.
Current status: DatasetFeaturizationCompleted. Completed featurizing the dataset.
Current status: DatasetCrossValidationSplit. Generating individually featurized CV splits.
Current status: ModelSelection. Beginning model selection.

****************************************************************************************************
ITERATION: The iteration being evaluated.
PIPELINE: A summary description of the pipeline being evaluated.
DURATION: Time taken for the current iteration.
METRIC: The result of computing score on the fitted pipeline.
BEST: The best observed score thus far.
****************************************************************************************************

 ITERATION   PIPELINE                              DURATION     METRIC     BEST
       0   StandardScalerWrapper RandomForest          0:00:16      0.8746   0.8746
       1   MinMaxScaler RandomForest                 0:00:15      0.9468   0.9468
       2   StandardScalerWrapper ExtremeRandomTrees      0:00:09      0.9303   0.9468
       3   StandardScalerWrapper LightGBM             0:00:10      0.9424   0.9468
       4   RobustScaler DecisionTree                 0:00:09      0.9449   0.9468
       5   StandardScalerWrapper LassoLars            0:00:09      0.9440   0.9468
       6   StandardScalerWrapper LightGBM             0:00:10      0.9282   0.9468
       7   StandardScalerWrapper RandomForest          0:00:12      0.8946   0.9468
       8   StandardScalerWrapper LassoLars            0:00:16      0.9439   0.9468
       9   MinMaxScaler ExtremeRandomTrees            0:00:35      0.9199   0.9468
      10   RobustScaler ExtremeRandomTrees            0:00:19      0.9411   0.9468
      11   StandardScalerWrapper ExtremeRandomTrees      0:00:13      0.9077   0.9468
      12   StandardScalerWrapper LassoLars            0:00:15      0.9433   0.9468
      13   MinMaxScaler ExtremeRandomTrees            0:00:14      0.9186   0.9468
      14   RobustScaler RandomForest                 0:00:10      0.8810   0.9468
      15   StandardScalerWrapper LassoLars            0:00:55      0.9433   0.9468
      16   StandardScalerWrapper ExtremeRandomTrees      0:00:13      0.9026   0.9468
      17   StandardScalerWrapper RandomForest          0:00:13      0.9140   0.9468
      18   VotingEnsemble                         0:00:23      0.9471   0.9471
      19   StackEnsemble                          0:00:27      0.9463   0.9471

Utforska resultat

Utforska resultatet av automatisk träning med en Jupyter-widget. Med widgeten kan du se ett diagram och en tabell med alla enskilda jobb-iterationer, tillsammans med träningsnoggrannhetsmått och metadata. Dessutom kan du filtrera på olika noggrannhetsmått än ditt primära mått med listruteväljaren.

Följande kod skapar en graf för att utforska resultaten:

from azureml.widgets import RunDetails
RunDetails(local_run).show()

Körningsinformationen för Jupyter-widgeten:

Ritdiagrammet för Jupyter-widgeten:

Hämta bästa modell

Med följande kod kan du välja den bästa modellen från dina iterationer. Funktionen get_output returnerar den bästa körningen och den anpassade modellen för den senaste anropet. Genom att använda överlagringarna på get_output funktionen kan du hämta den bästa körningsmodellen och den anpassade modellen för alla loggade mått eller en viss iteration.

best_run, fitted_model = local_run.get_output()
print(best_run)
print(fitted_model)

Testa bästa modellnoggrannhet

Använd den bästa modellen för att köra förutsägelser på testdatauppsättningen för att förutsäga taxipriser. Funktionen predict använder den bästa modellen och förutsäger värdena för y, resekostnad, från datauppsättningen x_test .

Följande kod skriver ut de första 10 förutsagda kostnadsvärdena från datauppsättningen y_predict :

y_test = x_test.pop("totalAmount")

y_predict = fitted_model.predict(x_test)
print(y_predict[:10])

Beräkna root mean squared error för resultatet. Konvertera dataramen y_test till en lista och jämför med de förutsagda värdena. Funktionen mean_squared_error tar två matriser med värden och beräknar det genomsnittliga kvadratfelet mellan dem. Att ta kvadratroten ur resultatet ger ett fel i samma enheter som y-variabeln, kostnad. Det indikerar ungefär hur långt taxiprisförutsägelserna är från de faktiska priserna.

from sklearn.metrics import mean_squared_error
from math import sqrt

y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))
rmse

Kör följande kod för att beräkna genomsnittligt absolut procentfel (MAPE) med hjälp av de fullständiga y_actual datauppsättningarna och y_predict datauppsättningarna. Det här måttet beräknar en absolut skillnad mellan varje förväntat och faktiskt värde och summerar alla skillnaderna. Sedan uttrycker den summan som en procent av summan av de faktiska värdena.

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)

Så här ser utdata ut:

Model MAPE:
0.14353867606052823

Model Accuracy:
0.8564613239394718

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, vanligtvis inom +- 4,00 USD och cirka 15 % fel.

Den traditionella utvecklingsprocessen för maskininlärningsmodeller är mycket resurskrävande. Det kräver betydande domänkunskap och tidsinvesteringar för att köra och jämföra resultaten från dussintals modeller. Användning av automatisk maskininlärning är ett bra sätt att snabbt testa flera olika modeller för ett scenario.

Rensa resurser

Om du inte planerar att arbeta med andra Självstudier för Azure Mašinsko učenje utför du följande steg för att ta bort de resurser som du inte längre behöver.

Stoppa beräkning

Om du använde en beräkning kan du stoppa den virtuella datorn när du inte använder den och minska kostnaderna:

1. Gå till din arbetsyta i Azure Mašinsko učenje Studio och välj Beräkning.

2. I listan väljer du den beräkning som du vill stoppa och väljer sedan Stoppa.

När du är redo att använda beräkningen igen kan du starta om den virtuella datorn.

Ta bort andra resurser

Om du inte planerar att använda de resurser som du skapade i den här självstudien kan du ta bort dem och undvika ytterligare avgifter.

Följ dessa steg för att ta bort resursgruppen och alla resurser:

1. I Azure Portal går du till Resursgrupper.

2. I listan väljer du den resursgrupp som du skapade i den här självstudien och väljer sedan Ta bort resursgrupp.

3. I bekräftelseprompten anger du resursgruppens namn och väljer sedan Ta bort.

Om du vill behålla resursgruppen och endast ta bort en enda arbetsyta följer du dessa steg:

1. Gå till den resursgrupp som innehåller den arbetsyta som du vill ta bort i Azure-portalen.

2. Välj arbetsytan, välj Egenskaper och välj sedan Ta bort.

Gå vidare