Eseguire il training di un modello di regressione con ML automatizzato e Python (SDK v1)
SI APPLICA A:
Python SDK azureml v1
Questo articolo illustra come eseguire il training di un modello di regressione con Azure Machine Learning Python SDK utilizzando Azure Machine Learning AutoML. Questo modello di regressione stima le tariffe dei taxi di New York.
Questo processo accetta impostazioni di configurazione e dati di training ed esegue automaticamente iterazioni di combinazioni di metodi di normalizzazione/standardizzazione delle caratteristiche, impostazioni di iperparametri e modelli diversi per ottenere il modello ottimale.
Il codice viene scritto usando Python SDK, in questo articolo. Vengono illustrate le attività seguenti:
- Scaricare i dati, trasformarli e pulirli con i set di dati aperti di Azure
- Eseguire il training di un modello di regressione di Machine Learning automatizzato
- Calcolare l'accuratezza del modello
Per AutoML senza codice, provare le esercitazioni seguenti:
Esercitazione: Eseguire il training di modelli di classificazione senza codice
Esercitazione: Prevedere la domanda con Machine Learning automatizzato
Prerequisiti
Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.
- Completare la guida introduttiva: Iniziare a usare Azure Machine Learning se non si ha già un'area di lavoro di Azure Machine Learning o un'istanza di ambiente di calcolo.
- Dopo aver completato la guida introduttiva:
- Selezionare Notebook in Studio.
- Selezionare la scheda Esempi.
- Aprire il notebook SDK v1/tutorials/regression-automl-nyc-taxi-data/regression-automated-ml.ipynb.
- Per eseguire ogni cella dell'esercitazione, selezionare Clona questo notebook
Questa esercitazione è disponibile anche in GitHub se si vuole eseguirla nel proprio ambiente locale. Per ottenere i pacchetti richiesti:
- Installare il client
automlcompleto. - Eseguire
pip install azureml-opendatasets azureml-widgetsper ottenere i pacchetti necessari.
Scaricare e preparare i dati
Importare i pacchetti necessari. Nel pacchetto Set di dati Open, ogni origine dati è rappresentata da una classe (ad esempio, NycTlcGreen) che consente di filtrare facilmente i parametri di data prima del download.
from azureml.opendatasets import NycTlcGreen
import pandas as pd
from datetime import datetime
from dateutil.relativedelta import relativedelta
Per iniziare, creare un frame di dati che conterrà i dati dei taxi. Quando si lavora in un ambiente non Spark, Set di dati aperti consente di scaricare solo un mese di dati alla volta con determinate classi per evitare MemoryError in caso di set di dati di grandi dimensioni.
Per scaricare i dati relativi ai taxi, recuperare in modo iterativo un mese alla volta e campionare in modo casuale 2.000 record da ogni mese prima dell'aggiunta a green_taxi_df per evitare di aumentare eccessivamente le dimensioni del frame di dati. Visualizzare quindi in anteprima i dati.
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)
| vendorID | lpepPickupDatetime | lpepDropoffDatetime | passengerCount | tripDistance | puLocationId | doLocationId | pickupLongitude | pickupLatitude | dropoffLongitude | ... | paymentType | fareAmount | extra | mtaTax | improvementSurcharge | tipAmount | tollsAmount | ehailFee | totalAmount | tripType |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 131969 | 2 | 2015-01-11 05:34:44 | 2015-01-11 05:45:03 | 3 | 4,84 | None | None | -73,88 | 40,84 | -73,94 | ... | 2 | 15.00 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 16.30 |
| 1129817 | 2 | 2015-01-20 16:26:29 | 2015-01-20 16:30:26 | 1 | 0.69 | None | None | -73,96 | 40,81 | -73,96 | ... | 2 | 4.50 | 1.00 | 0,50 | 0,3 | 0.00 | 0.00 | nan | 6,30 |
| 1278620 | 2 | 2015-01-01 05:58:10 | 2015-01-01 06:00:55 | 1 | 0,45 | None | None | -73,92 | 40,76 | -73,91 | ... | 2 | 4.00 | 0.00 | 0,50 | 0,3 | 0.00 | 0.00 | nan | 4,80 |
| 348430 | 2 | 2015-01-17 02:20:50 | 2015-01-17 02:41:38 | 1 | 0.00 | None | None | -73,81 | 40,70 | -73,82 | ... | 2 | 12,50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 13,80 |
| 1269627 | 1 | 2015-01-01 05:04:10 | 2015-01-01 05:06:23 | 1 | 0,50 | None | None | -73,92 | 40,76 | -73,92 | ... | 2 | 4.00 | 0.50 | 0.50 | 0 | 0,00 | 0.00 | nan | 5.00 |
| 811755 | 1 | 2015-01-04 19:57:51 | 2015-01-04 20:05:45 | 2 | 1,10 | None | None | -73,96 | 40,72 | -73,95 | ... | 2 | 6,50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 7,80 |
| 737281 | 1 | 2015-01-03 12:27:31 | 2015-01-03 12:33:52 | 1 | 0.90 | None | None | -73,88 | 40,76 | -73,87 | ... | 2 | 6,00 | 0.00 | 0,50 | 0,3 | 0.00 | 0.00 | nan | 6,80 |
| 113951 | 1 | 2015-01-09 23:25:51 | 2015-01-09 23:39:52 | 1 | 3,30 | None | None | -73,96 | 40,72 | -73,91 | ... | 2 | 12,50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 13,80 |
| 150436 | 2 | 2015-01-11 17:15:14 | 2015-01-11 17:22:57 | 1 | 1,19 | None | None | -73,94 | 40,71 | -73,95 | ... | 1 | 7.00 | 0,00 | 0,50 | 0,3 | 1,75 | 0.00 | nan | 9,55 |
| 432136 | 2 | 2015-01-22 23:16:33 2015-01-22 23:20:13 1 0.65 | None | None | -73,94 | 40,71 | -73,94 | ... | 2 | 5.00 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 6,30 |
Rimuovere alcune delle colonne che non saranno necessarie per il training o altre compilazioni di funzionalità. Automatizzare l'apprendimento automatico consentirà di gestire automaticamente le funzionalità basate sul tempo, come lpepPickupDatetime.
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)
Pulire i dati
Eseguire la funzione describe() sul nuovo frame di dati per visualizzare statistiche di riepilogo per ogni campo.
green_taxi_df.describe()
| vendorID | passengerCount | tripDistance | pickupLongitude | pickupLatitude | dropoffLongitude | dropoffLatitude | totalAmount | month_num day_of_month | day_of_week | hour_of_day |
|---|---|---|---|---|---|---|---|---|---|---|
| numero | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 | 48000,00 |
| mean | 1,78 | 1,37 | 2,87 | -73,83 | 40,69 | -73,84 | 40,70 | 14,75 | 6,50 | 15,13 |
| std | 0,41 | 1.04 | 2.93 | 2.76 | 1,52 | 2.61 | 1,44 | 12,08 | 3.45 | 8,45 |
| min | 1.00 | 0.00 | 0.00 | -74,66 | 0.00 | -74,66 | 0.00 | -300,00 | 1.00 | 1.00 |
| 25% | 2.00 | 1.00 | 1,06 | -73,96 | 40,70 | -73,97 | 40,70 | 7,80 | 3.75 | 8.00 |
| 50% | 2.00 | 1.00 | 1,90 | -73,94 | 40,75 | -73,94 | 40,75 | 11,30 | 6,50 | 15.00 |
| 75% | 2.00 | 1.00 | 3.60 | -73,92 | 40,80 | -73,91 | 40,79 | 17,80 | 9,25 | 22,00 |
| max | 2.00 | 9.00 | 97,57 | 0.00 | 41.93 | 0.00 | 41,94 | 450.00 | 12,00 | 30.00 |
Nelle statistiche di riepilogo si rileva che sono presenti diversi campi contenenti outlier o valori che ridurranno l'accuratezza del modello. Per prima cosa, filtrare i campi di latitudine e longitudine in modo che rientrino nei limiti della zona di Manhattan. In questo modo si filtrano le corse dei taxi più lunghe o le corse che sono outlier rispetto alla relazione con altre funzionalità.
Filtrare inoltre il campo tripDistance in modo che sia maggiore di zero ma minore di 31 miglia (la distanza dell'emisenoverso tra le due coppie latitudine/longitudine). In questo modo si eliminano le corse outlier lunghe con costi di viaggio incoerenti.
Il campo totalAmount, infine, contiene valori negativi per le tariffe dei taxi, privi di senso nel contesto del modello, e il campo passengerCount contiene dati non validi il cui valore minimo è zero.
Escludere queste anomalie usando funzioni di query e quindi rimuovere le ultime colonne non necessarie per il training.
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)
Chiamare di nuovo describe() sui dati per verificare che la pulizia abbia funzionato come previsto. È ora disponibile un set preparato e pulito di dati relativi a taxi, festività e meteo da usare per il training del modello di Machine Learning.
final_df.describe()
Configurare l'area di lavoro
Creare un oggetto area di lavoro dall'area di lavoro esistente. Un'area di lavoro è una classe che accetta le informazioni sulla sottoscrizione e sulle risorse di Azure. Crea inoltre una risorsa cloud per monitorare le esecuzioni del modello e tenerne traccia. Workspace.from_config() legge il file config.json e carica i dettagli di autenticazione in un oggetto denominato ws. ws viene usato in tutto il resto del codice in questo articolo.
from azureml.core.workspace import Workspace
ws = Workspace.from_config()
Dividere i dati in set di training e di test
Dividere i dati in set di training e di test usando la funzione train_test_split nella libreria scikit-learn. Questa funzione separa i dati nel set di dati x (caratteristiche) per il training del modello e nel set di dati y (valori da stimare) per il test.
Il parametro test_size determina la percentuale di dati da allocare al test. Il parametro random_state imposta un valore di inizializzazione sul generatore di casuale, in modo che le divisioni training-test siano deterministiche.
from sklearn.model_selection import train_test_split
x_train, x_test = train_test_split(final_df, test_size=0.2, random_state=223)
Lo scopo di questo passaggio consiste nell'usare punti dati per testare il modello finito che non sono stati usati per il training del modello, per misurare l'accuratezza.
In altre parole, un modello con training ottimale deve poter eseguire in modo accurato le stime dai dati che non ha già visualizzato. Sono stati preparati i dati per il training automatico di un modello di Machine Learning.
Eseguire il training automatico di un modello
Per eseguire il training automatico di un modello, eseguire queste operazioni:
- Definire le impostazioni per l'esecuzione dell'esperimento. Allegare i dati di training alla configurazione e modificare le impostazioni che controllano il processo di training.
- Inviare l'esperimento per l'ottimizzazione del modello. Dopo aver inviato l'esperimento, il processo esegue l'iterazione attraverso diversi algoritmi di machine learning e impostazioni degli iperparametri, rispettando i vincoli definiti dall'utente. Sceglie il modello più appropriato ottimizzando una metrica di accuratezza.
Definire le impostazioni di training
Definire le impostazioni del modello e dei parametri dell'esperimento per il training. Visualizzare l'elenco completo delle impostazioni. L'invio dell'esperimento con queste impostazioni predefinite richiederà circa 5-20 minuti. Se si vuole abbreviare il tempo di esecuzione, ridurre il parametro experiment_timeout_hours.
| Proprietà | Valore in questo articolo | Descrizione |
|---|---|---|
| iteration_timeout_minutes | 10 | Limite di tempo in minuti per ogni iterazione. Aumentare questo valore per i set di dati più grandi in cui ogni iterazione richiede più tempo. |
| experiment_timeout_hours | 0,3 | Quantità massima di tempo, in ore, che tutte le iterazioni combinate possono impiegare prima che l'esperimento venga terminato. |
| enable_early_stopping | Vero | Flag che abilita la terminazione anticipata se il punteggio non sta migliorando a breve termine. |
| primary_metric | spearman_correlation | Metrica che si vuole ottimizzare. Verrà scelto il modello più appropriato in base a questa metrica. |
| featurization | auto | Usando auto, l'esperimento può pre-elaborare i dati di input (gestendo i dati mancanti, convertendo il testo in valori numerici e così via) |
| verbosity | logging.INFO | Controlla il livello di dettaglio della registrazione. |
| n_cross_validations | 5 | Numero di divisioni di convalida incrociata da eseguire quando i dati di convalida non sono specificati. |
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
}
Usare le impostazioni di training definite come parametro **kwargs a un oggetto AutoMLConfig. In aggiunta, specificare i dati di training e il tipo di modello, ovvero regression in questo caso.
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)
Nota
I passaggi di pre-elaborazione di Machine Learning automatizzati (normalizzazione delle funzionalità, gestione dei dati mancanti, conversione di valori di testo nel formato numerico e così via) diventano parte del modello sottostante. Quando si usa il modello per le previsioni, gli stessi passaggi di pre-elaborazione applicati durante il training vengono automaticamente applicati ai dati di input.
Eseguire il training del modello di regressione automatica
Creare un oggetto esperimento nell'area di lavoro. Un esperimento funge da contenitore per i singoli processi. Passare l'oggetto automl_config definito all'esperimento e impostare l'output su True per visualizzare lo stato di avanzamento durante il processo.
Dopo aver iniziato l'esperimento, l'output visualizzato si aggiorna in tempo reale durante l'esecuzione. Per ogni iterazione, vengono visualizzati il tipo di modello, la durata dell'esecuzione e l'accuratezza del training. Il campo BEST traccia il miglior punteggio di training in esecuzione in base del tipo di metrica.
from azureml.core.experiment import Experiment
experiment = Experiment(ws, "Tutorial-NYCTaxi")
local_run = experiment.submit(automl_config, show_output=True)
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
Esplorare i risultati
Esplorare i risultati del training automatico usando un widget di Jupyter. Il widget consente di visualizzare un grafico e una tabella di tutte le iterazioni di processo singole, insieme alle metriche e ai metadati di accuratezza del training. Inoltre, è possibile filtrare in base a metriche di accuratezza diverse rispetto alla metrica primaria con il selettore a discesa.
from azureml.widgets import RunDetails
RunDetails(local_run).show()
Recuperare il modello migliore
Selezionare il modello migliore dalle iterazioni. La funzione get_output restituisce l'esecuzione migliore e il modello più adatto per l'ultima chiamata alla funzione di fit. Usando gli overload in get_output, è possibile recuperare l'esecuzione migliore e il modello più adatto per qualsiasi metrica registrata o per un'iterazione specifica.
best_run, fitted_model = local_run.get_output()
print(best_run)
print(fitted_model)
Testare l'accuratezza del modello migliore
Usare il modello migliore per eseguire stime sul set di dati di test per stimare le tariffe dei taxi. La funzione predict usa il modello migliore ed esegue una stima dei valori di y (costo della corsa) in base al set di dati x_test. Stampare i primi 10 valori dei costi stimati da y_predict.
y_test = x_test.pop("totalAmount")
y_predict = fitted_model.predict(x_test)
print(y_predict[:10])
Calcolare il root mean squared error dei risultati. Convertire il frame di dati y_test in un elenco da confrontare con i valori previsti. La funzione mean_squared_error accetta due matrici di valori e calcola l'errore quadratico medio tra di essi. La radice quadrata del risultato restituisce un errore nelle stesse unità di misura della variabile y, cost. Indica approssimativamente quanto le stime dei prezzi delle corse in taxi si discostano dai prezzi effettivi.
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
Eseguire il codice seguente per calcolare l'errore percentuale assoluto medio usando i set di dati completi y_actual e y_predict. Questa metrica calcola una differenza assoluta tra ogni valore stimato ed effettivo e somma tutte le differenze. Esprime quindi la somma come percentuale del totale dei valori effettivi.
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.14353867606052823
Model Accuracy:
0.8564613239394718
Dalle due metriche di accuratezza della stima finali, si nota che il modello esegue una stima discreta dei prezzi delle corse in taxi in base alle funzionalità del set di dati, in genere con un margine di $4.00 in eccesso o in difetto e un errore di circa il 15%.
Il processo di sviluppo del modello di Machine Learning tradizionale richiede risorse ingenti, notevoli conoscenze settoriali e tempi estremamente lunghi per poter eseguire un elevato numero di modelli e confrontarne i risultati. L'uso dell'apprendimento automatico automatizzato è un ottimo modo per testare rapidamente molti modelli diversi per il proprio scenario.
Pulire le risorse
Se si intende eseguire altre esercitazioni su Azure Machine Learning, non completare questa sezione.
Arrestare l'istanza di calcolo
Se è stata usata un'istanza di ambiente di calcolo, per ridurre i costi arrestare la macchina virtuale quando non viene usata.
Nell'area di lavoro selezionare Compute.
Nell'elenco selezionare il nome dell'istanza di ambiente di calcolo.
Selezionare Interrompi.
Quando si è pronti a usare di nuovo il server, selezionare Avvia.
Eliminare tutto
Se non si prevede di usare le risorse create, eliminarle per evitare addebiti.
- Nel portale di Azure fare clic su Gruppi di risorse all'estrema sinistra.
- Nell'elenco selezionare il gruppo di risorse creato.
- Selezionare Elimina gruppo di risorse.
- Immettere il nome del gruppo di risorse. Quindi seleziona Elimina.
È anche possibile mantenere il gruppo di risorse ma eliminare una singola area di lavoro. Visualizzare le proprietà dell'area di lavoro e selezionare Elimina.
Passaggi successivi
In questo articolo di Machine Learning automatizzato sono state descritte le attività seguenti:
- Configurare un'area di lavoro e preparare i dati per un esperimento.
- Eseguire il training usando un modello di regressione automatizzato in locale con parametri personalizzati.
- Esplorare ed esaminare i risultati del training.