Dalam tutorial ini, kita akan menelusuri dataset Titanic, menganalisisnya, dan mengirimkan hasilnya ke kompetisi yang sebenarnya. Anda sudah mempelajari cara mengambil data dan mengimpornya ke Kaggle Notebook Anda dalam tutorial ini. Sekarang kita akan menggunakan DataLab sebagai notebook data science. Anda akan mempelajari cara menggunakan kedua alat di platform yang berbeda sehingga Anda dapat memilih yang paling Anda sukai.
Pertama, buka bagian "Competitions" di Kaggle dan cari Titanic (Gambar 5.4). Sebelum langsung masuk ke notebook, Anda harus memahami semua informasi yang dibagikan di bagian "Description and Rules". Penting juga untuk memeriksa notebook milik pengguna lain, karena ini dapat memberi Anda lebih banyak ide tentang solusinya.
Kompetisi ini tentang menggunakan machine learning untuk membuat model yang memprediksi penumpang mana yang akan selamat dari karamnya kapal Titanic. Kita akan menggunakan dataset yang mencakup informasi penumpang seperti nama, jenis kelamin, usia, dan sebagainya. Akan ada 2 dataset berbeda yang akan kita gunakan. Yang pertama berjudul 'train.csv'. Dalam dataset ini, selain informasi penumpang, terdapat juga nilai ground truth seperti 'survived' dan 'not survived'. Pada dataset kedua yang berjudul 'test.csv', tidak akan ada nilai ground truth, karena kita diminta untuk memprediksi nilai tersebut dan mengunggah hasilnya.
Berkas submission hanya akan memiliki 2 kolom: PassengerId dan Survived. Sistem submission akan menghasilkan galat jika Anda mencoba mengunggah berkas dengan lebih dari 2 nilai. Perlu diketahui bahwa Anda dapat mengirimkan hingga 10 submission per hari.
Dengan informasi yang diberikan di bagian "Competition Description", langkah berikutnya adalah mengambil data ke DataLab kita dan menganalisis data tersebut.
Pertama, Anda perlu mengunduh dataset di Data Explorer dengan masuk ke tab Data (Gambar 5.5). Anda harus mengunduh 'train.csv' dan 'test.csv'.
Setelah mengunduh berkas, Anda harus menuju ke DataLab. Harap dicatat bahwa Anda perlu membuat akun terlebih dahulu. Membuat akun dan menggunakan DataLab gratis.
Anda dapat dengan mudah melakukan drag and drop berkas di sisi kiri notebook (Gambar 5.6).
Langkah berikutnya adalah memeriksa kamus data di bagian deskripsi dataset. Ini akan membantu kita memutuskan kolom mana yang akan divisualisasikan.
- survival: Kelangsungan hidup
- pclass: Kelas tiket
- sex: Jenis kelamin
- Age: Usia dalam tahun
- sibsp: Jumlah saudara kandung/pasangan di atas kapal Titanic
- parch: Jumlah orang tua/anak di atas kapal Titanic
- ticket: Nomor tiket
- fare: Tarif penumpang
- cabin: Nomor kabin
- embarked: Pelabuhan keberangkatan
Mengimpor Data
Anda dapat menggunakan perintah bash di jupyter notebooks dengan menempatkan tanda seru di depan sel. Kita akan memeriksa lokasi berkas dataset yang diunggah menggunakan perintah pwd dan ls.
!pwd; ls
/work/files/workspace
notebook.ipynb test.csv train.csv
Pandas adalah pustaka Python yang digunakan untuk proses manipulasi dan analisis data. Kini kita telah menghapus kolom Ticket, Name, dan PassengerId karena tidak memiliki data numerik atau kategorikal yang bermakna. Sekarang Anda akan dapat melihat fitur lainnya yang akan digunakan.
Pada beberapa baris berikut, berkas dataset pelatihan dan pengujian dibaca menggunakan metode read_csv dari Pandas. Perhatikan bahwa kolom Survived dan PassengerId masing-masing ditambahkan ke dataframe train dan test. Kita akan memberi masukan ke model secara terpisah menggunakan fitur dalam columns_to_be_added_as_features dan label di kolom Survived. Namun untuk menyederhanakan prapemrosesan, untuk saat ini kita dapat menggabungkannya. Variabel test_df_matcher juga menyertakan PassengerId. Kita akan menggunakannya untuk mencocokkan PassengerId dengan prediksi himpunan uji, guna menghasilkan berkas CSV yang akan diunggah ke Kaggle sebagai hasil kita.
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]
Dengan metode head(), kita dapat melihat 5 baris pertama beserta nama kolomnya. Anda dapat menentukan jumlah baris awal yang akan ditampilkan sebagai parameter di dalam metode head(). Jumlah baris pada himpunan pelatihan dan himpunan uji dicetak masing-masing pada sel berikut.
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
Prapemrosesan
Kita harus mengonversi tipe nilai menjadi float, yang akan digunakan sebagai fitur dalam model. Konversi ini memungkinkan kita melakukan beberapa operasi numerik saat menormalkan data.
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")
Kita perlu memberi masukan ke model menggunakan nilai numerik. Pada potongan kode di bawah ini string dikonversi menjadi nilai numerik
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())
Di bawah ini, semua fitur dinormalisasi, yang dalam kasus ini berarti diskalakan antara 0 dan 1.
#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())
Karena dataset akan dipisah menjadi pelatihan dan validasi, kita akan mengacak dataset terlebih dahulu untuk menghindari pengelompokan hanya pada satu himpunan.
#Credit: Kris, https://stackoverflow.com/questions/29576430/shuffle-dataframe-rows
train_df = train_df.sample(frac=1).reset_index(drop=True)
Semua nilai kosong akan diganti dengan 0; pilihan ini dibuat untuk menghemat waktu. Namun, Anda dapat membaca tutorial ini untuk mempelajari cara menangani nilai hilang dalam machine learning.
train_df = train_df.fillna(0)
test_df = test_df.fillna(0)
Di bawah ini, rasio validasi ditetapkan ke 0,2, yang berarti 20% data akan digunakan untuk validasi. Untuk membagi dataset menjadi himpunan pelatihan dan validasi, kita akan menggunakan metode train_test_split dari Sklearn. Lalu kita akan memisahkan fitur dan label seperti yang ditunjukkan pada 4 baris terakhir potongan kode berikut.
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']]
Pelatihan
Support vector machine adalah model pembelajaran terawasi yang digunakan untuk klasifikasi dan regresi. Model ini dipilih dengan parameter di bawah. Anda sebaiknya mencoba model lain dengan kombinasi parameter yang berbeda. Tidak perlu memulai dan menghentikan kode setiap kali Anda ingin mengubah parameter atau mencoba model lain, karena Anda dapat mengotomatiskan proses ini. Jika Anda tertarik dengan Support Vector Machines, Anda dapat melihat tutorial Support Vector Machines dengan Scikit-learn di DataCamp.
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)
Mendapatkan Prediksi Himpunan Validasi
Pada bagian ini, kita akan memberi masukan fitur himpunan validasi ke model dan mendapatkan prediksinya. Lalu kita akan membandingkannya dengan nilai ground truth. Metode metrics.accuracy_score dari Sklearn digunakan untuk memudahkan perhitungan akurasi. Akurasi himpunan validasi dihitung sebesar 0,799, yang merupakan awal yang baik.
from sklearn import metrics
y_pred = svm_model.predict(val_X)
print("Accuracy:",metrics.accuracy_score(val_Label, y_pred))
Accuracy: 0.7988826815642458
Mendapatkan Prediksi Himpunan Uji
Sekarang kita lanjut untuk mendapatkan prediksi bagi himpunan uji yang sebenarnya. Karena tidak ada nilai ground truth untuk himpunan uji, kita hanya dapat mengetahui akurasinya setelah berkas prediksi diunggah ke Kaggle.
test_pred = svm_model.predict(test_df)
Membuat Dataframe Keluaran
Kolom PassengerId diambil dari dataframe bernama test_df_matcher. Saat dikembalikan secara langsung, tipe nilai kembalian akan berupa Series. Karena itu, kita akan mengubahnya menjadi tipe Pandas DataFrame. Lalu kita akan menyisipkan prediksi himpunan uji sebagai kolom kedua dari dataframe.
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))
Membuat Berkas Keluaran
Akhirnya, format keluaran sudah siap. Sebagai langkah terakhir, nilai indeks akan dihapus dengan memberikan False pada parameter index. Sekarang Anda dapat mengunduh berkas yang dihasilkan dan mengunggahnya ke Kaggle. Dengan cara ini, Anda akan mengetahui akurasi himpunan uji, setelah itu Anda akan masuk ke papan peringkat.
result.to_csv("out.csv", index=False)
Sekarang kita akan kembali ke halaman kompetisi dan klik "Submit Predictions" lalu unggah berkas prediksi. Setelah beberapa detik, Anda akan mendapatkan akurasi uji Anda (Gambar 5.12).
Kesimpulan
Dalam tutorial ini, Anda telah mempelajari cara menganalisis sebuah dataset dan mengirimkan hasil Anda ke kompetisi Kaggle. Jika Anda menikmati kompetisi data science, Anda dapat mempelajari lebih lanjut tentang DataCamp Competitions di sini.
