{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Programming set 1" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#imports\n", "\n", "%matplotlib inline\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import matplotlib.patches as mpatches\n", "import pandas as pd\n", "import scipy.spatial" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.0\n", "\n", "done" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (a)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def generate_a_b(size_each = 10):\n", " two_eye = np.eye(2) #eye ist die Einheitsmatrix\n", "\n", " mean_a = np.array([2/3, 0])\n", " _a = np.random.multivariate_normal(mean_a,two_eye,10)\n", "\n", " mean_b = np.array([0, 2/3])\n", " _b = np.random.multivariate_normal(mean_b,two_eye,10)\n", " return _a, _b" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "a,b = generate_a_b()\n", "\n", "plt.scatter(a[:,0],a[:,1],marker='+',c='orange')\n", "plt.scatter(b[:,0],b[:,1],marker='+',c='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (b)\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Creates sample_size many points around the points in _a and _b each.\n", "\n", "def generate_x(sample_size, _a, _b):\n", " indices = np.random.choice(np.size(_a[:,0]), sample_size*2)\n", " epsilon = np.random.multivariate_normal(np.zeros(2),np.eye(2)/4,sample_size*2)\n", "\n", " _x = np.empty((sample_size*2,np.size(_a[0,:])))\n", "\n", " _x[:sample_size,:] = np.matrix(epsilon[:sample_size,:]) + np.matrix(_a[indices[:sample_size]])\n", " _x[sample_size:,:] = np.matrix(epsilon[sample_size:,:]) + np.matrix(_b[indices[sample_size:]])\n", " \n", " return _x" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# generate our trainings data set.\n", "\n", "x = generate_x(100,a,b)\n", "\n", "plt.scatter(x[:100,0],x[:100,1],marker='+',c='orange')\n", "plt.scatter(x[100:,0],x[100:,1],marker='+',c='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (c)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "#these are the labels for the points aligned to a, b respectively.\n", "\n", "y = np.zeros(200)\n", "y[100:] = 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.2" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# computes the alpha minimizing the LLS function given by the points X_in and the labels Y_in.\n", "\n", "def linear_least_square(X_in, Y_in):\n", " _X = np.matrix(X_in)\n", " _y = np.matrix(Y_in)\n", " alpha = np.linalg.solve(np.dot(_X.T, _X), np.dot(_X.T,_y.T))\n", " return alpha" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# creates the linear function resulting from the vector alpha, which minimizes the LLS.\n", "\n", "def make_minimal_linear_function(X_in, Y_in):\n", " X_hat = np.ones((np.size(Y_in),np.size(X_in[0][:])+1))\n", " X_hat[:,1:] = X_in[:,:]\n", " _alpha = linear_least_square(X_hat, Y_in)\n", " def minimal_linear_function(_x):\n", " return _alpha[0] + np.dot(_alpha[1:,:].T, _x.T)\n", " return minimal_linear_function" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# for a given characterization function, this creates the function, which returns interger labels, by rounding the result.\n", "\n", "def make_label_function(function):\n", " def label_function(_x):\n", " return_val = np.array(np.int_(np.round(function(_x))).flat)\n", " for i in range(np.size(return_val)):\n", " if return_val[i] < 0:\n", " return_val[i] = 0\n", " if return_val[i] > 1:\n", " return_val[i] = 1\n", " return return_val\n", " return label_function" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# plots the contour line for a given function.\n", "\n", "def PlotContourLine(func, value=0, minx = -5, maxx = 5, miny = -5, maxy = 5):\n", " #This plots the contourline func(x) = value\n", " \n", " samplenum = 1000\n", "\n", " xrange = np.arange(minx, maxx, (maxx-minx)/samplenum)\n", " yrange = np.arange(miny, maxy, (maxy-miny)/samplenum)\n", " \n", " #This generates a two-dimensional mesh\n", " X, Y = np.meshgrid(xrange,yrange)\n", " \n", " argsForf = np.array([X.flatten(),Y.flatten()]).T\n", " Z = func(argsForf)\n", " Z = np.reshape(Z,X.shape)\n", " \n", " plt.xlim(minx, maxx)\n", " plt.ylim(miny, maxy)\n", " plt.xlabel(r'$x_1$')\n", " plt.ylabel(r'$x_2$')\n", "\n", " Z = np.where(Z > value, -1, 1)\n", " plt.contourf(X, Y, Z, alpha=value)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "minimal_linear_function = make_minimal_linear_function(x,y)\n", "\n", "PlotContourLine(func=minimal_linear_function,value=.5)\n", "plt.scatter(x[:100,0],x[:100,1],marker='+',c='orange')\n", "plt.scatter(x[100:,0],x[100:,1],marker='+',c='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.3" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# calculates the confusion matrix for the labelling function classifier_function, which classifies points points\n", "# with labels labels.\n", "# The function must return real labels (eg. use make_label_function)\n", "\n", "def confusion_matrix(points, labels, classifier_function):\n", " CM = np.zeros((2,2))\n", " our_labels = classifier_function(points[:,:])\n", " for k in range(np.size(labels)):\n", " label = int(labels[k])\n", " our_label = our_labels[k]\n", " CM[our_label][label] = CM[our_label][label] +1\n", " return CM" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy = 0.92\n", "confusion matrix = \n", "[[91. 7.]\n", " [ 9. 93.]]\n" ] } ], "source": [ "# calculates the confusion matrix for the first data points.\n", "\n", "label_function = make_label_function(minimal_linear_function)\n", "\n", "C = confusion_matrix(x,y,label_function)\n", "accuracy = np.trace(C)/200\n", "print(\"accuracy = \" + str(accuracy))\n", "print(\"confusion matrix = \\n\" + str(C))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.4" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy = 0.904\n", "confusion matrix = \n", "[[9014. 934.]\n", " [ 986. 9066.]]\n" ] } ], "source": [ "# generate our test data set.\n", "\n", "x2 = generate_x(10000,a,b) \n", "y2 = np.zeros(2*10000)\n", "y2[10000:] = 1\n", "C2 = confusion_matrix(x2,y2,label_function)\n", "accuracy2 = np.trace(C2)/20000\n", "print(\"accuracy = \" + str(accuracy2))\n", "print(\"confusion matrix = \\n\" + str(C2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function, we generated on the training points seems to work exteramely well on the test points. The accuracy we get for the test points is about the same, as the one we got on the training points." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.5" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# import iris data set\n", "\n", "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data\"\n", "irisDataFrame = pd.read_csv(url, header = None)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# creates a vector of length length with label one for the plants with name name in the dataFrame\n", "\n", "def generate_label_for(name, dataFrame, length):\n", " _y = np.zeros(length)\n", " for i in range(length):\n", " if(name == dataFrame[4][i]):\n", " _y[i] = 1\n", " return _y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (a)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# get the label vector identifying the Iris setosa plants\n", "y_setosa = generate_label_for(\"Iris-setosa\", irisDataFrame, 150)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# create the vector x from the data frame using the first two dimensions\n", "x_a_1 = irisDataFrame.as_matrix((0,1))\n", "\n", "# get the labelling function labelling Iris setosas against the others in the first two dimensions with LLS\n", "min_lin_setosa_a_1 = make_minimal_linear_function(x_a_1, y_setosa)\n", "\n", "PlotContourLine(func=min_lin_setosa_a_1,value=.5,minx = 0, maxx = 10, miny = 0, maxy = 10)\n", "plt.scatter(x_a_1[50:,0],x_a_1[50:,1],marker='+',c='orange')\n", "plt.scatter(x_a_1[:50,0],x_a_1[:50,1],marker='+',c='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks loke we can almost perfectly seperate the two sets in two dimensions." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy = 1.0\n", "confusion matrix = \n", "[[100. 0.]\n", " [ 0. 50.]]\n" ] } ], "source": [ "# create the vector x from the data frame using all four dimensions\n", "x_a_2 = irisDataFrame.as_matrix((0,1,2,3))\n", "\n", "# get the labelling function labelling Iris setosas against the others in the all four dimensions with LLS\n", "min_lin_setosa_a_2 = make_minimal_linear_function(x_a_2, y_setosa)\n", "label_func_a_2 = make_label_function(min_lin_setosa_a_2)\n", "\n", "C_a_2 = confusion_matrix(x_a_2, y_setosa, label_func_a_2)\n", "accuracy_a_2 = np.trace(C_a_2)/150\n", "print(\"accuracy = \" + str(accuracy_a_2))\n", "print(\"confusion matrix = \\n\" + str(C_a_2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It seems to be possible to keep the Iris setosa apart from the others using the data in all four dimensions." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (b)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# get the label vector identifying the Iris versicolor plants\n", "y_versicolor = generate_label_for(\"Iris-versicolor\", irisDataFrame, 150)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "accuracy = 0.7333333333333333\n", "confusion matrix = \n", "[[86. 26.]\n", " [14. 24.]]\n" ] } ], "source": [ "# create the vector x from the data frame using the first two dimensions\n", "x_b_1 = irisDataFrame.as_matrix((0,1))\n", "\n", "# get the labelling function labelling Iris verticolor against the others in the first two dimensions with LLS\n", "min_lin_setosa_b_1 = make_minimal_linear_function(x_b_1, y_versicolor)\n", "\n", "PlotContourLine(func=min_lin_setosa_b_1,value=.5,minx = 0, maxx = 10, miny = 0, maxy = 10)\n", "plt.scatter(x_b_1[:50 ,0],x_b_1[0:50 ,1],marker='+',c='orange')\n", "plt.scatter(x_b_1[100:,0],x_b_1[100:,1],marker='+',c='orange')\n", "plt.scatter(x_b_1[50:100,0],x_b_1[50:100,1],marker='+',c='blue')\n", "plt.show()\n", "\n", "# create the vector x from the data frame using all four dimensions\n", "x_b_2 = irisDataFrame.as_matrix((0,1,2,3))\n", "# get the labelling function labelling Iris verticolor against the others in the all four dimensions with LLS\n", "min_lin_setosa_b_2 = make_minimal_linear_function(x_b_2, y_versicolor)\n", "\n", "label_func_b_2 = make_label_function(min_lin_setosa_b_2)\n", "\n", "C_b_2 = confusion_matrix(x_b_2, y_versicolor, label_func_b_2)\n", "accuracy_b_2 = np.trace(C_b_2)/150\n", "print(\"accuracy = \" + str(accuracy_b_2))\n", "print(\"confusion matrix = \\n\" + str(C_b_2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is harder to keep a part. My guess would be, that versicolor and virginica are hard to keep apart, by the criteriors we have." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.6" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# this creates the LLS goal function (i.e. the function J from the exercise).\n", "\n", "def make_LLS_value_function(X_in, Y_in):\n", " X_hat = np.ones((np.size(Y_in),np.size(X_in[0][:])+1))\n", " X_hat[:,1:] = X_in[:,:]\n", " def LLS_value_function(_alpha):\n", " alphaxy = np.dot(np.matrix(X_hat), np.matrix(_alpha).T) - np.matrix(Y_in).T\n", " value = np.dot(alphaxy.T, alphaxy)\n", " return np.asscalar(value/np.size(Y_in))\n", " return LLS_value_function" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "# this creates the gradient LLS goal function (i.e. the function grad(J) from the exercise).\n", "\n", "def make_LLS_gradient_function(X_in, Y_in):\n", " X_hat = np.ones((np.size(Y_in),np.size(X_in[0][:])+1))\n", " X_hat[:,1:] = X_in[:,:]\n", " def LLS_gradienet(_alpha):\n", " alphax = np.dot(np.matrix(X_hat), np.matrix(_alpha).T) - np.matrix(Y_in).T\n", " alphaxprod = np.dot(np.matrix(X_hat).T, alphax)\n", " return 2*alphaxprod.T/np.size(Y_in)\n", " return LLS_gradienet" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "# this performes the gradient descent on the LLS goal function, by using its gradient (the function is created with the\n", "# function above)\n", "\n", "# The function returnes the optimal alpha and a list of the goal function values taken on the way there.\n", "\n", "def gradient_descent(X_in, Y_in, maxStep, nu):\n", " # this is the tolerance, whith which we want to terminate.\n", " _epsilon = 10**(-2)\n", " \n", " # we say we terminated, when the gradient is small compared to the alpha value (i.e. when we barely change anymore)\n", " def converged(_grd, _alp):\n", " return (np.abs(_grd)<_epsilon*(np.abs(_alp)+_epsilon)).all()\n", " \n", " # this gives a stop criterior, when we diverged in any direction.\n", " def diverged(_grd):\n", " return (np.isinf(_grd)).any()\n", " \n", " value_func = make_LLS_value_function(X_in, Y_in)\n", " grad_func = make_LLS_gradient_function(X_in, Y_in)\n", " \n", " #initiate alpha and gradient\n", " _alpha = (np.random.random_sample(np.size(X_in[1,:])+1)-.5)*2\n", " _grad = grad_func(_alpha)\n", " step = 0\n", " lls_values = list([value_func(_alpha)])\n", " \n", " #perform the gradient descent\n", " while((not converged(_grad, _alpha)) and (not diverged(_grad)) and (step" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 1 converges with value alpha = [False]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.1 converges with value alpha = [False]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.01 converges with value alpha = [[ 1.12901277 -0.4017871 0.50907538]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.001 converges with value alpha = [[ 0.78757481 -0.38136076 0.58103234]]\n" ] } ], "source": [ "#test for different step size nu\n", "\n", "for nu in [1, .1, .01, .001]:\n", " alp, values = gradient_descent(x_a_1,y_setosa,100000, nu)\n", " plt.scatter(range(np.size(values)),values, marker='+')\n", " plt.show()\n", " print(\"nu = \" + str(nu) + \" converges with value alpha = \" + str(alp.T))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can observe, that the value of the LLS shrink very fast in the first fiew iterations, but dont change a lot later on. The first nu, that converges is: $$\\nu = 10^{-2}$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.7" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# retunrs the normalization of the points X_in\n", "\n", "def normalized(X_in):\n", " means = np.mean(X_in, 0)\n", " std_deviations = np.std(X_in, 0)\n", " X_normed = np.array(X_in)\n", " return ((X_in - means)/std_deviations)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 1 converges with value alpha = [False]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.1 converges with value alpha = [[ 0.33325546 -0.31132866 0.24555415]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.01 converges with value alpha = [[ 0.33255844 -0.3095182 0.24775079]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "nu = 0.001 converges with value alpha = [[ 0.332926 -0.30999713 0.24558931]]\n" ] } ], "source": [ "# test for different step sizes nu on the normalaized data\n", "\n", "x_a_1_normal = normalized(x_a_1)\n", "for nu in [1, .1, .01, .001]:\n", " alp, values = gradient_descent(x_a_1_normal,y_setosa,100000, nu)\n", " plt.scatter(range(np.size(values)),values, marker='+')\n", " plt.show()\n", " print(\"nu = \" + str(nu) + \" converges with value alpha = \" + str(alp.T))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we can see, that we can use a nu, which is by a factor 10 bigger, than in the unnormalized form." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now lets compare the two approaches on the first 100 iterations." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#compare the normalizes against the not normalized gradient descent approach.\n", "\n", "values_first_approach = gradient_descent(x_a_1,y_setosa,100, .01)[1]\n", "values_normalized_approach = gradient_descent(x_a_1_normal,y_setosa,100, .1)[1]\n", "plt.scatter(range(np.size(values_first_approach)),values_first_approach, marker='+', color='blue')\n", "plt.scatter(range(np.size(values_normalized_approach)),values_normalized_approach, marker='+', color='orange')\n", "untouched_data_label = mpatches.Patch(color='blue', label='Untouched data')\n", "normalized_data_label = mpatches.Patch(color='orange', label='Normalized data')\n", "\n", "plt.legend(handles=[untouched_data_label, normalized_data_label])\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see, that the normalize approach converges way faster, than the non normalized one. The fact, that the normalized (orange) curve has less than 100 points, is that it already converged earlyier, such that the last points would all be the same. As the first alpha is genearated randomly, a randomly good/bad choice for one of the two might influence the clearance, with which, we can obeserve this." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.8" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "# returns the k newarest neighbors function for the trainings set X_in with labels Y_in\n", "\n", "def make_k_nearest_neighbor_function(X_in, Y_in, k):\n", " def k_nearest_neighbors(_x):\n", " distances = scipy.spatial.distance.cdist(X_in, _x)\n", " indices = np.argsort(distances.T)\n", " return np.average(Y_in[indices[:,:k]], 1)\n", " return k_nearest_neighbors" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "k = 1\n", "accuracy = 1.0\n", "confusion matrix = \n", "[[100. 0.]\n", " [ 0. 100.]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "k = 15\n", "accuracy = 0.935\n", "confusion matrix = \n", "[[92. 5.]\n", " [ 8. 95.]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "k = 30\n", "accuracy = 0.94\n", "confusion matrix = \n", "[[93. 5.]\n", " [ 7. 95.]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# test the k nearest neighbors function on the trainings set for different k.\n", "\n", "for k in [1, 15, 30]:\n", " # create label function for k nearest neighbors\n", " k_nearest_neighbors_function = make_label_function(make_k_nearest_neighbor_function(x,y,k))\n", " \n", " _confusion = confusion_matrix(x,y,k_nearest_neighbors_function)\n", " _accuracy = np.trace(_confusion)/np.size(y)\n", " print(\"k = \" + str(k))\n", " print(\"accuracy = \" + str(_accuracy))\n", " print(\"confusion matrix = \\n\" + str(_confusion))\n", " PlotContourLine(func=k_nearest_neighbors_function,value=.5)\n", " plt.scatter(x[:100,0],x[:100,1],marker='+',c='orange')\n", " plt.scatter(x[100:,0],x[100:,1],marker='+',c='blue')\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It is not a suprise, that the k nearest neighbor algorithm for k=1 is exact on the training data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1.9" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (a)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "# find the accuracys for k = 1,...200 for on the training data\n", "\n", "accuracys_a = np.zeros(200)\n", "for k in range(np.size(accuracys_a)):\n", " k_nearest_neighbors_function = make_label_function(make_k_nearest_neighbor_function(x,y,k+1))\n", " _confusion = confusion_matrix(x,y,k_nearest_neighbors_function)\n", " accuracys_a[k] = np.trace(_confusion)/np.size(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (b)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "# find the accuracys for k = 1,...200 for on the test data\n", "\n", "accuracys_b = np.zeros(200)\n", "for k in range(np.size(accuracys_b)):\n", " k_nearest_neighbors_function = make_label_function(make_k_nearest_neighbor_function(x,y,k+1))\n", " _confusion = confusion_matrix(x2,y2,k_nearest_neighbors_function)\n", " accuracys_b[k] = np.trace(_confusion)/np.size(y2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### (c)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#plot the accuracy vectors generated in (a) and (b)\n", "\n", "plt.plot(range(np.size(accuracys_a)),accuracys_a, color='blue')\n", "plt.plot(range(np.size(accuracys_b)),accuracys_b, color='orange')\n", "accuracys_a_data_label = mpatches.Patch(color='blue', label='(a)')\n", "accuracys_b_data_label = mpatches.Patch(color='orange', label='(b)')\n", "\n", "plt.legend(handles=[accuracys_a_data_label, accuracys_b_data_label])\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimal k for tests on (b): 13\n", "Optimal accuracy on (b): 0.91695\n" ] } ], "source": [ "print(\"Optimal k for tests on (b): \" + str(np.argmax(accuracys_b)+1))\n", "print(\"Optimal accuracy on (b): \" + str(np.max(accuracys_b)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We observe, that the accuracy on the data taken in (b) first grows, with growing k and then starts to fall. We can also see, that the k nearest neighbors approach achieves better results, than the LLS approach." ] }, { "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.5.2" } }, "nbformat": 4, "nbformat_minor": 2 }