Ett kort inledande ord
Jag tror att vi skulle kunna göra fler saker om vi fick steg-för-steg-instruktioner som talar om för oss vad vi ska göra och hur vi ska göra. Jag minns själv stunder i mitt liv när jag inte kunde starta något för att det helt enkelt var svårt att förstå var jag skulle börja. Kanske såg du en gång på Internet orden "Data Science" och bestämde dig för att du var långt ifrån detta, och de som gör det här fanns någonstans där ute, i en annan värld. Nej, de är här. Och kanske, tack vare människor från detta område, dök en artikel upp på ditt flöde. Det finns gott om kurser som hjälper dig att vänja dig vid detta hantverk, men här hjälper jag dig att ta första steget.
Tja, är du redo? Låt mig berätta omedelbart att du kommer att behöva känna till Python 3, eftersom det är vad jag kommer att använda här. Jag råder dig också att installera den på Jupyter Notebook i förväg eller se hur du använder google colab.
Шаг первый
Kaggle är din viktiga assistent i den här frågan. I princip kan du klara dig utan det, men jag kommer att prata om detta i en annan artikel. Detta är en plattform som är värd för Data Science-tävlingar. I varje sådan tävling får du i tidiga skeden en orealistisk erfarenhet av att lösa problem av olika slag, utvecklingserfarenhet och erfarenhet av att arbeta i ett team, vilket är viktigt i vår tid.
Vi tar vår uppgift därifrån. Den heter "Titanic". Villkoret är detta: förutsäg om varje enskild person kommer att överleva. Generellt sett är uppgiften för en person som är involverad i DS att samla in data, bearbeta den, träna en modell, prognostisera och så vidare. I kaggle får vi hoppa över datainsamlingsstadiet – de presenteras på plattformen. Vi måste ladda ner dem och vi kan komma igång!
Du kan göra detta på följande sätt:
fliken Data innehåller filer som innehåller data
Vi laddade ner data, förberedde våra Jupyter-anteckningsböcker och...
Шаг второй
Hur laddar vi nu denna data?
Låt oss först importera de nödvändiga biblioteken:
import pandas as pd
import numpy as np
Pandas tillåter oss att ladda ner .csv-filer för vidare bearbetning.
Numpy behövs för att representera vår datatabell som en matris med siffror.
Varsågod. Låt oss ta filen train.csv och ladda upp den till oss:
dataset = pd.read_csv('train.csv')
Vi kommer att hänvisa till vårt train.csv-dataval genom datasetvariabeln. Låt oss se vad som finns där:
dataset.head()
Head()-funktionen låter oss titta på de första raderna i en dataram.
Стобцы Survived — это, как раз, наши результаты, которые в этом датафрейме известны. По вопросу задачи нам нужно предсказать столбец Survived для данных test.csv. В этих данных хранится информация о других пассажирах Титаника, для которых нам, решающим задачу, неизвестны исходы.
Så låt oss dela upp vår tabell i beroende och oberoende data. Allt är enkelt här. Beroende data är de data som beror på den oberoende data som finns i resultaten. Oberoende data är de data som påverkar resultatet.
Till exempel har vi följande datauppsättning:
"Vova undervisade i datavetenskap - nej.
Vova fick en 2:a i datavetenskap.”
Betyget i datavetenskap beror på svaret på frågan: läste Vova datavetenskap? Är det klart? Låt oss gå vidare, vi är redan närmare målet!
Den traditionella variabeln för oberoende data är X. För beroende data, y.
Vi gör följande:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Vad det är? Med funktionen iloc[:, 2: ] säger vi till Python: Jag vill se i variabel X data från den andra kolumnen (inklusive och förutsatt att räkningen börjar från noll). På den andra raden säger vi att vi vill se data i den första kolumnen.
[ a:b, c:d ] är konstruktionen av det vi använder inom parentes. Om du inte anger några variabler kommer de att sparas som standard. Det vill säga vi kan specificera [:,: d] och då får vi alla kolumner i dataramen, förutom de som går från nummer d och framåt. Variablerna a och b definierar strängar, men vi behöver dem alla, så vi lämnar detta som standard.Låt oss se vad vi har:
X.head()
y.head()
För att förenkla denna lilla lektion kommer vi att ta bort kolumner som kräver särskild vård eller inte påverkar överlevnadsförmågan alls. De innehåller data av typen str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Låt oss gå vidare till nästa steg.
Steg tre
Här behöver vi koda våra data så att maskinen bättre förstår hur denna data påverkar resultatet. Men vi kommer inte att koda allt, utan bara str-data som vi lämnade. Kolumn "Sex". Hur vill vi koda? Låt oss representera data om en persons kön som en vektor: 10 - man, 01 - kvinna.
Låt oss först konvertera våra tabeller till en NumPy-matris:
X = np.array(X)
y = np.array(y)
Och nu ska vi titta:
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 är ett så coolt bibliotek som låter oss göra kompletta uppgifter inom Data Science. Den innehåller ett stort antal intressanta maskininlärningsmodeller och låter oss också göra dataförberedelser.
OneHotEncoder tillåter oss att koda en persons kön i den representationen, som vi beskrev. 2 klasser kommer att skapas: man, kvinna. Om personen är en man kommer 1 att skrivas i kolumnen "man" respektive 0 i kolumnen "kvinna".
Efter OneHotEncoder() finns [1] - detta betyder att vi vill koda kolumn nummer 1 (räknat från noll).
Super. Låt oss gå ännu längre!
Som regel händer detta att vissa data lämnas tomma (det vill säga NaN - inte ett nummer). Till exempel finns det information om en person: hans namn, kön. Men det finns inga uppgifter om hans ålder. I det här fallet kommer vi att tillämpa följande metod: vi kommer att hitta det aritmetiska medelvärdet över alla kolumner och, om några data saknas i kolumnen, kommer vi att fylla tomrummet med det aritmetiska medelvärdet.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Låt oss nu ta hänsyn till att situationer inträffar när data är mycket stor. Vissa data ligger i intervallet [0:1], medan vissa kan gå längre än hundratals och tusentals. För att eliminera sådan spridning och göra datorn mer exakt i sina beräkningar kommer vi att skanna data och skala den. Låt alla siffror inte överstiga tre. För att göra detta kommer vi att använda StandardScaler-funktionen.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Nu ser vår data ut så här:
Klass. Vi är redan nära vårt mål!
Steg fyra
Låt oss träna vår första modell! Från sklearn-biblioteket kan vi hitta ett stort antal intressanta saker. Jag använde Gradient Boosting Classifier-modellen på detta problem. Vi använder en klassificerare eftersom vår uppgift är en klassificeringsuppgift. Prognosen bör tilldelas 1 (överlevde) eller 0 (överlevde inte).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
Anpassningsfunktionen säger till Python: Låt modellen leta efter beroenden mellan X och y.
Mindre än en sekund och modellen är klar.
Hur applicerar man det? Vi får se nu!
Steg fem. Slutsats
Nu måste vi ladda en tabell med våra testdata som vi behöver göra en prognos för. Med den här tabellen kommer vi att göra samma åtgärder som vi gjorde för 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:])
Låt oss tillämpa vår modell nu!
gbc_predict = gbc.predict(X_test)
Allt. Vi gjorde en prognos. Nu måste det spelas in i csv och skickas till sajten.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Redo. Vi fick en fil med prognoser för varje passagerare. Allt som återstår är att ladda upp dessa lösningar till hemsidan och få en bedömning av prognosen. En sådan primitiv lösning ger inte bara 74% av korrekta svar på allmänheten, utan också en viss drivkraft inom Data Science. De mest nyfikna kan när som helst skriva till mig i privata meddelanden och ställa en fråga. Tack till alla!
Källa: will.com