SSC_Vidal2013_Wine.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DhW6WxwgtBk1"
   },
   "source": [
    "# Sparse Subspace Clustering (Vidal IEEE Trans. on PAMI 2013) on Wine Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "t2L05ocWW0kh"
   },
   "source": [
    "#### References:\n",
    "\n",
    "\n",
    "1.   Main Paper (Vidal IEEE Trans. on PAMI 2013): https://arxiv.org/pdf/1203.1005.pdf\n",
    "2.   Supplementary Paper (Vidal CVPR 2009): http://cis.jhu.edu/~ehsan/Downloads/SSC-CVPR09-Ehsan.pdf\n",
    "3.   Spectral Clustering: http://people.csail.mit.edu/dsontag/courses/ml14/notes/Luxburg07_tutorial_spectral_clustering.pdf\n",
    "4.   Spectral Clustering Code: https://juanitorduz.github.io/spectral_clustering/\n",
    "5.   Wine Dataset: https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_wine.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RbmYLWex6v0o"
   },
   "source": [
    "Our objective is given a set of points drawn from a `union of subspaces`, we need to find the number of subspaces, their dimensions, a basis for each subspace, and the segmentation of the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XZThPNGr_vd5"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "from cvxpy.atoms.elementwise.power import power"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "t4XgMb2uI9oE"
   },
   "source": [
    "##### Set Parameters of the data space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8rdHJFmv_yev"
   },
   "outputs": [],
   "source": [
    "N = 178 # Total no of points\n",
    "D = 13  # Dimension of space\n",
    "K = 3 # Number of clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "scnY2bC4sG6Q"
   },
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_wine\n",
    "wine_data = load_wine()\n",
    "wine_X = np.asarray(wine_data.data)\n",
    "input_data = wine_X.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WPE1xClxI_W7"
   },
   "source": [
    "The matrix *input_data* contains the data points arranged sequentially forming a matrix of shape $(13, 178), ie. (D,N)$. The *input_data* matrix is of the form $[y[0],y[1], \\ldots, y[N-1]], $where each $y_i$ denotes the vector of a data point of dimension $D$.\n",
    "\n",
    "Also, *input_data* can be assumed to be of the form $[Y_0, Y_1, \\ldots, Y_n]$, where each $Y_i$ denotes the set of $N_i$ data points belonging to subspace $i$. Also assume that the dimension of each subspace $i$ is $d_i$ and $A_i$ is its basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uThqA_EnMbUP"
   },
   "outputs": [],
   "source": [
    "def find_sparse_sol(Y,i,N):\n",
    "    if i == 0:\n",
    "        Ybari = Y[:,1:N]\n",
    "    if i == N-1:\n",
    "        Ybari = Y[:,0:N-1]\n",
    "    if i!=0 and i!=N-1:\n",
    "        Ybari = np.concatenate((Y[:,0:i],Y[:,i+1:N]),axis=1)\n",
    "    yi = Y[:,i].reshape(D,1)\n",
    "    \n",
    "    # this ci will contain the solution of the l1 optimisation problem:  \n",
    "    # min (||yi - Ybari*ci||F)^2 + lambda*||ci||1   st. sum(ci) = 1\n",
    "    \n",
    "    ci = cp.Variable(shape=(N-1,1))\n",
    "    constraint = [cp.sum(ci)==1]\n",
    "    obj = cp.Minimize(power(cp.norm(yi-Ybari@ci,2),2) + 1.957*cp.norm(ci,1)) #lambda = 1.957\n",
    "    prob = cp.Problem(obj, constraint)\n",
    "    prob.solve()\n",
    "    return ci.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r-SZ0G0wKG9v"
   },
   "source": [
    "The above function `find_sparse_sol` finds the solution to the following optimisation problem $(\\textrm{min} \\; ||y_i - Y_{\\hat{i}}c_i||_{F}^2 + \\lambda||c_i||_1)$ subject to the constraint $\\sum_{i=i}^{N}c_i=1$. We use this optimisation term to *deal with all the possible noise values in the data.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "ZwXYwvvC_kHS",
    "outputId": "ad02b727-2dcd-4572-8f48-1af205227902"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(178, 178)\n"
     ]
    }
   ],
   "source": [
    "C = np.concatenate((np.zeros((1,1)),find_sparse_sol(input_data,0,N)),axis=0)\n",
    "\n",
    "for i in range(1,N):\n",
    "    ci = find_sparse_sol(input_data,i,N)\n",
    "    zero_element = np.zeros((1,1))\n",
    "    cif = np.concatenate((ci[0:i,:],zero_element,ci[i:N,:]),axis=0)\n",
    "    C = np.concatenate((C,cif),axis=1)\n",
    "print(C.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "E3cBxKja1e6z"
   },
   "source": [
    "We now include a zero vector of size $(1,1)$ at the $i$ th position of $c_i$ to form $\\hat{c_i}$ which we represent as *cif* in the code.\n",
    "Then we concatenate $[\\hat{c_1}$, $\\hat{c_2}$, ..., $\\hat{c_N}]$ to form the matrix $C$.  \n",
    "\n",
    "$C$ is the *Matrix of Coefficients* and is of the form $C = [\\hat{c_1}, \\hat{c_2}, ..., \\hat{c_N}] \\in \\mathbb{R}^{NXN}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "NlY4sREA2-d9",
    "outputId": "898b3dab-331b-42d6-da6a-9ce62989f1e5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(178, 178)\n"
     ]
    }
   ],
   "source": [
    "W = np.add(np.absolute(C), np.absolute(C.T))\n",
    "print(W.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "PQh2rr72WBrx",
    "outputId": "d19035f6-3f9d-4c11-acb7-c5dc65e8b989"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28954\n"
     ]
    }
   ],
   "source": [
    "# Check sparsity by counting the number of zeros\n",
    "\n",
    "cz = 0\n",
    "for i in range(W.shape[0]):\n",
    "    for j in range(W.shape[1]):\n",
    "        if W[i,j] < 1e-5 and W[i,j] > -1e-5:\n",
    "            cz += 1\n",
    "print(cz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m1L7S6u044O3"
   },
   "source": [
    "In the above code block, we make $C$ a symmetric matrix by the operation $W = |C| + |C^T|$. It is still a valid representation of the similarity since if $y_i$ can write itself as a linear combination of all the points in the same subspace including $y_j$, then $y_j$ can also be represented as a linear combination of all the other points belonging to the same subspace including $c_i$.\n",
    "            In the above code block, we print the number of $0$'s in the matrix $W$, we denote any $|W_{ij}|$ less then $e^{-5}$ as $0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 134
    },
    "colab_type": "code",
    "id": "WJPCzyQB7EZV",
    "outputId": "6ee6a864-68bc-4b77-cf7f-bae9a795e6dc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.77566829 0.         0.         ... 0.         0.         0.        ]\n",
      " [0.         3.0934134  0.         ... 0.         0.         0.        ]\n",
      " [0.         0.         1.26613727 ... 0.         0.         0.        ]\n",
      " ...\n",
      " [0.         0.         0.         ... 4.42537469 0.         0.        ]\n",
      " [0.         0.         0.         ... 0.         1.67255326 0.        ]\n",
      " [0.         0.         0.         ... 0.         0.         2.04561665]]\n"
     ]
    }
   ],
   "source": [
    "D = np.zeros((N,N))\n",
    "sum_list=[]\n",
    "for i in range(N):\n",
    "    csum = np.sum(W[:,i],axis=0)\n",
    "    sum_list.append(csum)\n",
    "\n",
    "D = np.diag(sum_list)\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7W1JwZZF8Ehk"
   },
   "source": [
    "$D$ is the `degree matrix`. In this case, $D \\in \\mathbb{R}^{NxN}$ is a diagonal matrix with $D_{ii} = \\sum_{j}W_{ij}$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "wbjEg6vPtePP",
    "outputId": "cc282f40-1b00-444b-9bf9-bdd768b4e603"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(178, 178)\n"
     ]
    }
   ],
   "source": [
    "L = np.subtract(D, W)\n",
    "LN =  np.diag(np.divide(1, np.sqrt(np.sum(D, axis=0) + np.finfo(float).eps)))@ L @  np.diag(np.divide(1, np.sqrt(np.sum(D, axis=0) + np.finfo(float).eps)))\n",
    "print(LN.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ntR93B89-PVd"
   },
   "source": [
    "This $L$ is the Laplacian matrix, which can be defined as $L = D - W$. Next, we calculate the `eigenvalues` and `eigenvectors` of the Normalized Laplacian matrix $LN$, which we will use for Spectral clustering of the data points. $LN$ is a *positive, semi-definite matrix* this means all the eigenvalues of the matrix will be greater than equal to $0$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "V9-CnwWNXvLl"
   },
   "source": [
    "### Perform Spectral Clustering with Normalized Laplacian Matrix LN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DRb2jMuntrii"
   },
   "outputs": [],
   "source": [
    "from scipy import linalg\n",
    "\n",
    "eigenvals, eigenvcts = linalg.eig(LN)\n",
    "\n",
    "eigenvals = np.real(eigenvals)\n",
    "eigenvcts = np.real(eigenvcts)\n",
    "\n",
    "eig = eigenvals.reshape((N,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q0m-mZwKU3RT"
   },
   "source": [
    "Sort Eigen Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cYP8FqrbJBnQ"
   },
   "outputs": [],
   "source": [
    "eigenvals_sorted_indices = np.argsort(eigenvals)\n",
    "eigenvals_sorted = eigenvals[eigenvals_sorted_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "colab_type": "code",
    "id": "u0QhkBsUun4r",
    "outputId": "1205d65e-dacc-4046-cac3-bd84e2c89f88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "indices = []\n",
    "for i in range(0,K):\n",
    "    ind = []\n",
    "    print(eigenvals_sorted_indices[i])\n",
    "    ind.append(eigenvals_sorted_indices[i])\n",
    "    indices.append(np.asarray(ind))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qFONfvwCzVG-"
   },
   "source": [
    "In the above code, we find out the indices of the eigenvectors corresponding to the $K$ smallest eigenvectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NO2k7fzRzD7u"
   },
   "outputs": [],
   "source": [
    "indices = np.asarray(indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "n4zaFueSviZd"
   },
   "outputs": [],
   "source": [
    "zero_eigenvals_index = np.array(indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7Hvtlq10bWu2"
   },
   "source": [
    "Here, the indices are arranged according to their sorted order of values and the sorted eigen values are stored in *eigenvals_sorted*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 67
    },
    "colab_type": "code",
    "id": "r5LywuQNJS-a",
    "outputId": "f534f149-3f8f-46d2-9b97-e00d15ceb8a4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.74983832e-16],\n",
       "       [2.09684993e-01],\n",
       "       [2.41962607e-01]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eigenvals[zero_eigenvals_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 195
    },
    "colab_type": "code",
    "id": "FFRDm3KxJZRq",
    "outputId": "b1079be1-9842-436c-865f-7a1d8a431d0f"
   },
   "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>v_0</th>\n",
       "      <th>v_1</th>\n",
       "      <th>v_2</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-0.065889</td>\n",
       "      <td>-0.074208</td>\n",
       "      <td>0.094794</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.086966</td>\n",
       "      <td>-0.078291</td>\n",
       "      <td>0.065595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-0.055638</td>\n",
       "      <td>-0.049584</td>\n",
       "      <td>0.022806</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>-0.080217</td>\n",
       "      <td>-0.086148</td>\n",
       "      <td>0.103212</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.050234</td>\n",
       "      <td>-0.009348</td>\n",
       "      <td>0.019664</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        v_0       v_1       v_2\n",
       "0 -0.065889 -0.074208  0.094794\n",
       "1 -0.086966 -0.078291  0.065595\n",
       "2 -0.055638 -0.049584  0.022806\n",
       "3 -0.080217 -0.086148  0.103212\n",
       "4 -0.050234 -0.009348  0.019664"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "proj_df = pd.DataFrame(eigenvcts[:, zero_eigenvals_index.squeeze()])\n",
    "proj_df.columns = ['v_' + str(c) for c in proj_df.columns]\n",
    "proj_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Qri19uQ4dJBN"
   },
   "source": [
    "Stack the Eigen Vectors corresponding to the zero Eigen Values in a dataframe *proj_df*. This can be thought of as a $N X K$ matrix where the columns denote an eigen vector and the rows denote a data point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HVNDq5caWTO9"
   },
   "source": [
    "Apply *K-Means Clustering* with $K = 3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YSsmqs6pJv00"
   },
   "outputs": [],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "\n",
    "def run_k_means(df, n_clusters):\n",
    "    k_means = KMeans(random_state=25, n_clusters=n_clusters)\n",
    "    k_means.fit(df)\n",
    "    cluster = k_means.predict(df)\n",
    "    return cluster\n",
    "\n",
    "cluster = run_k_means(proj_df, n_clusters=K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pPnf2mI1drid"
   },
   "source": [
    "*run_k_means* applies `K-Means Clustering` on *proj_df* with number of clusters = $3$.The clustering of the data points is returned in the variable *'cluster'*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fwOidi1bWjem"
   },
   "source": [
    "Display clusters formed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 101
    },
    "colab_type": "code",
    "id": "jLRKyRkfJ_U5",
    "outputId": "1d73dae5-a9c7-4a72-ad93-173b56deb5db"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 0 0 2 0 0 0 0 0 2 0 0 0 0 2\n",
      " 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(cluster)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QHQACwpQed8s"
   },
   "source": [
    "As we can see, the data points have been clustered into two subspaces: $0$ and $1$ corresponding to the $2$ subspaces that we have considered."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "3smn0NN4Kbk7",
    "outputId": "3ecb5509-1aa4-46d7-8153-aa47f89dda7e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66\n"
     ]
    }
   ],
   "source": [
    "c0 = 0\n",
    "for l in cluster:\n",
    "    if l == 0:\n",
    "        c0 += 1\n",
    "print(c0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "F7f1v-_bofIE",
    "outputId": "554bb746-216e-46ee-8f3f-dd9322d84616"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49\n"
     ]
    }
   ],
   "source": [
    "c1 = 0\n",
    "for l in cluster:\n",
    "    if l == 1:\n",
    "        c1 += 1\n",
    "print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "jvdHX2_lok3p",
    "outputId": "f973ff8e-fdcf-444d-806e-12f2e8310312"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63\n"
     ]
    }
   ],
   "source": [
    "c2 = 0\n",
    "for l in cluster:\n",
    "    if l == 2:\n",
    "        c2 += 1\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "H36SQElze54g"
   },
   "source": [
    "So we find that $68$ data points have been labelled $0$, signifying that they belong to  the $1$st subspace, while $49$ have been labelled $1$ and the remaining $61$ points have been labelled $2$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nU6VYuVgwTBx"
   },
   "outputs": [],
   "source": [
    "orig = wine_data.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Bx0uk4fAwZek"
   },
   "outputs": [],
   "source": [
    "pred = np.asarray(cluster)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bExLkqYQzVHk"
   },
   "source": [
    "### Calculate Performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 50
    },
    "colab_type": "code",
    "id": "tRV6m17FxNr4",
    "outputId": "d66452fa-ccc7-4392-84fe-b3302dc65121"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ARI = 0.912130038265503\n",
      "NMI = 0.8958104668415263\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import adjusted_rand_score\n",
    "from sklearn.metrics import normalized_mutual_info_score\n",
    "print(\"ARI = \" + str(adjusted_rand_score(orig, pred)))\n",
    "print(\"NMI = \" + str(normalized_mutual_info_score(orig, pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rHk42GwL1peN"
   },
   "source": [
    "In the above code block, we calculate the `Adjusted random score` and the `normalized mutual info score` between the `original` and the `predicted` labels for the various data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NGTd6klF1qlb"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "SSC_Vidal2013_Wine.ipynb",
   "provenance": []
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}