{"cells":[{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<p style=\"text-align:center\">\n","    <a href=\"https://skills.network/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2022-01-01\">\n","    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\"  />\n","    </a>\n","</p>\n","\n","# K-Nearest Neighbors\n","\n","Estimated time needed: **25** minutes\n","\n","## Objectives\n","\n","After completing this lab you will be able to:\n","\n","*   Use K Nearest neighbors to classify data\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["In this Lab you will load a customer dataset, fit the data, and use K-Nearest Neighbors to predict a data point. But what is **K-Nearest Neighbors**?\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["**K-Nearest Neighbors** is a supervised learning algorithm. Where the data is 'trained' with data points corresponding to their classification. To predict the class of a given data point, it takes into account the classes of the 'K' nearest data points and chooses the class in which the majority of the 'K' nearest data points belong to as the predicted class.\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Here's an visualization of the K-Nearest Neighbors algorithm.\n","\n","<img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/images/KNN_Diagram.png\">\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["In this case, we have data points of Class A and B. We want to predict what the star (test data point) is. If we consider a k value of 3 (3 nearest data points), we will obtain a prediction of Class B. Yet if we consider a k value of 6, we will obtain a prediction of Class A.\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["In this sense, it is important to consider the value of k. Hopefully from this diagram, you should get a sense of what the K-Nearest Neighbors algorithm is. It considers the 'K' Nearest Neighbors (data points) when it predicts the classification of the test point.\n"]},{"cell_type":"markdown","metadata":{},"source":["<h1>Table of contents</h1>\n","\n","<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n","    <ol>\n","        <li><a href=\"https://#about_dataset\">About the dataset</a></li>\n","        <li><a href=\"https://#visualization_analysis\">Data Visualization and Analysis</a></li>\n","        <li><a href=\"https://#classification\">Classification</a></li>\n","    </ol>\n","</div>\n","<br>\n","<hr>\n"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["!pip install scikit-learn==0.23.1"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["Let's load required libraries\n"]},{"cell_type":"code","execution_count":2,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt\n","import pandas as pd\n","import numpy as np\n","from sklearn import preprocessing\n","%matplotlib inline"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<div id=\"about_dataset\">\n","    <h2>About the dataset</h2>\n","</div>\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["Imagine a telecommunications provider has segmented its customer base by service usage patterns, categorizing the customers into four groups. If demographic data can be used to predict group membership, the company can customize offers for individual prospective customers. It is a classification problem. That is, given the dataset,  with predefined labels, we need to build a model to be used to predict class of a new or unknown case.\n","\n","The example focuses on using demographic data, such as region, age, and marital, to predict usage patterns.\n","\n","The target field, called **custcat**, has four possible values that correspond to the four customer groups, as follows:\n","1- Basic Service\n","2- E-Service\n","3- Plus Service\n","4- Total Service\n","\n","Our objective is to build a classifier, to predict the class of unknown cases. We will use a specific type of classification called K nearest neighbour.\n"]},{"cell_type":"markdown","metadata":{},"source":["**Did you know?** When it comes to Machine Learning, you will likely be working with large datasets. As a business, where can you host your data? IBM is offering a unique opportunity for businesses, with 10 Tb of IBM Cloud Object Storage: [Sign up now for free](http://cocl.us/ML0101EN-IBM-Offer-CC)\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Load Data \n"]},{"cell_type":"markdown","metadata":{},"source":["Let's read the data using pandas library and print the first five rows.\n"]},{"cell_type":"code","execution_count":4,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"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>region</th>\n","      <th>tenure</th>\n","      <th>age</th>\n","      <th>marital</th>\n","      <th>address</th>\n","      <th>income</th>\n","      <th>ed</th>\n","      <th>employ</th>\n","      <th>retire</th>\n","      <th>gender</th>\n","      <th>reside</th>\n","      <th>custcat</th>\n","    </tr>\n","  </thead>\n","  <tbody>\n","    <tr>\n","      <th>0</th>\n","      <td>2</td>\n","      <td>13</td>\n","      <td>44</td>\n","      <td>1</td>\n","      <td>9</td>\n","      <td>64.0</td>\n","      <td>4</td>\n","      <td>5</td>\n","      <td>0.0</td>\n","      <td>0</td>\n","      <td>2</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>1</th>\n","      <td>3</td>\n","      <td>11</td>\n","      <td>33</td>\n","      <td>1</td>\n","      <td>7</td>\n","      <td>136.0</td>\n","      <td>5</td>\n","      <td>5</td>\n","      <td>0.0</td>\n","      <td>0</td>\n","      <td>6</td>\n","      <td>4</td>\n","    </tr>\n","    <tr>\n","      <th>2</th>\n","      <td>3</td>\n","      <td>68</td>\n","      <td>52</td>\n","      <td>1</td>\n","      <td>24</td>\n","      <td>116.0</td>\n","      <td>1</td>\n","      <td>29</td>\n","      <td>0.0</td>\n","      <td>1</td>\n","      <td>2</td>\n","      <td>3</td>\n","    </tr>\n","    <tr>\n","      <th>3</th>\n","      <td>2</td>\n","      <td>33</td>\n","      <td>33</td>\n","      <td>0</td>\n","      <td>12</td>\n","      <td>33.0</td>\n","      <td>2</td>\n","      <td>0</td>\n","      <td>0.0</td>\n","      <td>1</td>\n","      <td>1</td>\n","      <td>1</td>\n","    </tr>\n","    <tr>\n","      <th>4</th>\n","      <td>2</td>\n","      <td>23</td>\n","      <td>30</td>\n","      <td>1</td>\n","      <td>9</td>\n","      <td>30.0</td>\n","      <td>1</td>\n","      <td>2</td>\n","      <td>0.0</td>\n","      <td>0</td>\n","      <td>4</td>\n","      <td>3</td>\n","    </tr>\n","  </tbody>\n","</table>\n","</div>"],"text/plain":["   region  tenure  age  marital  address  income  ed  employ  retire  gender  \\\n","0       2      13   44        1        9    64.0   4       5     0.0       0   \n","1       3      11   33        1        7   136.0   5       5     0.0       0   \n","2       3      68   52        1       24   116.0   1      29     0.0       1   \n","3       2      33   33        0       12    33.0   2       0     0.0       1   \n","4       2      23   30        1        9    30.0   1       2     0.0       0   \n","\n","   reside  custcat  \n","0       2        1  \n","1       6        4  \n","2       2        3  \n","3       1        1  \n","4       4        3  "]},"execution_count":4,"metadata":{},"output_type":"execute_result"}],"source":["df = pd.read_csv('https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%203/data/teleCust1000t.csv')\n","df.head()"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<div id=\"visualization_analysis\">\n","    <h2>Data Visualization and Analysis</h2> \n","</div>\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["#### Let’s see how many of each class is in our data set\n"]},{"cell_type":"code","execution_count":5,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["custcat\n","3    281\n","1    266\n","4    236\n","2    217\n","Name: count, dtype: int64"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["df['custcat'].value_counts()"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["#### 281 Plus Service, 266 Basic-service, 236 Total Service, and 217 E-Service customers\n"]},{"cell_type":"markdown","metadata":{},"source":["You can easily explore your data using visualization techniques:\n"]},{"cell_type":"code","execution_count":6,"metadata":{},"outputs":[{"data":{"text/plain":["array([[<Axes: title={'center': 'income'}>]], dtype=object)"]},"execution_count":6,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["df.hist(column='income', bins=50)"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Feature set\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["Let's define feature sets, X:\n"]},{"cell_type":"code","execution_count":9,"metadata":{},"outputs":[{"data":{"text/plain":["(1000, 12)"]},"execution_count":9,"metadata":{},"output_type":"execute_result"}],"source":["df.columns\n","df.shape"]},{"cell_type":"code","execution_count":8,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["array([[  2.,  13.,  44.,   1.,   9.,  64.,   4.,   5.,   0.,   0.,   2.],\n","       [  3.,  11.,  33.,   1.,   7., 136.,   5.,   5.,   0.,   0.,   6.],\n","       [  3.,  68.,  52.,   1.,  24., 116.,   1.,  29.,   0.,   1.,   2.],\n","       [  2.,  33.,  33.,   0.,  12.,  33.,   2.,   0.,   0.,   1.,   1.],\n","       [  2.,  23.,  30.,   1.,   9.,  30.,   1.,   2.,   0.,   0.,   4.]])"]},"execution_count":8,"metadata":{},"output_type":"execute_result"}],"source":["X = df[['region', 'tenure','age', 'marital', 'address', 'income', 'ed', 'employ','retire', 'gender', 'reside']] .values  #.astype(float)\n","X[0:5]\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["What are our labels?\n"]},{"cell_type":"code","execution_count":10,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["array([1, 4, 3, 1, 3])"]},"execution_count":10,"metadata":{},"output_type":"execute_result"}],"source":["y = df['custcat'].values\n","y[0:5]"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["## Normalize Data\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["Data Standardization gives the data zero mean and unit variance, it is good practice, especially for algorithms such as KNN which is based on the distance of data points:\n"]},{"cell_type":"code","execution_count":11,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["array([[-0.02696767, -1.055125  ,  0.18450456,  1.0100505 , -0.25303431,\n","        -0.12650641,  1.0877526 , -0.5941226 , -0.22207644, -1.03459817,\n","        -0.23065004],\n","       [ 1.19883553, -1.14880563, -0.69181243,  1.0100505 , -0.4514148 ,\n","         0.54644972,  1.9062271 , -0.5941226 , -0.22207644, -1.03459817,\n","         2.55666158],\n","       [ 1.19883553,  1.52109247,  0.82182601,  1.0100505 ,  1.23481934,\n","         0.35951747, -1.36767088,  1.78752803, -0.22207644,  0.96655883,\n","        -0.23065004],\n","       [-0.02696767, -0.11831864, -0.69181243, -0.9900495 ,  0.04453642,\n","        -0.41625141, -0.54919639, -1.09029981, -0.22207644,  0.96655883,\n","        -0.92747794],\n","       [-0.02696767, -0.58672182, -0.93080797,  1.0100505 , -0.25303431,\n","        -0.44429125, -1.36767088, -0.89182893, -0.22207644, -1.03459817,\n","         1.16300577]])"]},"execution_count":11,"metadata":{},"output_type":"execute_result"}],"source":["X = preprocessing.StandardScaler().fit(X).transform(X.astype(float))\n","X[0:5]"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Train Test Split\n","\n","Out of Sample Accuracy is the percentage of correct predictions that the model makes on data that the model has NOT been trained on. Doing a train and test on the same dataset will most likely have low out-of-sample accuracy, due to the likelihood of our model overfitting.\n","\n","It is important that our models have a high, out-of-sample accuracy, because the purpose of any model, of course, is to make correct predictions on unknown data. So how can we improve out-of-sample accuracy? One way is to use an evaluation approach called Train/Test Split.\n","Train/Test Split involves splitting the dataset into training and testing sets respectively, which are mutually exclusive. After which, you train with the training set and test with the testing set.\n","\n","This will provide a more accurate evaluation on out-of-sample accuracy because the testing dataset is not part of the dataset that has been used to train the model. It is more realistic for the real world problems.\n"]},{"cell_type":"code","execution_count":14,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"name":"stdout","output_type":"stream","text":["Train set: (800, 11) (800,)\n","Test set: (200, 11) (200,)\n"]}],"source":["from sklearn.model_selection import train_test_split\n","X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=4)\n","print ('Train set:', X_train.shape,  y_train.shape)\n","print ('Test set:', X_test.shape,  y_test.shape)"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<div id=\"classification\">\n","    <h2>Classification</h2>\n","</div>\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<h3>K nearest neighbor (KNN)</h3>\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["#### Import library\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["Classifier implementing the k-nearest neighbors vote.\n"]},{"cell_type":"code","execution_count":12,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[],"source":["from sklearn.neighbors import KNeighborsClassifier"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Training\n","\n","Let's start the algorithm with k=4 for now:\n"]},{"cell_type":"code","execution_count":19,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/html":["<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>KNeighborsClassifier(n_neighbors=4)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">KNeighborsClassifier</label><div class=\"sk-toggleable__content\"><pre>KNeighborsClassifier(n_neighbors=4)</pre></div></div></div></div></div>"],"text/plain":["KNeighborsClassifier(n_neighbors=4)"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["k = 4\n","#Train Model and Predict  \n","neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)\n","neigh"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Predicting\n","\n","We can use the model to make predictions on the test set:\n"]},{"cell_type":"code","execution_count":20,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["array([1, 1, 3, 2, 4])"]},"execution_count":20,"metadata":{},"output_type":"execute_result"}],"source":["yhat = neigh.predict(X_test)\n","yhat[0:5]"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["### Accuracy evaluation\n","\n","In multilabel classification, **accuracy classification score** is a function that computes subset accuracy. This function is equal to the jaccard_score function. Essentially, it calculates how closely the actual labels and predicted labels are matched in the test set.\n"]},{"cell_type":"code","execution_count":21,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Train set Accuracy:  0.5475\n","Test set Accuracy:  0.32\n"]}],"source":["from sklearn import metrics\n","print(\"Train set Accuracy: \", metrics.accuracy_score(y_train, neigh.predict(X_train)))\n","print(\"Test set Accuracy: \", metrics.accuracy_score(y_test, yhat))"]},{"cell_type":"markdown","metadata":{},"source":["## Practice\n","\n","Can you build the model again, but this time with k=6?\n"]},{"cell_type":"code","execution_count":22,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Train set Accuracy:  0.51625\n","Test set Accuracy:  0.31\n"]}],"source":["# write your code here\n","\n","k=6 # do over with this k\n","neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train); neigh\n","yhat = neigh.predict(X_test); yhat[0:5]\n","print(\"Train set Accuracy: \", metrics.accuracy_score(y_train, neigh.predict(X_train)))\n","print(\"Test set Accuracy: \", metrics.accuracy_score(y_test, yhat))\n"]},{"cell_type":"markdown","metadata":{},"source":["<details><summary>Click here for the solution</summary>\n","\n","```python\n","k = 6\n","neigh6 = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)\n","yhat6 = neigh6.predict(X_test)\n","print(\"Train set Accuracy: \", metrics.accuracy_score(y_train, neigh6.predict(X_train)))\n","print(\"Test set Accuracy: \", metrics.accuracy_score(y_test, yhat6))\n","\n","```\n","\n","</details>\n"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["#### What about other K?\n","\n","K in KNN, is the number of nearest neighbors to examine. It is supposed to be specified by the user. So, how can we choose right value for K?\n","The general solution is to reserve a part of your data for testing the accuracy of the model. Then choose k =1, use the training part for modeling, and calculate the accuracy of prediction using all samples in your test set. Repeat this process, increasing the k, and see which k is the best for your model.\n","\n","We can calculate the accuracy of KNN for different values of k.\n"]},{"cell_type":"code","execution_count":24,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"text/plain":["array([0.3  , 0.29 , 0.315, 0.32 , 0.315, 0.31 , 0.335, 0.325, 0.34 ])"]},"execution_count":24,"metadata":{},"output_type":"execute_result"}],"source":["Ks = 10\n","mean_acc = np.zeros((Ks-1))\n","std_acc = np.zeros((Ks-1))\n","\n","for n in range(1,Ks):\n","    \n","    #Train Model and Predict  \n","    neigh = KNeighborsClassifier(n_neighbors = n).fit(X_train,y_train)\n","    yhat=neigh.predict(X_test)\n","    mean_acc[n-1] = metrics.accuracy_score(y_test, yhat)\n","\n","    \n","    std_acc[n-1]=np.std(yhat==y_test)/np.sqrt(yhat.shape[0])\n","\n","mean_acc"]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["#### Plot the model accuracy for a different number of neighbors.\n"]},{"cell_type":"code","execution_count":25,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["plt.plot(range(1,Ks),mean_acc,'g')\n","plt.fill_between(range(1,Ks),mean_acc - 1 * std_acc,mean_acc + 1 * std_acc, alpha=0.10)\n","plt.fill_between(range(1,Ks),mean_acc - 3 * std_acc,mean_acc + 3 * std_acc, alpha=0.10,color=\"green\")\n","plt.legend(('Accuracy ', '+/- 1xstd','+/- 3xstd'))\n","plt.ylabel('Accuracy ')\n","plt.xlabel('Number of Neighbors (K)')\n","plt.tight_layout()\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"outputs":[],"source":["print( \"The best accuracy was with\", mean_acc.max(), \"with k=\", mean_acc.argmax()+1) "]},{"cell_type":"markdown","metadata":{"button":false,"new_sheet":false,"run_control":{"read_only":false}},"source":["<h2>Want to learn more?</h2>\n","\n","IBM SPSS Modeler is a comprehensive analytics platform that has many machine learning algorithms. It has been designed to bring predictive intelligence to decisions made by individuals, by groups, by systems – by your enterprise as a whole. A free trial is available through this course, available here: <a href=\"https://www.ibm.com/analytics/spss-statistics-software?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2022-01-01\">SPSS Modeler</a>\n","\n","Also, you can use Watson Studio to run these notebooks faster with bigger datasets. Watson Studio is IBM's leading cloud solution for data scientists, built by data scientists. With Jupyter notebooks, RStudio, Apache Spark and popular libraries pre-packaged in the cloud, Watson Studio enables data scientists to collaborate on their projects without having to install anything. Join the fast-growing community of Watson Studio users today with a free account at <a href=\"https://www.ibm.com/cloud/watson-studio?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2022-01-01\">Watson Studio</a>\n"]},{"cell_type":"markdown","metadata":{},"source":["### Thank you for completing this lab!\n","\n","## Author\n","\n","Saeed Aghabozorgi\n","\n","### Other Contributors\n","\n","<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2022-01-01\">Joseph Santarcangelo</a>\n","\n","## Change Log\n","\n","| Date (YYYY-MM-DD) | Version | Changed By | Change Description                 |\n","| ----------------- | ------- | ---------- | ---------------------------------- |\n","| 2021-01-21        | 2.4     | Lakshmi    | Updated sklearn library            |\n","| 2020-11-20        | 2.3     | Lakshmi    | Removed unused imports             |\n","| 2020-11-17        | 2.2     | Lakshmi    | Changed plot function of KNN       |\n","| 2020-11-03        | 2.1     | Lakshmi    | Changed URL of csv                 |\n","| 2020-08-27        | 2.0     | Lavanya    | Moved lab to course repo in GitLab |\n","|                   |         |            |                                    |\n","|                   |         |            |                                    |\n","\n","## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"]}],"metadata":{"kernelspec":{"display_name":"venv3.10.4","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.4"}},"nbformat":4,"nbformat_minor":4}