Oefening: het Machine Learning-model maken

15 minuten

Voor het maken van een Machine Learning-model hebt u twee gegevenssets nodig: één voor het trainen en één voor het testen. In de praktijk hebt u vaak slechts één gegevensset, zodat u deze in tweeën moet splitsen. In deze oefening gaat u een 80-20-splitsing uitvoeren in het DataFrame dat u hebt voorbereid in het vorige lab, zodat u het kunt gebruiken om een Machine Learning-model te trainen. U gaat het DataFrame ook scheiden in functiekolommen en labelkolommen. Functiekolommen worden gebruikt als invoer voor het model (bijvoorbeeld de herkomst en bestemming van de vlucht en de geplande vertrektijd). De labelkolom bevat de kolom die door het model moet worden voorspeld, zoals in dit geval kolom ARR_DEL15, die aangeeft of een vlucht op tijd zal komen.

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 in een cel aan het einde van het notebook in en voer ze uit:
```
from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(df.drop('ARR_DEL15', axis=1), df['ARR_DEL15'], test_size=0.2, random_state=42)
```
Met de eerste instructie importeert u de helperfunctie train_test_split van scikit-learn. Met de functie in de tweede regel splitst u het DataFrame in een trainingsset die 80 procent van de oorspronkelijke gegevens bevat en een testset die de resterende 20 procent bevat. Met de parameter random_state wordt de generator voor willekeurige getallen die voor het splitsen wordt gebruikt gevuld, terwijl de eerste en tweede parameter DataFrames zijn met de functiekolommen en de labelkolom.
Met train_test_split worden vier DataFrames geretourneerd. Gebruik de volgende opdracht om het aantal rijen en kolommen weer te geven in het DataFrame dat de functiekolommen voor het trainen bevat:
```
train_x.shape
```
Gebruik deze opdracht nu om het aantal rijen en kolommen weer te geven in het DataFrame dat de functiekolommen voor het testen bevat:
```
test_x.shape
```
In welk opzicht verschilt de uitvoer van deze twee opdrachten, en waarom?

Kunt u voorspellen wat u ziet als u shape aanroept in de andere twee DataFrames, train_y en test_y? Probeer het uit als u het niet zeker weet, zodat u erachter komt.

Er zijn veel soorten Machine Learning-modellen. Een van de meest gebruikte is het regressiemodel, dat gebruikmaakt van één van een aantal regressiealgoritmen om een numerieke waarde te produceren, bijvoorbeeld iemands leeftijd of de waarschijnlijkheid dat een creditcardtransactie frauduleus is. U gaat een classificatiemodel trainen, waarmee wordt geprobeerd om een set invoerwaarden om te zetten in een set bekende uitvoerwaarden. Een klassiek voorbeeld van een classificatiemodel is een model dat e-mailberichten onderzoekt en classificeert als 'spam' of 'geen spam'. Uw model is een binair classificatiemodel dat voorspelt of een vlucht op tijd of laat aankomt ('binair' omdat er slechts twee mogelijke uitvoerbewerkingen zijn).

Een van de voordelen van het gebruik van scikit-learn is dat u deze modellen niet handmatig hoeft te maken en ook de benodigde algoritmen niet hoeft te implementeren. Scikit-learn bevat diverse klassen om algemene Machine Learning-modellen te implementeren. Een ervan is RandomForestClassifier, waarmee meerdere beslissingsstructuren op de gegevens worden toegepast en het gemiddelde wordt berekend om de algehele nauwkeurigheid te verbeteren en overfitting te beperken.

Voer de volgende code uit in een nieuwe cel om een RandomForestClassifier-object te maken en het te trainen door de methode fit aan te roepen.
```
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=13)
model.fit(train_x, train_y)
```
In de uitvoer ziet u de parameters die voor de classificatie zijn gebruikt, zoals n_estimators, waarmee het aantal structuren in elke beslissingsstructuurforest wordt aangegeven, en max_depth, waarmee de maximale diepte van de beslissingsstructuren wordt aangegeven. De weergegeven waarden zijn de standaardwaarden, maar deze kunt u overschrijven bij het maken van het RandomForestClassifier-object.

Het model trainen
Roep nu de methode predict aan om het model te testen met de waarden in test_x, gevolgd door de methode score om de gemiddelde nauwkeurigheid van het model te bepalen:
```
predicted = model.predict(test_x)
model.score(test_x, test_y)
```
Controleer of de volgende uitvoer wordt weergegeven:

Het model testen

De gemiddelde nauwkeurigheid is 86 procent, wat oppervlakkig gezien goed lijkt. De gemiddelde nauwkeurigheid is echter niet altijd een betrouwbare indicator van de nauwkeurigheid van een classificatiemodel. Laten we hier eens wat uitgebreider naar kijken en bepalen hoe nauwkeurig het model echt is, dat wil zeggen, hoe goed ermee kan worden bepaald of een vlucht op tijd zal komen.

Er zijn verschillende manieren om de nauwkeurigheid van een classificatiemodel te meten. Een van de beste algemene metingen voor een binair classificatiemodel is Area Under Receiver Operating Characteristic Curve (ook wel aangeduid als ROC AUC), waarmee wordt berekend hoe vaak het model een juiste voorspelling zal doen, ongeacht het resultaat. In deze eenheid gaat u een ROC AUC-score berekenen voor het model dat u eerder hebt gemaakt en verneemt u diverse redenen waarom die score lager is dan de gemiddelde nauwkeurigheid volgens methode score. U leert ook andere manieren om de nauwkeurigheid van het model te meten.

Voordat u de ROC-AUC gaat berekenen, moet u voorspellingskansen genereren voor de testset. Deze kansen zijn schattingen voor alle klassen, ofwel antwoorden die door het model kunnen worden voorspeld. [0.88199435, 0.11800565] betekent bijvoorbeeld dat de kans 89 procent is dat een vlucht op tijd aankomt (ARR_DEL15 = 0) en 12 procent dat dat niet zo is (ARR_DEL15 = 1). De som van de twee kansen is 100 procent.

Voer de volgende code uit om een set voorspellingskansen te genereren uit de testgegevens:
```
from sklearn.metrics import roc_auc_score
probabilities = model.predict_proba(test_x)
```
Gebruik nu de volgende instructie om een ROC AUC-score te genereren uit de kansen met behulp van de methode roc_auc_score van scikit-learn:
```
roc_auc_score(test_y, probabilities[:, 1])
```
Controleer of de uitvoer een score van 67 procent aangeeft:

Een AUC-score genereren

Waarom is de AUC-score lager dan de gemiddelde nauwkeurigheid die in de vorige oefening is berekend?

De uitvoer van de methode score geeft aan hoeveel van de items in de testset correct is voorspeld door het model. Deze score is vervormd door het feit dat de gegevensset waarmee het model is getraind en getest veel meer rijen voor tijdige aankomsten bevatten dan rijen voor te late aankomsten. Door deze onevenwichtigheid in de gegevens is de kans groter dat u het goed hebt als u voorspelt dat een vlucht op tijd is dan als u voorspelt dat een vlucht te laat is.

Bij de ROC AUC wordt hier rekening mee gehouden, zodat er een nauwkeurigere indicatie uitkomt van de kans dat een voorspelde tijdige of te late aankomst correct is.
U komt meer te weten over het gedrag van het model als u een verwarringsmatrix, ook bekend als foutmatrix, maakt. Met de verwarringsmatrix wordt het aantal keren berekend dat elk antwoord juist of onjuist is geclassificeerd. Om precies te zijn wordt hiermee het aantal fout-positieven, fout-negatieven, goed-positieven en goed-negatieven berekend. Dit is belangrijk. Als een binair classificeringsmodel dat is getraind op het herkennen van katten en honden namelijk is getest met een gegevensset die voor 95 procent uit honden bestaat, kan er een score van 95 procent worden gehaald door simpelweg altijd 'hond' te raden. Als er echter helemaal geen katten worden geïdentificeerd, heeft dat model weinig nut.

Gebruik de volgende code om een verwarringsmatrix te produceren voor uw model:
```
from sklearn.metrics import confusion_matrix
confusion_matrix(test_y, predicted)
```
De eerste rij van de uitvoer staat voor de vluchten die op tijd waren. De eerste kolom in die rij geeft aan van hoeveel vluchten correct is voorspeld dat ze op tijd waren, terwijl de tweede kolom aangeeft van hoeveel vluchten is voorspeld dat ze vertraagd waren terwijl dat niet zo was. Op basis hiervan lijkt het model goed in staat om te voorspellen dat een vlucht op tijd zal zijn.

Een verwarringsmatrix genereren

Maar kijk nu eens naar de tweede rij, met de vluchten die vertraagd waren. De eerste kolom geeft aan van hoeveel vertraagde vluchten onjuist is voorspeld dat ze op tijd zouden zijn. De tweede kolom geeft aan van hoeveel vluchten correct werd voorspeld dat ze vertraagd zouden zijn. Het model is kennelijk minder goed in staat om te voorspellen dat een vlucht vertraagd zal zijn dan dat een vlucht op tijd zal zijn. Wat u wilt in een verwarringsmatrix is hoge cijfers in de linkerboven- en rechterbenedenhoek, en lage cijfers (bij voorkeur nullen) in de rechterboven- en linkerbenedenhoek.
Andere nauwkeurigheidsmetingen voor een classificatiemodel zijn precisie en relevante overeenkomsten. Stel dat het model drie tijdige aankomsten en drie vertraagde aankomsten had binnengekregen en het twee van de tijdige aankomsten juist heeft voorspeld, maar ten onrechte heeft voorspeld dat twee van de vertraagde aankomsten op tijd zouden zijn. In dat geval zou de precisie 50 procent zijn (twee van de vier vluchten die door het model als op tijd waren geclassificeerd, waren ook echt op tijd), terwijl de relevante overeenkomsten 67 procent zouden zijn (het model heeft twee van de drie tijdige aankomsten juist geïdentificeerd). Zie https://en.wikipedia.org/wiki/Precision_and_recall voor meer informatie over precisie en relevante overeenkomsten

Scikit-learn bevat een handige methode, precision_score om de precisie te berekenen. Als u de precisie van uw model wilt meten, voert u de volgende instructies uit:
```
from sklearn.metrics import precision_score

train_predictions = model.predict(train_x)
precision_score(train_y, train_predictions)
```
Controleer de uitvoer. Wat is de precisie van het model?

De precisie meten
Scikit-learn bevat ook de methode recall_score om de relevante overeenkomsten te berekenen. Als u de relevante overeenkomsten van het model wilt meten, voert u de volgende instructies uit:
```
from sklearn.metrics import recall_score

recall_score(train_y, train_predictions)
```
Wat zijn de relevante overeenkomsten van het model?

De relevante overeenkomsten meten
Gebruik de opdracht Bestand ->Opslaan en Controlepunt om het notitieblok op te slaan.

In de praktijk zou een ervaren gegevenswetenschapper manieren zoeken om het model nog nauwkeuriger te maken. Onder andere zou hij of zij verschillende algoritmen proberen en stappen ondernemen om het gekozen algoritme af te stemmen om de optimale combinatie van parameters te vinden. Een andere waarschijnlijke stap zou zijn om de gegevensset uit te breiden tot miljoenen rijen in plaats van een paar duizend en ook proberen om de vertraagde en tijdige vluchten meer in evenwicht te brengen. Voor ons doel is het model echter prima zoals het is.

Doorgaan

Feedback