Titanic Survival Prediction using Danfo.js and Tensorflow.js
The titanic survival prediction is a classic problem in the data science space. In this tutorial, you are going to create a regression model to predict who will survive the disaster.
The RMS Titanic was a British passenger liner that sank in the North Atlantic Ocean in the early morning hours of 15 April 1912, after it collided with an iceberg during its maiden voyage from Southampton to New York City. There were an estimated 2,224 passengers and crew aboard the ship, and more than 1,500 died, making it one of the deadliest commercial peacetime maritime disasters in modern history. The RMS Titanic was the largest ship afloat at the time it entered service and was the second of three Olympic-class ocean liners operated by the White Star Line. The Titanic was built by the Harland and Wolff shipyard in Belfast. Thomas Andrews, her architect, died in the disaster. (Wikipedia)
In this tutorial, I will show you how to load and process the famous Titanic dataset with danfo.js, and also how to create a deep learning model with Tensorflow.js to predict survival. This is a classic problem used to introduce new concepts in the field of Machine Learning.
The main objective of this tutorial is to show you how to use danfo.js to load and process data easily in JavaScript, so we won't be doing anything too advanced. Also, I assumed that you're familiar with basic deep learning with Tensorflow.js and Pandas as well. If you do not have any background in ML, these are good resources to get started:
Danfo.js comes in two builds. There's the browser-based build, optimized for browser environments, and there is the node.js version optimized for Node.js environment.
In this tutorial, you're going to use the Node.js build. If you do not have Node.js installed, following the guide here. When you're done, create a new project by running the command below in a terminal opened in your preferred terminal.
npm init
Fill in the necessary details to create your app. Next, in your terminal, install danfo.js:
Update (14th Feb 2021):
Danfo now ships with an exported version of tensorflow (v2.8.5). This is exported under the namespace tf. This fixes the double registration of runtime issue many users have faced in the past.
npm install danfojs-node
When you're done, create a file called app.js and import the packages:
constdfd=require("danfojs-node")consttf=dfd.tensorflow //Reference to the exported tensorflowjs library
Loading and processing your data
To load a CSV dataset, you can use the readCSV function. This can load a file from both a local path, as well as over the internet. In this tutorial, you'll load the titanic dataset from the internet.
Below your import add the following lines of code:
You wrote an async function because loading a dataset over the internet takes a few seconds depending on your network. Inside the async function, you pass in the url of the titanic dataset to the read_csv function.
Next you'll perform some basic data preprocessing. The ctypes attribute returns the column data types:
df.ctypes.print()
╔═════════════════════════╤══════════════════════╗║ │ 0 ║╟─────────────────────────┼──────────────────────╢║ Survived │ int32 ║╟─────────────────────────┼──────────────────────╢║ Pclass │ int32 ║╟─────────────────────────┼──────────────────────╢║ Name │ string ║╟─────────────────────────┼──────────────────────╢║ Sex │ string ║╟─────────────────────────┼──────────────────────╢║ Age │ int32 ║╟─────────────────────────┼──────────────────────╢║ Siblings/Spouses Aboard │ int32 ║╟─────────────────────────┼──────────────────────╢║ Parents/Children Aboard │ int32 ║╟─────────────────────────┼──────────────────────╢║ Fare │ float32 ║╚═════════════════════════╧══════════════════════╝
From the data types table above, you'll notice that there are two string columns. The first is the Name column which contains Names of each passenger. From the head of the dataset you printed above, you'll confirm that each name has a title. So you can extract these titles from the names and this can serve as a new feature.
//A feature engineering: Extract all titles from names columnslet title = df['Name'].apply((x) => { returnx.split(".")[0] }).values//replace in dfdf.addColumn("Name", title, { inplace:true })
In the code above, you are calling the apply function on the Name column. The parameter to the apply function is a function that gets called on each element of the column. This function can be any JavaScript function.
So what exactly is the function doing? Well, it is basically slicing each name and extracting the title. And finally, you are using the result to replace the original name column. When you're done, your output becomes:
In code cell above, you're label encoding the Sex and Name column. You loop over each column name, fit the encoder to the column, transform it and finally reassign it to the DataFrame. The output is shown below:
Next, you'll split data. You'll separate the features from the labels. In this task, you're trying to predict Survival of a passenger. Survival column is the first in the DataFramw, so you'll use iloc to subset the DataFrame:
let Xtrain,ytrain;Xtrain =df.iloc({ columns: [`1:`] })ytrain = df['Survived']
Next, you'll scale the data using MinMaxScaler. It is important to scale your data before model training, as this will affect training.
// Standardize the data with MinMaxScalerlet scaler =newdfd.MinMaxScaler()scaler.fit(Xtrain)Xtrain =scaler.transform(Xtrain)return [Xtrain.tensor,ytrain.tensor]
In the code cell above, first, you create an instance from the MinMaxScaler class. Next, you fit the train data and finally, you transform. The output from the scaler is a DataFrame of same size with the values scaled.
In the code cell above, you created a neural network with 4 layers. Note the input shape, this should be the same as your column numbers. Also, note that you used a sigmoid in the output layer. This is because you're working on a binary classification problem.
This function calls the load_process_data function to retrieve training data as tensors and also calls the get_model to retrieve the model. Next, you compile the model by specifying an optimizer, a loss function and a metric to report.
Next, you call the fit function on the model, by passing the training data and labels (tensors), specify batch size, epoch size, validation split size, and also a callback function to track training progress.
The training progress is printed to the console at the end of each Epoch. Below is the full code from loading data to training your model:
constdfd=require("danfojs-node-nightly")consttf=dfd.tensorflowasyncfunctionload_process_data() {let df =awaitdfd.readCSV("https://web.stanford.edu/class/archive/cs/cs109/cs109.1166/stuff/titanic.csv")//A feature engineering: Extract all titles from names columnslet title = df['Name'].apply((x) => { returnx.split(".")[0] }).values//replace in dfdf.addColumn("Name", title, { inplace:true })//label Encode Name featurelet encoder =newdfd.LabelEncoder()let cols = ["Sex","Name"]cols.forEach(col => {encoder.fit(df[col]) enc_val =encoder.transform(df[col])df.addColumn( col, enc_val, { inplace:true }) })let Xtrain, ytrain; Xtrain =df.iloc({ columns: [`1:`] }) ytrain = df['Survived']// Standardize the data with MinMaxScalerlet scaler =newdfd.MinMaxScaler()scaler.fit(Xtrain) Xtrain =scaler.transform(Xtrain)return [Xtrain.tensor,ytrain.tensor] //return the data as tensors}load_process_data()functionget_model() {constmodel=tf.sequential();model.add(tf.layers.dense({ inputShape: [7], units:124, activation:'relu', kernelInitializer:'leCunNormal' }));model.add(tf.layers.dense({ units:64, activation:'relu' }));model.add(tf.layers.dense({ units:32, activation:'relu' }));model.add(tf.layers.dense({ units:1, activation:"sigmoid" }))model.summary();return model}asyncfunctiontrain() {constmodel=awaitget_model()constdata=awaitload_process_data()constXtrain= data[0]constytrain= data[1]model.compile({ optimizer:"rmsprop", loss:'binaryCrossentropy', metrics: ['accuracy'], });console.log("Training started....")awaitmodel.fit(Xtrain, ytrain,{ batchSize:32, epochs:15, validationSplit:0.2, callbacks:{onEpochEnd:async(epoch, logs)=>{console.log(`EPOCH (${epoch +1}): Train Accuracy: ${(logs.acc *100).toFixed(2)}, Val Accuracy: ${(logs.val_acc *100).toFixed(2)}\n`); } } });};train()
In your terminal, run the script with node:
node app.js
This runs the script, and displays training progress after each Epoch as shown below:
After 15 epochs, you reach an accuracy of about 83%. This can definitely be improved, but for the sake of simplicity, we'll stop here.
In this tutorial, you have seen how to use danfo.js with tensorflow.js to load and process data, as well as train a neural network. This is similar to the Pandas-Tensorflow packages in Python.
You also notice that danfo.js provides a similar API as Pandas and can easily be picked up by Python developers.
As an extra task, you can try to do more feature engineering using danfo.js and try to improve the accuracy of your model.
