{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Lab 3: From binary classification to multiclass classification" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this demo, we cover binary classication through the OLS criterion. we consider both the K class discriminant as well as the one vs one and one vs rest classifiers. For each, we plot the decision bounndary using the meshgrid function from numpy. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Part I. K class discriminant\n", "\n", "The first and less ambiguous approach is to consider a single K classes discriminant. In this case, the first step is to encode the target using a binary representation $t = [0,1,0\\ldots, 0]$ with $t^{(i)}_k = 1$ if $x^{(i)}$ is in class $k$. We can then solve the normal equations." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 2 1 2 0 0 1 2 1 2 0 2 0 1 0 1 2 1 0 2 0 1 1 2 1 2 0 0 1 2]\n" ] } ], "source": [ "from sklearn.datasets import make_blobs\n", "import numpy as np\n", "\n", "\n", "X, y = make_blobs(n_samples=30, centers=3, n_features=2)\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "#plt.scatter(X[:,0], X[:,1], c=)\n", "print(y)\n", "\n", "from sklearn.preprocessing import OneHotEncoder\n", "\n", "enc = OneHotEncoder()\n", "enc.fit(y.reshape(-1,1))\n", "T = enc.transform(y.reshape(-1,1)).toarray()\n", "T = np.array(T)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(30, 3)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.shape(np.array(T))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 0.30111694 1.00905125 -0.3101682 ]\n", " [ 0.06256932 -0.17844449 0.11587516]\n", " [ 0.15731053 -0.01088175 -0.14642878]]\n" ] } ], "source": [ "import numpy as np\n", "from numpy.linalg import inv\n", "\n", "Xtilde = np.hstack((np.ones((np.shape(X)[0],1)), X))\n", "\n", "XX = np.matmul(Xtilde.T, Xtilde)\n", "XT = np.matmul(Xtilde.T, T)\n", "\n", "Beta = np.matmul(inv(XX), XT)\n", "print(Beta)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.scatter(X[:,0], X[:,1], c = y)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(3, 10000)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "\n", "x1min = np.min(X[:,0])\n", "x1max = np.max(X[:,0])\n", "x2min = np.min(X[:,1])\n", "x2max = np.max(X[:,1])\n", "\n", "xx1, xx2 = np.meshgrid(np.linspace(x1min, x1max, 100), np.linspace(x2min, x2max, 100))\n", "\n", "Xpredict = np.vstack((xx1.flatten(), xx2.flatten())).T\n", "\n", "XtildePredict = np.hstack((np.ones((np.shape(Xpredict)[0],1)), Xpredict))\n", "\n", "prediction = np.matmul(Beta.T,XtildePredict.T) \n", "print(np.shape(prediction))\n", "\n", "predictedTargets = np.zeros((len(xx1.flatten()), 1))\n", "\n", "for i in range(len(xx1.flatten())):\n", " \n", " predictedTargets[i] = np.argmax(prediction[:,i])\n", " \n", "\n", " \n", " \n", "plt.scatter(X[:,0], X[:,1], c = y)\n", "plt.contourf(xx1, xx2, np.reshape(predictedTargets,np.shape(xx1)), alpha = .3)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Part II: One vs One\n", "\n", "In this case, we need to learn K(K-1)/2 = 3 classifiers. The classification is then made through a majority vote. Some ambiguity might remain when the maximum number of votes is shared equally among multiple classes. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(01)\n", "(02)\n", "(12)\n" ] } ], "source": [ "# one vs one \n", "\n", "num_classes = max(y)+1\n", "\n", "\n", "from __future__ import division\n", "\n", "\n", "\n", "num_classifiers = int(num_classes*(num_classes-1)/2)\n", "\n", "## generating the grid for the final display\n", "x1min = np.min(X[:,0])\n", "x1max = np.max(X[:,0])\n", "x2min = np.min(X[:,1])\n", "x2max = np.max(X[:,1])\n", "\n", "xx1, xx2 = np.meshgrid(np.linspace(x1min, x1max, 100), np.linspace(x2min, x2max, 100))\n", "\n", "Xpredict = np.vstack((xx1.flatten(), xx2.flatten())).T\n", "Xtilde_predict = np.hstack((np.ones((np.shape(Xpredict)[0],1)), Xpredict))\n", "\n", "\n", "PredictionMatrix = np.zeros((len(xx1.flatten()),num_classifiers))\n", "\n", "counter = 0\n", "\n", "for i in range(num_classes):\n", "\n", " for j in range(num_classes):\n", "\n", " if j> i:\n", "\n", " print('('+str(i)+str(j)+')')\n", "\n", " indices_i = np.squeeze(np.where(y==i))\n", " indices_j = np.squeeze(np.where(y==j))\n", "\n", " points_classi = Xtilde[indices_i,:]\n", " points_classj = Xtilde[indices_j,:]\n", "\n", "\n", " Xtilde_ij = np.vstack((points_classi, points_classj))\n", "\n", " target_i = np.ones((len(indices_i),1))\n", " target_j = np.zeros((len(indices_j),1))\n", "\n", "\n", "\n", " target_ij = np.vstack((target_i, target_j))\n", "\n", " # learning the plane\n", "\n", " XX = np.matmul(Xtilde_ij.T, Xtilde_ij)\n", " XT = np.matmul(Xtilde_ij.T, target_ij)\n", "\n", " beta_ij = np.matmul(inv(XX), XT)\n", "\n", " prediction_ij = np.matmul(XtildePredict, beta_ij)\n", "\n", " target_final_ij = np.zeros((len(prediction_ij),1))\n", " Test_indices_i = np.squeeze(np.where(prediction_ij>0.5)) \n", " target_final_ij[Test_indices_i] = i\n", " Test_indices_j = np.squeeze(np.where(prediction_ij<=0.5)) \n", " target_final_ij[Test_indices_j] = j\n", "\n", " PredictionMatrix[:,counter] = np.squeeze(target_final_ij)\n", "\n", " \n", " counter +=1\n", " " ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1. 2. 2.]\n", " [1. 2. 1.]\n", " [1. 2. 1.]\n", " ...\n", " [0. 0. 1.]\n", " [0. 0. 1.]\n", " [0. 0. 1.]]\n" ] } ], "source": [ "print(PredictionMatrix)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To get the final classification, we now use a majority vote. Relying on the classes stored in 'PredictionMatrix' we count the number of times each sample is classified in a particular class. we then associate the most represented class to each point. In the case of a draw we illustrate the result with a fourth class. " ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "final_class = np.zeros((np.shape(PredictionMatrix)[0],1))\n", "\n", "for i in np.arange(np.shape(PredictionMatrix)[0]):\n", "\n", " count = np.zeros((3,1))\n", " for j in np.arange(3):\n", " tmp1 = np.where(PredictionMatrix[i,:]== j)\n", " numVotesForj = len(tmp1[0])\n", " count[j] = numVotesForj \n", " \n", " maxVotes = np.max(count)\n", " tmp2 = np.where(count == maxVotes)\n", " Is_Vote_ambiguous = len(tmp2[0])>1\n", " \n", " if not Is_Vote_ambiguous:\n", " final_class[i] = np.argmax(count)\n", " else:\n", " final_class[i] = 3\n", " print('decision is ambiguous')" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# displaying the result \n", "\n", "plt.scatter(X[:,0], X[:,1], c = y)\n", "plt.contourf(xx1, xx2, np.reshape(final_class,np.shape(xx1)), alpha = .3)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Part III: One vs rest \n", "\n", "Here we need to compute N-1 classifier for each of the K-1 vs rest classes. The last (i.e. K) class is defined from the points that haven't been put in any of the K-1 previous classes. The only difference with the one vs one classifier lies in the relabelling of the samples at each step. " ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0)\n", "(1)\n" ] } ], "source": [ "# one vs one \n", "\n", "num_classes = max(y)+1\n", "\n", "\n", "from __future__ import division\n", "\n", "\n", "\n", "num_classifiers = int(num_classes*(num_classes-1)/2)\n", "\n", "## generating the grid for the final display\n", "x1min = np.min(X[:,0])\n", "x1max = np.max(X[:,0])\n", "x2min = np.min(X[:,1])\n", "x2max = np.max(X[:,1])\n", "\n", "xx1, xx2 = np.meshgrid(np.linspace(x1min, x1max, 100), np.linspace(x2min, x2max, 100))\n", "\n", "Xpredict = np.vstack((xx1.flatten(), xx2.flatten())).T\n", "Xtilde_predict = np.hstack((np.ones((np.shape(Xpredict)[0],1)), Xpredict))\n", "\n", "\n", "prediction_final = 2*np.ones((len(xx1.flatten()),1))\n", "\n", "\n", "indices_Allclasses = np.zeros((len(xx1.flatten()),num_classes-1))\n", "\n", "\n", "counter = 0\n", "\n", "for i in np.arange(num_classes-1):\n", "\n", " print('('+str(i)+')')\n", "\n", " indices_i = np.squeeze(np.where(y==i))\n", "\n", " indices = np.zeros((len(y),1))\n", " indices[indices_i] = 1\n", " \n", " points_classi = Xtilde[np.where(indices==1)[0],:]\n", " points_rest = Xtilde[np.where(indices==0)[0],:]\n", "\n", " Xtilde_total = np.vstack((points_classi, points_rest))\n", "\n", " target_i = np.ones((len(np.where(indices==1)[0]),1))\n", " target_rest = np.zeros((len(np.where(indices==0)[0]),1))\n", "\n", " target_total = np.vstack((target_i, target_rest))\n", "\n", " # learning the plane\n", "\n", " XX = np.matmul(Xtilde_total.T, Xtilde_total)\n", " XT = np.matmul(Xtilde_total.T, target_total)\n", "\n", " beta_i = np.matmul(inv(XX), XT)\n", "\n", " prediction_i = np.matmul(XtildePredict, beta_i)\n", "\n", " indices_classi = np.where(prediction_i>0.5)[0]\n", " \n", " # checking for possible ambiguity \n", " \n", " indices_Allclasses[indices_classi,i] = 1\n", "\n", " \n", " prediction_final[indices_classi] = i\n" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6241 6339 6340 ... 9937 9938 9939]\n" ] } ], "source": [ "print(ambiguous_indices)" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [], "source": [ "# displaying ambiguous classifications\n", "\n", "ambiguous_indices = np.where(np.sum(indices_Allclasses,axis=1)==2)[0]\n", "prediction_final[ambiguous_indices]=-1" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# displaying the result, and highlighting ambiguities \n", "\n", "plt.scatter(X[:,0], X[:,1], c = y)\n", "plt.contourf(xx1, xx2, np.reshape(prediction_final,np.shape(xx1)), alpha = .3)\n", "plt.show()" ] } ], "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 }