{

"cells": [
{
"metadata": {
"_cell_guid": "ea25cdf7-bdbc-3cf1-0737-bc51675e3374",
"_uuid": "92c2e9a9a67334c04c6cbe789a8372e5a80b2365"
},
"cell_type": "markdown",
"source": "# Titanic Data Science Solutions\n\n---\n\n### I have released a
new Python package [Speedml](https://speedml.com) which codifies the techniques
used in this notebook into an intuitive, powerful, and productive API. \n\n###
Speedml helps me jump from low 80% on the Kaggle leaderboard to high 20% within few
iterations.\n\n### One more thing... Speedml achieves this with nearly 70% fewer
lines of code!\n\n### Run and download the [Titanic Solution using Speedml]
(https://github.com/Speedml/notebooks/blob/master/titanic/titanic-solution-using-
speedml.ipynb).\n\n---\n\nThis notebook is a companion to the book [Data Science
Solutions](https://startupsci.com). The notebook walks us through a typical
workflow for solving data science competitions at sites like Kaggle.\n\nThere are
several excellent notebooks to study data science competition entries. However many
will skip some of the explanation on how the solution is developed as these
notebooks are developed by experts for experts. The objective of this notebook is
to follow a step-by-step workflow, explaining each step and rationale for every
decision we take during solution development.\n\n## Workflow stages\n\nThe
competition solution workflow goes through seven stages described in the Data
Science Solutions book.\n\n1. Question or problem definition.\n2. Acquire training
and testing data.\n3. Wrangle, prepare, cleanse the data.\n4. Analyze, identify
patterns, and explore the data.\n5. Model, predict and solve the problem.\n6.
Visualize, report, and present the problem solving steps and final solution.\n7.
Supply or submit the results.\n\nThe workflow indicates general sequence of how
each stage may follow the other. However there are use cases with exceptions.\n\n-
We may combine mulitple workflow stages. We may analyze by visualizing data.\n-
Perform a stage earlier than indicated. We may analyze data before and after
wrangling.\n- Perform a stage multiple times in our workflow. Visualize stage may
be used multiple times.\n- Drop a stage altogether. We may not need supply stage to
productize or service enable our dataset for a competition.\n\n\n## Question and
problem definition\n\nCompetition sites like Kaggle define the problem to solve or
questions to ask while providing the datasets for training your data science model
and testing the model results against a test dataset. The question or problem
definition for Titanic Survival competition is [described here at Kaggle]
(https://www.kaggle.com/c/titanic).\n\n> Knowing from a training set of samples
listing passengers who survived or did not survive the Titanic disaster, can our
model determine based on a given test dataset not containing the survival
information, if these passengers in the test dataset survived or not.\n\nWe may
also want to develop some early understanding about the domain of our problem. This
is described on the [Kaggle competition description page here]
(https://www.kaggle.com/c/titanic). Here are the highlights to note.\n\n- On April
15, 1912, during her maiden voyage, the Titanic sank after colliding with an
iceberg, killing 1502 out of 2224 passengers and crew. Translated 32% survival
rate.\n- One of the reasons that the shipwreck led to such loss of life was that
there were not enough lifeboats for the passengers and crew.\n- Although there was
some element of luck involved in surviving the sinking, some groups of people were
more likely to survive than others, such as women, children, and the upper-
class.\n\n## Workflow goals\n\nThe data science solutions workflow solves for seven
major goals.\n\n**Classifying.** We may want to classify or categorize our samples.
We may also want to understand the implications or correlation of different classes
with our solution goal.\n\n**Correlating.** One can approach the problem based on
available features within the training dataset. Which features within the dataset
contribute significantly to our solution goal? Statistically speaking is there a
[correlation](https://en.wikiversity.org/wiki/Correlation) among a feature and
solution goal? As the feature values change does the solution state change as well,
and visa-versa? This can be tested both for numerical and categorical features in
the given dataset. We may also want to determine correlation among features other
than survival for subsequent goals and workflow stages. Correlating certain
features may help in creating, completing, or correcting
features.\n\n**Converting.** For modeling stage, one needs to prepare the data.
Depending on the choice of model algorithm one may require all features to be
converted to numerical equivalent values. So for instance converting text
categorical values to numeric values.\n\n**Completing.** Data preparation may also
require us to estimate any missing values within a feature. Model algorithms may
work best when there are no missing values.\n\n**Correcting.** We may also analyze
the given training dataset for errors or possibly innacurate values within features
and try to corrent these values or exclude the samples containing the errors. One
way to do this is to detect any outliers among our samples or features. We may also
completely discard a feature if it is not contribting to the analysis or may
significantly skew the results.\n\n**Creating.** Can we create new features based
on an existing feature or a set of features, such that the new feature follows the
correlation, conversion, completeness goals.\n\n**Charting.** How to select the
right visualization plots and charts depending on nature of the data and the
solution goals."
},
{
"metadata": {
"_cell_guid": "56a3be4e-76ef-20c6-25e8-da16147cf6d7",
"_uuid": "9079d24e16a56ccd4bb2fb5c8485d9546052f1f2"
},
"cell_type": "markdown",
"source": "## Refactor Release 2017-Jan-29\n\nWe are significantly
refactoring the notebook based on (a) comments received by readers, (b) issues in
porting notebook from Jupyter kernel (2.7) to Kaggle kernel (3.5), and (c) review
of few more best practice kernels.\n\n### User comments\n\n- Combine training and
test data for certain operations like converting titles across dataset to numerical
values. (thanks @Sharan Naribole)\n- Correct observation - nearly 30% of the
passengers had siblings and/or spouses aboard. (thanks @Reinhard)\n- Correctly
interpreting logistic regresssion coefficients. (thanks @Reinhard)\n\n### Porting
issues\n\n- Specify plot dimensions, bring legend into plot.\n\n\n### Best
practices\n\n- Performing feature correlation analysis early in the project.\n-
Using multiple plots instead of overlays for readability."
},
{
"metadata": {
"_cell_guid": "5767a33c-8f18-4034-e52d-bf7a8f7d8ab8",
"_uuid": "11dae061ed4be5400a6781574f55552d024bf5ad",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# data analysis and wrangling\nimport pandas as pd\nimport numpy
as np\nimport random as rnd\n\n# visualization\nimport seaborn as sns\nimport
matplotlib.pyplot as plt\n%matplotlib inline\n\n# machine learning\nfrom
sklearn.linear_model import LogisticRegression\nfrom sklearn.svm import SVC,
LinearSVC\nfrom sklearn.ensemble import RandomForestClassifier\nfrom
sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.naive_bayes import
GaussianNB\nfrom sklearn.linear_model import Perceptron\nfrom sklearn.linear_model
import SGDClassifier\nfrom sklearn.tree import DecisionTreeClassifier",
"execution_count": null,
"outputs": []
},
{
 "metadata": {
"_cell_guid": "6b5dc743-15b1-aac6-405e-081def6ecca1",
"_uuid": "e88c3e3fb9dbc9aa8b7a7e79cc9966a6b9ed40b3"
},
"cell_type": "markdown",
"source": "## Acquire data\n\nThe Python Pandas packages helps us work with
our datasets. We start by acquiring the training and testing datasets into Pandas
DataFrames. We also combine these datasets to run certain operations on both
datasets together."
},
{
"metadata": {
"_cell_guid": "e7319668-86fe-8adc-438d-0eef3fd0a982",
"_uuid": "49ac413d3421641f524fadb308ddb26f0e9cb29e",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "train_df = pd.read_csv('../input/train.csv')\ntest_df =
pd.read_csv('../input/test.csv')\ncombine = [train_df, test_df]",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "3d6188f3-dc82-8ae6-dabd-83e28fcbf10d",
"_uuid": "02468e8d5b6657437b3b6206d44b5f857af889a6"
},
"cell_type": "markdown",
"source": "## Analyze by describing data\n\nPandas also helps describe the
datasets answering following questions early in our project.\n\n**Which features
are available in the dataset?**\n\nNoting the feature names for directly
manipulating or analyzing these. These feature names are described on the [Kaggle
data page here](https://www.kaggle.com/c/titanic/data)."
},
{
"metadata": {
"_cell_guid": "ce473d29-8d19-76b8-24a4-48c217286e42",
"_uuid": "c466d69893455c373a731172f48045c88229199b",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "print(train_df.columns.values)",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "cd19a6f6-347f-be19-607b-dca950590b37",
"_uuid": "ca6c24182bcfa236e647145eecb80e05b2820940"
},
"cell_type": "markdown",
"source": "**Which features are categorical?**\n\nThese values classify the
samples into sets of similar samples. Within categorical features are the values
nominal, ordinal, ratio, or interval based? Among other things this helps us select
the appropriate plots for visualization.\n\n- Categorical: Survived, Sex, and
Embarked. Ordinal: Pclass.\n\n**Which features are numerical?**\n\nWhich features
are numerical? These values change from sample to sample. Within numerical features
are the values discrete, continuous, or timeseries based? Among other things this
helps us select the appropriate plots for visualization.\n\n- Continous: Age, Fare.
Discrete: SibSp, Parch."
},
{
"metadata": {
"_cell_guid": "8d7ac195-ac1a-30a4-3f3f-80b8cf2c1c0f",
"_uuid": "84c488f861ac5ed7243cc073e11b02f8eec04d94",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# preview the data\ntrain_df.head()",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "97f4e6f8-2fea-46c4-e4e8-b69062ee3d46",
"_uuid": "38798960607df977d8661123ed656496a8edafdd"
},
"cell_type": "markdown",
"source": "**Which features are mixed data types?**\n\nNumerical,
alphanumeric data within same feature. These are candidates for correcting
goal.\n\n- Ticket is a mix of numeric and alphanumeric data types. Cabin is
alphanumeric.\n\n**Which features may contain errors or typos?**\n\nThis is harder
to review for a large dataset, however reviewing a few samples from a smaller
dataset may just tell us outright, which features may require correcting.\n\n- Name
feature may contain errors or typos as there are several ways used to describe a
name including titles, round brackets, and quotes used for alternative or short
names."
},
{
"metadata": {
"_cell_guid": "f6e761c2-e2ff-d300-164c-af257083bb46",
"_uuid": "ca3035f1a8d2c9b442b4d7b819815f084a20e1cd",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "train_df.tail()",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "8bfe9610-689a-29b2-26ee-f67cd4719079",
"_uuid": "cb70d90c0c173d4fa5f3c4ba1afd291fd3ffbbce"
},
"cell_type": "markdown",
"source": "**Which features contain blank, null or empty values?**\n\nThese
will require correcting.\n\n- Cabin > Age > Embarked features contain a number of
null values in that order for the training dataset.\n- Cabin > Age are incomplete
in case of test dataset.\n\n**What are the data types for various features?
**\n\nHelping us during converting goal.\n\n- Seven features are integer or floats.
Six in case of test dataset.\n- Five features are strings (object)."
},
{
"metadata": {
 "_cell_guid": "9b805f69-665a-2b2e-f31d-50d87d52865d",
"_uuid": "2140db34cccc7da212a1176fa66ed197427576b9",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "train_df.info()\nprint('_'*40)\ntest_df.info()",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "859102e1-10df-d451-2649-2d4571e5f082",
"_uuid": "a7e11f7f53e795d42fbe53bcb71555981b56cbbd"
},
"cell_type": "markdown",
"source": "**What is the distribution of numerical feature values across the
samples?**\n\nThis helps us determine, among other early insights, how
representative is the training dataset of the actual problem domain.\n\n- Total
samples are 891 or 40% of the actual number of passengers on board the Titanic
(2,224).\n- Survived is a categorical feature with 0 or 1 values.\n- Around 38%
samples survived representative of the actual survival rate at 32%.\n- Most
passengers (> 75%) did not travel with parents or children.\n- Nearly 30% of the
passengers had siblings and/or spouse aboard.\n- Fares varied significantly with
few passengers (<1%) paying as high as $512.\n- Few elderly passengers (<1%) within
age range 65-80."
},
{
"metadata": {
"_cell_guid": "58e387fe-86e4-e068-8307-70e37fe3f37b",
"_uuid": "4149ea4118e3a5011d37ee8dcfa35c370507326e",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "train_df.describe()\n# Review survived rate using
`percentiles=[.61, .62]` knowing our problem description mentions 38% survival
rate.\n# Review Parch distribution using `percentiles=[.75, .8]`\n# SibSp
distribution `[.68, .69]`\n# Age and Fare `[.1, .2, .3, .4, .5, .6, .7, .8, .9, .
99]`",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "5462bc60-258c-76bf-0a73-9adc00a2f493",
"_uuid": "9e885b46fa913910611755dfd0bd872bbc9c149d"
},
"cell_type": "markdown",
"source": "**What is the distribution of categorical features?**\n\n- Names
are unique across the dataset (count=unique=891)\n- Sex variable as two possible
values with 65% male (top=male, freq=577/count=891).\n- Cabin values have several
dupicates across samples. Alternatively several passengers shared a cabin.\n-
Embarked takes three possible values. S port used by most passengers (top=S)\n-
Ticket feature has high ratio (22%) of duplicate values (unique=681)."
},
{
"metadata": {
"_cell_guid": "8066b378-1964-92e8-1352-dcac934c6af3",
 "_uuid": "f5efd99ee95dbb79be3dfa001fba27886eb78e8b",
"trusted"ell_type": "markdown",
"source": "In pattern recognition, the k-Nearest Neighbors algorithm (or k-NN
for short) is a non-parametric method used for classification and regression. A
sample is classified by a majority vote of its neighbors, with the sample being
assigned to the class most common among its k nearest neighbors (k is a positive
integer, typically small). If k = 1, then the object is simply assigned to the
class of that single nearest neighbor. Reference [Wikipedia]
(https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm).\n\nKNN confidence
score is better than Logistics Regression but worse than SVM."
},
{
"metadata": {
"_cell_guid": "ca14ae53-f05e-eb73-201c-064d7c3ed610",
"_uuid": "15dcc1e24c14c67591ee4319dc0cd5b1b8ec1e08",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "knn = KNeighborsClassifier(n_neighbors = 3)\nknn.fit(X_train,
Y_train)\nY_pred = knn.predict(X_test)\nacc_knn = round(knn.score(X_train, Y_train)
* 100, 2)\nacc_knn",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "810f723d-2313-8dfd-e3e2-26673b9caa90",
"_uuid": "2193ef4816826d4ed27d444db617926bac15f623"
},
"cell_type": "markdown",
"source": "In machine learning, naive Bayes classifiers are a family of
simple probabilistic classifiers based on applying Bayes' theorem with strong
(naive) independence assumptions between the features. Naive Bayes classifiers are
highly scalable, requiring a number of parameters linear in the number of variables
(features) in a learning problem. Reference [Wikipedia]
(https://en.wikipedia.org/wiki/Naive_Bayes_classifier).\n\nThe model generated
confidence score is the lowest among the models evaluated so far."
},
{
"metadata": {
"_cell_guid": "50378071-7043-ed8d-a782-70c947520dae",
"_uuid": "67860d99c1993970db7116b1a5c0bfc1b5459a0e",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Gaussian Naive Bayes\n\ngaussian =
GaussianNB()\ngaussian.fit(X_train, Y_train)\nY_pred =
gaussian.predict(X_test)\nacc_gaussian = round(gaussian.score(X_train, Y_train) *
100, 2)\nacc_gaussian",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "1e286e19-b714-385a-fcfa-8cf5ec19956a",
"_uuid": "024bedaed5297fce5f89063d1af6d0b487ada628"
},
 "cell_type": "markdown",
"source": "The perceptron is an algorithm for supervised learning of binary
classifiers (functions that can decide whether an input, represented by a vector of
numbers, belongs to some specific class or not). It is a type of linear classifier,
i.e. a classification algorithm that makes its predictions based on a linear
predictor function combining a set of weights with the feature vector. The
algorithm allows for online learning, in that it processes elements in the training
set one at a time. Reference [Wikipedia]
(https://en.wikipedia.org/wiki/Perceptron)."
},
{
"metadata": {
"_cell_guid": "ccc22a86-b7cb-c2dd-74bd-53b218d6ed0d",
"_uuid": "ae591b6596828905554eeefed6d066b00e6d25eb",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Perceptron\n\nperceptron = Perceptron()\nperceptron.fit(X_train,
Y_train)\nY_pred = perceptron.predict(X_test)\nacc_perceptron =
round(perceptron.score(X_train, Y_train) * 100, 2)\nacc_perceptron",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "a4d56857-9432-55bb-14c0-52ebeb64d198",
"_uuid": "0851fd8bf9675dfc19dad5c49970bc39c6d8cb09",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Linear SVC\n\nlinear_svc = LinearSVC()\nlinear_svc.fit(X_train,
Y_train)\nY_pred = linear_svc.predict(X_test)\nacc_linear_svc =
round(linear_svc.score(X_train, Y_train) * 100, 2)\nacc_linear_svc",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "dc98ed72-3aeb-861f-804d-b6e3d178bf4b",
"_uuid": "072363264b4026bcb63b957706864e8d30c898c9",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Stochastic Gradient Descent\n\nsgd =
SGDClassifier()\nsgd.fit(X_train, Y_train)\nY_pred = sgd.predict(X_test)\nacc_sgd =
round(sgd.score(X_train, Y_train) * 100, 2)\nacc_sgd",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "bae7f8d7-9da0-f4fd-bdb1-d97e719a18d7",
"_uuid": "2fd4de9e48e31b4372e5a64b6794ab1ab3cbd8b1"
},
"cell_type": "markdown",
"source": "This model uses a decision tree as a predictive model which maps
features (tree branches) to conclusions about the target value (tree leaves). Tree
models where the target variable can take a finite set of values are called
classification trees; in these tree structures, leaves represent class labels and
branches represent conjunctions of features that lead to those class labels.
Decision trees where the target variable can take continuous values (typically real
numbers) are called regression trees. Reference [Wikipedia]
(https://en.wikipedia.org/wiki/Decision_tree_learning).\n\nThe model confidence
score is the highest among models evaluated so far."
},
{
"metadata": {
"_cell_guid": "dd85f2b7-ace2-0306-b4ec-79c68cd3fea0",
"_uuid": "21c14121407cd4d05d250e921499065ba1321feb",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Decision Tree\n\ndecision_tree =
DecisionTreeClassifier()\ndecision_tree.fit(X_train, Y_train)\nY_pred =
decision_tree.predict(X_test)\nacc_decision_tree =
round(decision_tree.score(X_train, Y_train) * 100, 2)\nacc_decision_tree",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "85693668-0cd5-4319-7768-eddb62d2b7d0",
"_uuid": "595608f8b099219b666c4e86611cb931abb715b4"
},
"cell_type": "markdown",
"source": "The next model Random Forests is one of the most popular. Random
forests or random decision forests are an ensemble learning method for
classification, regression and other tasks, that operate by constructing a
multitude of decision trees (n_estimators=100) at training time and outputting the
class that is the mode of the classes (classification) or mean prediction
(regression) of the individual trees. Reference [Wikipedia]
(https://en.wikipedia.org/wiki/Random_forest).\n\nThe model confidence score is the
highest among models evaluated so far. We decide to use this model's output
(Y_pred) for creating our competition submission of results."
},
{
"metadata": {
"_cell_guid": "f0694a8e-b618-8ed9-6f0d-8c6fba2c4567",
"_uuid": "6bf2cd7e2e304013bd82e41b528e9f26304eabd5",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "# Random Forest\n\nrandom_forest =
RandomForestClassifier(n_estimators=100)\nrandom_forest.fit(X_train,
Y_train)\nY_pred = random_forest.predict(X_test)\nrandom_forest.score(X_train,
Y_train)\nacc_random_forest = round(random_forest.score(X_train, Y_train) * 100,
2)\nacc_random_forest",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "f6c9eef8-83dd-581c-2d8e-ce932fe3a44d",
 "_uuid": "e93b2e9f80cae0efbf48f2986504f7ed3e66d6b3"
},
"cell_type": "markdown",
"source": "### Model evaluation\n\nWe can now rank our evaluation of all the
models to choose the best one for our problem. While both Decision Tree and Random
Forest score the same, we choose to use Random Forest as they correct for decision
trees' habit of overfitting to their training set. "
},
{
"metadata": {
"_cell_guid": "1f3cebe0-31af-70b2-1ce4-0fd406bcdfc6",
"_uuid": "90f3e2d38ceceaf7248d2343eb3aae78ac419ecb",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "models = pd.DataFrame({\n 'Model': ['Support Vector Machines',
'KNN', 'Logistic Regression', \n 'Random Forest', 'Naive Bayes',
'Perceptron', \n 'Stochastic Gradient Decent', 'Linear SVC', \n
'Decision Tree'],\n 'Score': [acc_svc, acc_knn, acc_log, \n
acc_random_forest, acc_gaussian, acc_perceptron, \n acc_sgd,
acc_linear_svc, acc_decision_tree]})\nmodels.sort_values(by='Score',
ascending=False)",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "28854d36-051f-3ef0-5535-fa5ba6a9bef7",
"_uuid": "c3631aa3e9c18954eab66d2bbc925c0e925115d1",
"trusted": false,
"collapsed": true
},
"cell_type": "code",
"source": "submission = pd.DataFrame({\n \"PassengerId\":
test_df[\"PassengerId\"],\n \"Survived\": Y_pred\n })\n#
submission.to_csv('../output/submission.csv', index=False)",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"_cell_guid": "fcfc8d9f-e955-cf70-5843-1fb764c54699",
"_uuid": "36e88712d81936b4a64d75f107553bf9636442a9"
},
"cell_type": "markdown",
"source": "Our submission to the competition site Kaggle results in scoring
3,883 of 6,082 competition entries. This result is indicative while the competition
is running. This result only accounts for part of the submission dataset. Not bad
for our first attempt. Any suggestions to improve our score are most welcome."
},
{
"metadata": {
"_cell_guid": "aeec9210-f9d8-cd7c-c4cf-a87376d5f693",
"_uuid": "696a3d5594217780f36030480a0360648c369ffd"
},
"cell_type": "markdown",
"source": "## References\n\nThis notebook has been created based on great
work done solving the Titanic competition and other sources.\n\n- [A journey
through Titanic](https://www.kaggle.com/omarelgabry/titanic/a-journey-through-
titanic)\n- [Getting Started with Pandas: Kaggle's Titanic Competition]
(https://www.kaggle.com/c/titanic/details/getting-started-with-random-forests)\n-
[Titanic Best Working Classifier]
(https://www.kaggle.com/sinakhorami/titanic/titanic-best-working-classifier)"
}
],
"metadata": {
"_change_revision": 0,
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"version": "3.6.0",
"nbconvert_exporter": "python",
"codemirror_mode": {
"version": 3,
"name": "ipython"
},
"file_extension": ".py",
"mimetype": "text/x-python",
"pygments_lexer": "ipython3",
"name": "python"
},
"_is_fork": false
},
"nbformat": 4,
"nbformat_minor": 1
}