From 792294f8d44f57f68ce6409f7d09f1d4a6014385 Mon Sep 17 00:00:00 2001
From: Diwakar Gupta <39624018+Diwakar-Gupta@users.noreply.github.com>
Date: Tue, 10 May 2022 10:33:53 +0530
Subject: [PATCH] Assignment Solution

---
 22-05-07-End-To-End/Assignment_Solution.ipynb | 3190 +++++++++++++++++
 1 file changed, 3190 insertions(+)
 create mode 100644 22-05-07-End-To-End/Assignment_Solution.ipynb

diff --git a/22-05-07-End-To-End/Assignment_Solution.ipynb b/22-05-07-End-To-End/Assignment_Solution.ipynb
new file mode 100644
index 0000000..d0916a7
--- /dev/null
+++ b/22-05-07-End-To-End/Assignment_Solution.ipynb
@@ -0,0 +1,3190 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "End_To_End_Project_Assignment.ipynb",
+      "provenance": [],
+      "collapsed_sections": [],
+      "toc_visible": true,
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/Diwakar-Gupta/Data-Science-APRIL/blob/main/22-05-07-End-To-End/Assignment_Solution.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Agenda**\n",
+        "\n",
+        "1. Look at the big picture.\n",
+        "2. Get the data.\n",
+        "3. Discover and visualize the data to gain insights.\n",
+        "4. Prepare the data for Machine Learning algorithms.\n",
+        "5. Select a model and train it.\n",
+        "6. Fine-tune your model.\n",
+        "7. Present your solution.\n",
+        "8. Launch, monitor, and maintain your system."
+      ],
+      "metadata": {
+        "id": "BA7AsnN771kU"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## **How to Approach**\n",
+        "\n",
+        "Gather knowledge about problem it's current solution and how it will be used by company and downstreams\n",
+        "\n",
+        "First Task is to Frame the Problem by asking question's\n",
+        "\n",
+        "**Question:** What exactly is the business objective?\n",
+        "\n",
+        "This is important for performance measure to evaluate your model and time spend tweaking it.\n",
+        "\n",
+        "Next Question is What's the current solution?\n",
+        "\n",
+        "It will give a reference performance, as well as insights on how to solve the problem.\n",
+        "Select a Performance Measure\n",
+        "\n",
+        "Metric system gives an idea of how much error the system typically makes in its predictions.\n",
+        "1. **RMSE:** Root Mean Squared Error \n",
+        "2. **MAE:** Mean Absolute Error\n",
+        "3. **Accuracy**: used for classification problems\n",
+        "\n",
+        "![image](https://miro.medium.com/max/710/1*5OQunI-NR-S0gAZFIit1Rw.png)\n",
+        "\n",
+        "**Check the Assumptions**\n",
+        "\n",
+        "My output is used by other machine.\n",
+        "Ask how downstream will use your output.\n",
+        "example exact price or label's(“cheap,”, “medium,” or “expensive”)."
+      ],
+      "metadata": {
+        "id": "0WoXP9KK8YRT"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Import all the required packages**\n",
+        "\n",
+        "1. Numpy is required for all mathematical computations\n",
+        "2. Pandas is required for manipulating data\n",
+        "3. Matplotlib and Seaborn will be required for drawing graphs and drawing conclusions from the given data. Hence, EDA (Exploratory Data Analysis)"
+      ],
+      "metadata": {
+        "id": "YyVbMvC8-MHA"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Bt5sE1_7wqNK"
+      },
+      "outputs": [],
+      "source": [
+        "import numpy as np \n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "1. Read the Data from the following link:\n",
+        "https://raw.githubusercontent.com/Diwakar-Gupta/assets_resources/main/datasets/titanic.csv\n",
+        "\n",
+        "2. View the actual format of the data and the various features and label"
+      ],
+      "metadata": {
+        "id": "GWHXjbOV_HpJ"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Get The Data"
+      ],
+      "metadata": {
+        "id": "SCrRPYuFY0aH"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train = pd.read_csv('https://raw.githubusercontent.com/Diwakar-Gupta/assets_resources/main/datasets/titanic.csv')\n",
+        "df_train.sample(5)"
+      ],
+      "metadata": {
+        "id": "3n0DBmSjM_2e",
+        "outputId": "674539e4-3ff3-4c1e-f27a-6a8f050ebd72",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 268
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-b63b27bb-9461-48be-8472-d7fdc3c6033c\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>PassengerId</th>\n",
+              "      <th>Survived</th>\n",
+              "      <th>Pclass</th>\n",
+              "      <th>Name</th>\n",
+              "      <th>Sex</th>\n",
+              "      <th>Age</th>\n",
+              "      <th>SibSp</th>\n",
+              "      <th>Parch</th>\n",
+              "      <th>Ticket</th>\n",
+              "      <th>Fare</th>\n",
+              "      <th>Cabin</th>\n",
+              "      <th>Embarked</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>146</th>\n",
+              "      <td>147</td>\n",
+              "      <td>1</td>\n",
+              "      <td>3</td>\n",
+              "      <td>Andersson, Mr. August Edvard (\"Wennerstrom\")</td>\n",
+              "      <td>male</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>350043</td>\n",
+              "      <td>7.7958</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>S</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>205</th>\n",
+              "      <td>206</td>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>Strom, Miss. Telma Matilda</td>\n",
+              "      <td>female</td>\n",
+              "      <td>2.0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "      <td>347054</td>\n",
+              "      <td>10.4625</td>\n",
+              "      <td>G6</td>\n",
+              "      <td>S</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>222</th>\n",
+              "      <td>223</td>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>Green, Mr. George Henry</td>\n",
+              "      <td>male</td>\n",
+              "      <td>51.0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>21440</td>\n",
+              "      <td>8.0500</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>S</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>344</th>\n",
+              "      <td>345</td>\n",
+              "      <td>0</td>\n",
+              "      <td>2</td>\n",
+              "      <td>Fox, Mr. Stanley Hubert</td>\n",
+              "      <td>male</td>\n",
+              "      <td>36.0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>229236</td>\n",
+              "      <td>13.0000</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>S</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>551</th>\n",
+              "      <td>552</td>\n",
+              "      <td>0</td>\n",
+              "      <td>2</td>\n",
+              "      <td>Sharp, Mr. Percival James R</td>\n",
+              "      <td>male</td>\n",
+              "      <td>27.0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>244358</td>\n",
+              "      <td>26.0000</td>\n",
+              "      <td>NaN</td>\n",
+              "      <td>S</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-b63b27bb-9461-48be-8472-d7fdc3c6033c')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-b63b27bb-9461-48be-8472-d7fdc3c6033c button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-b63b27bb-9461-48be-8472-d7fdc3c6033c');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "     PassengerId  Survived  Pclass  ...     Fare Cabin  Embarked\n",
+              "146          147         1       3  ...   7.7958   NaN         S\n",
+              "205          206         0       3  ...  10.4625    G6         S\n",
+              "222          223         0       3  ...   8.0500   NaN         S\n",
+              "344          345         0       2  ...  13.0000   NaN         S\n",
+              "551          552         0       2  ...  26.0000   NaN         S\n",
+              "\n",
+              "[5 rows x 12 columns]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 33
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "C8F75E_nwycp"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "![image](https://raw.githubusercontent.com/Pepcoders/Pepcoding-Data-Science/main/dataset/images/titanicColumns.png)"
+      ],
+      "metadata": {
+        "id": "5XHHOzq7Eyep"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Look at the Shape of the DataFrame, to get an idea about the total entries in the dataset"
+      ],
+      "metadata": {
+        "id": "itcxxZD3_XfS"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.shape"
+      ],
+      "metadata": {
+        "id": "AjxTYCMBNMpx",
+        "outputId": "a6c1af5f-11f7-4319-d876-b99680edc169",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(891, 12)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 34
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "rwAtb4jUw0Mb"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that we have a fair idea about the data, we need to look for the following things:\n",
+        "1. Try finding out the null values present in the data\n",
+        "2. See the data types of various features \n"
+      ],
+      "metadata": {
+        "id": "EtbPptD4_kh9"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.info()"
+      ],
+      "metadata": {
+        "id": "jWzraccnNXGo",
+        "outputId": "2bb49461-d345-47c1-b15c-b332dd160390",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 891 entries, 0 to 890\n",
+            "Data columns (total 12 columns):\n",
+            " #   Column       Non-Null Count  Dtype  \n",
+            "---  ------       --------------  -----  \n",
+            " 0   PassengerId  891 non-null    int64  \n",
+            " 1   Survived     891 non-null    int64  \n",
+            " 2   Pclass       891 non-null    int64  \n",
+            " 3   Name         891 non-null    object \n",
+            " 4   Sex          891 non-null    object \n",
+            " 5   Age          714 non-null    float64\n",
+            " 6   SibSp        891 non-null    int64  \n",
+            " 7   Parch        891 non-null    int64  \n",
+            " 8   Ticket       891 non-null    object \n",
+            " 9   Fare         891 non-null    float64\n",
+            " 10  Cabin        204 non-null    object \n",
+            " 11  Embarked     889 non-null    object \n",
+            "dtypes: float64(2), int64(5), object(5)\n",
+            "memory usage: 83.7+ KB\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "GihqtEzLw11j"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Data Cleaning + EDA"
+      ],
+      "metadata": {
+        "id": "Svbv6DHBY-Ox"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now, if you can see the null values, try finding the total sum of null values present for each feature. "
+      ],
+      "metadata": {
+        "id": "2ooFeq8cAa9R"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.isna().sum()"
+      ],
+      "metadata": {
+        "id": "8AKR3Fg-Nb2n",
+        "outputId": "a1ed8165-b68c-4fe7-883c-e24d4c7468e5",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "PassengerId      0\n",
+              "Survived         0\n",
+              "Pclass           0\n",
+              "Name             0\n",
+              "Sex              0\n",
+              "Age            177\n",
+              "SibSp            0\n",
+              "Parch            0\n",
+              "Ticket           0\n",
+              "Fare             0\n",
+              "Cabin          687\n",
+              "Embarked         2\n",
+              "dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 36
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "lM57wU13w3S-"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Number of Null Values gives a good idea about what to do with the null values, but a graphical representation would give the impact of null values with respect to total data present. Try drawing a map of null values present"
+      ],
+      "metadata": {
+        "id": "-fQDV6wpAnhL"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.heatmap(df_train.isnull(), cmap = 'rainbow')"
+      ],
+      "metadata": {
+        "id": "zrt1KIarNoW6",
+        "outputId": "0dffd173-3838-4e49-c407-0c843ab1c8b9",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 338
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b452abe50>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 37
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "ePSAYwlQw40U"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that we can see the null values, we need to first deal with numerical null values, there are a few options at our disposal, these are listed below:\n",
+        "1. Delete the entire row where null value is present.\n",
+        "2. Fill the null value with previous entry\n",
+        "3. Fill the null value with next entry\n",
+        "4. Fill the null value with mean, median or mode\n",
+        "\n",
+        "The type of cleaning done on null values depends on our choice. This does not mean only these 4 values will be done when encountered with a null value. Though these are the most frequent ones, with respect to a numerical column containing a null value. \n",
+        "This time we have to deal with 'Age', which means most appropriate thing would be the fill it with the mean value. \n",
+        "\n",
+        "This would also be clear if we make a graph, see the type of distribution, for various ages present in the data.\n",
+        "\n",
+        "If you see a normal distribution, fill it with null values without giving much thought, as normal distribution, has max values near its mean"
+      ],
+      "metadata": {
+        "id": "hXu3xyoFA8yb"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.distplot(df_train['Age'], bins=10)"
+      ],
+      "metadata": {
+        "id": "iSEhBpj4N9ml",
+        "outputId": "95f1f4b9-0054-489d-d9ec-936f7bba0a2d",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 351
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
+            "  warnings.warn(msg, FutureWarning)\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b45080110>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 38
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "qGQKDLiww6ak"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now, that we are filling null values in Age feature with the mean Age, we need to find the mean age, this can be done, if we find the mean.\n",
+        "One way is the actually find the arithmetic mean, but that is tedious.\n",
+        "Try using the Describe Function, this would also give min, max, quatile values. "
+      ],
+      "metadata": {
+        "id": "vBBhwUmpC9My"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.describe()"
+      ],
+      "metadata": {
+        "id": "D99rZN4DOIUv",
+        "outputId": "8faca78a-b67d-4371-e1e1-d4114d281ab5",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 300
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-43b66e1d-e557-474b-957f-cd22e64bb738\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>PassengerId</th>\n",
+              "      <th>Survived</th>\n",
+              "      <th>Pclass</th>\n",
+              "      <th>Age</th>\n",
+              "      <th>SibSp</th>\n",
+              "      <th>Parch</th>\n",
+              "      <th>Fare</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>count</th>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>714.000000</td>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>891.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>mean</th>\n",
+              "      <td>446.000000</td>\n",
+              "      <td>0.383838</td>\n",
+              "      <td>2.308642</td>\n",
+              "      <td>29.699118</td>\n",
+              "      <td>0.523008</td>\n",
+              "      <td>0.381594</td>\n",
+              "      <td>32.204208</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>std</th>\n",
+              "      <td>257.353842</td>\n",
+              "      <td>0.486592</td>\n",
+              "      <td>0.836071</td>\n",
+              "      <td>14.526497</td>\n",
+              "      <td>1.102743</td>\n",
+              "      <td>0.806057</td>\n",
+              "      <td>49.693429</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>min</th>\n",
+              "      <td>1.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>1.000000</td>\n",
+              "      <td>0.420000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>25%</th>\n",
+              "      <td>223.500000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>2.000000</td>\n",
+              "      <td>20.125000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>7.910400</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>50%</th>\n",
+              "      <td>446.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>3.000000</td>\n",
+              "      <td>28.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>14.454200</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>75%</th>\n",
+              "      <td>668.500000</td>\n",
+              "      <td>1.000000</td>\n",
+              "      <td>3.000000</td>\n",
+              "      <td>38.000000</td>\n",
+              "      <td>1.000000</td>\n",
+              "      <td>0.000000</td>\n",
+              "      <td>31.000000</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>max</th>\n",
+              "      <td>891.000000</td>\n",
+              "      <td>1.000000</td>\n",
+              "      <td>3.000000</td>\n",
+              "      <td>80.000000</td>\n",
+              "      <td>8.000000</td>\n",
+              "      <td>6.000000</td>\n",
+              "      <td>512.329200</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-43b66e1d-e557-474b-957f-cd22e64bb738')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-43b66e1d-e557-474b-957f-cd22e64bb738 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-43b66e1d-e557-474b-957f-cd22e64bb738');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "       PassengerId    Survived      Pclass  ...       SibSp       Parch        Fare\n",
+              "count   891.000000  891.000000  891.000000  ...  891.000000  891.000000  891.000000\n",
+              "mean    446.000000    0.383838    2.308642  ...    0.523008    0.381594   32.204208\n",
+              "std     257.353842    0.486592    0.836071  ...    1.102743    0.806057   49.693429\n",
+              "min       1.000000    0.000000    1.000000  ...    0.000000    0.000000    0.000000\n",
+              "25%     223.500000    0.000000    2.000000  ...    0.000000    0.000000    7.910400\n",
+              "50%     446.000000    0.000000    3.000000  ...    0.000000    0.000000   14.454200\n",
+              "75%     668.500000    1.000000    3.000000  ...    1.000000    0.000000   31.000000\n",
+              "max     891.000000    1.000000    3.000000  ...    8.000000    6.000000  512.329200\n",
+              "\n",
+              "[8 rows x 7 columns]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 39
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "gCln1hnQw8Kb"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Here you can see the age feature varies from 20 to 38 from 1st quartile to 3rd Quartile, This means most of the passengers in the ship are between 20 to 38 years old. And a really new born kid of few months is in the ship.**\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "BO2o2CKNDo_c"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that, we know the mean, store it in a variable where we will fill it later, \n",
+        "also check if there are duplicate rows in the data.\n",
+        "\n",
+        "All this is required so that we clean the data, which will make sure there are no absurd values in our model and prediction will be easy."
+      ],
+      "metadata": {
+        "id": "dd4LRsq6Doi4"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Age_fill = 30"
+      ],
+      "metadata": {
+        "id": "mc0YXGPzw9uR"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We can also check for correlations in the data, sometimes, there is high degree of correlation between the labels and the feature and hence, we can drop the feature which have little correlation as that will not impact our prediction significantly or we can use those features to do some feature engineering and create new features."
+      ],
+      "metadata": {
+        "id": "cfPWQPZmEDmN"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.corr()['Survived'].sort_values(ascending=False)"
+      ],
+      "metadata": {
+        "id": "win3CVI3Og4T",
+        "outputId": "0bb1c289-2201-480d-a5fa-979e8278c054",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Survived       1.000000\n",
+              "Fare           0.257307\n",
+              "Parch          0.081629\n",
+              "PassengerId   -0.005007\n",
+              "SibSp         -0.035322\n",
+              "Age           -0.077221\n",
+              "Pclass        -0.338481\n",
+              "Name: Survived, dtype: float64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 41
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "AsDJ5uUwxdaW"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now, we are performing EDA,i.e., Exploratory Data Analysis. \n",
+        "So we need to know what each feature is signifying and also how much importance it will carry when we prepare our model."
+      ],
+      "metadata": {
+        "id": "0JmY-b7MEbdm"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Firstly, we know that our label is which person survived. \n",
+        "Now in our training data, we need to know exactly, how many people survived, so that we know about the greater percentage in our data.\n",
+        "This means we must know whether more people survived in our training data or whether more people did not survive in our training data.\n",
+        "\n",
+        "We can use function for counting all of them, but generally graphs are preferred in EDA, simply due to visual appeal, people process images quickly when compared to raw numbers, hence try using graphs, as much as possible."
+      ],
+      "metadata": {
+        "id": "sr4Rxhw-Eu9S"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train[\"Survived\"].value_counts()"
+      ],
+      "metadata": {
+        "id": "4hMQyu2XO2vT",
+        "outputId": "766fd8e1-79bf-46b8-ef78-5ee60ea78360",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0    549\n",
+              "1    342\n",
+              "Name: Survived, dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 42
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "4Gg9J1ZfFMPx"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.set_style('whitegrid')\n",
+        "sns.countplot(x = 'Survived', data =df_train)"
+      ],
+      "metadata": {
+        "id": "rpchNdPYO9JE",
+        "outputId": "cc54dc06-ea4e-43d3-99f2-6ca750969e26",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 296
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44ffdbd0>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 43
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "tqQOeyQVxA8X"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that we know the number of Survived people, we also need to know their variations when sex is accounted, this means we want to know how many men were their among the survived ones, because during a calamity such as the sinking of Titanic, women, children and elderly are the ones which will be saved first, but the mean age on the ship being 30, sex should be the first parameter which we look for and check it. "
+      ],
+      "metadata": {
+        "id": "dgT8sT2XFwpI"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.set_style('whitegrid')\n",
+        "sns.countplot(x= 'Survived', hue = 'Sex', data = df_train, palette = 'rainbow')"
+      ],
+      "metadata": {
+        "id": "YayC1lbVPWyn",
+        "outputId": "d82673f0-b073-4a8f-e7a3-8b605b1b0383",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 296
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44f6d350>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 44
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "aFYnX523xDhZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Appart from Sex, Rich people will get to survive, so we need to find rich or poor, among the survived ones. One thing to note here is that we do not have an income feature, so we try to find something that relates it, Passenger class could be a good idea, as Rich People will buy better Cabins. \n",
+        "Cabin could have been used, but firstly it is a categorical data which does not represent anything where we could deduce, moreover it has a high amount of null Values\n",
+        "\n",
+        "\n",
+        "Fare is also a good parameter to judge economy but we have no idea about the price range for each class, so it would lead to a random selection of arbitrary fare, therefore we find the Passenger class `Pclass` bought by survived people. "
+      ],
+      "metadata": {
+        "id": "UtZpoxUpGXhX"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.set_style('whitegrid')\n",
+        "sns.countplot(x='Survived', hue = 'Pclass', data = df_train, palette = 'rainbow')"
+      ],
+      "metadata": {
+        "id": "JhMv7cQ6Pvl3",
+        "outputId": "1d68370e-79e2-4b5f-fcd4-b2857b514917",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 296
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44ed90d0>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 45
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "ipEzLdKfxK2E"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We should also look for number of people travelling with parents, siblings and spouse as, one would try to save their family first, and a rough idea would help us select the type of model which needs to be prepared. "
+      ],
+      "metadata": {
+        "id": "M4T0-YfUHZVQ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.countplot(x = 'SibSp', data = df_train)"
+      ],
+      "metadata": {
+        "id": "Bv5UpD8IQhFA",
+        "outputId": "3e01262d-0f61-43de-bf95-588a7a8263ac",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 296
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44e50890>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 46
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "KeCq4pEexSit"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that we looked at each paremeters, lets look at the number of people that bought a certain type of ticket, like say there is a ticket priced 20$, getting to know the number of people which bought that ticket will help me know, the percentage economy of people on board "
+      ],
+      "metadata": {
+        "id": "gBdXTgDpHt0t"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.distplot(df_train['Fare'], kde = False, color = 'Darkred', bins = 40)"
+      ],
+      "metadata": {
+        "id": "ML6DxJ93QyGQ",
+        "outputId": "6bc716dc-7541-4ffc-fcf5-8b8c52db3f91",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 353
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
+            "  warnings.warn(msg, FutureWarning)\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44e44290>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 47
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "FgwJcqP0xXAj"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "One, thing which we can see is, we needed to access each feature and see its relation with my label, i.e, Survived. This might not be needed if we see high correlation among the features and label. \n",
+        "\n",
+        "Now that, we know about the data present, lets clean the null values here and prepare our model"
+      ],
+      "metadata": {
+        "id": "mu1MtePxIMTd"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "First fill the mean age to clean that data and see the info to check whether the null value has been accounted for. "
+      ],
+      "metadata": {
+        "id": "5FrDKVumJD4Y"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train['Age'] = df_train['Age'].fillna(Age_fill)"
+      ],
+      "metadata": {
+        "id": "jBbJdCcSxp-d"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.isna().sum()"
+      ],
+      "metadata": {
+        "id": "cMkibyzdRYUm",
+        "outputId": "966adab0-2241-4d10-da84-65c3108bd6cb",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "PassengerId      0\n",
+              "Survived         0\n",
+              "Pclass           0\n",
+              "Name             0\n",
+              "Sex              0\n",
+              "Age              0\n",
+              "SibSp            0\n",
+              "Parch            0\n",
+              "Ticket           0\n",
+              "Fare             0\n",
+              "Cabin          687\n",
+              "Embarked         2\n",
+              "dtype: int64"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 49
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "3EfsZWD3x5MA"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "One can also check a heatmap, to see the same, as we know, maps and graphs are preferred due to visual conclusions."
+      ],
+      "metadata": {
+        "id": "ev0lZjhDJMXi"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "sns.heatmap(df_train.isnull(), cmap= 'viridis')"
+      ],
+      "metadata": {
+        "id": "9Cmnq_MKRhVV",
+        "outputId": "b7bd160e-6508-47e8-9e1e-cd6cc9b73047",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 338
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<matplotlib.axes._subplots.AxesSubplot at 0x7f8b44d32d50>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 50
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 2 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "qH1m_NCKyAvW"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pd.crosstab(df_train['Pclass'], df_train['Cabin'].apply(lambda x: x[0] if type(x) == str else np.nan))"
+      ],
+      "metadata": {
+        "id": "BdHsQshiRpK2",
+        "outputId": "011e207a-1c59-4268-985a-a915ab830ee3",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 175
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-e841498a-9522-4012-9a0f-4100ce20450d\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th>Cabin</th>\n",
+              "      <th>A</th>\n",
+              "      <th>B</th>\n",
+              "      <th>C</th>\n",
+              "      <th>D</th>\n",
+              "      <th>E</th>\n",
+              "      <th>F</th>\n",
+              "      <th>G</th>\n",
+              "      <th>T</th>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>Pclass</th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "      <th></th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>15</td>\n",
+              "      <td>47</td>\n",
+              "      <td>59</td>\n",
+              "      <td>29</td>\n",
+              "      <td>25</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>4</td>\n",
+              "      <td>4</td>\n",
+              "      <td>8</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>5</td>\n",
+              "      <td>4</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e841498a-9522-4012-9a0f-4100ce20450d')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-e841498a-9522-4012-9a0f-4100ce20450d button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-e841498a-9522-4012-9a0f-4100ce20450d');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "Cabin    A   B   C   D   E  F  G  T\n",
+              "Pclass                             \n",
+              "1       15  47  59  29  25  0  0  1\n",
+              "2        0   0   0   4   4  8  0  0\n",
+              "3        0   0   0   0   3  5  4  0"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 51
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "SsLUwP40L3B7"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We can notice, there are huge amount of null values present in the cabin features but this does not mean this feature is useless, `Pclass` and `Cabin` both feature combinely have some information to give.\n",
+        "\n",
+        "**This is left for you to find.**\n",
+        "\n",
+        "For now we have just removed that column from dataset."
+      ],
+      "metadata": {
+        "id": "ocNWydUVJWAj"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.drop(['Cabin'], axis = 1, inplace = True)"
+      ],
+      "metadata": {
+        "id": "TYGlqIKxyFXJ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Another thing of importance, is there are 2 null values in the feature 'Embarked', this feature represents where did the person boarded the ship, here firstly it is categorical value, secondly this parameter could be filled with the most frequently occuring value\n",
+        "\n",
+        "First try to make a plot to see the most frequently occuring value, and then fill the data with this value."
+      ],
+      "metadata": {
+        "id": "-VjMUVQOJscz"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train['Embarked'].value_counts().plot(kind='pie', autopct='%.2f')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "id": "gYzjodHrSmwI",
+        "outputId": "ac953477-2107-4d77-fbf8-5155260d99f4",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 248
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "image/png": "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\n",
+            "text/plain": [
+              "<Figure size 432x288 with 1 Axes>"
+            ]
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "sw1NOZgbxcMy"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train['Embarked'] = df_train['Embarked'].fillna('S')"
+      ],
+      "metadata": {
+        "id": "ua8W8R4vyObf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "One can try and check the information, to see the null values, if remaining."
+      ],
+      "metadata": {
+        "id": "Zmk-wTOJKV7m"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.info()"
+      ],
+      "metadata": {
+        "id": "iovne8xLTEL-",
+        "outputId": "41b6cfdb-c331-4443-bb0f-0feb055ee122",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "<class 'pandas.core.frame.DataFrame'>\n",
+            "RangeIndex: 891 entries, 0 to 890\n",
+            "Data columns (total 11 columns):\n",
+            " #   Column       Non-Null Count  Dtype  \n",
+            "---  ------       --------------  -----  \n",
+            " 0   PassengerId  891 non-null    int64  \n",
+            " 1   Survived     891 non-null    int64  \n",
+            " 2   Pclass       891 non-null    int64  \n",
+            " 3   Name         891 non-null    object \n",
+            " 4   Sex          891 non-null    object \n",
+            " 5   Age          891 non-null    float64\n",
+            " 6   SibSp        891 non-null    int64  \n",
+            " 7   Parch        891 non-null    int64  \n",
+            " 8   Ticket       891 non-null    object \n",
+            " 9   Fare         891 non-null    float64\n",
+            " 10  Embarked     891 non-null    object \n",
+            "dtypes: float64(2), int64(5), object(4)\n",
+            "memory usage: 76.7+ KB\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "id": "ZRvefRdbzMJ4"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Feature Engineering"
+      ],
+      "metadata": {
+        "id": "hzN5qpiNZHjY"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "SibSp: count of siblings or spouce\n",
+        "\n",
+        "Parch: count of parents and childrens\n",
+        "\n",
+        "combining this two features make sense as a count of family members."
+      ],
+      "metadata": {
+        "id": "zIKxKxifRAuV"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train['family_count'] = df_train['SibSp'] + df_train['Parch']"
+      ],
+      "metadata": {
+        "id": "Be4XHjbtRah1"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now we dont need this two fields any more, we can drop them both"
+      ],
+      "metadata": {
+        "id": "9esOCmy3RlB4"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.drop(['SibSp', 'Parch'], axis = 1, inplace = True)"
+      ],
+      "metadata": {
+        "id": "Ktl-eX3bRjdP"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Preprocessing\n",
+        "\n",
+        "Prepare data for machine learning algorithm"
+      ],
+      "metadata": {
+        "id": "GXnrPIgTZP4M"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We can see that there are certain *text values* remaining in our dataset, we also know that our models do not work well with text values, hence we need to convert them to numerical values, of some sort.\n",
+        "\n",
+        "One Hot Encoding, Ordinal Encoding is a good method to do that, but here only 2 or 3 parameters are present hence, get_dummies of pandas would not only prove simpler but also quicker.\n",
+        "\n",
+        "Here **embarked and sex both are of Nominal type**, get_dummies or OneHot will do our job."
+      ],
+      "metadata": {
+        "id": "TJNGTxp2K8N7"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "embk = pd.get_dummies(df_train['Embarked'], drop_first= True)\n",
+        "sex = pd.get_dummies(df_train['Sex'], drop_first= True)"
+      ],
+      "metadata": {
+        "id": "Qn_kjNb9zNdO"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now, Name, PassengerId and Ticket will not affect whether the person survives or not, hence we can drop them.\n",
+        "Sex and Embarked can be encoded and hence should be dropped as encoded parameters, will be added to the dataframe. "
+      ],
+      "metadata": {
+        "id": "FPl90lkkMYei"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.drop(['Name', 'Ticket', 'Sex', 'Embarked', 'PassengerId'], axis = 1, inplace = True)"
+      ],
+      "metadata": {
+        "id": "88Aqzd5izUxc"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now, add the encoded values to the main dataframe\n",
+        "\n",
+        "This now makes our data clean and ready for training it appropriately. "
+      ],
+      "metadata": {
+        "id": "_sJslI__MoZD"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train = pd.concat([df_train, sex, embk], axis = 1)"
+      ],
+      "metadata": {
+        "id": "MIPK5uTQzgSz"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "You can also see the dataframe into the current format to check whether its converted appropriately. "
+      ],
+      "metadata": {
+        "id": "jUIld6qOM2BE"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "df_train.head()"
+      ],
+      "metadata": {
+        "id": "nEi-fehVUoYh",
+        "outputId": "09a369d0-2aa1-4082-8a8e-3e66945ac32b",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-2ae05b0a-95fc-4d00-aab9-f2dca62c0271\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>Survived</th>\n",
+              "      <th>Pclass</th>\n",
+              "      <th>Age</th>\n",
+              "      <th>Fare</th>\n",
+              "      <th>family_count</th>\n",
+              "      <th>male</th>\n",
+              "      <th>Q</th>\n",
+              "      <th>S</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>22.0</td>\n",
+              "      <td>7.2500</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>38.0</td>\n",
+              "      <td>71.2833</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1</td>\n",
+              "      <td>3</td>\n",
+              "      <td>26.0</td>\n",
+              "      <td>7.9250</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>53.1000</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>8.0500</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-2ae05b0a-95fc-4d00-aab9-f2dca62c0271')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-2ae05b0a-95fc-4d00-aab9-f2dca62c0271 button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-2ae05b0a-95fc-4d00-aab9-f2dca62c0271');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "   Survived  Pclass   Age     Fare  family_count  male  Q  S\n",
+              "0         0       3  22.0   7.2500             1     1  0  1\n",
+              "1         1       1  38.0  71.2833             1     0  0  0\n",
+              "2         1       3  26.0   7.9250             0     0  0  1\n",
+              "3         1       1  35.0  53.1000             1     0  0  1\n",
+              "4         0       3  35.0   8.0500             0     1  0  1"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 61
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "oOpaIjZZznNE",
+        "outputId": "5aeadb17-91d9-4f26-987c-931a2ee9c054"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/html": [
+              "\n",
+              "  <div id=\"df-66d9beff-96ef-4650-9074-288924c8214d\">\n",
+              "    <div class=\"colab-df-container\">\n",
+              "      <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>Survived</th>\n",
+              "      <th>Pclass</th>\n",
+              "      <th>Age</th>\n",
+              "      <th>Fare</th>\n",
+              "      <th>family_count</th>\n",
+              "      <th>male</th>\n",
+              "      <th>Q</th>\n",
+              "      <th>S</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>22.0</td>\n",
+              "      <td>7.2500</td>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>38.0</td>\n",
+              "      <td>71.2833</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1</td>\n",
+              "      <td>3</td>\n",
+              "      <td>26.0</td>\n",
+              "      <td>7.9250</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1</td>\n",
+              "      <td>1</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>53.1000</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>0</td>\n",
+              "      <td>3</td>\n",
+              "      <td>35.0</td>\n",
+              "      <td>8.0500</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "      <td>0</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-66d9beff-96ef-4650-9074-288924c8214d')\"\n",
+              "              title=\"Convert this dataframe to an interactive table.\"\n",
+              "              style=\"display:none;\">\n",
+              "        \n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "       width=\"24px\">\n",
+              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
+              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
+              "  </svg>\n",
+              "      </button>\n",
+              "      \n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      flex-wrap:wrap;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "      <script>\n",
+              "        const buttonEl =\n",
+              "          document.querySelector('#df-66d9beff-96ef-4650-9074-288924c8214d button.colab-df-convert');\n",
+              "        buttonEl.style.display =\n",
+              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "        async function convertToInteractive(key) {\n",
+              "          const element = document.querySelector('#df-66d9beff-96ef-4650-9074-288924c8214d');\n",
+              "          const dataTable =\n",
+              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                     [key], {});\n",
+              "          if (!dataTable) return;\n",
+              "\n",
+              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "            + ' to learn more about interactive tables.';\n",
+              "          element.innerHTML = '';\n",
+              "          dataTable['output_type'] = 'display_data';\n",
+              "          await google.colab.output.renderOutput(dataTable, element);\n",
+              "          const docLink = document.createElement('div');\n",
+              "          docLink.innerHTML = docLinkHtml;\n",
+              "          element.appendChild(docLink);\n",
+              "        }\n",
+              "      </script>\n",
+              "    </div>\n",
+              "  </div>\n",
+              "  "
+            ],
+            "text/plain": [
+              "   Survived  Pclass   Age     Fare  family_count  male  Q  S\n",
+              "0         0       3  22.0   7.2500             1     1  0  1\n",
+              "1         1       1  38.0  71.2833             1     0  0  0\n",
+              "2         1       3  26.0   7.9250             0     0  0  1\n",
+              "3         1       1  35.0  53.1000             1     0  0  1\n",
+              "4         0       3  35.0   8.0500             0     1  0  1"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 31
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Separate the features and labels, into x and y so that we can train our features, in order to predict the labels accordingly. "
+      ],
+      "metadata": {
+        "id": "0lkvZlf5NIAv"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "y = df_train['Survived']"
+      ],
+      "metadata": {
+        "id": "wBpHCXr8zpca"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x = df_train.drop('Survived', axis= 1)"
+      ],
+      "metadata": {
+        "id": "F9IONoVXzttZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that my features are recorded separately, I need to scale the features, so that all my data, in within close quarters, as we can see that fare and age will not be a close value, so we need to perform preprocessing, and scale the value within close quarters, this will be done using, Standard Scaler. "
+      ],
+      "metadata": {
+        "id": "LhTW6AEJNxSx"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "from sklearn import preprocessing"
+      ],
+      "metadata": {
+        "id": "OYTzzTpP6aq5"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import StandardScaler\n",
+        "scaler = preprocessing.StandardScaler()\n",
+        "scaled_X = scaler.fit_transform(x)"
+      ],
+      "metadata": {
+        "id": "1YaYJ8kH6aly"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Select and Train Model"
+      ],
+      "metadata": {
+        "id": "b9UyMFoIZjzU"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now the entire data is ready to be split into testing and training, splitting the data is necessary, to check the accuracies of our model. \n",
+        "While splitting the features, use the scaled values\n"
+      ],
+      "metadata": {
+        "id": "zoiWQMp-O_E4"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import trian test split\n",
+        "from sklearn.model_selection import train_test_split"
+      ],
+      "metadata": {
+        "id": "n7cTtK30z0oS"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# split using train test split method usign test_size 03\n",
+        "X_train, X_test, Y_train, Y_test = train_test_split(scaled_X, y, test_size = 0.3, random_state= 42)"
+      ],
+      "metadata": {
+        "id": "9NlHv-Igz3dW"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Initially, we can use various models, to train and predict the data. \n",
+        "Initially try, Logistic Regression, fit and predict the data, find score and see the accuracy of that algorithm.\n",
+        "\n",
+        "**Logistic Regression** is a classification algorithm and here we want to classify each person to weather he/she survived or not."
+      ],
+      "metadata": {
+        "id": "INVbGqMbPOaX"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import logisticRegression and Train the model\n",
+        "from sklearn.linear_model import LogisticRegression\n",
+        "\n",
+        "log_reg = LogisticRegression()\n",
+        "log_reg.fit(X_train, Y_train)"
+      ],
+      "metadata": {
+        "id": "to11XeZ_hXwQ",
+        "outputId": "840d3b33-3d66-4a68-a8fd-88681add0b34",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "LogisticRegression()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 68
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d5z1rezT16Mm",
+        "outputId": "79ebec11-40d3-4673-aa01-be0c202692a5"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "LogisticRegression()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 39
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# predict the score on test and store into y_pred\n",
+        "y_pred = log_reg.predict(X_test)"
+      ],
+      "metadata": {
+        "id": "SUYw3Ozf2gmZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Try, finding accuracy_score, to calculate for accuracy of the model. "
+      ],
+      "metadata": {
+        "id": "NIskLYQlPjEn"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import accuracy score and print accuracy\n",
+        "from sklearn.metrics import accuracy_score\n",
+        "\n",
+        "titanic_predictions = log_reg.predict(X_test)\n",
+        "og_score = accuracy_score(Y_test, titanic_predictions)\n",
+        "og_score"
+      ],
+      "metadata": {
+        "id": "c9NiZtyckeim",
+        "outputId": "107432c5-9019-4734-ebfd-5d9f3ca9b7bb",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.8059701492537313"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 70
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "N7hpE0OP2yK0",
+        "outputId": "83c32006-26f1-4ef2-b792-921324a76754"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.8059701492537313"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 41
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Upon getting the score, we can see the logistic regression algorithm has done decent work, but nothing bad with trying other classification algorithms like DecisionTree.\n"
+      ],
+      "metadata": {
+        "id": "O5lDF2Q7Pte2"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import decision Tree and train\n",
+        "from sklearn.tree import DecisionTreeClassifier\n",
+        "\n",
+        "tree_clf = DecisionTreeClassifier()\n",
+        "tree_clf.fit(X_train, Y_train)"
+      ],
+      "metadata": {
+        "id": "Mq3-cu65ky4q",
+        "outputId": "e80f20a2-05bf-41cb-e589-d8e893439e73",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DecisionTreeClassifier()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 71
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "irzOgxIG3M3J",
+        "outputId": "815f05a2-bc90-4ee4-8001-0adf9f2b9a51"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DecisionTreeClassifier()"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 42
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# using accuaracy_score print accuracy\n",
+        "titanic_predictions = tree_clf.predict(X_test)\n",
+        "tree_score = accuracy_score(Y_test, titanic_predictions)\n",
+        "tree_score"
+      ],
+      "metadata": {
+        "id": "GPeuQ2W2m3Aj",
+        "outputId": "96e2689d-cbe1-4f8f-ea6e-b7e182a81fd7",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.7798507462686567"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 72
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D_2eNhfS3hdf",
+        "outputId": "624bd39c-e650-451d-9f2f-017f1397ea5f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.7798507462686567"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 43
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "sccuracy has decreased a bit, we can try using cross validation and see the score for both Decision Tree and Linear Regression "
+      ],
+      "metadata": {
+        "id": "2fCRU-qDP8yV"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.model_selection import cross_val_score\n",
+        "\n",
+        "scores = cross_val_score(tree_clf, X_train, Y_train,scoring=\"accuracy\", cv=10)"
+      ],
+      "metadata": {
+        "id": "fud7Tp2C3yQm"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def display_scores(scores):\n",
+        "    print(\"Scores:\", scores)\n",
+        "    print(\"Mean:\", scores.mean())\n",
+        "    print(\"Standard deviation:\", scores.std())\n",
+        "\n",
+        "display_scores(scores)"
+      ],
+      "metadata": {
+        "id": "pUsWjJxrndHi",
+        "outputId": "1d939448-9e68-49a9-9e18-9b430b631ca8",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: [0.73015873 0.79365079 0.74603175 0.80645161 0.77419355 0.69354839\n",
+            " 0.75806452 0.82258065 0.85483871 0.80645161]\n",
+            "Mean: 0.7785970302099334\n",
+            "Standard deviation: 0.0453946434587528\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Zn3xL51337Ig",
+        "outputId": "259f021a-ffc8-4dbc-fb1c-e8ac1d60cd33"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: [0.71428571 0.77777778 0.71428571 0.80645161 0.77419355 0.70967742\n",
+            " 0.77419355 0.80645161 0.85483871 0.80645161]\n",
+            "Mean: 0.7738607270865334\n",
+            "Standard deviation: 0.04580104507258628\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "log_scores = cross_val_score(log_reg, X_train, Y_train,scoring=\"accuracy\", cv=10)\n",
+        "\n",
+        "display_scores(log_scores)"
+      ],
+      "metadata": {
+        "id": "elbJHv1nnmtP",
+        "outputId": "714e9839-4102-4ff3-8fe0-6ccdab0cbe5d",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: [0.76190476 0.76190476 0.88888889 0.85483871 0.80645161 0.74193548\n",
+            " 0.72580645 0.77419355 0.72580645 0.93548387]\n",
+            "Mean: 0.7977214541730671\n",
+            "Standard deviation: 0.0687047480828934\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "MUYyBM793-ru",
+        "outputId": "6745577f-8300-44e6-8c2a-22ef9cfdbe03"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: [0.76190476 0.76190476 0.88888889 0.85483871 0.80645161 0.74193548\n",
+            " 0.72580645 0.77419355 0.72580645 0.93548387]\n",
+            "Mean: 0.7977214541730671\n",
+            "Standard deviation: 0.0687047480828934\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Both of the above algorithms are not the best for this dataset, we may try various algorithms and try increasing the accuracy, but Random Forrest is generally known to be the best, so maybe try that."
+      ],
+      "metadata": {
+        "id": "qxxaUjXyQJyW"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.ensemble import RandomForestClassifier\n",
+        "\n",
+        "forest_clf = RandomForestClassifier()\n",
+        "forest_clf.fit(X_train, Y_train)\n",
+        "\n",
+        "titanic_predictions = forest_clf.predict(X_test)\n",
+        "forest_score = accuracy_score(Y_test, titanic_predictions)\n",
+        "forest_score"
+      ],
+      "metadata": {
+        "id": "qDAFM410nvV8",
+        "outputId": "55111a0e-7f57-4191-bbde-f2159218a0d9",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.7947761194029851"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 78
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Spay_mrC4HXu",
+        "outputId": "2621c8f8-cc16-4220-8485-ea9973e11651"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "0.7835820895522388"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 47
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "display_scores(forest_score)"
+      ],
+      "metadata": {
+        "id": "MGmhRKdan41I",
+        "outputId": "110abdf1-d45a-4cfd-fae2-2fd47e52a4ba",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: 0.7947761194029851\n",
+            "Mean: 0.7947761194029851\n",
+            "Standard deviation: 0.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CkR-N9bw4aAl",
+        "outputId": "7ebd5c46-8565-49b5-8943-487be83084ba"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Scores: 0.7835820895522388\n",
+            "Mean: 0.7835820895522388\n",
+            "Standard deviation: 0.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Fine Tune Model\n",
+        "\n",
+        "HyperParameter Tuning"
+      ],
+      "metadata": {
+        "id": "iO_BYHibZpDA"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "After looking at these scores we might perform GridSearchCV, in order to check the best suited params from the data. \n"
+      ],
+      "metadata": {
+        "id": "Yr5Ck4baQnAN"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from sklearn.model_selection import GridSearchCV\n",
+        "\n",
+        "param_grid = [\n",
+        "    {'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6]},\n",
+        "    {'bootstrap': [False], 'n_estimators': [3, 10], 'max_features': [2, 3, 4]},\n",
+        "]\n",
+        "\n",
+        "forest_clf = RandomForestClassifier()\n",
+        "\n",
+        "grid_search = GridSearchCV(forest_clf, param_grid, cv=5,\n",
+        "                            scoring='accuracy',\n",
+        "                            return_train_score=True)\n",
+        "\n",
+        "grid_search.fit(X_train, Y_train)\n",
+        "print(grid_search.best_params_)\n",
+        "print(grid_search.best_score_)"
+      ],
+      "metadata": {
+        "id": "OAh4eHctoAHR",
+        "outputId": "c1820e5e-e60f-4733-a57e-25bfd54c3b03",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'max_features': 4, 'n_estimators': 30}\n",
+            "0.8074838709677421\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        ""
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "JV_BgZFv4dGC",
+        "outputId": "5bc689e2-667a-4f6f-d179-7e5c5ca67c0f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'max_features': 4, 'n_estimators': 30}\n",
+            "0.8010193548387097\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Here the best model has highest n_estimators value so we can try to further increase value of `n_estimators`. Higher values of n_estimators takes a longer time to fit model you can try this in your own. Reason for this longer time will be **clearly explaned** in your future classes of RandomForest."
+      ],
+      "metadata": {
+        "id": "QGdcekx-WJph"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "After finding the best params, we can find all mean params and check that best params gives the highest score."
+      ],
+      "metadata": {
+        "id": "3r-YVWkyQ_Eh"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "cvres = grid_search.cv_results_\n",
+        "for score, params in zip(cvres[\"mean_test_score\"], cvres[\"params\"]):\n",
+        "  print(np.sqrt(score), params)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VMcC4Jql4nuY",
+        "outputId": "0a43893f-95a2-4676-e87d-2f591206a1ee"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "0.8649072297819185 {'max_features': 2, 'n_estimators': 3}\n",
+            "0.8950112632198115 {'max_features': 2, 'n_estimators': 10}\n",
+            "0.888717815078954 {'max_features': 2, 'n_estimators': 30}\n",
+            "0.8777610814618249 {'max_features': 4, 'n_estimators': 3}\n",
+            "0.8823867925195296 {'max_features': 4, 'n_estimators': 10}\n",
+            "0.8986010633021431 {'max_features': 4, 'n_estimators': 30}\n",
+            "0.881457736896945 {'max_features': 6, 'n_estimators': 3}\n",
+            "0.8949896377125846 {'max_features': 6, 'n_estimators': 10}\n",
+            "0.8913925314704462 {'max_features': 6, 'n_estimators': 30}\n",
+            "0.8769154150551183 {'bootstrap': False, 'max_features': 2, 'n_estimators': 3}\n",
+            "0.8796480234510223 {'bootstrap': False, 'max_features': 2, 'n_estimators': 10}\n",
+            "0.8860131798335225 {'bootstrap': False, 'max_features': 3, 'n_estimators': 3}\n",
+            "0.8859986164701934 {'bootstrap': False, 'max_features': 3, 'n_estimators': 10}\n",
+            "0.8859986164701934 {'bootstrap': False, 'max_features': 4, 'n_estimators': 3}\n",
+            "0.8823648576045421 {'bootstrap': False, 'max_features': 4, 'n_estimators': 10}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Hurray! you have completed this excercise🤘🤘🤘**"
+      ],
+      "metadata": {
+        "id": "RaNppu5UXCEy"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Here are some tasks left for you if u wish to improve you skills then solve it.\n",
+        "\n",
+        "\n",
+        "\n",
+        "*   **Find the relation between 'SibSp', 'Parch'.**\n",
+        "*   **Do some Hyperparameter Tuning in Logistic Regression to enhance your model.** To see the hyperparameters in logistic regression you can use sklearn official weibite to see parameters.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "_IxX1MxfXXv0"
+      }
+    }
+  ]
+}
\ No newline at end of file