In diesem Tutorial gehen wir das Titanic-Dataset durch, analysieren es und reichen die Ergebnisse beim echten Wettbewerb ein. Wie du die Daten abrufst und in dein Kaggle Notebook importierst, hast du bereits in diesem Tutorial gelernt. Jetzt verwenden wir DataLab als Data-Science-Notebook. So lernst du, beide Tools auf unterschiedlichen Plattformen zu nutzen und kannst dir deinen Favoriten aussuchen.
Wechsle zuerst in Kaggle zum Bereich "Competitions" und suche nach Titanic (Abbildung 5.4). Bevor du direkt ins Notebook springst, solltest du die Informationen in den Bereichen "Description" und "Rules" genau verstehen. Schau dir außerdem Notebooks anderer Nutzer an – das bringt oft zusätzliche Ideen für die Lösung.
In diesem Wettbewerb geht es darum, mit Machine Learning ein Modell zu erstellen, das vorhersagt, welche Passagiere das Titanic-Unglück überlebt hätten. Wir nutzen ein Dataset mit Passagierdaten wie Name, Geschlecht, Alter usw. Wir arbeiten mit zwei verschiedenen Datasets. Das erste heißt 'train.csv'. Hier sind neben den Passagierinformationen auch die Ground-Truth-Werte wie 'survived' und 'not survived' enthalten. Im zweiten Dataset, 'test.csv', gibt es keine Ground-Truth-Werte, da wir diese vorhersagen und unsere Ergebnisse einreichen sollen.
Die Einreichungsdatei hat genau 2 Spalten: PassengerId und Survived. Das System wirft einen Fehler aus, wenn du eine Datei mit mehr als zwei Spalten hochlädst. Beachte außerdem: Du kannst pro Tag bis zu 10 Einreichungen machen.
Mit den Informationen aus der "Competition Description" laden wir als nächsten Schritt die Daten in unser DataLab und analysieren sie.
Lade das Dataset zuerst im Data Explorer herunter, indem du in den Tab Data gehst (Abbildung 5.5). Lade sowohl 'train.csv' als auch 'test.csv' herunter.
Nach dem Download wechselst du zu DataLab. Hinweis: Du brauchst dafür ein Konto. Die Kontoerstellung und die Nutzung von DataLab sind kostenlos.
Du kannst Dateien bequem per Drag-and-drop auf der linken Seite des Notebooks hinzufügen (Abbildung 5.6).
Als Nächstes wirfst du einen Blick ins Data Dictionary in der Datasetsbeschreibung. Das hilft dir zu entscheiden, welche Spalten du visualisieren willst.
- survival: Überleben
- pclass: Ticketklasse
- sex: Geschlecht
- Age: Alter in Jahren
- sibsp: Anzahl Geschwister/Ehegatten an Bord der Titanic
- parch: Anzahl Eltern/Kinder an Bord der Titanic
- ticket: Ticketnummer
- fare: Fahrpreis
- cabin: Kabinennummer
- embarked: Einschiffungshafen
Daten importieren
In Jupyter Notebooks kannst du Bash-Befehle ausführen, indem du ein Ausrufezeichen vor die Zelle setzt. Wir prüfen den Speicherort der hochgeladenen Dateien mit den Befehlen pwd und ls.
!pwd; ls
/work/files/workspace
notebook.ipynb test.csv train.csv
Pandas ist eine Python-Bibliothek für Datenmanipulation und -analyse. Wir haben die Spalten Ticket, Name und PassengerId entfernt, da sie keine sinnvollen numerischen oder kategorialen Informationen liefern. Jetzt siehst du die verbleibenden Features, die wir nutzen.
In den nächsten Zeilen werden die Trainings- und Testdateien mit der Pandas-Methode read_csv eingelesen. Beachte, dass die Spalten Survived und PassengerId entsprechend zu den Train- bzw. Test-DataFrames hinzugefügt werden. Wir füttern das Modell getrennt mit den Features in columns_to_be_added_as_features und den Labels in der Spalte Survived. Um das Preprocessing zu vereinfachen, kombinieren wir sie vorübergehend. Die Variable test_df_matcher enthält ebenfalls die PassengerId. Damit gleichen wir später die PassengerId mit den Vorhersagen des Testsets ab, um die CSV-Datei zu erzeugen, die wir bei Kaggle hochladen.
import pandas as pd
columns_to_be_added_as_features = ['Sex','Age','SibSp','Parch','Pclass','Fare','Embarked']
train_df = pd.read_csv('train.csv', usecols=columns_to_be_added_as_features + ['Survived'])
test_df_matcher = pd.read_csv('test.csv', usecols=columns_to_be_added_as_features + ['PassengerId'])
test_df = test_df[columns_to_be_added_as_features]
Mit der Methode head() sehen wir die ersten 5 Zeilen samt Spaltennamen. Wie viele Anfangszeilen angezeigt werden sollen, kannst du als Parameter übergeben. Darunter drucken wir die Anzahl der Zeilen im Trainings- und im Testset.
print(train_df.head())
print("Number of rows in training set: {}".format(len(train_df)))
print("Number of rows in test set: {}".format(len(test_df)))
Number of rows in training set: 891 Number of rows in test set: 418
Preprocessing
Wir sollten die Werte, die als Features ins Modell gehen, in den Typ float konvertieren. So können wir beim Normalisieren numerische Operationen durchführen.
for column_title in columns_to_be_added_as_features:
if column_title in ['Embarked', "Sex"]:
continue
train_df[column_title] = pd.to_numeric(train_df[column_title], downcast="float")
test_df[column_title] = pd.to_numeric(test_df[column_title], downcast="float")
train_df["Survived"] = pd.to_numeric(train_df["Survived"], downcast="float")
Das Modell braucht numerische Eingaben. Im folgenden Code werden Strings in Zahlen umgewandelt.
train_df['Embarked'].replace('Q', 0,inplace=True)
train_df['Embarked'].replace('S', 1,inplace=True)
train_df['Embarked'].replace('C', 2,inplace=True)
test_df['Embarked'].replace('Q', 0,inplace=True)
test_df['Embarked'].replace('S', 1,inplace=True)
test_df['Embarked'].replace('C', 2,inplace=True)
train_df['Sex'].replace('male', 0,inplace=True)
train_df['Sex'].replace('female', 1,inplace=True)
test_df['Sex'].replace('male', 0,inplace=True)
test_df['Sex'].replace('female', 1,inplace=True)
print(train_df.head())
Unten werden alle Features normalisiert, hier also auf den Bereich 0 bis 1 skaliert.
#Credit: Michael Aquilina,
#https://stackoverflow.com/questions/26414913/normalize-columns-of-pandas-data-frame
def normalize(df):
result = df.copy()
for feature_name in df.columns:
max_value = df[feature_name].max()
min_value = df[feature_name].min()
result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
return result
train_df = normalize(train_df)
test_df = normalize(test_df)
print(train_df.head())
Da wir das Dataset in Training und Validation aufteilen, mischen wir es zuerst durch, um Cluster nur in einem Teilset zu vermeiden.
#Credit: Kris, https://stackoverflow.com/questions/29576430/shuffle-dataframe-rows
train_df = train_df.sample(frac=1).reset_index(drop=True)
Alle fehlenden Werte werden durch 0 ersetzt; diese Entscheidung spart Zeit. In diesem Tutorial erfährst du mehr darüber, wie man fehlende Werte im Machine Learning behandelt.
train_df = train_df.fillna(0)
test_df = test_df.fillna(0)
Unten setzen wir das Verhältnis für das Validationsset auf 0,2, also 20% der Daten zur Validierung. Zum Aufteilen verwenden wir Sklearns train_test_split. Danach trennen wir Features und Labels wie in den letzten 4 Zeilen gezeigt.
validation_set_ratio = 0.2
validation_set_size = int(len(train_df)*validation_set_ratio)
training_set_size = len(train_df) - validation_set_size
print("Total set size: {}".format(len(train_df)))
print("Training set size: {}".format(training_set_size))
print("Validation set size: {}".format(validation_set_size))
from sklearn.model_selection import train_test_split
train, val = train_test_split(train_df, test_size=validation_set_ratio)
train_X = train[columns_to_be_added_as_features]
train_Label = train[['Survived']]
val_X = val[columns_to_be_added_as_features]
val_Label = val[['Survived']]
Training
Support Vector Machines sind überwachte Lernmodelle für Klassifikation und Regression. Wir verwenden das Modell mit den untenstehenden Parametern. Probiere unbedingt auch andere Modelle und Parameterkombinationen aus. Du musst den Code dafür nicht jedes Mal manuell starten und stoppen – du kannst den Prozess automatisieren. Wenn dich Support Vector Machines interessieren, schau dir das DataCamp-Tutorial Support Vector Machines mit Scikit-learn an.
from sklearn.svm import SVC
SVM_KERNEL = "linear"
SVM_C = 10
SVM_GAMMA = 0.00001
svm_model = SVC(kernel = SVM_KERNEL, C = SVM_C, gamma = SVM_GAMMA)
svm_model.fit(train_X, train_Label)
Vorhersagen für das Validationsset
Hier füttern wir das Modell mit den Features des Validationssets und holen uns die Vorhersagen. Anschließend vergleichen wir sie mit den Ground-Truth-Werten. Für die einfache Genauigkeitsberechnung nutzen wir Sklearns metrics.accuracy_score. Die Accuracy des Validationssets beträgt 0,799 – ein guter Start.
from sklearn import metrics
y_pred = svm_model.predict(val_X)
print("Accuracy:",metrics.accuracy_score(val_Label, y_pred))
Accuracy: 0.7988826815642458
Vorhersagen für das Testset
Jetzt erstellen wir die Vorhersagen für das eigentliche Testset. Da es dort keine Ground-Truth-Werte gibt, erfahren wir die Accuracy erst, nachdem wir die Vorhersagedatei bei Kaggle hochgeladen haben.
test_pred = svm_model.predict(test_df)
Den Ergebnis-DataFrame erzeugen
Die Spalte PassengerId entnehmen wir dem DataFrame test_df_matcher. Bei direkter Rückgabe ist der Typ eine Series. Daher casten wir in einen Pandas DataFrame. Anschließend fügen wir die Testset-Vorhersagen als zweite Spalte ein.
result = pd.DataFrame(test_df_matcher['PassengerId'])
print(result.head(10))
result.insert(1, "Survived", test_pred, True)
result["Survived"] = pd.to_numeric(result["Survived"], downcast="integer")
print(result.head(10))
Die Ausgabedatei erzeugen
Das Ausgabeformat ist nun bereit. Zum Schluss entfernen wir die Indexwerte, indem wir False an den Parameter index übergeben. Jetzt kannst du die erzeugte Datei herunterladen und bei Kaggle hochladen. So erfährst du die Accuracy auf dem Testset und wirst anschließend auf dem Leaderboard platziert.
result.to_csv("out.csv", index=False)
Wechsle nun zurück zur Wettbewerbsseite, klicke auf "Submit Predictions" und lade die Vorhersagedatei hoch. Nach ein paar Sekunden erhältst du deine Test-Accuracy (Abbildung 5.12).
Fazit
In diesem Tutorial hast du gelernt, wie du ein Dataset analysierst und deine Ergebnisse bei einem Kaggle-Wettbewerb einreichst. Wenn dir Data-Science-Wettbewerbe Spaß machen, erfährst du hier mehr über DataCamp Competitions: hier.