Et kort indledende ord
Jeg tror på, at vi kunne gøre flere ting, hvis vi fik trin-for-trin instruktioner, der fortæller os, hvad vi skal gøre, og hvordan vi skal gøre det. Jeg husker selv øjeblikke i mit liv, hvor jeg ikke kunne starte noget, fordi det simpelthen var svært at forstå, hvor man skulle begynde. Måske så du engang på internettet ordene "Data Science" og besluttede, at du var langt fra dette, og de mennesker, der gør dette, var et sted derude, i en anden verden. Nej, de er lige her. Og måske, takket være folk fra dette felt, dukkede en artikel op på dit feed. Der er masser af kurser, som vil hjælpe dig med at vænne dig til dette håndværk, men her hjælper jeg dig med at tage det første skridt.
Nå, er du klar? Lad mig fortælle dig med det samme, at du bliver nødt til at kende Python 3, da det er det, jeg vil bruge her. Jeg råder dig også til at installere det på Jupyter Notebook på forhånd eller se, hvordan du bruger google colab.
Step One
Kaggle er din betydningsfulde assistent i denne sag. I princippet kan du undvære det, men jeg vil tale om dette i en anden artikel. Dette er en platform, der er vært for Data Science-konkurrencer. I hver sådan konkurrence vil du i de tidlige stadier få en urealistisk mængde erfaring med at løse problemer af forskellig art, udviklingserfaring og erfaring med at arbejde i et team, hvilket er vigtigt i vores tid.
Vi tager vores opgave derfra. Det hedder "Titanic". Betingelsen er denne: forudsige, om hver enkelt person vil overleve. Generelt er opgaven for en person involveret i DS at indsamle data, behandle dem, træne en model, prognoser og så videre. I kaggle har vi lov til at springe dataindsamlingsfasen over – de præsenteres på platformen. Vi skal downloade dem, og vi kan komme i gang!
Du kan gøre dette på følgende måde:
fanen Data indeholder filer, der indeholder data
Vi downloadede dataene, forberedte vores Jupyter-notesbøger og...
Trin to
Hvordan indlæser vi nu disse data?
Lad os først importere de nødvendige biblioteker:
import pandas as pd
import numpy as np
Pandas giver os mulighed for at downloade .csv-filer til yderligere behandling.
Numpy er nødvendig for at repræsentere vores datatabel som en matrix med tal.
Fortsæt. Lad os tage filen train.csv og uploade den til os:
dataset = pd.read_csv('train.csv')
Vi vil referere til vores train.csv-datavalg gennem datasætvariablen. Lad os se, hvad der er der:
dataset.head()
Head()-funktionen giver os mulighed for at se på de første par rækker af en dataramme.
De overlevede kolonner er netop vores resultater, som er kendt i denne dataramme. Til opgavespørgsmålet skal vi forudsige kolonnen Overlevet for test.csv-data. Disse data gemmer oplysninger om andre passagerer på Titanic, som vi, som løser problemet, ikke kender resultatet.
Så lad os opdele vores tabel i afhængige og uafhængige data. Alt er enkelt her. Afhængige data er de data, der afhænger af de uafhængige data, der er i resultaterne. Uafhængige data er de data, der påvirker resultatet.
For eksempel har vi følgende datasæt:
“Vova underviste i datalogi - nej.
Vova fik en 2 i datalogi."
Karakteren i datalogi afhænger af svaret på spørgsmålet: læste Vova datalogi? Det er klart? Lad os komme videre, vi er allerede tættere på målet!
Den traditionelle variabel for uafhængige data er X. For afhængige data, y.
Vi gør følgende:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Hvad er det? Med funktionen iloc[:, 2: ] fortæller vi Python: Jeg ønsker at se i variabel X dataene startende fra den anden kolonne (inklusive og forudsat at optællingen starter fra nul). I anden linje siger vi, at vi ønsker at se dataene i den første kolonne.
[a:b, c:d] er konstruktionen af det, vi bruger i parentes. Hvis du ikke angiver nogen variable, vil de blive gemt som standard. Det vil sige, at vi kan angive [:,: d], og så får vi alle kolonnerne i datarammen, undtagen dem der går fra nummer d og fremefter. Variablerne a og b definerer strenge, men vi har brug for dem alle, så vi lader dette være standard.Lad os se, hvad vi har:
X.head()
y.head()
For at forenkle denne lille lektion vil vi fjerne kolonner, der kræver særlig pleje eller slet ikke påvirker overlevelsesevnen. De indeholder data af typen str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Lad os gå videre til næste trin.
Trin tre
Her skal vi indkode vores data, så maskinen bedre forstår, hvordan disse data påvirker resultatet. Men vi vil ikke kode alt, men kun de str-data, som vi forlod. Kolonne "Sex". Hvordan vil vi kode? Lad os repræsentere data om en persons køn som en vektor: 10 - mand, 01 - kvinde.
Lad os først konvertere vores tabeller til en NumPy-matrix:
X = np.array(X)
y = np.array(y)
Og lad os nu se:
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X = np.array(ct.fit_transform(X))
Sklearn-biblioteket er så sejt et bibliotek, der giver os mulighed for at udføre komplet arbejde i Data Science. Den indeholder en lang række interessante machine learning-modeller og giver os også mulighed for at lave dataforberedelse.
OneHotEncoder giver os mulighed for at indkode en persons køn i denne repræsentation, som vi beskrev. Der oprettes 2 klasser: mand, kvinde. Hvis personen er en mand, vil der blive skrevet henholdsvis 1 i kolonnen "mand" og 0 i kolonnen "kvinde".
Efter OneHotEncoder() er der [1] - det betyder, at vi ønsker at kode kolonne nummer 1 (tæller fra nul).
Super. Lad os gå endnu længere!
Som regel sker det, at nogle data efterlades tomme (det vil sige NaN - ikke et tal). For eksempel er der oplysninger om en person: hans navn, køn. Men der er ingen oplysninger om hans alder. I dette tilfælde vil vi anvende følgende metode: vi finder det aritmetiske middelværdi over alle kolonner, og hvis der mangler nogle data i kolonnen, udfylder vi tomrummet med det aritmetiske middelværdi.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Lad os nu tage højde for, at situationer opstår, når dataene er meget store. Nogle data er i intervallet [0:1], mens nogle kan gå ud over hundreder og tusinder. For at eliminere en sådan spredning og for at gøre computeren mere nøjagtig i dens beregninger, scanner vi dataene og skalerer dem. Lad alle tal ikke overstige tre. For at gøre dette vil vi bruge StandardScaler-funktionen.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Nu ser vores data sådan ud:
Klasse. Vi er allerede tæt på vores mål!
Trin fire
Lad os træne vores første model! Fra sklearn-biblioteket kan vi finde en lang række interessante ting. Jeg anvendte Gradient Boosting Classifier-modellen på dette problem. Vi bruger En klassificeringsanordning, fordi vores opgave er en klassifikationsopgave. Prognosen bør tildeles til 1 (overlevede) eller 0 (overlevede ikke).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
Tilpasningsfunktionen fortæller Python: Lad modellen lede efter afhængigheder mellem X og y.
Mindre end et sekund og modellen er klar.
Hvordan anvender man det? Vi får se nu!
Trin fem. Konklusion
Nu skal vi indlæse en tabel med vores testdata, som vi skal lave en prognose for. Med denne tabel vil vi udføre alle de samme handlinger, som vi gjorde for X.
X_test = pd.read_csv('test.csv', index_col=0)
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X_test.drop(count, inplace=True, axis=1)
X_test = np.array(X_test)
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X_test = np.array(ct.fit_transform(X_test))
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X_test)
X_test = imputer.transform(X_test)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_test[:, 2:] = sc.fit_transform(X_test[:, 2:])
Lad os anvende vores model nu!
gbc_predict = gbc.predict(X_test)
Alle. Vi lavede en prognose. Nu skal det optages i csv og sendes til hjemmesiden.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Parat. Vi modtog en fil med forudsigelser for hver passager. Tilbage er blot at uploade disse løsninger til hjemmesiden og få en vurdering af prognosen. En sådan primitiv løsning giver ikke kun 74% korrekte svar i offentligheden, men også en vis fremdrift inden for Data Science. De mest nysgerrige kan til enhver tid skrive til mig i private beskeder og stille et spørgsmål. Tak til alle!
Kilde: www.habr.com