{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Title\n", "\n", "**Exercise: A.2 - Simple kNN regression**\n", "\n", "# Description\n", "\n", "The goal of this exercise is to **re-create the plots** below from the lecture.\n" ] }, { "cell_type": "markdown", "metadata": { "jupyter": { "outputs_hidden": false }, "pycharm": { "name": "#%% md\n" } }, "source": [ "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# Instructions:\n", "Part 1 **KNN by hand for k=1**\n", "\n", "- Read the Advertisement data \n", "- Get a subset of the data from row 5 to row 13\n", "- Apply the kNN algorithm by hand and plot the first graph as given above.\n", "\n", "Part 2 **Using sklearn package**\n", "- Read the entire Advertisement dataset\n", "- Split the data into train and test sets using `train_test_split()` function\n", "- Select `k_list` as possible k values ranging from 1 to 70.\n", "- For each value of k in `k_list`:\n", " - Use sklearn `KNearestNeighbors()` to fit train data\n", " - Predict on the test data\n", " - Use the helper code to get the second plot above for k=1,10,70\n", "\n", "# Hints:\n", "np.argsort() : Returns the indices that would sort an array. \n", "\n", "df.iloc[] : Returns a subset of the dataframe that is contained in the column range passed as the argument\n", "\n", "df.values : Returns a Numpy representation of the DataFrame.\n", "\n", "pd.idxmin() : Returns index of the first occurrence of minimum over requested axis.\n", "\n", "np.min() : Returns the minimum along a given axis.\n", "\n", "np.max() : Returns the maximum along a given axis.\n", "\n", "np.zeros() : Returns a new array of given shape and type, filled with zeros.\n", "\n", "train_test_split(X,y) : Split arrays or matrices into random train and test subsets.\n", "\n", "np.linspace() : Returns evenly spaced numbers over a specified interval.\n", "\n", "KNeighborsRegressor(n_neighbors=k_value) : Regression-based on k-nearest neighbors.\n", "\n", "Note: This exercise is **auto-graded and you can try multiple attempts.**" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
TVRadioNewspaperSales
0230.137.869.222.1
144.539.345.110.4
217.245.969.39.3
3151.541.358.518.5
4180.810.858.412.9
58.748.975.07.2
\n", "
" ], "text/plain": [ " TV Radio Newspaper Sales\n", "0 230.1 37.8 69.2 22.1\n", "1 44.5 39.3 45.1 10.4\n", "2 17.2 45.9 69.3 9.3\n", "3 151.5 41.3 58.5 18.5\n", "4 180.8 10.8 58.4 12.9\n", "5 8.7 48.9 75.0 7.2" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# take a quick look of the dataset\n", "\n", "df_adv.head(6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 1: KNN by hand for $k=1$" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 4)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m data_y = df_adv.Sales.iloc[]\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "# Get a subset of the data rows 6 to 13 and only TV advertisement. \n", "# The first row in the dataframe is the first row and not the zeroth row. \n", "data_x = df_adv.TV.iloc[5:13]\n", "data_y = df_adv.Sales.iloc[5:13]\n", "\n", "# Sort the data\n", "\n", "idx = np.argsort(___).values # Get indices ordered from lowest to highest values\n", "\n", "# Get the actual data in the order from above and turn them into numpy arrays. \n", "\n", "data_x = data_x.iloc[___].___\n", "data_y = data_y.iloc[___].___" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "### edTest(test_findnearest) ###\n", "# Define a function that finds the index of the nearest neighbor \n", "# and returns the value of the nearest neighbor. Note that this \n", "# is just for k = 1 and the distance function is simply the \n", "# absolute value.\n", "\n", "def find_nearest(array,value):\n", " idx = pd.Series(___).___ # hint: use pd.idxmin()\n", " return idx, array[idx]" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "# Create some artificial x-values (might not be in the actual dataset)\n", "\n", "x = np.linspace(np.min(data_x), np.max(data_x))\n", "\n", "# Initialize the y-values to zero\n", "\n", "y = np.zeros( (len(x)))" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "# Apply the KNN algorithm. Try to predict the y-value at a given x-value\n", "# Note: You may have tried to use the `range' method in your code. Enumerate \n", "# is far better in this case. \n", "\n", "# Try to understand why.\n", "\n", "for i, xi in enumerate(x):\n", " y[i] = data_y[find_nearest( data_x, xi )[0]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plotting the data" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot your solution \n", "plt.plot(x,y, '-.')\n", "# Plot the original data using black x's.\n", "plt.plot(___, ___, 'kx')\n", "plt.title('')\n", "plt.xlabel('TV budget in $1000')\n", "plt.ylabel('Sales in $1000')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 2: KNN for $k\\ge1$ using sklearn" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# import train_test_split and KNeighborsRegressor from sklearn\n", "\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.neighbors import KNeighborsRegressor" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "### Reading the complete Advertising dataset\n", "\n", "# This time you are expected to read the entire dataset\n", "\n", "data_filename = 'Advertising.csv'\n", "\n", "# Read advertising.csv file using the pandas library (using pandas.read_csv)\n", "\n", "df = pd.read_csv(data_filename)\n", "\n", "# Choose sales as your response variable 'y' and 'TV' as your 'predictor variable' \n", "\n", "x = df[[___]]\n", "y = df[___]" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "### edTest(test_shape) ###\n", "\n", "# Split the dataset in training and testing with 60% training set and 40% testing set \n", "# with random state = 42\n", "\n", "x_train, x_test, y_train, y_test = train_test_split(___, ___, train_size=___)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "### edTest(test_nums) ###\n", "# Choosing \n", "k_value_min = ___\n", "k_value_max = ___\n", "\n", "# creating list of integer k values betwwen k_value_min and k_value_max using linspace\n", "\n", "k_list = np.linspace(k_value_min, k_value_max, 70)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAFpCAYAAACrn+1KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQdElEQVR4nO3dX4jld3nH8c/TXQP1T1XMKjZ/MC3RuBem6BilaBsrrUl6sQheJIqhQVhCjXiZUKheeFMvCiJGlyWE4I25qEFjiYZCsSnYtJmARqNEtpEm2wjZqFiI0LDJ04uZyjDO7pydnGd3T3y94MD8fuc7Zx74Mst7f+fMOdXdAQBgxu+c6wEAAF7KxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMCgXWOrqu6sqqer6genuL+q6vNVdayqHqmqty9/TACA1bTIla27klxzmvuvTXL55u1wki+9+LEAAF4ado2t7n4gyc9Ps+RQki/3hgeTvKaq3risAQEAVtkyXrN1UZIntxwf3zwHAPBbb/8SHqN2OLfjZwBV1eFsPNWYV7ziFe+44oorlvDjAQBmPfzww89094G9fO8yYut4kku2HF+c5KmdFnb30SRHk2Rtba3X19eX8OMBAGZV1X/t9XuX8TTivUlu3PyrxHcn+WV3/3QJjwsAsPJ2vbJVVV9JcnWSC6vqeJJPJ3lZknT3kST3JbkuybEkv0py09SwAACrZtfY6u4bdrm/k3x8aRMBALyEeAd5AIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGLRRbVXVNVT1WVceq6rYd7n91VX2jqr5XVY9W1U3LHxUAYPXsGltVtS/J7UmuTXIwyQ1VdXDbso8n+WF3X5nk6iR/X1UXLHlWAICVs8iVrauSHOvux7v7uSR3Jzm0bU0neVVVVZJXJvl5kpNLnRQAYAUtElsXJXlyy/HxzXNbfSHJW5M8leT7ST7Z3S8sZUIAgBW2SGzVDud62/EHknw3ye8n+aMkX6iq3/uNB6o6XFXrVbV+4sSJMxwVAGD1LBJbx5NcsuX44mxcwdrqpiT39IZjSX6S5IrtD9TdR7t7rbvXDhw4sNeZAQBWxiKx9VCSy6vqss0XvV+f5N5ta55I8v4kqao3JHlLkseXOSgAwCrav9uC7j5ZVbckuT/JviR3dvejVXXz5v1HknwmyV1V9f1sPO14a3c/Mzg3AMBK2DW2kqS770ty37ZzR7Z8/VSSv1juaAAAq887yAMADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMWii2quqaqnqsqo5V1W2nWHN1VX23qh6tqn9Z7pgAAKtp/24LqmpfktuT/HmS40keqqp7u/uHW9a8JskXk1zT3U9U1euH5gUAWCmLXNm6Ksmx7n68u59LcneSQ9vWfDjJPd39RJJ099PLHRMAYDUtElsXJXlyy/HxzXNbvTnJa6vq21X1cFXduNMDVdXhqlqvqvUTJ07sbWIAgBWySGzVDud62/H+JO9I8pdJPpDkb6vqzb/xTd1Hu3utu9cOHDhwxsMCAKyaXV+zlY0rWZdsOb44yVM7rHmmu59N8mxVPZDkyiQ/XsqUAAArapErWw8lubyqLquqC5Jcn+TebWu+nuS9VbW/ql6e5F1JfrTcUQEAVs+uV7a6+2RV3ZLk/iT7ktzZ3Y9W1c2b9x/p7h9V1beSPJLkhSR3dPcPJgcHAFgF1b395Vdnx9raWq+vr5+Tnw0AcCaq6uHuXtvL93oHeQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABi0UW1V1TVU9VlXHquq206x7Z1U9X1UfWt6IAACra9fYqqp9SW5Pcm2Sg0luqKqDp1j32ST3L3tIAIBVtciVrauSHOvux7v7uSR3Jzm0w7pPJPlqkqeXOB8AwEpbJLYuSvLkluPjm+d+raouSvLBJEdO90BVdbiq1qtq/cSJE2c6KwDAylkktmqHc73t+HNJbu3u50/3QN19tLvXunvtwIEDC44IALC69i+w5niSS7YcX5zkqW1r1pLcXVVJcmGS66rqZHd/bRlDAgCsqkVi66Ekl1fVZUn+O8n1ST68dUF3X/b/X1fVXUn+UWgBACwQW919sqpuycZfGe5Lcmd3P1pVN2/ef9rXaQEA/DZb5MpWuvu+JPdtO7djZHX3X734sQAAXhq8gzwAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIPEFgDAILEFADBIbAEADBJbAACDxBYAwCCxBQAwSGwBAAwSWwAAg8QWAMAgsQUAMEhsAQAMElsAAIMWiq2quqaqHquqY1V12w73f6SqHtm8faeqrlz+qAAAq2fX2KqqfUluT3JtkoNJbqiqg9uW/STJn3b325J8JsnRZQ8KALCKFrmydVWSY939eHc/l+TuJIe2Luju73T3LzYPH0xy8XLHBABYTYvE1kVJntxyfHzz3Kl8LMk3X8xQAAAvFfsXWFM7nOsdF1a9Lxux9Z5T3H84yeEkufTSSxccEQBgdS1yZet4kku2HF+c5Knti6rqbUnuSHKou3+20wN199HuXuvutQMHDuxlXgCAlbJIbD2U5PKquqyqLkhyfZJ7ty6oqkuT3JPko9394+WPCQCwmnZ9GrG7T1bVLUnuT7IvyZ3d/WhV3bx5/5Ekn0ryuiRfrKokOdnda3NjAwCshure8eVX49bW1np9ff2c/GwAgDNRVQ/v9UKSd5AHABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGCQ2AIAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYJDYAgAYJLYAAAaJLQCAQWILAGDQQrFVVddU1WNVdayqbtvh/qqqz2/e/0hVvX35owIArJ5dY6uq9iW5Pcm1SQ4muaGqDm5bdm2Syzdvh5N8aclzAgCspEWubF2V5Fh3P97dzyW5O8mhbWsOJflyb3gwyWuq6o1LnhUAYOUsElsXJXlyy/HxzXNnugYA4LfO/gXW1A7neg9rUlWHs/E0Y5L8b1X9YIGfz/npwiTPnOsh2BN7t9rs32qzf6vrLXv9xkVi63iSS7YcX5zkqT2sSXcfTXI0SapqvbvXzmhazhv2b3XZu9Vm/1ab/VtdVbW+1+9d5GnEh5JcXlWXVdUFSa5Pcu+2NfcmuXHzrxLfneSX3f3TvQ4FAPBSseuVre4+WVW3JLk/yb4kd3b3o1V18+b9R5Lcl+S6JMeS/CrJTXMjAwCsjkWeRkx335eNoNp67siWrzvJx8/wZx89w/WcX+zf6rJ3q83+rTb7t7r2vHe10UkAAEzwcT0AAIPGY8tH/ayuBfbuI5t79khVfaeqrjwXc7Kz3fZvy7p3VtXzVfWhszkfp7fI/lXV1VX13ap6tKr+5WzPyM4W+Lfz1VX1jar63ubeeZ3zeaKq7qyqp0/11lR7bpbuHrtl4wX1/5nkD5JckOR7SQ5uW3Ndkm9m47263p3k3ydnclvq3v1xktdufn2tvTt/bovs35Z1/5yN12R+6FzP7bb4/iV5TZIfJrl08/j153put4X37m+SfHbz6wNJfp7kgnM9u1snyZ8keXuSH5zi/j01y/SVLR/1s7p23bvu/k53/2Lz8MFsvL8a54dFfveS5BNJvprk6bM5HLtaZP8+nOSe7n4iSbrbHp4fFtm7TvKqqqokr8xGbJ08u2Oyk+5+IBv7cSp7apbp2PJRP6vrTPflY9mofc4Pu+5fVV2U5INJjoTzzSK/f29O8tqq+nZVPVxVN5616TidRfbuC0nemo03//5+kk929wtnZzxepD01y0Jv/fAiLO2jfjjrFt6XqnpfNmLrPaMTcSYW2b/PJbm1u5/f+A8255FF9m9/knckeX+S303yb1X1YHf/eHo4TmuRvftAku8m+bMkf5jkn6rqX7v7f4Zn48XbU7NMx9bSPuqHs26hfamqtyW5I8m13f2zszQbu1tk/9aS3L0ZWhcmua6qTnb3187KhJzOov92PtPdzyZ5tqoeSHJlErF1bi2ydzcl+bveeBHQsar6SZIrkvzH2RmRF2FPzTL9NKKP+lldu+5dVV2a5J4kH/W/6fPOrvvX3Zd195u6+01J/iHJXwut88Yi/3Z+Pcl7q2p/Vb08ybuS/Ogsz8lvWmTvnsjGFclU1Ruy8QHHj5/VKdmrPTXL6JWt9lE/K2vBvftUktcl+eLm1ZGT7QNWzwsL7h/nqUX2r7t/VFXfSvJIkheS3NHdO/65OmfPgr97n0lyV1V9PxtPS93a3c+cs6H5tar6SpKrk1xYVceTfDrJy5IX1yzeQR4AYJB3kAcAGCS2AAAGiS0AgEFiCwBgkNgCABgktgAABoktAIBBYgsAYND/AfWJF7iuHvcBAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "ename": "NameError", "evalue": "name 'k_list' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mj\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# Looping over k values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mk_value\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mk_list\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# creating KNN Regression model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'k_list' is not defined" ] } ], "source": [ "fig, ax = plt.subplots(figsize=(10,6))\n", "j=0\n", "# Looping over k values\n", "for k_value in k_list: \n", " \n", " # creating KNN Regression model \n", " model = KNeighborsRegressor(n_neighbors=int(___))\n", " \n", " # fitting model \n", " model.fit(___,___)\n", " \n", " # test predictions \n", " y_pred = model.predict(___)\n", " \n", " ## Plotting\n", " colors = ['grey','r','b']\n", " if k_value in [1,10,70]:\n", " xvals = np.linspace(x.min(),x.max(),100)\n", " ypreds = model.predict(xvals)\n", " ax.plot(xvals, ypreds,'-',label = f'k = {int(k_value)}',linewidth=j+2,color = colors[j])\n", " j+=1\n", " \n", "ax.legend(loc='lower right',fontsize=20)\n", "ax.plot(x_train, y_train,'x',label='test',color='k')\n", "ax.set_xlabel('TV budget in $1000',fontsize=20)\n", "ax.set_ylabel('Sales in $1000',fontsize=20)\n", "plt.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the plotting code above, re-run `ax.plot(x_train, y_train,'x',label='test',color='k')` but this time with `x_test` and `y_test`. \n", "\n", "According to you works , which k value is the best. Why?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Your answer here*" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }