Een kort inleidend woord
Ik geloof dat we meer dingen zouden kunnen doen als we stapsgewijze instructies zouden krijgen die ons vertellen wat we moeten doen en hoe we het moeten doen. Zelf herinner ik me momenten in mijn leven waarop ik ergens niet aan kon beginnen omdat het simpelweg moeilijk was om te begrijpen waar ik moest beginnen. Misschien zag je ooit op internet de woorden ‘Data Science’ en besloot je dat je hier verre van was, en dat de mensen die dit doen ergens daarbuiten waren, in een andere wereld. Nee, ze zijn hier. En misschien is er dankzij mensen uit dit vakgebied een artikel op uw feed verschenen. Er zijn tal van cursussen die je helpen wennen aan dit vak, maar hier help ik je de eerste stap te zetten.
Nou, ben je klaar? Laat me je meteen vertellen dat je Python 3 moet kennen, want dat is wat ik hier ga gebruiken. Ik raad je ook aan om het vooraf op Jupyter Notebook te installeren of te kijken hoe je Google Colab gebruikt.
Шаг первый
Kaggle is uw belangrijke assistent in deze kwestie. In principe kun je het zonder doen, maar ik zal hierover in een ander artikel praten. Dit is een platform dat Data Science-wedstrijden organiseert. Bij elke dergelijke competitie zul je in de beginfase een onrealistische hoeveelheid ervaring opdoen met het oplossen van verschillende soorten problemen, ontwikkelingservaring en ervaring met het werken in een team, wat belangrijk is in onze tijd.
Van daaruit zullen wij onze taak overnemen. Het heet 'Titanic'. De voorwaarde is deze: voorspel of elke individuele persoon zal overleven. Over het algemeen is de taak van iemand die betrokken is bij DS het verzamelen van gegevens, het verwerken ervan, het trainen van een model, het voorspellen, enzovoort. In Kaggle mogen we de fase van het verzamelen van gegevens overslaan: ze worden op het platform gepresenteerd. We moeten ze downloaden en we kunnen aan de slag!
U kunt dit als volgt doen:
het tabblad Gegevens bevat bestanden die gegevens bevatten
We hebben de gegevens gedownload, onze Jupyter-notebooks voorbereid en...
Шаг второй
Hoe laden we deze gegevens nu in?
Laten we eerst de benodigde bibliotheken importeren:
import pandas as pd
import numpy as np
Met Panda's kunnen we .csv-bestanden downloaden voor verdere verwerking.
Numpy is nodig om onze gegevenstabel weer te geven als een matrix met getallen.
Doe Maar. Laten we het bestand train.csv nemen en naar ons uploaden:
dataset = pd.read_csv('train.csv')
We zullen verwijzen naar onze train.csv-gegevensselectie via de datasetvariabele. Laten we eens kijken wat er is:
dataset.head()
Met de functie head() kunnen we naar de eerste paar rijen van een dataframe kijken.
De Overleefd-kolommen zijn precies onze resultaten, die bekend zijn in dit dataframe. Voor de taakvraag moeten we de kolom Overleefd voorspellen voor test.csv-gegevens. Deze gegevens slaan informatie op over andere passagiers van de Titanic, waarvan wij, bij het oplossen van het probleem, de uitkomst niet weten.
Laten we onze tabel dus verdelen in afhankelijke en onafhankelijke gegevens. Alles is hier eenvoudig. Afhankelijke gegevens zijn gegevens die afhankelijk zijn van de onafhankelijke gegevens in de uitkomsten. Onafhankelijke gegevens zijn gegevens die de uitkomst beïnvloeden.
We hebben bijvoorbeeld de volgende dataset:
“Vova doceerde computerwetenschappen - nee.
Vova behaalde een 2 in computerwetenschappen.”
Het cijfer voor computerwetenschappen hangt af van het antwoord op de vraag: heeft Vova computerwetenschappen gestudeerd? Is het duidelijk? Laten we verder gaan, we zijn al dichter bij het doel!
De traditionele variabele voor onafhankelijke gegevens is X. Voor afhankelijke gegevens is dit y.
Wij doen het volgende:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Wat het is? Met de functie iloc[:, 2: ] vertellen we Python: ik wil in variabele X de gegevens zien vanaf de tweede kolom (inclusief en op voorwaarde dat het tellen vanaf nul begint). In de tweede regel zeggen we dat we de gegevens in de eerste kolom willen zien.
[ a:b, c:d ] is de constructie van wat we tussen haakjes gebruiken. Als u geen variabelen opgeeft, worden deze standaard opgeslagen. Dat wil zeggen, we kunnen [:,: d] specificeren en dan krijgen we alle kolommen in het dataframe, behalve degene die vanaf nummer d gaan. De variabelen a en b definiëren strings, maar we hebben ze allemaal nodig, dus laten we dit als standaard staan.Laten we eens kijken wat we hebben:
X.head()
y.head()
Om deze kleine les te vereenvoudigen, zullen we kolommen verwijderen die speciale zorg vereisen of helemaal geen invloed hebben op de overlevingskansen. Ze bevatten gegevens van het type str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Laten we verder gaan met de volgende stap.
Stap drie
Hier moeten we onze gegevens coderen, zodat de machine beter begrijpt hoe deze gegevens het resultaat beïnvloeden. Maar we zullen niet alles coderen, maar alleen de str-gegevens die we hebben achtergelaten. Kolom "Seks". Hoe willen we coderen? Laten we gegevens over het geslacht van een persoon weergeven als een vector: 10 - mannelijk, 01 - vrouwelijk.
Laten we eerst onze tabellen omzetten in een NumPy-matrix:
X = np.array(X)
y = np.array(y)
En laten we nu eens kijken:
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))
De sklearn-bibliotheek is zo'n coole bibliotheek waarmee we volledig werk kunnen doen in Data Science. Het bevat een groot aantal interessante machine learning-modellen en stelt ons ook in staat aan datavoorbereiding te doen.
Met OneHotEncoder kunnen we het geslacht van een persoon in die representatie coderen, zoals we hebben beschreven. Er worden 2 klassen gecreëerd: mannelijk en vrouwelijk. Als de persoon een man is, wordt respectievelijk 1 in de kolom ‘mannelijk’ en 0 in de kolom ‘vrouwelijk’ geschreven.
Na OneHotEncoder() staat [1] - dit betekent dat we kolomnummer 1 willen coderen (tellend vanaf nul).
Super. Laten we nog verder gaan!
In de regel gebeurt dit dat sommige gegevens leeg blijven (dat wil zeggen NaN - geen getal). Er is bijvoorbeeld informatie over een persoon: zijn naam, geslacht. Maar er is geen informatie over zijn leeftijd. In dit geval passen we de volgende methode toe: we vinden het rekenkundig gemiddelde over alle kolommen en als er gegevens ontbreken in de kolom, vullen we de leegte op met het rekenkundig gemiddelde.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Laten we er nu rekening mee houden dat er zich situaties voordoen waarin de gegevens erg groot zijn. Sommige gegevens bevinden zich in het interval [0:1], terwijl andere gegevens verder kunnen gaan dan honderden en duizenden. Om dergelijke spreiding te elimineren en de computer nauwkeuriger te maken in zijn berekeningen, zullen we de gegevens scannen en schalen. Laat alle getallen niet groter zijn dan drie. Om dit te doen, zullen we de StandardScaler-functie gebruiken.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Nu zien onze gegevens er als volgt uit:
Klas. We zijn al dicht bij ons doel!
Stap vier
Laten we ons eerste model trainen! In de sklearn-bibliotheek kunnen we een groot aantal interessante dingen vinden. Ik heb het Gradient Boosting Classifier-model op dit probleem toegepast. We gebruiken een classificatie omdat onze taak een classificatietaak is. De prognose moet worden toegewezen aan 1 (overleefd) of 0 (niet overleefd).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
De fit-functie vertelt Python: Laat het model zoeken naar afhankelijkheden tussen X en y.
Nog geen seconde en het model is klaar.
Hoe moet je het toepassen? We zullen het nu zien!
Stap vijf. Conclusie
Nu moeten we een tabel laden met onze testgegevens waarvoor we een voorspelling moeten maken. Met deze tabel zullen we dezelfde acties uitvoeren als voor 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:])
Laten we ons model nu toepassen!
gbc_predict = gbc.predict(X_test)
Alle. Wij hebben een voorspelling gemaakt. Nu moet het in csv worden vastgelegd en naar de website worden verzonden.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Klaar. We ontvingen een bestand met voorspellingen voor elke passagier. Het enige dat overblijft is deze oplossingen naar de website te uploaden en een beoordeling van de voorspelling te krijgen. Zo’n primitieve oplossing levert niet alleen 74% van de juiste antwoorden op bij het publiek, maar ook een impuls in de Data Science. De meest nieuwsgierigen kunnen mij op elk moment in privéberichten schrijven en een vraag stellen. Bedankt aan iedereen!
Bron: www.habr.com