Prediksi Ketahanan Hidup Penumpang Kapal Titanic Menggunakan K-NN | Python
Kaggle: Titanic — Machine Learning from Disaster
Data yang akan digunakan pada artikel ini berasal dari titanic. Data ini berisi 12 variabel, termasuk di dalamnya adalah variabel personal seperti id dan nama, serta variabel target berupa “Survived” (bernilai 0 dan 1). Tujuan yang ingin dicapai adalah memprediksi penumpang mana yang selamat (Survived = 1) dan penumpang mana saja yang tidak selamat (Survived = 0) dalam peristiwa kapal Titanic berdasarkan fitur yang ada. Akan ada data “train.csv” yang digunakan untuk membuat model dan data “test.csv” sebagai data yang akan diprediksi dengan model yang telah terbentuk. Teknik Machine Learning yang digunakan adalah Klasifikasi dengan langkah-langkah yang saya lakukan adalah sebagai berikut:
- Import library dasar yang diperlukan
- Import dataset
- Exploratory Data Analysis (EDA)
- Feature Selection dengan menghapus beberapa fitur
- Feature Engineering yaitu mengatasi missing value, mengatasi variabel kategorik, dan melakukan penskalaan data
- Modelling dengan menggunakan K-Nearest Neighbors (K-NN) sekaligus evalusi model menggunakan nilai akurasi. Akan ada perbandingan beberapa model juga di sini
Buka terlebih dahulu Jupyter Notebook atau Google Colab, dan mari praktek!
1. Import Library
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns2. Import Dataset
Download data pada link sebelumnya dan import data “train.csv” terlebih dahulu. Sampai pada tahap pembuatan model, data yang digunakan adalah “train.csv”.
titanic = pd.read_csv("train.csv")
titanic.head()
3. EDA
# Ukuran data
titanic.shape
Data “titanic” terdiri dari 891 baris dan 12 kolom. Selanjutnya, akan dibuat fungsi yang berisi ringkasan data berupa tipe data, jumlah missing value, dan jumlah unique value.
def summarize_features(df):
# tipe data
summary = pd.DataFrame(df.dtypes, columns = ['dtypes'])
summary = summary.reset_index()
# jumlah missing value
summary['Missing'] = df.isnull().sum().values
# jumlah unique value
summary['Uniques'] = df.nunique().values
return summarysummarize_features(titanic)
4. Feature Selection
Dari ringkasan tersebut, terlihat adanya variabel personal yaitu “PassengerId” dan “Name”. Selain itu, terlihat pula bahwa variabel “Cabin” memiliki missing value sebanyak 687 (dari 891 data) dan variabel “Ticket” dengan tipe data object memiliki unique value sebanyak 681. Keempat variabel ini akan dihapus dan tidak digunakan.
# Hapus kolom "PassengerId" dan "Name" -> Data personal (unique)
# Hapus kolom "Cabin" -> Missing-nya banyak (687)
# Hapus kolom "Ticket" -> Object dengan unique banyak (681)
titanic = titanic.drop(columns = ["PassengerId", "Name", "Cabin", "Ticket"])summarize_features(titanic)
Dari Feature Selection ini, didapatkan 8 kolom yang akan digunakan, termasuk variabel “Survived” sebagai target.
5. Feature Engineering
Proses selanjutnya yang saya lakukan adalah Feature Engineering berupa mengatasi missing value, mengatasi variabel kategorik, dan melakukan penskalaan data.
Handling Missing Value
Seperti yang terlihat dalam gambar “summarize_features(titanic)-2”, terdapat 2 variabel yang mempunyai missing value yaitu variabel “Embarked” dan “Age” .
Missing value untuk variabel “Embarked” dimana bertipe object (kategorik) akan saya isi dengan modus data.
# "Embarked" -> Isi dengan modus
titanic["Embarked"] = titanic["Embarked"].fillna(titanic["Embarked"].value_counts().index[0])Sedangkan untuk variabel “Age” dimana bertipe float (numerik) akan saya buat terlebih dahulu boxplot-nya, sehingga terlihat apakah data tersebut mengandung outlier.
sns.boxplot(titanic["Age"])
Terlihat bahwa variabel “Age” mengandung outlier sehingga missing value pada data tersebut akan saya isi denga nilai median.
# "Age" -> Isi dengan median
titanic["Age"].fillna(titanic["Age"].median(), inplace = True)Ringkasan data akan menujukkan bahwa missing value sudah tidak ada, yang berarti bahwa missing value sudah teratasi.
Handling Categorical Data
Selanjutnya adalah mengatasi variabel kategorik. Nilai-nilai kategorik harus diubah menjadi numerik terlebih dahulu sebelum membuat model.
Variabel yang bertipe kategorik adalah variabel “Sex” dan “Embarked” dimana kedua variabel ini memiliki skala nominal. Saya akan mengatasi kedua variabel kategorik ini menggunakan get_dummies.
# "Sex" dan "Embarked" adalah variabel kategorik (nominal)
#encode the data
data_encoded = pd.get_dummies(data = titanic[["Sex", "Embarked"]], drop_first = True)
data_encoded
Saya akan menggabungkan hasil kodifikasi “data_encoded” dengan data asli yaitu “titanic”. Karena sudah dikodifikasi, maka kolom/variabel kategorik yang asli akan dihapus.
# Menggabungkan dengan data keseluruhan
titanic = pd.concat(objs = [titanic, data_encoded], axis = 1)
titanic.drop(["Sex", "Embarked"], axis = 1, inplace = True)titanic
Feature Scaling
Penskalaan variabel penjelas (fitur) dilakukan karena range nilai antar variabel beragam dan cukup jauh jaraknya. Hal ini dapat dilihat dari nilai min dan max masing-masing variabel yang berbeda, ada yang bernilai 0 hingga 1, ada pula yang bernilai 0,42 hingga 80 dan 0 hingga 512.
Saya menggunakan StandardScaler untuk melakukan penskalaan pada fitur. Perlu diingat bahwa variabel dengan index 0 yaitu “Survived” adalah variabel target, sehingga tidak diikutkan dalam penskalaan.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
titanic.iloc[:, 1:] = sc.fit_transform(titanic.iloc[:, 1:])
Data “titanic” sudah siap dibuat model!
6. Modelling
Buat terlebih dahulu variabel yang menunjukkan fitur (X) dan target (y).
X = titanic.iloc[:, 1:].values
y = titanic.iloc[:, 0].valuesBagi data menjadi training set dan test set. Saya menggunakan 25% data untuk test set.
# Splitting into the training set and test setfrom sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
Saya akan mencoba membuat model dengan metode K-Nearest Neighbors (K-NN).
K-Nearest Neighbors (K-NN)
K-NN adalah algoritma untuk melakukan klasifikasi suatu data yang diambil dari k tetangga terdekatnya (nearest neighbors). K merupakan banyaknya tetangga terdekat yang akan digunakan dan biasanya bernilai ganjil. Teknik pencarian tetangga terdekat yang umum digunakan yaitu formula Euclidean Distance.
# 1. K-NEAREST NEIGHBORS (K-NN)
from sklearn.neighbors import KNeighborsClassifier
classifier1 = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
classifier1.fit(X_train, y_train)Selanjutnya, dilakukan evaluasi model dengan melihat nilai akurasi (accuracy score).
# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred1 = classifier1.predict(X_test)
cm1 = confusion_matrix(y_test, y_pred1)
print(cm1)
accuracy_score(y_test, y_pred1)
Dapat pula dilihat perbandingan antara nilai target data asli dengan hasil prediksi.
# Perbandingan Data Asli dan Hasil Prediksi
print(np.concatenate((y_test.reshape(len(y_test), 1), y_pred1.reshape(len(y_pred1), 1)), 1))
Beberapa Model Lain
Saya mencoba membuat beberapa model lain untuk melihat perbandingan nilai akurasinya. Model yang saya coba yaitu Logistic Regression, Kernel SVM, Naive Bayes, Decision Tree, dan Random Forest.
Logistic Regression
# 2. LOGISTIC REGRESSION
from sklearn.linear_model import LogisticRegression
classifier2 = LogisticRegression(random_state = 0)
classifier2.fit(X_train, y_train)# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred2 = classifier2.predict(X_test)
cm2 = confusion_matrix(y_test, y_pred2)
print(cm2)
accuracy_score(y_test, y_pred2)
Kernel SVM
# 3. KERNEL SVM
from sklearn.svm import SVC
classifier3 = SVC(kernel = 'rbf', random_state = 0)
classifier3.fit(X_train, y_train)# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred3 = classifier3.predict(X_test)
cm3 = confusion_matrix(y_test, y_pred3)
print(cm3)
accuracy_score(y_test, y_pred3)
Naive Bayes
# 4. NAIVE BAYES
from sklearn.naive_bayes import GaussianNB
classifier4 = GaussianNB()
classifier4.fit(X_train, y_train)# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred4 = classifier4.predict(X_test)
cm4 = confusion_matrix(y_test, y_pred4)
print(cm4)
accuracy_score(y_test, y_pred4)
Decision Tree
# 5. DECISION TREE
from sklearn.tree import DecisionTreeClassifier
classifier5 = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)
classifier5.fit(X_train, y_train)# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred5 = classifier5.predict(X_test)
cm5 = confusion_matrix(y_test, y_pred5)
print(cm5)
accuracy_score(y_test, y_pred5)
Random Forest
# 6. RANDOM FOREST
from sklearn.ensemble import RandomForestClassifier
classifier6 = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0)
classifier6.fit(X_train, y_train)# Evaluasi
from sklearn.metrics import confusion_matrix, accuracy_score
y_pred6 = classifier6.predict(X_test)
cm6 = confusion_matrix(y_test, y_pred6)
print(cm6)
accuracy_score(y_test, y_pred6)
Kesimpulan
Dari data ini, model K-Nearest Neighbors (K-NN) dapat digunakan untuk memprediksi ketahanan hidup penumpang kapal Titanic (“Survived”) dengan nilai akurasi (accuracy score) sebesar 0,807 atau 80,7%. Dibandingkan dengan kelima model lain, nilai akurasi model K-NN adalah yang paling besar.
Artikel ini hanya membahas sampai terbentuk model. Untuk menerapkan modelnya pada data “test.csv” yang ada di Kaggle, dapat dilakukan dengan cara yang sama. Selamat mencoba!
Untuk full code langkah di atas dan hasil pengerjaan pada data “test.csv”, dapat dilihat pula pada github saya. Score submission saya di Kaggle adalah 0.71531.
Semoga artikel ini bermanfaat. Jika terdapat kekeliruan, mohon koreksinya ya. Terima kasih! :)
Referensi:
