exercise_02_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming assignment 1: k-Nearest Neighbors classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn import datasets, model_selection\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your task\n",
    "In this notebook code to perform k-NN classification is provided. However, some functions are incomplete. Your task is to fill in the missing code and run the entire notebook. \n",
    "\n",
    "You are only allowed to use the imported packages. Importing anything else is NOT allowed. \n",
    "\n",
    "In the beginning of every function there is docstring, which specifies the format of input and output. Write your code in a way that adheres to it.\n",
    "You may only use plain python and `numpy` functions (i.e. no scikit-learn classifiers).\n",
    "\n",
    "In addition, we strongly recommend you to solve this task **without a single for loop**, i.e., only via vectorized (`numpy`) operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "For those of you new to Python, there are lots of tutorials online, just pick whichever you like best :)\n",
    "\n",
    "If you never worked with Numpy or Jupyter before, you can check out these guides\n",
    "* https://docs.scipy.org/doc/numpy-dev/user/quickstart.html\n",
    "* http://jupyter.readthedocs.io/en/latest/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load dataset\n",
    "The iris data set (https://en.wikipedia.org/wiki/Iris_flower_data_set) is loaded and split into train and test parts by the function `load_dataset`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting the results to PDF\n",
    "Once you complete the assignments, export the entire notebook as PDF and attach it to your homework solutions. \n",
    "The best way of doing that is\n",
    "1. Run all the cells of the notebook.\n",
    "2. Export/download the notebook as PDF (File -> Download as -> PDF via LaTeX (.pdf)).\n",
    "3. Concatenate your solutions for other tasks with the output of Step 2. On a Linux machine you can simply use `pdfunite`, there are similar tools for other platforms too. You can only upload a single PDF file to Moodle.\n",
    "\n",
    "Make sure you are using `nbconvert` Version 5.5 or later by running `jupyter nbconvert --version`. Older versions clip lines that exceed page width, which makes your code harder to grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'load_dataset' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-2-399964791c83>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# prepare data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0msplit\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0.75\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_test\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mload_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msplit\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'load_dataset' is not defined"
     ]
    }
   ],
   "source": [
    "# prepare data\n",
    "split = 0.75\n",
    "X_train, X_test, y_train, y_test = load_dataset(split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset(split):\n",
    "    \"\"\"Load and split the dataset into training and test parts.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    split : float in range (0, 1)\n",
    "        Fraction of the data used for training.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    X_train : array, shape (N_train, 4)\n",
    "        Training features.\n",
    "    y_train : array, shape (N_train)\n",
    "        Training labels.\n",
    "    X_test : array, shape (N_test, 4)\n",
    "        Test features.\n",
    "    y_test : array, shape (N_test)\n",
    "        Test labels.\n",
    "    \"\"\"\n",
    "    dataset = datasets.load_iris()\n",
    "    X, y = dataset['data'], dataset['target']\n",
    "    X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=123, test_size=(1 - split))\n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'X_train' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-470f276154d1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m             \u001b[0maxes\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Petal. width'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'center'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mva\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'center'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m24\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m.5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m             \u001b[0maxes\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0my_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcool\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'X_train' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, axes = plt.subplots(4, 4,figsize=(15, 15))\n",
    "for i in range(4):\n",
    "    for j in range(4):\n",
    "        if j == 0 and i == 0:\n",
    "            axes[i,j].text(0.5, 0.5, 'Sepal. length', ha='center', va='center', size=24, alpha=.5)\n",
    "        elif j == 1 and i == 1:\n",
    "            axes[i,j].text(0.5, 0.5, 'Sepal. width', ha='center', va='center', size=24, alpha=.5)\n",
    "        elif j == 2 and i == 2:\n",
    "            axes[i,j].text(0.5, 0.5, 'Petal. length', ha='center', va='center', size=24, alpha=.5)\n",
    "        elif j == 3 and i == 3:\n",
    "            axes[i,j].text(0.5, 0.5, 'Petal. width', ha='center', va='center', size=24, alpha=.5)\n",
    "        else:\n",
    "            axes[i,j].scatter(X_train[:,j],X_train[:,i], c=y_train, cmap=plt.cm.cool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot dataset\n",
    "Since the data has 4 features, 16 scatterplots (4x4) are plotted showing the dependencies between each pair of features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1: Euclidean distance\n",
    "Compute Euclidean distance between two data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean_distance(x1, x2):\n",
    "    \"\"\"Compute pairwise Euclidean distances between two data points.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x1 : array, shape (N, 4)\n",
    "        First set of data points.\n",
    "    x2 : array, shape (M, 4)\n",
    "        Second set of data points.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    distance : float array, shape (N, M)\n",
    "        Pairwise Euclidean distances between x1 and x2.\n",
    "    \"\"\"\n",
    "    # TODO\n",
    "    [N,Ne]=x1.shape\n",
    "    [M,Me]=x2.shape\n",
    "    distance=np.zeros((N,M))\n",
    "    distance=np.sqrt(np.matmul(x1**2,np.ones((Ne,M)))+np.transpose(np.matmul(x2**2,np.ones((Me,N))))-2*np.matmul(x1,np.transpose(x2)))\n",
    "    #print('Euclidean Distance:{}'.format(d))\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2: get k nearest neighbors' labels\n",
    "Get the labels of the *k* nearest neighbors of the datapoint *x_new*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_neighbors_labels(X_train, y_train, X_new, k):\n",
    "    \"\"\"Get the labels of the k nearest neighbors of the datapoints x_new.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X_train : array, shape (N_train, 4)\n",
    "        Training features.\n",
    "    y_train : array, shape (N_train)\n",
    "        Training labels.\n",
    "    X_new : array, shape (M, 4)\n",
    "        Data points for which the neighbors have to be found.\n",
    "    k : int\n",
    "        Number of neighbors to return.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    neighbors_labels : array, shape (M, k)\n",
    "        Array containing the labels of the k nearest neighbors.\n",
    "    \"\"\"\n",
    "    # TODO\n",
    "    [N,Ne]=X_train.shape\n",
    "    [M,Me]=X_new.shape\n",
    "    A=np.zeros((N,M))\n",
    "    A=euclidean_distance(X_train,X_new)\n",
    "    neighbor=np.zeros((k,M))\n",
    "    neighbors_labels=np.zeros((M,k))\n",
    "    '''\n",
    "    for i in range(M):\n",
    "        neighbor=np.argpartition(A[:,i],k)[:k]\n",
    "        for j in range(k):\n",
    "            a=neighbor[j]\n",
    "            neighbors_labels[i,j]=y_train[a]\n",
    "        end\n",
    "    end\n",
    "    '''\n",
    "    neighbor=np.argpartition(A,k,axis=0)[:k,:]\n",
    "    neighbors_labels=np.transpose(y_train[neighbor])\n",
    "    global test_nl,test_n\n",
    "    test_n=neighbor\n",
    "    test_nl=neighbors_labels\n",
    "    return neighbors_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3: get the majority label\n",
    "For the previously computed labels of the *k* nearest neighbors, compute the actual response. I.e. give back the class of the majority of nearest neighbors. In case of a tie, choose the \"lowest\" label (i.e. the order of tie resolutions is 0 > 1 > 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_response(neighbors_labels, num_classes=3):\n",
    "    \"\"\"Predict label given the set of neighbors.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    neighbors_labels : array, shape (M, k)\n",
    "        Array containing the labels of the k nearest neighbors per data point.\n",
    "    num_classes : int\n",
    "        Number of classes in the dataset.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    y : int array, shape (M,)\n",
    "        Majority class among the neighbors.\n",
    "    \"\"\"\n",
    "    # TODO\n",
    "    class_votes = np.zeros(num_classes)\n",
    "    [M,k]=neighbors_labels.shape\n",
    "    y=np.arange(M)\n",
    "    for i in range(M):    \n",
    "        y[i]=np.argmax(np.bincount(neighbors_labels[i,:]))\n",
    "    \n",
    "    #y=np.apply_along_axis(np.bincount,0,neighbors_labels)\n",
    "    global test_y\n",
    "    test_y=y\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4: compute accuracy\n",
    "Compute the accuracy of the generated predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_accuracy(y_pred, y_test):\n",
    "    \"\"\"Compute accuracy of prediction.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    y_pred : array, shape (N_test)\n",
    "        Predicted labels.\n",
    "    y_test : array, shape (N_test)\n",
    "        True labels.\n",
    "    \"\"\"\n",
    "    # TODO\n",
    "    accuracy=np.sum(y_pred==y_test)/len(y_test)\n",
    "    global test_a,test_b\n",
    "    test_a=np.sum(y_pred==y_test)\n",
    "    test_b=len(y_test)\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function is given, nothing to do here.\n",
    "def predict(X_train, y_train, X_test, k):\n",
    "    \"\"\"Generate predictions for all points in the test set.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X_train : array, shape (N_train, 4)\n",
    "        Training features.        \n",
    "    y_train : array, shape (N_train)\n",
    "        Training labels.\n",
    "    X_test : array, shape (N_test, 4)\n",
    "        Test features.\n",
    "    k : int\n",
    "        Number of neighbors to consider.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    y_pred : array, shape (N_test)\n",
    "        Predictions for the test data.\n",
    "    \"\"\"\n",
    "    neighbors = get_neighbors_labels(X_train, y_train, X_test, k)\n",
    "    y_pred = get_response(neighbors)\n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "Should output an accuracy of 0.9473684210526315."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set: 112 samples\n",
      "Test set: 38 samples\n",
      "Accuracy = 0.9473684210526315\n"
     ]
    }
   ],
   "source": [
    "# prepare data\n",
    "split = 0.75\n",
    "X_train, X_test, y_train, y_test = load_dataset(split)\n",
    "print('Training set: {0} samples'.format(X_train.shape[0]))\n",
    "print('Test set: {0} samples'.format(X_test.shape[0]))\n",
    "\n",
    "# generate predictions\n",
    "k = 3\n",
    "y_pred = predict(X_train, y_train, X_test, k)\n",
    "accuracy = compute_accuracy(y_pred, y_test)\n",
    "print('Accuracy = {0}'.format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "207px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "439px",
    "left": "767px",
    "right": "20px",
    "top": "110px",
    "width": "496px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}