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.

  1. 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.

  2. 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 magic-opdrachten die worden ondersteund door de Python-kernel die u hebt geselecteerd tijdens het maken van het notebook. Met deze instructie kan Matplotlib-uitvoer door Jupyter worden weergegeven in een notebook zonder dat er herhaalde show-aanroepen nodig zijn. En deze instructie moet verschijnen vóór verwijzingen naar Matplotlib zelf. Met de laatste instructie wordt Seaborn geconfigureerd om de Matplotlib-uitvoer te verbeteren.

  3. Als u Matplotlib in actie wilt zien, kunt u de volgende code in een nieuwe cel uitvoeren om de ROC-curve te tekenen voor het Machine Learning-model dat 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')

  4. Controleer of de volgende uitvoer wordt weergegeven:

    ROC curve generated with Matplotlib.

    ROC-curve, gegenereerd door 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.

  1. 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.

  2. 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:

    Predicting whether a flight will arrive on time.

    Voorspellen of een vlucht op tijd aankomt

  3. 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?

  4. 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.

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

  2. Controleer of de uitvoer er als volgt uitziet:

    Probability of on-time arrivals for a range of dates.

    De kans op tijdige aankomst voor een reeks datums

  3. 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?

  4. 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:

    Probability of on-time arrivals for a range of times.

    De kans op tijdige aankomst voor een reeks tijden

Als u niet bekend bent met Matplotlib en er meer over wilt weten, is er een uitstekende zelfstudie op https://www.labri.fr/perso/nrougier/teaching/matplotlib/.. U kunt er nog veel meer mee doen dan hier is getoond. Mede daarom is Matplotlib ook zo populair bij de Python-community.