'n Klein inleidende woord
Ek glo dat ons meer dinge kan doen as ons voorsien word van stap-vir-stap instruksies wat ons vertel wat om te doen en hoe om dit te doen. Ek onthou self in my lewe sulke oomblikke toe ek nie een of ander besigheid kon begin nie, want dit was eenvoudig moeilik om te verstaan waar om te begin. Miskien het jy eens op 'n tyd op die internet die woorde "Data Science" gesien en besluit dat jy ver daarvan is, en die mense wat dit doen is iewers daar buite, in 'n ander wêreld. Nee, hulle is reg hier. En, miskien, te danke aan mense van hierdie gebied, het 'n artikel in jou voer gekom. Daar is baie kursusse om jou te help om hierdie kunsvlyt te bemeester, maar hier sal ek jou help om die eerste stap te neem.
Wel, is jy gereed? Ek sal dadelik sê dat jy Python 3 sal moet ken, aangesien ek dit hier sal gebruik. En ek raai jou ook aan om dit vooraf op Jupyter Notebook te installeer of te kyk hoe om google colab te gebruik.
stap Een
Kaggle is jou belangrike assistent in hierdie saak. In beginsel kan jy daarsonder klaarkom, maar ek sal in 'n ander artikel hieroor praat. Dit is die soort platform wat Data Science-kompetisies aanbied. In elke so 'n kompetisie in die vroeë stadiums sal jy 'n onrealistiese hoeveelheid ondervinding in die oplossing van probleme van verskillende soorte, ontwikkelingservaring en spanwerkervaring ontvang, wat in ons tyd belangrik is.
Ons sal ons taak van daar af neem. Dit word so genoem: "Titanic". Die toestand is soos volg: voorspel of elke individuele persoon sal oorleef. Oor die algemeen is die taak van 'n persoon wat by DS betrokke is, data-insameling, verwerking, modelopleiding, voorspelling, ensovoorts. In kaggle word ons toegelaat om die data-insamelingstadium oor te slaan - dit word op die platform aangebied. Ons moet dit aflaai en ons kan begin!
U kan dit soos volg doen:
die Data-oortjie bevat lêers wat data bevat
Ons het die data gelaai, ons Jupyter-notaboeke voorberei en ...
stap twee
Hoe kan ons hierdie data nou aflaai?
Eerstens voer ons die nodige biblioteke in:
import pandas as pd
import numpy as np
Pandas sal ons toelaat om .csv-lêers te laai vir verdere verwerking.
Numpy is nodig om ons datatabel as 'n matriks met getalle voor te stel.
Gaan voort. Kom ons neem die train.csv-lêer en laai dit na ons op:
dataset = pd.read_csv('train.csv')
Ons sal na ons train.csv-datastel verwys via die datastelveranderlike. Kom ons kyk wat is daar:
dataset.head()
Die head() funksie stel ons in staat om die eerste paar reëls van die dataraam te sien.
Oorleefde kolomme is net ons resultate, wat in hierdie dataraam bekend is. Vir die taakvraag moet ons die Oorleef-kolom vir toets.csv-data voorspel. Hierdie data bevat inligting oor ander passasiers van die Titanic, waarvoor ons, wat die probleem oplos, nie die uitkoms ken nie.
Dus, kom ons verdeel ons tabel in afhanklike en onafhanklike data. Alles is eenvoudig hier. Afhanklike data is data wat afhang van wat onafhanklik is van wat in die uitkomste is. Onafhanklike data is daardie data wat die uitkoms beïnvloed.
Ons het byvoorbeeld die volgende datastel:
“Vova het rekenaarwetenskap gestudeer - nee.
Vova het 2 in rekenaarwetenskap ontvang.
Die telling in rekenaarwetenskap hang af van die antwoord op die vraag: het Vova rekenaarwetenskap gestudeer? Duidelik? As ons aanbeweeg, is ons nader aan die doel!
Die tradisionele veranderlike vir onafhanklike data is X. Vir afhanklike data, y.
Ons doen die volgende:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Wat dit is? Met die iloc[:, 2:]-funksie sê ons vir die luislang: Ek wil in die veranderlike X data sien wat vanaf die tweede kolom begin (insluitend en mits die telling vanaf nul begin). In die tweede reël sê ons dat ons die data van die eerste kolom in y wil sien.
[ a:b, c:d ] is die konstruksie van wat ons tussen hakies gebruik. As jy geen veranderlikes spesifiseer nie, sal hulle by verstek gestoor word. Dit wil sê, ons kan [:,: d] spesifiseer en dan sal ons al die kolomme in die dataraam kry, behalwe dié wat van die getal d en verder gaan. Veranderlikes a en b definieer stringe, maar ons het hulle almal nodig, so ons laat dit by verstek.Kom ons kyk wat ons gekry het:
X.head()
y.head()
Om hierdie klein lesie te vereenvoudig, sal ons kolomme verwyder wat spesiale sorg vereis, of glad nie oorlewingsvermoë beïnvloed nie. Hulle bevat data van tipe str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Kom ons gaan na die volgende stap.
Stap drie
Hier moet ons ons data enkodeer sodat die masjien beter verstaan hoe hierdie data die resultaat beïnvloed. Maar ons sal nie alles enkodeer nie, maar net die str data wat ons gelos het. Die "Seks" kolom. Hoe wil ons enkodeer? Kom ons stel data oor 'n persoon se geslag as 'n vektor voor: 10 - manlik, 01 - vroulik.
Om mee te begin, sal ons ons tabelle in 'n NumPy-matriks vertaal:
X = np.array(X)
y = np.array(y)
En nou kyk ons:
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))
Die sklearn-biblioteek is so 'n gawe biblioteek wat ons in staat stel om volle werk in Data Science te doen. Dit bevat 'n groot aantal interessante masjienleermodelle, en stel ons ook in staat om datavoorbereiding te doen.
OneHotEncoder sal ons toelaat om die geslag van 'n persoon te enkodeer in dieselfde voorstelling as wat ons beskryf het. 2 klasse sal geskep word: manlik, vroulik. As die persoon 'n man is, sal 1 onderskeidelik in die "manlike" kolom en 0 in die "vroulike" kolom geskryf word.
Na OneHotEncoder() is [1] - dit beteken dat ons kolom nommer 1 wil enkodeer (tel vanaf nul).
Super. Ons beweeg nog verder!
As 'n reël gebeur dit dat sommige data nie ingevul is nie (dit wil sê NaN - nie 'n nommer nie). Daar is byvoorbeeld inligting oor 'n persoon: sy naam, geslag. Maar daar is geen inligting oor sy ouderdom nie. In hierdie geval sal ons die volgende metode toepas: ons sal die rekenkundige gemiddelde oor al die kolomme vind en, as sommige data in die kolom ontbreek, sal ons die leemte met die rekenkundige gemiddelde vul.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
En laat ons nou in ag neem dat daar situasies is wanneer die data baie oorgroei is. Sommige data is in die interval [0:1], en sommige kan meer as honderde en duisende oorskry. Om so 'n verspreiding uit te skakel en die rekenaar was meer akkuraat in die berekeninge, sal ons die data skaal, skaal dit. Laat alle getalle nie drie oorskry nie. Om dit te doen, gebruik ons die StandardScaler-funksie.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Nou lyk ons data so:
Klas. Ons is naby ons doelwit!
Stap vier
Kom ons lei ons eerste model op! Uit die sklearn-biblioteek kan ons 'n groot aantal interessante dinge vind. Ek het die Gradient Boosting Classifier-model op hierdie probleem toegepas. 'n Klassifiseerder word gebruik omdat ons taak 'n klassifikasietaak is. Dit is nodig om die voorspelling te verwys na 1 (oorleef) of 0 (nie oorleef nie).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
Die pasfunksie sê vir luislang: Laat die model kyk vir afhanklikhede tussen x en y.
Minder as 'n sekonde en die model is gereed.
Hoe om dit toe te pas? Nou sal ons sien!
Stap vyf. Afsluiting
Nou moet ons 'n tabel laai met ons toetsdata waarvoor ons 'n voorspelling wil maak. Met hierdie tabel sal ons dieselfde aksies doen as wat ons vir X gedoen het.
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:])
Kom ons pas ons model toe!
gbc_predict = gbc.predict(X_test)
Almal. Ons het 'n voorspelling gemaak. Nou moet dit na csv geskryf word en na die webwerf gestuur word.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Gereed. Ons het 'n lêer ontvang wat voorspellings vir elke passasier bevat. Dit bly om hierdie oplossings na die webwerf op te laai en 'n skatting van die voorspelling te kry. So 'n primitiewe oplossing gee nie net 74% korrekte antwoorde in die openbaar nie, maar ook 'n mate van hupstoot in Data Science. Die mees nuuskieriges kan enige tyd vir my in privaat boodskappe skryf en 'n vraag vra. Dankie aan almal!
Bron: will.com