Oefening: de uitvoer van het model visualiseren

8 minuten

In deze eenheid gaat u Matplotlib importeren in het notebook waarmee u werkt en het notebook zo configureren dat het inline-Matplotlib-uitvoer ondersteunt.

Ga terug naar het Azure-notebook dat u in de vorige sectie hebt gemaakt. Als u het notitieblok hebt gesloten, kunt u zich weer aanmelden bij de Microsoft Azure Notebooks-portal, uw notitieblok openen en de Cel ->Alles uitvoeren gebruiken om alle cellen in het notitieblok opnieuw uit te voeren nadat u het hebt geopend.
Voer de volgende instructies uit in een nieuwe cel aan het einde van het notebook. Negeer eventuele waarschuwingsberichten over het opslaan van lettertypen in cache:
```
%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns

sns.set()
```
De eerste instructie is een van de verschillende magic-opdrachten die worden ondersteund door de Python-kernel die u hebt geselecteerd toen u het notebook maakte. Hiermee kan Jupyter Matplotlib-uitvoer weergeven in een notebook zonder herhaalde aanroepen om weer te geven. En deze instructie moet verschijnen vóór verwijzingen naar Matplotlib zelf. De laatste instructie configureert Seaborn om de uitvoer van Matplotlib te verbeteren.

Als u Matplotlib op het werk wilt zien, voert u de volgende code uit in een nieuwe cel om de ROC-curve te tekenen voor het machine learning-model dat u in het vorige lab hebt gemaakt:

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

Controleer of de volgende uitvoer wordt weergegeven:

ROC-curve gegenereerd met Matplotlib

De stippellijn in het midden van de grafiek geeft aan dat er een 50/50-kans is dat er een juist antwoord wordt verkregen. De blauwe curve geeft de nauwkeurigheid van het model aan. Belangrijker is dat het feit dat deze grafiek überhaupt wordt weergegeven aangeeft dat u Matplotlib in een Jupyter-notebook kunt gebruiken.

De reden dat u een Machine Learning-model hebt gemaakt is om te voorspellen of een vlucht op tijd of te laat aankomt. In deze oefening gaat u een Python-functie schrijven waarmee het Machine Learning-model wordt aangeroepen dat u in het vorige lab hebt gemaakt om de kans te berekenen dat een vlucht op tijd komt. Vervolgens gebruikt u de functie om verschillende vluchten te analyseren.

Voer de volgende functiedefinitie in een nieuwe cel in en voer de cel vervolgens uit.

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]

De invoer voor deze functie is een datum en tijd, de code van de herkomstluchthaven en een code van de bestemmingsluchthaven. De uitvoer is een waarde tussen 0,0 en 1,0 voor de kans dat de vlucht op tijd op de bestemming aankomt. De functie maakt gebruik van het Machine Learning-model dat u in het vorige lab voor de kansberekening hebt gemaakt. En er wordt een DataFrame met de invoerwaarden doorgegeven aan predict_proba om het model aan te roepen. De structuur van het DataFrame komt exact overeen met de structuur van het DataFrame dat we eerder hebben gebruikt.

Notitie

Invoerdatums voor de functie predict_delay moeten de internationale datumnotatie dd/mm/year hebben.

Gebruik de onderstaande code om de kans te berekenen dat een vlucht van New York naar Atlanta op de avond van 1 oktober op tijd aankomt. Het jaar dat u invoert, is niet van belang omdat dat niet door het model wordt gebruikt.
```
predict_delay('1/10/2018 21:45:00', 'JFK', 'ATL')
```
Controleer of de uitvoer aangeeft dat de kans op een tijdige aankomst 60 procent is:

Voorspellen of een vlucht op tijd aankomt
Wijzig de code om de kans te berekenen dat dezelfde vlucht van een dag later op tijd aankomt:
```
predict_delay('2/10/2018 21:45:00', 'JFK', 'ATL')
```
Hoe groot is de kans dat deze vlucht op tijd aankomt? Als u flexibel bent qua planning, zou u dan overwegen om uw reis met één dag uit te stellen?
Wijzig nu de code om de kans te berekenen dat een ochtendvlucht op dezelfde dag van Atlanta naar Seattle op tijd aankomt:
```
predict_delay('2/10/2018 10:00:00', 'ATL', 'SEA')
```
Is de kans groot dat deze vlucht op tijd aankomt?

U hebt nu een eenvoudige methode, met slechts één regel code, om te voorspellen of een vlucht waarschijnlijk op tijd of te laat aankomt. Experimenteer gerust met andere datums, tijden, herkomsten en bestemmingen. Houd er wel rekening mee dat de resultaten alleen relevant zijn voor de luchthavencodes ATL, DTW, JFK, MSP en SEA omdat dit de enige luchthavencodes zijn waarop dit model is getraind.

Voer de volgende code uit om de kans op tijdige aankomst van een avondvlucht van JFK naar ATL binnen een reeks dagen te tekenen:

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

Controleer of de uitvoer er als volgt uitziet:

Waarschijnlijkheid van tijdige aankomsten voor een bereik van datums
Wijzig de code om een vergelijkbare grafiek te produceren voor vluchten die JFK voor MSP verlaten om 13:00 uur op 10 april tot en met 16 april. Wat zijn de overeenkomsten en verschillen met de uitvoer van de vorige stap?
Schrijf zelf code om de kans dat vluchten die SEA verlaten voor ATL om 9:00 uur, middag, 15:00 uur, 18:00 uur, 16:00 uur en 19:00 uur op tijd aan. Controleer of de uitvoer er als volgt uitziet:

Waarschijnlijkheid van tijdige aankomsten voor een reeks tijden

Als u nieuw bent bij Matplotlib en er meer over wilt leren, vindt u een uitstekende zelfstudie op https://www.labri.fr/perso/nrougier/teaching/matplotlib/. Er is veel meer aan Matplotlib dan wat hier werd getoond, wat een van de redenen is waarom het zo populair is in de Python-community.

Feedback

Is deze pagina nuttig?