Esercizio - Visualizzare l'output del modello

8 minuti

In questa unità si importerà Matplotlib nel notebook usato in precedenza e si configurerà il notebook per supportare l'output Matplotlib inline.

Tornare al notebook di Azure creato nella sezione precedente. Se il notebook è stato chiuso, è possibile accedere di nuovo al portale di Microsoft Azure Notebooks, aprire il notebook e usare Cell ->Run All (Cella > Esegui tutto) per eseguire di nuovo tutte le celle del notebook dopo averlo aperto.
Eseguire le istruzioni seguenti in una nuova cella alla fine del notebook. Ignorare eventuali messaggi di avviso relativi alla cache dei tipi di carattere:
```
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

sns.set()
```
La prima istruzione è uno dei tanti comandi magic supportati dal kernel Python selezionato durante la creazione del notebook. Consente a Jupyter di eseguire il rendering dell'output Matplotlib in un notebook senza chiamare ripetutamente show. Deve precedere qualsiasi riferimento a Matplotlib. L'istruzione finale configura Seaborn per migliorare l'output di Matplotlib.

Per vedere come funziona Matplotlib, in una nuova cella eseguire il codice seguente per tracciare la curva ROC per il modello di Machine Learning creato nel lab precedente:

from sklearn.metrics import roc_curve

fpr, tpr, _ = roc_curve(test_y, probabilities[:, 1])
plt.plot(fpr, tpr)
plt.plot([0, 1], [0, 1], color='grey', lw=1, linestyle='--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')

Verificare che l'output visualizzato sia il seguente:

Curva ROC generata con Matplotlib

La linea tratteggiata nella parte centrale del grafo rappresenta il 50% di probabilità di ottenere una risposta corretta. La curva blu rappresenta l'accuratezza del modello. Ma soprattutto, la visualizzazione di questo grafico dimostra che è possibile usare Matplotlib in un notebook Jupyter.

Il modello di Machine Learning è stato creato allo scopo di prevedere se un volo arriverà puntuale o in ritardo. In questo esercizio si scriverà una funzione Python che chiama il modello di Machine Learning creato nel lab precedente per calcolare la probabilità che un volo sia puntuale. Quindi si userà la funzione per analizzare diversi voli.

Immettere la definizione di funzione seguente in una nuova cella e quindi eseguire la cella.

def predict_delay(departure_date_time, origin, destination):
    from datetime import datetime

    try:
        departure_date_time_parsed = datetime.strptime(departure_date_time, '%d/%m/%Y %H:%M:%S')
    except ValueError as e:
        return 'Error parsing date/time - {}'.format(e)

    month = departure_date_time_parsed.month
    day = departure_date_time_parsed.day
    day_of_week = departure_date_time_parsed.isoweekday()
    hour = departure_date_time_parsed.hour

    origin = origin.upper()
    destination = destination.upper()

    input = [{'MONTH': month,
              'DAY': day,
              'DAY_OF_WEEK': day_of_week,
              'CRS_DEP_TIME': hour,
              'ORIGIN_ATL': 1 if origin == 'ATL' else 0,
              'ORIGIN_DTW': 1 if origin == 'DTW' else 0,
              'ORIGIN_JFK': 1 if origin == 'JFK' else 0,
              'ORIGIN_MSP': 1 if origin == 'MSP' else 0,
              'ORIGIN_SEA': 1 if origin == 'SEA' else 0,
              'DEST_ATL': 1 if destination == 'ATL' else 0,
              'DEST_DTW': 1 if destination == 'DTW' else 0,
              'DEST_JFK': 1 if destination == 'JFK' else 0,
              'DEST_MSP': 1 if destination == 'MSP' else 0,
              'DEST_SEA': 1 if destination == 'SEA' else 0 }]

    return model.predict_proba(pd.DataFrame(input))[0][0]

Questa funzione accetta come input una data e ora, il codice di un aeroporto di origine e il codice di un aeroporto di destinazione, quindi restituisce un valore compreso tra 0,0 e 1,0 che indica la probabilità che il volo arriverà puntuale a destinazione. Per calcolare la probabilità, la funzione usa il modello di Machine Learning creato nel lab precedente. E per chiamare il modello passa un DataFrame contenente i valori di input a predict_proba. La struttura del DataFrame corrisponde esattamente alla struttura del DataFrame usato in precedenza.

Nota

L'input data per la funzione predict_delay usa il formato di data internazionale dd/mm/year.

Usare il codice seguente per calcolare la probabilità che un volo da New York ad Atlanta la sera del 1° ottobre arriverà puntuale. L'anno immesso è irrilevante perché non viene usato dal modello.
```
predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL')
```
Verificare che l'output indichi che la probabilità di un arrivo puntuale è del 60%:

Previsione della puntualità di un volo
Modificare il codice per calcolare la probabilità che lo stesso volo il giorno successivo arrivi in orario:
```
predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL')
```
Quali sono le probabilità che questo volo arrivi puntuale? Se i propri programmi di viaggio fossero flessibili, si prenderebbe in considerazione la possibilità di rimandare il viaggio di un giorno?
Ora modificare il codice per calcolare la probabilità che un volo la mattina dello stesso giorno da Atlanta a Seattle arrivi puntuale:
```
predict_delay('2/10/2018 10:00:00', 'ATL', 'SEA')
```
È probabile che questo volo arrivi puntuale?

Ora si ha la possibilità di prevedere facilmente, con una sola riga di codice, se un volo sarà probabilmente puntuale o in ritardo. È possibile sperimentare con altre date, ore, origini e destinazioni. Ma tenere presente che i risultati saranno significativi solo per i codici di aeroporto ATL, DTW, JFK, MSP e SEA perché il training del modello è stato eseguito solo con questi codici di aeroporto.

Eseguire il codice seguente per tracciare la probabilità di arrivi puntuali per un volo serale da JFK ad ATL in un intervallo di giorni:

import numpy as np

labels = ('Oct 1', 'Oct 2', 'Oct 3', 'Oct 4', 'Oct 5', 'Oct 6', 'Oct 7')
values = (predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('3/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('4/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('5/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('6/10/2018 21:45:00', 'JFK', 'ATL'),
          predict_delay('7/10/2018 21:45:00', 'JFK', 'ATL'))
alabels = np.arange(len(labels))

plt.bar(alabels, values, align='center', alpha=0.5)
plt.xticks(alabels, labels)
plt.ylabel('Probability of On-Time Arrival')
plt.ylim((0.0, 1.0))

Verificare che l'output sia il seguente:

Probabilità di arrivi puntuali per un intervallo di date
Modificare il codice per produrre un grafico simile per i voli in partenza da JFK per MSP alle ore 13:00 dal 10 aprile al 16 aprile. Quali sono le differenze tra questo output e quello del passaggio precedente?
Provare a scrivere il codice per rappresentare graficamente la probabilità che i voli in partenza da SEA per ATL alle 9:00, a mezzogiorno, alle 15:00, alle 18:00 e alle 21:00 del 30 gennaio arriveranno puntuali. Verificare che l'output corrisponda a quello riportato di seguito:

Probabilità di arrivi puntuali per un intervallo di ore

Se non si ha familiarità con Matplotlib e si vuole saperne di più, all'indirizzo https://www.labri.fr/perso/nrougier/teaching/matplotlib/. è disponibile un'eccellente esercitazione. Matplotlib è molto di più di quanto illustrato qui ed è per questo motivo che è ampiamente usato nella community Python.

Esercizio - Visualizzare l'output del modello

Commenti e suggerimenti