Dein erster Schritt in die Data Science. Titanic

Ein kleines einführendes Wort

Ich glaube, dass wir viel mehr erreichen könnten, wenn wir Schritt-für-Schritt-Anleitungen hätten, die uns sagen, was zu tun ist und wie wir es tun. Ich erinnere mich an Momente in meinem Leben, in denen ich nicht in der Lage war, mit einer Aufgabe zu beginnen, weil es einfach schwierig war, den Anfang zu finden. Vielleicht hast du vor langer Zeit im Internet die Begriffe "Data Science" gesehen und dachtest, dass du dafür noch nicht bereit bist, und dass die Menschen, die sich damit beschäftigen, irgendwo anders, in einer anderen Welt sind. Aber sie sind direkt hier. Und vielleicht hast du durch Menschen aus dieser Branche einen Artikel in deinem Feed entdeckt. Es gibt jede Menge Kurse, die dir helfen, dieses Handwerk zu erlernen, und hier werde ich dir helfen, den ersten Schritt zu machen.

Bist du bereit? Ich sage es gleich: Du musst Python 3 kennen, da ich es hier verwenden werde. Außerdem empfehle ich dir, Jupyter Notebook im Voraus zu installieren oder zu sehen, wie du Google Colab verwenden kannst.

Schritt eins

Kaggle — dein bedeutender Helfer in diesem Bereich. Im Grunde genommen kann man auch ohne ihn auskommen, aber darüber werde ich in einem anderen Artikel berichten. Es handelt sich um eine Plattform, auf der Wettbewerbe im Bereich Data Science stattfinden. In jedem dieser Wettbewerbe wirst du zu Beginn eine enorme Menge an Erfahrung im Lösen unterschiedlichster Aufgaben, in der Entwicklung und im Teamwork sammeln — Fähigkeiten, die heutzutage sehr wichtig sind.

Wir werden unsere Aufgabe von dort übernehmen. Sie trägt den Titel: „Titanic“. Die Vorgabe lautet: Vorhersagen, ob jede einzelne Person überlebt. Im Allgemeinen besteht die Aufgabe eines Data Scientists darin, Daten zu sammeln, diese zu verarbeiten, Modelle zu trainieren, Vorhersagen zu treffen und so weiter. Bei Kaggle dürfen wir jedoch den Schritt der Datensammlung überspringen — sie sind auf der Plattform bereitgestellt. Wir müssen sie nur herunterladen und können mit der Arbeit beginnen!

Das kannst du folgendermaßen machen:

Im Tab „Daten“ befinden sich die Dateien, die die Daten enthalten.

Haben wir die Daten heruntergeladen, unsere Jupyter-Notizbücher vorbereitet und…

Schritt zwei

Wie laden wir jetzt diese Daten herunter?

Zunächst importieren wir die notwendigen Bibliotheken:

import pandas as pd
import numpy as np

Pandas ermöglicht uns das Laden von .csv-Dateien für die weitere Verarbeitung.

Numpy wird benötigt, um unsere Datentabelle als Matrix mit Zahlen darzustellen.
Lassen Sie uns weitermachen. Wir nehmen die Datei train.csv und laden sie bei uns hoch:

dataset = pd.read_csv('train.csv')

Wir werden auf unsere Stichprobe train.csv über die Variable dataset verweisen. Lassen Sie uns sehen, was sich darin befindet:

dataset.head()

Die Funktion head() ermöglicht es uns, die ersten paar Zeilen des DataFrames anzusehen.

Die Spalte Survived sind genau unsere Ergebnisse, die in diesem DataFrame bekannt sind. In Bezug auf die Aufgabenstellung müssen wir die Spalte Survived für die Daten test.csv vorhersagen. Diese Daten enthalten Informationen über andere Passagiere der Titanic, für die uns, die wir die Aufgabe lösen, die Ergebnisse unbekannt sind.

Lassen Sie uns also unsere Tabelle in abhängige und unabhängige Daten aufteilen. Das ist ganz einfach. Die abhängigen Daten sind die Informationen, die von den unabhängigen abgeleitet werden, also das, was in den Ergebnissen steht. Die unabhängigen Daten sind die Informationen, die den Ausgang beeinflussen.

Zum Beispiel haben wir diesen Datensatz:

„Wowa hat Informatik gelernt – nein.
Wowa hat im Informatikunterricht 2 Punkte erhalten.“

Die Note in Informatik hängt von der Antwort auf die Frage ab: Hat Wowa Informatik gelernt? Verstanden? Weiter geht's, wir sind schon näher am Ziel!

Die traditionelle Variable für unabhängige Daten ist X. Für abhängige Daten ist es y.

Wir machen Folgendes:

X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]

Was ist das? Mit der Funktion iloc[:, 2: ] sagen wir Python: Ich möchte in der Variable X die Daten sehen, die ab der zweiten Spalte beginnen (einschließlich, vorausgesetzt, dass die Zählung bei null beginnt). In der zweiten Zeile sagen wir, dass wir in y die Daten der ersten Spalte sehen möchten.

[ a:b, c:d ] — das ist die Konstruktion dessen, was wir in Klammern verwenden. Wenn wir einige Variablen nicht angeben, werden sie standardmäßig beibehalten. Das bedeutet, wir können [:,: d] angeben und dann erhalten wir im DataFrame alle Spalten, außer denjenigen, die ab der Nummer d und darüber hinaus gehen. Die Variablen a und b definieren die Zeilen, aber wir benötigen alle, daher lassen wir das standardmäßig.

Schauen wir uns an, was wir bis jetzt haben:

X.head()

y.head()

Um diese kleine Lektion zu vereinfachen, entfernen wir die Spalten, die besondere "Pflege" benötigen oder überhaupt keinen Einfluss auf die Überlebensfähigkeit haben. Sie enthalten Daten vom Typ str.

count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)

Super! Gehen wir zum nächsten Schritt.

Dritter Schritt

Hier müssen wir unsere Daten kodieren, damit die Maschine besser versteht, wie diese Daten das Ergebnis beeinflussen. Aber wir kodieren nicht alles, sondern nur die Daten vom Typ str, die wir beibehalten haben. Die Spalte „Sex“. Wie möchten wir sie kodieren? Stellen wir uns die Daten zum Geschlecht einer Person als Vektor vor: 10 — männlich, 01 — weiblich.

Zunächst übersetzen wir unsere Tabellen in eine NumPy-Matrix:

X = np.array(X)
y = np.array(y)

Und jetzt schauen wir:

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 Bibliothek sklearn ist eine großartige Bibliothek, die uns ermöglicht, umfassende Arbeiten im Bereich Data Science durchzuführen. Sie enthält eine Vielzahl interessanter Modelle des maschinellen Lernens und ermöglicht es uns, Datenvorbereitung zu betreiben.

Der OneHotEncoder wird uns ermöglichen, das Geschlecht einer Person so zu kodieren, wie wir es beschrieben haben. Es werden 2 Klassen erstellt: männlich, weiblich. Wenn die Person ein Mann ist, wird in die Spalte „männlich“ eine 1 eingetragen, und in die Spalte „weiblich“ entsprechend eine 0.

Nach OneHotEncoder() steht [1] — das bedeutet, dass wir die Spalte Nummer 1 kodieren möchten (zählend von null).

Super. Gehen wir noch einen Schritt weiter!

In der Regel kommt es vor, dass einige Daten unvollständig bleiben (d.h. NaN — nicht eine Zahl). Zum Beispiel gibt es Informationen über eine Person: ihren Namen, ihr Geschlecht. Aber das Alter ist nicht vorhanden. In diesem Fall wenden wir folgende Methode an: Wir berechnen den Durchschnittswert über alle Spalten und wenn Daten in einer Spalte fehlen, fügen wir die Lücke mit dem Durchschnittswert auf.

from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)

Nun berücksichtigen wir, dass es Situationen gibt, in denen die Daten stark gestreut sind. Einige Daten befinden sich im Bereich [0:1], während andere in die Hunderte oder Tausende gehen können. Um diese Streuung zu vermeiden und die Berechnungen des Computers genauer zu machen, skalieren wir die Daten. Lassen Sie uns sicherstellen, dass alle Zahlen drei nicht überschreiten. Dafür verwenden wir die Funktion StandardScaler.

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])

Jetzt sehen unsere Daten so aus:

Klasse. Wir sind schon nah an unserem Ziel!

Schritt vier

Wir werden unser erstes Modell trainieren! In der sklearn-Bibliothek gibt es eine große Anzahl interessanter Möglichkeiten. Ich habe das Modell Gradient Boosting Classifier auf diese Aufgabe angewendet. Wir verwenden einen Klassifikator, da es sich um eine Klassifikationsaufgabe handelt. Wir müssen die Prognose entweder als 1 (überlebt) oder 0 (nicht überlebt) klassifizieren.

from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)

Die Funktion fit sagt Python: Lass das Modell die Zusammenhänge zwischen X und y suchen.

Weniger als eine Sekunde und das Modell ist bereit.

Wie wenden wir es an? Das sehen wir gleich!

Schritt fünf. Fazit

Jetzt müssen wir die Tabelle mit unseren Testdaten laden, für die wir eine Prognose erstellen müssen. Wir werden mit dieser Tabelle all die gleichen Schritte durchführen, die wir für X gemacht haben.

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:])

Lass uns unser Modell anwenden!

gbc_predict = gbc.predict(X_test)

Fertig. Wir haben eine Prognose erstellt. Jetzt muss sie in eine CSV-Datei geschrieben und auf die Website hochgeladen werden.

np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Überlebt')

Fertig. Wir haben eine Datei mit den Vorhersagen für jeden Passagier erhalten. Jetzt müssen wir diese Ergebnisse auf die Website hochladen und eine Einschätzung der Prognose erhalten. Diese grundlegende Lösung liefert nicht nur 74 % korrekte Antworten in der Öffentlichkeit, sondern gibt auch einen kleinen Schub in der Data Science. Die Neugierigen können mich jederzeit privat kontaktieren und Fragen stellen. Vielen Dank an alle!

Quelle: habr.com