04_KNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "04 KNN.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyOM3gM5N6xXCNyQsu3nJPLG",
      "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/sandipanpaul21/KNN-Naive-Bayes-in-Python/blob/main/04_KNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**K Nearest Neighbour**\n",
        "\n",
        "- KNN is a supervised alogrithim\n",
        "- KNN used for both \n",
        "  - Classification : Return Mode of K Labels\n",
        "  - Regression : Return Mean of K Labels\n",
        "- For a given data point in the set, the algorithms find the distances between this and all other K numbers of datapoint in the dataset close to the initial point and votes for that category that has the most frequency. \n",
        "- Usually, *Euclidean distance* is taking as a measure of distance. Thus the end resultant model is just the labeled data placed in a space. \n",
        "\n",
        "**So now how do we choose K?**\n",
        "- Generally we use the Square root of the number of samples in the dataset as value for K. \n",
        "- An optimal value has to be found out since lower value may lead to overfitting and higher value may require high computational complication in distance. So using an error plot may help. \n",
        "- Another method is the elbow method. You can prefer to take root else can also follow the elbow method.\n",
        "\n",
        "**Steps in KNN**\n",
        "1. Select the value of K neighbors(say k=5)\n",
        "2. Find the K (5) nearest data point for our new data point based on euclidean distance\n",
        "3. Among these K data points count the data points in each category\n",
        "4. Assign the new data point to the category that has the most neighbors of the new datapoint\n",
        "\n",
        "**KNN is a Lazy Algorithim**\n",
        "- KNN is a Lazy learner because it doesn't learn a discriminative function from training set but memorize the trainig dataset instead. In other word, during Training Time all it is doing is to store all the data it gets.\n",
        "- For example, in logistic regression alogrithim learns its model weight (parameters) during training time. In contrast, **there is no training time in KNN**. Although it become expensive later. \n",
        "- Expensive in terms of, each time a new datapoint comes in and we want to make prediction, KNN will search for the Nearest Neighbour in the entire set. Hence prediction step becomes more time-consuming and computationally expensive.\n",
        "\n",
        "**Data Preporcessing in KNN**\n",
        "- As, it is a distance based algorithim, all columns should be in same scale\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "KSUQKc5L-Xcy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**The Abalone Problem Statement**\n",
        "- The age of an abalone can be found by cutting its shell and counting the number of rings on the shell.\n",
        "- In the Abalone Dataset, you can find the age measurements of a large number of abalones along with a lot of other physical measurements.\n",
        "- The *goal of the project is to develop a model that can predict the age of an abalone based purely on the other physical measurements.* This would allow researchers to estimate the abalone’s age without having to cut its shell and count the rings.\n",
        "\n",
        "We’ll be applying a kNN to find the closest prediction score possible."
      ],
      "metadata": {
        "id": "UmtodpjX_69T"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "i5OTWFkS8r8c",
        "outputId": "ff079b99-6c67-43d8-8490-d29fb38e6dc8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<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>Length</th>\n",
              "      <th>Diameter</th>\n",
              "      <th>Height</th>\n",
              "      <th>Whole weight</th>\n",
              "      <th>Shucked weight</th>\n",
              "      <th>Viscera weight</th>\n",
              "      <th>Shell weight</th>\n",
              "      <th>Rings</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.455</td>\n",
              "      <td>0.365</td>\n",
              "      <td>0.095</td>\n",
              "      <td>0.5140</td>\n",
              "      <td>0.2245</td>\n",
              "      <td>0.1010</td>\n",
              "      <td>0.150</td>\n",
              "      <td>15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0.350</td>\n",
              "      <td>0.265</td>\n",
              "      <td>0.090</td>\n",
              "      <td>0.2255</td>\n",
              "      <td>0.0995</td>\n",
              "      <td>0.0485</td>\n",
              "      <td>0.070</td>\n",
              "      <td>7</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0.530</td>\n",
              "      <td>0.420</td>\n",
              "      <td>0.135</td>\n",
              "      <td>0.6770</td>\n",
              "      <td>0.2565</td>\n",
              "      <td>0.1415</td>\n",
              "      <td>0.210</td>\n",
              "      <td>9</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.440</td>\n",
              "      <td>0.365</td>\n",
              "      <td>0.125</td>\n",
              "      <td>0.5160</td>\n",
              "      <td>0.2155</td>\n",
              "      <td>0.1140</td>\n",
              "      <td>0.155</td>\n",
              "      <td>10</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0.330</td>\n",
              "      <td>0.255</td>\n",
              "      <td>0.080</td>\n",
              "      <td>0.2050</td>\n",
              "      <td>0.0895</td>\n",
              "      <td>0.0395</td>\n",
              "      <td>0.055</td>\n",
              "      <td>7</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Length  Diameter  Height  ...  Viscera weight  Shell weight  Rings\n",
              "0   0.455     0.365   0.095  ...          0.1010         0.150     15\n",
              "1   0.350     0.265   0.090  ...          0.0485         0.070      7\n",
              "2   0.530     0.420   0.135  ...          0.1415         0.210      9\n",
              "3   0.440     0.365   0.125  ...          0.1140         0.155     10\n",
              "4   0.330     0.255   0.080  ...          0.0395         0.055      7\n",
              "\n",
              "[5 rows x 8 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ],
      "source": [
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.neighbors import KNeighborsRegressor\n",
        "from sklearn.metrics import mean_squared_error\n",
        "from math import sqrt\n",
        "import seaborn as sns\n",
        "\n",
        "url = (\"https://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data\")\n",
        "abalone = pd.read_csv(url, header=None)\n",
        "abalone.columns = [\"Sex\",\"Length\",\"Diameter\",\"Height\",\"Whole weight\",\"Shucked weight\",\"Viscera weight\",\"Shell weight\",\"Rings\"]\n",
        "\n",
        "# For now wer are removinf Sex for analysis purpose\n",
        "abalone = abalone.drop(\"Sex\", axis=1)\n",
        "abalone.head()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Descriptive Statistics\n",
        "# The target variable of this exercise is Rings\n",
        "\n",
        "abalone[\"Rings\"].hist(bins=15)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "p-mITgm9AYrt",
        "outputId": "9d424582-9d78-4295-969b-8debe78be661"
      },
      "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": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Correlation \n",
        "# A strong correlation between an independent variable and your goal variable would be a good sign, \n",
        "# You can observe the complete correlation matrix in correlation_matrix. \n",
        "# The most important correlations are the ones with the target variable Rings. \n",
        "\n",
        "correlation_matrix = abalone.corr()\n",
        "correlation_matrix[\"Rings\"]\n",
        "\n",
        "# Inference : \n",
        "# Now look at the correlation coefficients for Rings with the other variables. \n",
        "# The closer they are to 1, the more correlation there is.\n",
        "# Very high correlations mean that you can expect a straightforward modeling process. \n",
        "# In this case, you’ll have to try and see what results you can obtain using the kNN algorithm."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oEZ2ovT2BEa5",
        "outputId": "1b7e0048-a012-4b64-c30f-90bfb9c7af63"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Length            0.556720\n",
              "Diameter          0.574660\n",
              "Height            0.557467\n",
              "Whole weight      0.540390\n",
              "Shucked weight    0.420884\n",
              "Viscera weight    0.503819\n",
              "Shell weight      0.627574\n",
              "Rings             1.000000\n",
              "Name: Rings, dtype: float64"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Separate the data into training and test data. \n",
        "X = abalone.drop(\"Rings\", axis=1)\n",
        "y = abalone[\"Rings\"]\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, \n",
        "                                                    test_size=0.2, \n",
        "                                                    random_state=12345)\n",
        "# The test_size refers to the number of observations \n",
        "# that you want to put in the training data and the test data. \n",
        "# If you specify a test_size of 0.2, your test_size will be 20 percent of the original data, \n",
        "# therefore leaving the other 80 percent as training data.\n",
        "\n",
        "# The random_state is a parameter that allows you to obtain the same results every time \n",
        "# the code is run. \n",
        "# train_test_split() makes a random split in the data, \n",
        "# which is problematic for reproducing the results. \n",
        "# Therefore, it’s common to use random_state. \n",
        "# The choice of value in random_state is arbitrary.\n",
        "\n",
        "# Model Parameter\n",
        "knn_model = KNeighborsRegressor(n_neighbors=3)\n",
        "\n",
        "# Model Fit\n",
        "knn_model.fit(X_train, y_train)\n",
        "\n",
        "# Model Prediction\n",
        "test_preds = knn_model.predict(X_test)\n",
        "mse = mean_squared_error(y_test, test_preds)\n",
        "rmse = sqrt(mse)\n",
        "print(\"RMSE of K = 3 :\",rmse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ELZ5vPwBTVt",
        "outputId": "a6659d90-7b2d-44b2-f718-203b48701cbd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE of K = 3 : 2.375417924000521\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Tune and Optimize kNN**\n",
        "\n",
        "**Using GridSearchCV**\n",
        "\n",
        "- Until now, you’ve always worked with k=3 in the kNN algorithm, but the best value for k is something that you need to find empirically for each dataset.\n",
        "\n",
        "- When you use few neighbors, you have a prediction that will be much more variable than when you use more neighbors:\n",
        "    - If you *use one neighbor only*\n",
        "      - The prediction can strongly change from one point to the other. \n",
        "      - When you think about your own neighbors, one may be quite different from the others. \n",
        "      - If you lived next to an outlier, your 1-NN prediction would be wrong.\n",
        "      - **Underfit or Outlier**\n",
        "\n",
        "    - If you *have multiple data points*, the impact of one extremely different neighbor will be much less.\n",
        "\n",
        "    - If you use *too many neighbors*\n",
        "      - The prediction of each point risks being very close. \n",
        "      - Let’s say that you use all neighbors for a prediction. In that case, every prediction would be the same.\n",
        "      - **Overfit**\n",
        "\n",
        "- To find the best value for k, you’re going to use a tool called GridSearchCV, used for tuning hyperparameters of machine learning models. In your case, it will help by automatically finding the best value of k for your dataset."
      ],
      "metadata": {
        "id": "RMDgo44BEtxI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import GridSearchCV\n",
        "parameters = {\"n_neighbors\": range(1, 50)}\n",
        "gridsearch = GridSearchCV(KNeighborsRegressor(), parameters)\n",
        "gridsearch.fit(X_train, y_train)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "InYKyngsCmJ5",
        "outputId": "f715583b-ab82-48fa-cd48-9a69400d1a90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "GridSearchCV(estimator=KNeighborsRegressor(),\n",
              "             param_grid={'n_neighbors': range(1, 50)})"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Here, you use GridSearchCV to fit the model. \n",
        "# In short, GridSearchCV repeatedly fits kNN regressors on a part of the data \n",
        "# tests the performances on the remaining part of the data. \n",
        "# Doing this repeatedly will yield a reliable estimate of the predictive performance \n",
        "# of each of the values for k. In this example, you test the values from 1 to 50.\n",
        "# In the end, it will retain the best performing value of k, which you can access with .best_params_:\n",
        "\n",
        "gridsearch.best_params_\n",
        "\n",
        "# Inference : \n",
        "# In this code, you print the parameters that have the lowest error score. \n",
        "# With .best_params_, you can see that choosing 25 as value for k \n",
        "# It will yield the best predictive performance. "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c9pWiGaAEPLq",
        "outputId": "5049d27c-208f-491a-d463-694793630509"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'n_neighbors': 25}"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Now that you know what the best value of k is, \n",
        "# you can see how it affects your train and test performances:\n",
        "\n",
        "test_preds_grid = gridsearch.predict(X_test)\n",
        "test_mse = mean_squared_error(y_test, test_preds_grid)\n",
        "test_rmse = sqrt(test_mse)\n",
        "\n",
        "print(\"RMSE for k = 25 :\",test_rmse)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NHqthsZXF8Gf",
        "outputId": "aee1fd52-4dd7-4188-f5e3-ebdc19ed0955"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE for k = 25 : 2.1700197339962175\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Choosing a K Value**\n",
        "\n",
        "- Let’s go ahead and use the elbow method to pick a good K Value. \n",
        "- We will basically check the error rate for k = 1 to say k = 40. \n",
        "- For every value of k we will call KNN classifier and then choose the value of k which has the least error rate."
      ],
      "metadata": {
        "id": "7dr5M8bJU05o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Choose the K value which have least RMSE Value\n",
        "\n",
        "import numpy as np\n",
        "error_rate = []\n",
        "# Might take some time\n",
        "for i in range(1,40):\n",
        "    knn = KNeighborsRegressor(n_neighbors=i)\n",
        "    knn.fit(X_train,y_train)\n",
        "    y_pred = knn.predict(X_test)\n",
        "    error_rate.append(sqrt(mean_squared_error(y_test,y_pred)))\n",
        "\n",
        "# Plot for Error Rate vs K Value\n",
        "plt.figure(figsize=(10,6))\n",
        "plt.plot(range(1,40),error_rate,color='blue', linestyle='dashed', marker='o',\n",
        "         markerfacecolor='red', markersize=10)\n",
        "plt.title('RMSE Error Rate vs. K Value')\n",
        "plt.xlabel('K')\n",
        "plt.ylabel('RMSE Error Rate')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 422
        },
        "id": "Kq3BCK7PTbkk",
        "outputId": "650618e0-8dfe-4529-ca0e-acbe77888c7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'RMSE Error Rate')"
            ]
          },
          "metadata": {},
          "execution_count": 36
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}