Övning – Skapa maskininlärningsmodell

15 minuter

För att kunna skapa en maskininlärningsmodell behöver du två datamängder: en för träning och en för testning. I praktiken har du ofta bara en datamängd, så du delar upp den i två. I den här övningen utför du en delning 80–20 på den dataram som du förberedde i föregående övning, så att du kan använda den för att träna en maskininlärningsmodell. Du delar även in dataramen i egenskapskolumner och etikettkolumner. Egenskapskolumner innehåller de kolumner som används som indata för modellen (till exempel flygresans avgångsplats och mål samt schemalagd avgångstid), medan etikettkolumner innehåller den kolumn som modellen kommer att försöka förutsäga – idet här fallet kolumnen ARR_DEL15, som anger huruvida en flygresa kommer att ankomma i tid.

Gå tillbaka till den Azure-notebook-fil som du skapade i föregående avsnitt. Om du stängde anteckningsboken kan du logga in på Microsoft Azure Notebooks-portalen igen, öppna anteckningsboken och använda Cell ->Kör alla för att köra alla celler i anteckningsboken igen när du har öppnat den.
I en ny cell i slutet av notebook-filen anger och kör du följande instruktioner:
```
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)
```
Den första instruktionen importerar scikit-learns hjälpfunktion train_test_split. Den andra raden använder funktionen för att dela upp dataramen i en träningsdatamängd som innehåller 80 % av originaldata samt en testdatamängd som innehåller resterande 20 %. Parametern random_state skapar startvärden för den slumptalsgenerator som används för att utföra delningen, medan de första och andra parametrarna är dataramar som innehåller egenskapskolumnerna och etikettkolumnen.
train_test_split returnerar fyra dataramar. Använd följande kommando för att visa antalet rader och kolumner i dataramen som innehåller de egenskapskolumner som används för träning:
```
train_x.shape
```
Använd nu det här kommandot för att visa antalet rader och kolumner i dataramen som innehåller de egenskapskolumner som används för testning:
```
test_x.shape
```
Hur skiljer sig de två utdata och varför?

Kan du förutse vad som skulle visas om du hade anropat shape på de två andra dataramarna train_y och test_y? Om du inte är säker kan du prova och ta reda på det.

Det finns många typer av maskininlärningsmodeller. En av de vanligaste är regressionsmodellen, som använder en av flera regressionsalgoritmer för att skapa ett numeriskt värde – till exempel en persons ålder eller sannolikheten att en kreditkortstransaktion är bedräglig. Du kommer att träna en klassificeringsmodell som försöker omvandla en uppsättning indata till en annan uppsättning kända utdata. Ett klassiskt exempel på en klassificeringsmodell är ett exempel som undersöker e-postmeddelanden och klassificerar dem som "skräppost" eller "inte skräppost". Din modell kommer att vara en binär klassificeringsmodell som förutsäger om en flygning kommer att anlända i tid eller sent ("binärt" eftersom det bara finns två möjliga utdata).

En av fördelarna med att använda scikit-learn är att du inte manuellt behöver skapa de här modellerna eller implementera de algoritmer som de använder. Scikit-learn innehåller en mängd olika klasser för implementering av vanligt förekommande maskininlärningsmodeller. En av dem är RandomForestClassifier, som passar flera beslutsträd till data och använder genomsnitt för att öka den övergripande noggrannheten och begränsa överanpassningen.

Kör följande kod i en ny cell för att skapa ett RandomForestClassifier objekt och träna det genom att anropa fit-metoden .
```
from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=13)
model.fit(train_x, train_y)
```
Utdata visar de parametrar som används i klassificeraren, däribland n_estimators, som anger antalet träd i varje beslutsträdskog, och max_depth, som anger det maximala djupet på beslutsträden. De värden som visas är standardvärdena, men du kan åsidosätta dem när du skapar RandomForestClassifier-objektet.

Träna modellen
Anropa nu förutsägelsemetoden för att testa modellen med hjälp av värdena i test_x, följt av poängmetoden för att fastställa modellens genomsnittliga noggrannhet:
```
predicted = model.predict(test_x)
model.score(test_x, test_y)
```
Kontrollera att du ser följande utdata:

Testa modellen

Den genomsnittliga precisionen är 86 %, vilket vid första anblick låter bra. Men genomsnittlig precision är inte alltid en tillförlitlig indikator på en precisionen hos en klassificeringsmodell. Vi tittar lite mer ingående och fastställer exakt vilken precision modellen faktiskt har – det vill säga hur bra den är på att avgöra huruvida en flygresa kommer att ankomma i tid.

Det finns flera sätt att mäta precisionen hos en klassificeringsmodell. Ett av de bästa övergripande måtten för en binär klassificeringsmodell är Area Under Receiver Operating Characteristic Curve (kallas ibland "ROC AUC"), som i huvudsak kvantifierar hur ofta modellen kommer att göra en korrekt förutsägelse oavsett resultatet. I den här enheten beräknar du en ROC AUC-poäng för den modell som du skapade tidigare och lär dig om några av orsakerna till varför den poängen är lägre än den genomsnittliga precision som ges av metoden score. Du lär dig även om andra sätt att mäta modellens precision.

Innan du beräknar ROC AUC måste du generera förutsägelseannolikheter för testuppsättningen. De här sannolikheterna är uppskattningar för var och en av de klasser, eller svar, som modellen kan förutsäga. Till exempel innebär [0.88199435, 0.11800565] att det är 89 % risk att en flygresa ankommer i tid (ARR_DEL15 = 0) och 12 % chans att den inte gör det (ARR_DEL15 = 1). Summan av de två sannolikheterna är 100 %.

Kör följande kod för att skapa en uppsättning med sannolikheter för förutsägelse från testdata:
```
from sklearn.metrics import roc_auc_score
probabilities = model.predict_proba(test_x)
```
Använd nu följande instruktion för att generera en ROC AUC-poäng med sannolikheterna med scikit-learns metod roc_auc_score:
```
roc_auc_score(test_y, probabilities[:, 1])
```
Bekräfta att utdata visar en poäng på 67 %:

Generera ett AUC-värde

Varför är AUC-poängen lägre än den genomsnittliga precision som beräknats i föregående övning?

Utdata från metoden score visar hur många av objekten i testdatamängden som modellen förutsåg korrekt. Det här resultatet är förvrängt på grund av att den datamängd som modellen tränades och testades med innehåller många fler rader som representerar ankomst i tid än rader som representerar försenade ankomster. På grund av den här obalansen i data är det mer sannolikt att du har rätt om du förutser att en flygresa kommer att ankomma i tid än om du förutser att den blir sen.

ROC AUC tar hänsyn till detta och ger en mer exakt indikation på hur sannolikt det är att en förutsägelse om i tid eller sent kommer att vara korrekt.
Du kan lära dig mer om modellens beteende genom att generera en förvirringsmatris, även kallad felmatris. Förvirringsmatrisen kvantifierar det antal gånger som varje svar klassificerades korrekt eller felaktigt. Mer specifikt kvantifierar den antalet falska positiva, falska negativa, sanna positiva och sanna negativa. Det här är viktigt eftersom om en binär klassificeringsmodell som tränats att känna igen katter och hundar testas med en datamängd som till 95 % består av hundar så skulle den kunna få en poäng 95 % genom att helt enkelt gissa ”hund” varje gång. Men om den misslyckades helt med att identifiera katter skulle den inte vara särskilt värdefull.

Använd följande kod för att skapa en förvirringsmatris för din modell:
```
from sklearn.metrics import confusion_matrix
confusion_matrix(test_y, predicted)
```
Den första raden i utdata representerar flygresor som ankom i tid. Den första kolumnen i den raden visar hur många flygresor som korrekt förutsades ankomma i tid, medan den andra kolumnen visar hur många flygresor som förutsades bli försenade men som inte var det. Utifrån det här verkar modellen vara bra på att förutsäga att en flygresa kommer att ankomma i tid.

Generera en förvirringsmatris

Men titta på den andra raden, som representerar flygresor som försenades. Den första kolumnen visar hur många försenade flygresor som felaktigt förutsades ankomma i tid. Den andra kolumnen visar hur många flygresor som korrekt förutsades bli försenade. Uppenbarligen är modellen inte alls lika bra på att förutsäga att en flygresa kommer försenas som den är på att förutsäga att en flygresa kommer ankomma i tid. Vad du vill ha i en förvirringsmatris är stora tal i de övre vänstra och nedre högra hörnen och små tal (helst nollor) i de övre högra och nedre vänstra hörnen.
Andra mått på noggrannhet för en klassificeringsmodell är precision och träffsäkerhet. Anta att modellen visades tre ankomster i tid och tre försenade ankomster, och att den korrekt förutsade två av ankomsterna i tid men felaktigt förutsade att två av de försenade ankomsterna skulle ske i tid. I det här fallet skulle precisionen vara 50 % (två av de fyra flygresor som den klassificerade som ankomster i tid skedde faktiskt i tid) medan träffsäkerheten skulle vara 67 % (den identifierade korrekt två av tre ankomster i tid). Du kan läsa mer om precision och träffsäkerhet på https://en.wikipedia.org/wiki/Precision_and_recall

Scikit-learn innehåller en praktisk metod med namnet precision_score för beräkningsprecision. För att kvantifiera precisionen för din modell kör du följande instruktioner:
```
from sklearn.metrics import precision_score

train_predictions = model.predict(train_x)
precision_score(train_y, train_predictions)
```
Undersök resultatet. Vad är modellens precision?

Mätprecision
Scikit-learn innehåller också en metod med namnet recall_score för att beräkna återkallningspoäng. För att mäta modellens träffsäkerhet kör du följande instruktioner:
```
from sklearn.metrics import recall_score

recall_score(train_y, train_predictions)
```
Vad är modellens träffsäkerhet?

Mäta återkallelse
Använd kommandot Arkiv ->Spara och Kontrollpunkt för att spara anteckningsboken.

I verkligheten skulle en utbildad dataexpert försöka göra modellen ännu mer noggrann. De skulle bland annat prova olika algoritmer och vidta åtgärder för att finjustera den valda algoritmen för att hitta den optimala kombinationen av parametrar. Ett annat sannolikt steg är att expandera datamängden till miljontals rader i stället för några tusen och även försöka att minska obalansen mellan försenade ankomster och ankomster i tid. Men i vår övning duger modellen som den är.

Feedback

Var den här sidan till hjälp?