machinelearning_notebook/3_kmeans/k-means.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# k-means"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Theory\n",
    "\n",
    "由于具有出色的速度和良好的可扩展性，K-Means聚类算法算得上是最著名的聚类方法。K-Means算法是一个重复移动类中心点的过程，把类的中心点，也称重心（centroids），移动到其包含成员的平均位置，然后重新划分其内部成员。\n",
    "\n",
    "K是算法计算出的超参数，表示类的数量；K-Means可以自动分配样本到不同的类，但是不能决定究竟要分几个类。\n",
    "\n",
    "K必须是一个比训练集样本数小的正整数。有时，类的数量是由问题内容指定的。例如，一个鞋厂有三种新款式，它想知道每种新款式都有哪些潜在客户，于是它调研客户，然后从数据里找出三类。也有一些问题没有指定聚类的数量，最优的聚类数量是不确定的。\n",
    "\n",
    "K-Means的参数是类的重心位置和其内部观测值的位置。与广义线性模型和决策树类似，K-Means参数的最优解也是以成本函数最小化为目标。K-Means成本函数公式如下：\n",
    "$$\n",
    "J = \\sum_{k=1}^{K} \\sum_{i \\in C_k} | x_i - u_k|^2\n",
    "$$\n",
    "\n",
    "$u_k$是第$k$个类的重心位置，定义为：\n",
    "$$\n",
    "u_k = \\frac{1}{|C_k|} \\sum_{x \\in C_k} x\n",
    "$$\n",
    "\n",
    "\n",
    "成本函数是各个类畸变程度（distortions）之和。每个类的畸变程度等于该类重心与其内部成员位置距离的平方和。若类内部的成员彼此间越紧凑则类的畸变程度越小，反之，若类内部的成员彼此间越分散则类的畸变程度越大。\n",
    "\n",
    "求解成本函数最小化的参数就是一个重复配置每个类包含的观测值，并不断移动类重心的过程。\n",
    "1. 首先，类的重心是随机确定的位置。实际上，重心位置等于随机选择的观测值的位置。\n",
    "2. 每次迭代的时候，K-Means会把观测值分配到离它们最近的类，然后把重心移动到该类全部成员位置的平均值那里。\n",
    "3. 若达到最大迭代步数或两次迭代差小于设定的阈值则算法结束，否则重复步骤2。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "% matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "X0 = np.array([7, 5, 7, 3, 4, 1, 0, 2, 8, 6, 5, 3])\n",
    "X1 = np.array([5, 7, 7, 3, 6, 4, 0, 2, 7, 8, 5, 7])\n",
    "plt.figure()\n",
    "plt.axis([-1, 9, -1, 9])\n",
    "plt.grid(True)\n",
    "plt.plot(X0, X1, 'k.');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假设K-Means初始化时，将第一个类的重心设置在第5个样本，第二个类的重心设置在第11个样本.那么我们可以把每个实例与两个重心的距离都计算出来，将其分配到最近的类里面。计算结果如下表所示：\n",
    "![data_0](images/data_0.png)\n",
    "\n",
    "新的重心位置和初始聚类结果如下图所示。第一类用X表示，第二类用点表示。重心位置用稍大的点突出显示。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "C1 = [1, 4, 5, 9, 11]\n",
    "C2 = list(set(range(12)) - set(C1))\n",
    "X0C1, X1C1 = X0[C1], X1[C1]\n",
    "X0C2, X1C2 = X0[C2], X1[C2]\n",
    "plt.figure()\n",
    "plt.title('1st iteration results')\n",
    "plt.axis([-1, 9, -1, 9])\n",
    "plt.grid(True)\n",
    "plt.plot(X0C1, X1C1, 'rx')\n",
    "plt.plot(X0C2, X1C2, 'g.')\n",
    "plt.plot(4,6,'rx',ms=12.0)\n",
    "plt.plot(5,5,'g.',ms=12.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们重新计算两个类的重心，把重心移动到新位置，并重新计算各个样本与新重心的距离，并根据距离远近为样本重新归类。结果如下表所示：\n",
    "\n",
    "![data_1](images/data_1.png)\n",
    "\n",
    "画图结果如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "C1 = [1, 2, 4, 8, 9, 11]\n",
    "C2 = list(set(range(12)) - set(C1))\n",
    "X0C1, X1C1 = X0[C1], X1[C1]\n",
    "X0C2, X1C2 = X0[C2], X1[C2]\n",
    "plt.figure()\n",
    "plt.title('2nd iteration results')\n",
    "plt.axis([-1, 9, -1, 9])\n",
    "plt.grid(True)\n",
    "plt.plot(X0C1, X1C1, 'rx')\n",
    "plt.plot(X0C2, X1C2, 'g.')\n",
    "plt.plot(3.8,6.4,'rx',ms=12.0)\n",
    "plt.plot(4.57,4.14,'g.',ms=12.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们再重复一次上面的做法，把重心移动到新位置，并重新计算各个样本与新重心的距离，并根据距离远近为样本重新归类。结果如下表所示：\n",
    "![data_2](images/data_2.png)\n",
    "\n",
    "画图结果如下：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAEICAYAAAB/Dx7IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAFKhJREFUeJzt3X+Q3HV9x/Hn2wQiIQjaYCwk4VColuqoJagn1d41dgoVdabTMlAM1bTNFKvir+IPpFpptONYC1aLjXKM4FXKANNRC2oNd1U7EUnAiiFqGRJyICi08uNAL4S8+8d+jz3DXW4vt5vvfu6ej5mby+5+9/t9f9/Ze91nP7u3n8hMJEnleErdBUiSZsbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMGttoiIjIjjprjt+oj4kwNd0141jEbEs+usYTYi4oMR8fm661B3MLhFRHw+Iu6JiIci4kcR8Wft3H9mnpqZn6uO9YaI+FY797+3iBje+xwyc0lm3tHJ4x4oEdFT/aJcWHctqofBLYCPAD2Z+TTgtcDfRsSJk21Yd1jUffx96ebaNLcY3CIzt2bm2PjF6us5ABHRFxF3RcS7I+Je4LLq+r+qRuk/joi1+9r/+Ag4In4d+DTQW01dPFDdvigiPhYROyPiJxHx6Yg4ZKrjR8TTI+LLEXFfRPys+vfyavv1wCuAT1bH+GR1/RNTORFxeERcXt3/zoh4f0Q8pbrtDRHxraqen0XE9og4dR/ntqOq7XvAIxGxMCKOiohrqv1vj4i3Ttj+JRGxuXp285OI+PjE85xk36+a5LDfqL4/UJ1jb0QcFxH/GREPRsT9EfGv+/o/UdkMbgEQEf8UEY8CPwDuAa6bcPOzgGcAxwDrIuIU4F3A7wLHA5OFy5Nk5jbgL4BN1dTFEdVNfwf8GvAi4DjgaOCvpzo+jcftZdXllcDPgU9Wxzgf+Cbw5uoYb56klH8EDgeeDfw2cDbwxgm3vxT4IbAU+ChwaUTEPk7tTODVwBHAHuBLwH9X57EaeFtE/F617cXAxdWzm+cAV+1jv1N5ZfX9iOocNwEXAl8Dng4sr85Rc5TBLQAy803AYTRGq9cCYxNu3gN8IDPHMvPnwOnAZZn5/cx8BPjg/h63CsR1wNsz8/8y82Hgw8AZUx0/M/83M6/JzEer7dfTCOBWjreg2vd7M/PhzNwB/D2wZsJmd2bmZzLzceBzwK8Cy/ax209k5kjVm5OAIzPzQ5m5q5pX/8yE83kMOC4ilmbmaGZ+u5W6W/AYjV9kR2XmLzKzo68jqF4Gt56QmY9XP/DLgXMm3HRfZv5iwuWjgJEJl++cxWGPBBYDWyLigWr65CvV9ZMePyIWR8Q/V9McD9GYOjiiCuXpLAUO2qvmO2mMjsfdO/6PzHy0+ueSfexzYi+OAY4aP5fqfN5HM/j/lMazix9ExE0RcVoLNbfiPCCA70TE1ummr1Q2X0zRZBZSzXFX9v4IyXuAFRMur5zBvvfe1/00pjp+IzPvbvE+7wSeC7w0M++NiBcBt9AIrsm23/t446PT26rrVgJTHbsVE483AmzPzOMn3TDzf4Azqzn1PwCujohfAR6h8QsMeOKZwZGT7YNJzi8z7wX+vLrvbwFfj4hvZObt+3E+6nKOuOe5iHhmRJwREUsiYkE1F3smsHEfd7sKeENEnBARi4EPzOCQPwGWR8TBAJm5h8ZUwj9ExDOrmo6eMCc8mcNohP0DEfGMSY7/Exrz109STX9cBayPiMMi4hjgHUC73iP9HeDh6gXLQ6qePj8iTgKIiNdHxJHVeT9Q3WcP8CPgqRHx6og4CHg/sGiKY9xX3eeJc4yIPxp/gRb4GY1w39Omc1KXMbiVNKZF7qLxA/8x4G2Z+cUp75B5PXARcANwe/W9VTcAW4F7I+L+6rp3V/v5djX18XUaI+qpXAQcQmP0/G0aUysTXQz8YfWukE9Mcv+30Bjh3gF8C/gXYGAG5zCl6hfDaTReaN1e1fhZGi+GApwCbI2I0arOM6p5+weBN1Xb3l3VdxeTqKZv1gP/VU3HvIzG3PqN1X6/CJw7V963ricLF1KQpLI44pakwhjcklQYg1uSCmNwS1JhOvI+7qVLl2ZPT08ndt2yRx55hEMPPbTWGrqFvWiyF032oqkberFly5b7M3Oq9+7/ko4Ed09PD5s3b+7Erls2PDxMX19frTV0C3vRZC+a7EVTN/QiIlr+C2SnSiSpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwLQV3RLw9IrZGxPcj4gsR8dROFyapAz76URga+uXrhoYa16sY0wZ3RBwNvBVYlZnPBxYAZ3S6MEkdcNJJcPrpzfAeGmpcPumkeuvSjLS65uRC4JCIeAxYDPy4cyVJ6pj+frjqKjj9dHpOPRWuv75xub+/7so0A5GZ028UcS6wHvg58LXMPGuSbdYB6wCWLVt24pVXXtnmUmdmdHSUJUuW1FpDt7AXTfaioWdggJ4rrmDHmjXsWLu27nJq1w2Pi/7+/i2ZuaqljTNzn1/A04EbgCOBg4B/A16/r/uceOKJWbehoaG6S+ga9qLJXmTmDTdkLl2a29esyVy6tHF5nuuGxwWwOafJ4/GvVl6cfBWwPTPvy8zHgGuBl+/HLxRJdRuf077qqsZIu5o2edILlupqrQT3TuBlEbE4IgJYDWzrbFmSOuKmm355Tnt8zvumm+qtSzMy7YuTmXljRFwN3AzsBm4BNnS6MEkdcN55T76uv98XJwvT0rtKMvMDwAc6XIskqQX+5aQkFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcUjebbKmxqbgE2bxhcEvdbO+lxqbiEmTzisEtdbMJS41NGd4TPmPbT/mbHwxudY4rijfNphf7Cu8SQ7tbHhfdUsd+MLjVOa4o3jTbXkwW3iWGNnTP46Jb6tgfra5xNpMv15zsLrX2olrfMC+4oCvWNyy+F23sZ/G9aGMd3bD+Jm1ec1Laf/39cM45cOGFje8ljQzbrR29mCv97JbzqOroueKKovppcKuzhobgkkvgggsa3+fzorTt6MVc6We3nEdVx441a8rqZ6tD85l8OVXSXWrrxfjT4fGnn3tfrkHRvWhzP4vuRZvrGBoaqv3xiVMl6gquKN40215M9kJkK28V7Ebd8rjoljr2R6sJP5MvR9zdxV40FdmL6UaC+zlSLLIXHdINvcARtzRHtPKWv1JH3tpvBrfUzfZ+Oj+Vkp7ma9YW1l2ApH0477zWt+3vL+btbJodR9ySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCtNScEfEERFxdUT8ICK2RURvpwuTJE2u1RH3xcBXMvN5wAuBbZ0rSWqzglfzliYzbXBHxOHAK4FLATJzV2Y+0OnCpLYpeTVvaRKtfDrgscB9wGUR8UJgC3BuZj7S0cqkdpnwedU9p54K11/f2kelSl0qGgsv7GODiFXAt4GTM/PGiLgYeCgzL9hru3XAOoBly5adeOWVV3ao5NaMjo6yZMmSWmvoFvaioWdggJ4rrmDHmjXsWLu27nJq5+OiqRt60d/fvyUzV7W08XRL5ADPAnZMuPwK4N/3dR+XLusu9iKfWN5r+5o1tS9Y3C18XDR1Qy9o59JlmXkvMBIRz62uWg3cth+/UKR6TFj+a8fatS7zpeK1+q6StwCDEfE94EXAhztXktRmJa/mLU2ipaXLMvO7QGtzL1K3mWz5L5f5UsH8y0lJKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNzSgeCCxU32YtYMbulAcMHiJnsxay19HrekWZqwYDHnnAOXXDJ/Fyy2F7PmiFs6UPr7G0F14YWN7/M5qOzFrBjc0oEyNNQYXV5wQeP7fF7z0l7MisEtHQgTFizmQx+a3wsW24tZM7ilA8EFi5vsxaz54qR0ILhgcZO9mDVH3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMC0Hd0QsiIhbIuLLnSxIkrRvMxlxnwts61Qhc9GmkU185JsfYdPIprpLkTSHtLSQQkQsB14NrAfe0dGK5ohNI5tYfflqdj2+i4MXHMzGszfSu6K37rIkzQGtroBzEXAecNhUG0TEOmAdwLJlyxgeHp51cbMxOjpaaw2DOwcZ2z3GHvYwtnuMgaEBxlaO1VJL3b3oJvaiyV40ldaLaYM7Ik4DfpqZWyKib6rtMnMDsAFg1apV2dc35aYHxPDwMHXWsGhkEYMjg0+MuNf2r61txF13L7qJvWiyF02l9aKVEffJwGsj4veBpwJPi4jPZ+brO1ta2XpX9LLx7I0M7ximr6fPaRJJbTNtcGfme4H3AlQj7ncZ2q3pXdFrYEtqO9/HLUmFafXFSQAycxgY7kglkqSWOOKWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuNVxrnYvtdeMPo9bmilXu5fazxG3Omp4xzC7Ht/F4/k4ux7fxfCO4bpLkopncM9Tg7cO0nNRD0/5m6fQc1EPg7cOduQ4fT19HLzgYBbEAg5ecDB9PX0dOY40nzhVMg8N3jrIui+t49HHHgXgzgfvZN2X1gFw1gvOauuxXO1eaj+Dex46f+P5T4T2uEcfe5TzN57f9uAGV7uX2s2pknlo54M7Z3S9pO5icM9DKw9fOaPrJXUXg3seWr96PYsPWvxL1y0+aDHrV6+vqSJJM2Fwz0NnveAsNrxmA8ccfgxBcMzhx7DhNRs6Mr8tqf18cXKeOusFZxnUUqEccUtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmGmDe6IWBERQxFxW0RsjYhzD0RhkqTJtfIn77uBd2bmzRFxGLAlIv4jM2/rcG2SpElMO+LOzHsy8+bq3w8D24CjO12Y2mPTyCYGdw66wro0h8xojjsieoAXAzd2ohi11/gK6wPbB1h9+WrDW5ojWv50wIhYAlwDvC0zH5rk9nXAOoBly5YxPDzcrhr3y+joaO011G1w5yBju8fYwx7Gdo8xMDTA2MqxusuqlY+LJnvRVFovIjOn3yjiIODLwFcz8+PTbb9q1arcvHlzG8rbf8PDw/T19dVaQ93GR9xju8dYtHARG8/eOO/XfvRx0WQvmrqhFxGxJTNXtbJtK+8qCeBSYFsroa3uMb7C+tpj1xra0hzSylTJycAa4NaI+G513fsy87rOlaV26V3Ry9jKMUNbmkOmDe7M/BYQB6AWSVIL/MtJSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMAa3JBXG4JakwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFcbglqTCGNySVBiDW5IKY3BLUmEMbkkqjMEtSYUxuCWpMC0Fd0ScEhE/jIjbI+I9nS5KkjS1aYM7IhYAnwJOBU4AzoyIEzpd2GxsGtnE4M5BNo1sqrsUSWq7VkbcLwFuz8w7MnMXcCXwus6Wtf82jWxi9eWrGdg+wOrLVxvekuachS1sczQwMuHyXcBL994oItYB6wCWLVvG8PBwO+qbscGdg4ztHmMPexjbPcbA0ABjK8dqqaVbjI6O1vb/0W3sRZO9aCqtF60Ed0sycwOwAWDVqlXZ19fXrl3PyKKRRQyONMJ70cJFrO1fS++K3lpq6RbDw8PU9f/RbexFk71oKq0XrUyV3A2smHB5eXVdV+pd0cvGszey9ti1bDx747wPbUlzTysj7puA4yPiWBqBfQbwxx2tapZ6V/QytnLM0JY0J00b3Jm5OyLeDHwVWAAMZObWjlcmSZpUS3PcmXkdcF2Ha5EktcC/nJSkwhjcklQYg1uSCmNwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpMIY3JJUGINbkgpjcEtSYQxuSSqMwS1JhTG4JakwBrckFSYys/07jbgPuLPtO56ZpcD9NdfQLexFk71oshdN3dCLYzLzyFY27Ehwd4OI2JyZq+quoxvYiyZ70WQvmkrrhVMlklQYg1uSCjOXg3tD3QV0EXvRZC+a7EVTUb2Ys3PckjRXzeURtyTNSQa3JBVmTgZ3RJwSET+MiNsj4j1111OXiFgREUMRcVtEbI2Ic+uuqU4RsSAibomIL9ddS50i4oiIuDoifhAR2yKit+6a6hIRb69+Nr4fEV+IiKfWXVMr5lxwR8QC4FPAqcAJwJkRcUK9VdVmN/DOzDwBeBnwl/O4FwDnAtvqLqILXAx8JTOfB7yQedqTiDgaeCuwKjOfDywAzqi3qtbMueAGXgLcnpl3ZOYu4ErgdTXXVIvMvCczb67+/TCNH9Cj662qHhGxHHg18Nm6a6lTRBwOvBK4FCAzd2XmA/VWVauFwCERsRBYDPy45npaMheD+2hgZMLlu5inYTVRRPQALwZurLeS2lwEnAfsqbuQmh0L3AdcVk0bfTYiDq27qDpk5t3Ax4CdwD3Ag5n5tXqras1cDG7tJSKWANcAb8vMh+qu50CLiNOAn2bmlrpr6QILgd8ELsnMFwOPAPPydaCIeDqNZ+PHAkcBh0bE6+utqjVzMbjvBlZMuLy8um5eioiDaIT2YGZeW3c9NTkZeG1E7KAxdfY7EfH5ekuqzV3AXZk5/szrahpBPh+9Ctiemfdl5mPAtcDLa66pJXMxuG8Cjo+IYyPiYBovNnyx5ppqERFBYy5zW2Z+vO566pKZ783M5ZnZQ+PxcENmFjGyarfMvBcYiYjnVletBm6rsaQ67QReFhGLq5+V1RTyQu3Cugtot8zcHRFvBr5K41XigczcWnNZdTkZWAPcGhHfra57X2ZeV2NNqt9bgMFqYHMH8Maa66lFZt4YEVcDN9N4B9YtFPKn7/7JuyQVZi5OlUjSnGZwS1JhDG5JKozBLUmFMbglqTAGtyQVxuCWpML8P42o419LPfFMAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "C1 = [0, 1, 2, 4, 8, 9, 10, 11]\n",
    "C2 = list(set(range(12)) - set(C1))\n",
    "X0C1, X1C1 = X0[C1], X1[C1]\n",
    "X0C2, X1C2 = X0[C2], X1[C2]\n",
    "plt.figure()\n",
    "plt.title('3rd iteration results')\n",
    "plt.axis([-1, 9, -1, 9])\n",
    "plt.grid(True)\n",
    "plt.plot(X0C1, X1C1, 'rx')\n",
    "plt.plot(X0C2, X1C2, 'g.')\n",
    "plt.plot(5.5,7.0,'rx',ms=12.0)\n",
    "plt.plot(2.2,2.8,'g.',ms=12.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再重复上面的方法就会发现类的重心不变了，K-Means会在条件满足的时候停止重复聚类过程。通常，条件是前后两次迭代的成本函数值的差达到了限定值，或者是前后两次迭代的重心位置变化达到了限定值。如果这些停止条件足够小，K-Means就能找到最优解。不过这个最优解不一定是全局最优解。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "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>sepal-length</th>\n",
       "      <th>sepal-width</th>\n",
       "      <th>petal-length</th>\n",
       "      <th>petal-width</th>\n",
       "      <th>class</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Iris-setosa</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal-length  sepal-width  petal-length  petal-width        class\n",
       "0           5.1          3.5           1.4          0.2  Iris-setosa\n",
       "1           4.9          3.0           1.4          0.2  Iris-setosa\n",
       "2           4.7          3.2           1.3          0.2  Iris-setosa\n",
       "3           4.6          3.1           1.5          0.2  Iris-setosa\n",
       "4           5.0          3.6           1.4          0.2  Iris-setosa"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This line configures matplotlib to show figures embedded in the notebook, \n",
    "# instead of opening a new window for each figure. More about that later. \n",
    "# If you are using an old version of IPython, try using '%pylab inline' instead.\n",
    "%matplotlib inline\n",
    "\n",
    "# import librarys\n",
    "from numpy import *\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "# Load dataset\n",
    "names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']\n",
    "dataset = pd.read_csv(\"iris.csv\", header=0, index_col=0)\n",
    "dataset.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n",
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n",
      "/home/bushuhui/.virtualenv/dl/lib/python3.5/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  after removing the cwd from sys.path.\n"
     ]
    }
   ],
   "source": [
    "#对类别进行编码，3个类别分别赋值0，1，2\n",
    "dataset['class'][dataset['class']=='Iris-setosa']=0\n",
    "dataset['class'][dataset['class']=='Iris-versicolor']=1\n",
    "dataset['class'][dataset['class']=='Iris-virginica']=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "def originalDatashow(dataSet):\n",
    "    #绘制原始的样本点\n",
    "    num,dim=shape(dataSet)\n",
    "    marksamples=['ob'] #样本图形标记\n",
    "    for i in range(num):\n",
    "        plt.plot(datamat.iat[i,0],datamat.iat[i,1],marksamples[0],markersize=5)\n",
    "    plt.title('original dataset')\n",
    "    plt.xlabel('sepal length')\n",
    "    plt.ylabel('sepal width') \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "lines_to_end_of_cell_marker": 2,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#获取样本数据\n",
    "datamat = dataset.loc[:, ['sepal-length', 'sepal-width']]\n",
    "# 真实的标签\n",
    "labels = dataset.loc[:, ['class']]\n",
    "#原始数据显示\n",
    "originalDatashow(datamat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def randChosenCent(dataSet,k):\n",
    "    \"\"\"初始化聚类中心：通过在区间范围随机产生的值作为新的中心点\"\"\"\n",
    "\n",
    "    # 样本数\n",
    "    m=shape(dataSet)[0]\n",
    "    # 初始化列表\n",
    "    centroidsIndex=[]\n",
    "    #生成类似于样本索引的列表\n",
    "    dataIndex=list(range(m))\n",
    "    for i in range(k):\n",
    "        #生成随机数\n",
    "        randIndex=random.randint(0,len(dataIndex))\n",
    "        #将随机产生的样本的索引放入centroidsIndex\n",
    "        centroidsIndex.append(dataIndex[randIndex])\n",
    "        #删除已经被抽中的样本\n",
    "        del dataIndex[randIndex]\n",
    "    #根据索引获取样本\n",
    "    centroids = dataSet.iloc[centroidsIndex]\n",
    "    return mat(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def distEclud(vecA, vecB):\n",
    "    \"\"\"算距离, 两个向量间欧式距离\"\"\"\n",
    "    return sqrt(sum(power(vecA - vecB, 2))) #la.norm(vecA-vecB)\n",
    "\n",
    "\n",
    "def kMeans(dataSet, k):\n",
    "    # 样本总数\n",
    "    m = shape(dataSet)[0]\n",
    "    # 分配样本到最近的簇：存[簇序号,距离的平方] (m行 x 2 列)\n",
    "    clusterAssment = mat(zeros((m, 2)))\n",
    "\n",
    "    # step1: 通过随机产生的样本点初始化聚类中心\n",
    "    centroids = randChosenCent(dataSet, k)\n",
    "    print('最初的中心=', centroids)\n",
    "\n",
    "    # 标志位，如果迭代前后样本分类发生变化值为Tree，否则为False\n",
    "    clusterChanged = True\n",
    "    # 查看迭代次数\n",
    "    iterTime = 0\n",
    "    \n",
    "    # 所有样本分配结果不再改变，迭代终止\n",
    "    while clusterChanged:\n",
    "        clusterChanged = False\n",
    "        \n",
    "        # step2:分配到最近的聚类中心对应的簇中\n",
    "        for i in range(m):\n",
    "            # 初始定义距离为无穷大\n",
    "            minDist = inf;\n",
    "            # 初始化索引值\n",
    "            minIndex = -1\n",
    "            # 计算每个样本与k个中心点距离\n",
    "            for j in range(k):\n",
    "                # 计算第i个样本到第j个中心点的距离\n",
    "                distJI = distEclud(centroids[j, :], dataSet.values[i, :])\n",
    "                # 判断距离是否为最小\n",
    "                if distJI < minDist:\n",
    "                    # 更新获取到最小距离\n",
    "                    minDist = distJI\n",
    "                    # 获取对应的簇序号\n",
    "                    minIndex = j\n",
    "            # 样本上次分配结果跟本次不一样，标志位clusterChanged置True\n",
    "            if clusterAssment[i, 0] != minIndex:\n",
    "                clusterChanged = True\n",
    "            clusterAssment[i, :] = minIndex, minDist ** 2  # 分配样本到最近的簇\n",
    "            \n",
    "        iterTime += 1\n",
    "        sse = sum(clusterAssment[:, 1])\n",
    "        print('the SSE of %d' % iterTime + 'th iteration is %f' % sse)\n",
    "        \n",
    "        # step3:更新聚类中心\n",
    "        for cent in range(k):  # 样本分配结束后，重新计算聚类中心\n",
    "            # 获取该簇所有的样本点\n",
    "            ptsInClust = dataSet.iloc[nonzero(clusterAssment[:, 0].A == cent)[0]]\n",
    "            # 更新聚类中心：axis=0沿列方向求均值。\n",
    "            centroids[cent, :] = mean(ptsInClust, axis=0)\n",
    "    return centroids, clusterAssment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最初的中心= [[6.2 2.8]\n",
      " [6.7 3.1]\n",
      " [5.1 3.8]]\n",
      "the SSE of 1th iteration is 54.890000\n",
      "the SSE of 2th iteration is 37.397339\n",
      "the SSE of 3th iteration is 37.268236\n",
      "the SSE of 4th iteration is 37.201302\n",
      "the SSE of 5th iteration is 37.155048\n",
      "the SSE of 6th iteration is 37.141172\n"
     ]
    }
   ],
   "source": [
    "# 进行k-means聚类\n",
    "k = 3  # 用户定义聚类数\n",
    "mycentroids, clusterAssment = kMeans(datamat, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def datashow(dataSet, k, centroids, clusterAssment):  # 二维空间显示聚类结果\n",
    "    from matplotlib import pyplot as plt\n",
    "    num, dim = shape(dataSet)  # 样本数num ,维数dim\n",
    "\n",
    "    if dim != 2:\n",
    "        print('sorry,the dimension of your dataset is not 2!')\n",
    "        return 1\n",
    "    marksamples = ['or', 'ob', 'og', 'ok', '^r', '^b', '<g']  # 样本图形标记\n",
    "    if k > len(marksamples):\n",
    "        print('sorry,your k is too large,please add length of the marksample!')\n",
    "        return 1\n",
    "        # 绘所有样本\n",
    "    for i in range(num):\n",
    "        markindex = int(clusterAssment[i, 0])  # 矩阵形式转为int值, 簇序号\n",
    "        # 特征维对应坐标轴x,y；样本图形标记及大小\n",
    "        plt.plot(dataSet.iat[i, 0], dataSet.iat[i, 1], marksamples[markindex], markersize=6)\n",
    "\n",
    "    # 绘中心点\n",
    "    markcentroids = ['o', '*', '^']  # 聚类中心图形标记\n",
    "    label = ['0', '1', '2']\n",
    "    c = ['yellow', 'pink', 'red']\n",
    "    for i in range(k):\n",
    "        plt.plot(centroids[i, 0], centroids[i, 1], markcentroids[i], markersize=15, label=label[i], c=c[i])\n",
    "        plt.legend(loc='upper left')\n",
    "    plt.xlabel('sepal length')\n",
    "    plt.ylabel('sepal width')\n",
    "\n",
    "    plt.title('k-means cluster result')  # 标题\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# 画出实际图像\n",
    "def trgartshow(dataSet, k, labels):\n",
    "    from matplotlib import pyplot as plt\n",
    "\n",
    "    num, dim = shape(dataSet)\n",
    "    label = ['0', '1', '2']\n",
    "    marksamples = ['ob', 'or', 'og', 'ok', '^r', '^b', '<g']\n",
    "    # 通过循环的方式，完成分组散点图的绘制\n",
    "    for i in range(num):\n",
    "        plt.plot(datamat.iat[i, 0], datamat.iat[i, 1], marksamples[int(labels.iat[i, 0])], markersize=6)\n",
    "    for i in range(0, num, 50):\n",
    "        plt.plot(datamat.iat[i, 0], datamat.iat[i, 1], marksamples[int(labels.iat[i, 0])], markersize=6,\n",
    "                 label=label[int(labels.iat[i, 0])])\n",
    "    plt.legend(loc='upper left')\n",
    "    \n",
    "    # 添加轴标签和标题\n",
    "    plt.xlabel('sepal length')\n",
    "    plt.ylabel('sepal width')\n",
    "    plt.title('iris true result')  # 标题\n",
    "\n",
    "    # 显示图形\n",
    "    plt.show()\n",
    "    # label=labels.iat[i,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘图显示\n",
    "datashow(datamat, k, mycentroids, clusterAssment)\n",
    "trgartshow(datamat, 3, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to use sklearn to do the classifiction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "import matplotlib.pyplot as plt \n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "# load digital data\n",
    "digits, dig_label = load_digits(return_X_y=True)\n",
    "\n",
    "# draw one digital\n",
    "plt.gray() \n",
    "plt.matshow(digits[0].reshape([8, 8])) \n",
    "plt.show() \n",
    "\n",
    "# calculate train/test data number\n",
    "N = len(digits)\n",
    "N_train = int(N*0.8)\n",
    "N_test = N - N_train\n",
    "\n",
    "# split train/test data\n",
    "x_train = digits[:N_train, :]\n",
    "y_train = dig_label[:N_train]\n",
    "x_test  = digits[N_train:, :]\n",
    "y_test  = dig_label[N_train:]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAA/CAYAAADAByJpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAEHNJREFUeJztnWtsVNUWx/97ZjptZzqtVCqUhxT0+kDN1QZB8CZqfIAaJfpBfMRH1OADTPygxpuguWpEwUdqolGJuQokPquQaCwPTa0GTASjeBUEeRR5SC1tebUzbWdm3w90NmvvdqbnnHmcHrp+yYR1WNNz/nPmnDV7r7P23kJKCYZhGMY7+NwWwDAMw9iDAzfDMIzH4MDNMAzjMThwMwzDeAwO3AzDMB6DAzfDMIzH4MDNMAzjMSwFbiHELCHEViHEdiHEk/kWxTpYB+tgHSerjpwgpcz4AuAHsAPAJABBAJsATB7s73L9Yh2sg3WwDq/ryNVL9H2otAghpgP4j5RyZt/2v/sC/gsZ/ibtTiORiLY9duxYZQcCAc134MABZff29uLw4cMQQqDv+Np7pZTCjg6/369tn3HGGcqOx+Oab8+ePcpOJpNIJBLpdmtJh893oqMzfvx47b2nnnqqdixKS0uLsnt6etDW1qb2Zb7X7vkoLy/XtidOnKgdi/Lnn38qO5FIIBaLpdut7fMxYcIE7b2VlZXK/vvvvzXf/v376XH6nQO7OjJRXFysbHqtALr+rq4u7N69G6FQCABw9OjRnOoYNWqUsquqqjTfH3/8oexkMone3t60+7GrY8SIEdr2uHHjlG3eS9FoVLP379+vrq+Ojg4Ax89ZMplEMpkcVAeNCzU1Ndp7S0tL0+qgn7+rqwt79uxR8SelI4Xd83Haaael3c503wJAe3s7Pe6gOgYiMPhbMBbAHrK9F8A0KztPkQq2ADBlyhTN9+KLLyrbvDgWLVqk7F27dqGpqQlFRUUAkDFYWOGUU07Rtt9++21lmyf6scceU3ZXV5d24p1AL7YFCxZovrvuukvZ5md85ZVXlL1582asXLlSBZTOzs6sNF166aXa9tKlS5W9d+9ezffwww8ru62tTQsYTkgFOQB4/vnnNd+cOXOU/frrr2u+Z599Vtnd3d04duxYVjoyQQPV+++/r/nKysqU3dDQgIULF+Kcc84BADQ2NgI4fg8M1kgaCDMY3XnnncqeO3eu5rvuuuuUfezYMbS0tKgflVRjw44Oet9eddVVmm/x4sXKpj+uAPDLL78ou7GxEcuWLcP06dMBACtWrEBvby/Kyspw6NAhSzpoXHj11Vc130UXXaTscDis+VpbW5W9atUq1NXVYerUqQCAjz76yNKxKfS7uOOOOzTf/PnzlW3+WL/22mva9ocffqhs+iNnByuB2xJCiLkA5g76xjzDOlgH62AdXtcxGFYC9z4AtD8/ru//NKSUSwAsAex1/awSCoUstRTyrcNsAbmlIxKJDInzEQwGLb0v3zpousJNHaNGjbLUGyzEdToUro+qqiqtN5hMJge8hwrxvVhp3eZbR66wErg3APiHEGIijgfsWwHcbucgtCtJu3MAMGnSJGUfOXJE882ePVvZiUQCDQ0NKC8vh9/vx19//WVHAgC960e7+wBwySWXKPvxxx/XfPTCc9LdNbniiiuUfdlll2m+d999V9lnn3225rvpppuUHY/HsXz5clRWViIQCGDXrl22ddAu6JIlSzQfPVdmGuaNN97QdEyfPh0VFRXw+Xxoa2uzrePqq69W9jXXXKP5tm/fruwZM2ZovnPPPVfZUkqsW7fO9rEp9DPT1AgAPPnkiSKEVBokBf3M06ZNQ09PD0KhkEqJCSEcp0poKgDQU2srVqzQfDSn6/f74fP5EIlE4PP50N7ejkAgACFEv2c46aDpxIceekjz0edPmzZt0nznn3++squqqvDEE0+ocxKLxVBcXIxYLGb5fNA03g033KD5tm7dquwvvvhC89FnMclkEu3t7di0aZNKt9qFXm8LFy7UfB9//LGy6XUEALfeequ2/fnnnys7b6kSKWVcCDEfwGocfzL7Xynlb46OlgV+vx8VFRWOAkMuMb8UtwgEAhg5ciQOHDiQkx+TbHSUlZXh8OHDrmkAhtb3Ultbi6ampuNP//uCdqERQiAcDqvGkM/nc0VHIBDAjBkz0NDQACml+kEpND6fD2PHjsXOnTsLfux8YCnHLaX8EsCXedYyKCUlJSgpKQGgVxQMV0KhkHqw5+YFGQwG1QOqgwcPuqZjqDBmzBiMGTMGAPDJJ5+4piMYDKpUltmbLSTjx49X1VMffPCBazrKy8tVdYvZS/AaOXs4mQlaNWDmRHfs2JHWZ7bisq0koSkbs/tCKwWWLVum+XJdrfD7778r26wMoMeiKQkA2LJli7adbe/j4osvVraZGrj99hPZsA0bNmg+s4t+4YUXKvurr76yrYOWV5oVGzRVcv/992s+p13edIwcOVLZtJII0FNa+/bpj3jMUkqaxnPSG6LVEc8995zm2717t7LN78FMJdHr45tvvrGtg+aily9frvm+++47ZZvpi9GjR2vb9DukqYFM5ZsU+r10d3drvhdeOFGVvHbtWs1nlvxlGz9oGShNFQH6DzS9HwA9xQLocchpQ4eHvDMMw3gMDtwMwzAegwM3wzCMxyhIjpvmpcwyvrPOOkvZZn0nzV8B/XPedkk9MAL6j9KkoyWnTdMHhpojA2me0UkOk+b1zWHcTz31lLLN3Nhnn32mbWc7WrK6ulrZ5ujI77//XtlmTvenn37StmnJmpMc9/r165Vtno9Zs2YpO/VgOoWZw8wW+jluueUWzUfzsfQ6AvQReoBehubk+qAlkfTzA3oZq3l9pEYnpli1apWy16xZY1sH/czmtAfXXnutss1nD2bumua8rea1KfTBqpmnfuSRR5RNp2kAgHfeeUfbNqdIsAstPTRjAn0WYU5jYY7ENkd4OoFb3AzDMB6DAzfDMIzHKEiqhHazzNIpmrIwux9mGVqmWfmsQI9FZ+ED9FGJZveUdn0B4Omnn1Y2nVDHCeZnampqUjYdzQkA99xzj7ZNR4r99pv9MVF0siuzO0fLlMxZ5sxuJi33dAI9lrkvOgqvublZ8+U6VUJTYOYkRLR7e/PNN2s+M1XS1dWVlY6ZM2em9dFJ2sxRt2YKxywXtAtNXZqTkNF7xExRmGV55vmxyw8//KDst956S/PRY5ujTM3zU19fr2yzrNAKNMX5zDPPaD5aimmWNZvfJ02lOLlvAW5xMwzDeA5LLW4hRDOAowASAOJSyimZ/+LkZsuWLZYnm8on27Ztc20oM6Wurg7FxcWu6xgqHDx40LWh7pT6+noUFRW5rmPdunXw+/2u6+ju7nZdQ66w0+K+Qkp54XAP2ikmTZqkVcS4RU1NTb+J/d3g7rvvxoMPPui2jCHDiBEj+s1T7QYzZ87EjTfe6LYM1NbW9qvWcoOioiLLM1oOZQqS46ar3phfHs0Rm7lUc7WL5uZm9cttdYYzSqahyDS/aQ7vNS/8iooKzJs3D5FIBPfee6/6f6uaaFlbRUWF5qPldOaE7OZCAqWlpbjyyisRCoUc5co2b96sbPNc0+/MzDubZWiJRAItLS1aztwOdIWTCy64QPPRlWfMMkTzeEIIlJaWQgjhqFSSXh9vvvmm5qOf+frrr9d8ZqmclBLRaNRW646+99dff1U2feYB6Hlc8wf722+/1bZjsZhq7TqB3o/mkHn67MF8BmTmf7u7u7FhwwbHrV1axmcuSkCfA5mLG5x++unathBCzZDoJMdNY4ZZmvzpp58q24xj5oyX9FqiJZt2sBq4JYA1ffPTvt03Z60rZPuAMlcsXrwYQggkk0lXZjtLUV9f73r3TwiBL790fQ4yANnPR5ErnE7XmWvMuni3cBIo88FQuT6yxWrg/peUcp8Q4jQAa4UQv0sptZ/3QqwckWptSynTBvBC6FiwYAEqKytx5MgRzJ8/f8B8ZiF03HbbbYhEIujs7OzXQiykjtmzZyMcDiMajfaboKuQOkpKSuDz+SClTFvZUQgdpaWlak1FN3WMHj0agUAAiUSi3wCrQupIPf+QUqYNnMPp+sgFlpqKUsp9ff/+DWAFgKkDvGeJlHJKPnPgqeCYqYVZCB2p3GV5eXnaCfILoSOVzsg0EqsQOlLHz5QqKYSOVM/H7esjpSNTT6wQOlIpqEypkuF03w6V6yMXDNriFkKEAfiklEf77GsAPDvIn2nQbpI5RSoNOuY0nXSq0Xg8rv1yO8lx09XaGxoaNN+ZZ545oF5Ar/+ORqMIh8MIhUIqj1lcXIxAIGA5r0pz3Pfdd5/mo7kzc8VzusJ3Z2cnOjo6EAwGtZyanZVWfv75Z2WbPRi6KKv5w0Dz4Z2dnWhqaoLf73c0nBnQV1qZN2+e5qutrVU2nd4T0KfPjMViWL9+PYqLi9HT04OXX34Z4XAYwWDQcr13pqHVNF86UG49RTQaRTAYdLziDaAvJkunAwD08QbmCkkvvfSSsuPxuPbcxgl0MV863BvQr0Xz2QsdfyGlzLjavBXo+b788ss1H109afLkyZqP5p3j8Th6enqy+l7ofWuuCLRx40Zlm3Xr5sLkFPrjbuf+sZIqGQVgRd/FGQDwvpTSWUY9C6LR6JDIGx46dEg9fEkkEggEAtrDtULR2tqKlStXAjjxhbuR625tbXW0bFqu6ejowHvvvQfg+PmgiwgUkra2NtdXAwKGTk55qBCLxRw19oYqVpYu2wngnwXQkpFIJKJVN+R6cQOrVFdXa5PX0HUxC0lNTY02EZI5oqyQOmhvxelIsGyprq7GAw88oLbT5fzzzbhx47QWlltL7eViIqNc4PaD8xRlZWVaj96sBPIaBWkq0haI2a2i3TuzNM7svme74gntiphdnaVLlyrbXG7KLHeiq6PQhxxWuzq0G37eeedpvjlz5ijbbLmZZYp00VHa6rfasqCpAXM4PV381Nzfo48+qm1v27bN0vHSQXtSZgkk7ZKb0yWY76X7od3mH3/80bYm88amvQpz9RPze3JSfke773QKAJquAPRUiamDlnfmAhp0zdV16PlpbGzUfLleA5Xe9+Yi33RGxLq6Os23evVqbTvbYE3vdfOaX7RokbKrqqo0n1ny9/XXXyvb6bniIe8MwzAegwM3wzCMx+DAzTAM4zFErvNRACCEaAXQCcDZEsY6Iy3sZ4KUssr8T9YxpHXstrgP1sE6TgYdVrQMqGNApJR5eQHYOBT2wzqGpg7eB+9jOO0jl/uRUnKqhGEYxmtw4GYYhvEY+QzcuZpBMNv9sI7c/n0u98P74H0Ml33kcj/5eTjJMAzD5A9OlTAMw3iMvARuIcQsIcRWIcR2IcSTWeynWQjxPyHEz0KIjYP/BetgHayDdZxcOgYkV+UppOTFD2AHgEkAggA2AZjscF/NAEayDtbBOljHcNSR7pWPFvdUANullDullD0APgTgxhR6rIN1sA7W4XUdA5KPwD0WwB6yvbfv/5yQWuvyx74lhVgH62AdrGM46RiQwq8AYI9B17pkHayDdbCO4aYjHy3ufQDGk+1xff9nG2lhrUvWwTpYB+s4iXWk3WlOXzjeit8JYCJOJPXPc7CfMIAIsdcDmMU6WAfrYB3DRUe6V85TJVLKuBBiPoDVOP5k9r9SSifrWWW11iXrYB2sg3V4XUc6eOQkwzCMx+CRkwzDMB6DAzfDMIzH4MDNMAzjMThwMwzDeAwO3AzDMB6DAzfDMIzH4MDNMAzjMThwMwzDeIz/A3IZWsVEJuJMAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# do kmeans\n",
    "kmeans = KMeans(n_clusters=10, random_state=0).fit(x_train)\n",
    "\n",
    "# kmeans.labels_ - output label\n",
    "# kmeans.cluster_centers_ - cluster centers\n",
    "\n",
    "# draw cluster centers\n",
    "fig, axes = plt.subplots(nrows=1, ncols=10)\n",
    "for i in range(10):\n",
    "    img = kmeans.cluster_centers_[i].reshape(8, 8)\n",
    "    axes[i].imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exerciese - How to caluate the accuracy?\n",
    "\n",
    "1. How to match cluster label to groundtruth label\n",
    "2. How to solve the uncertainty of some digital"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估聚类性能\n",
    "\n",
    "方法1： 如果被用来评估的数据本身带有正确的类别信息，则利用Adjusted Rand Index(ARI)，ARI与分类问题中计算准确性的方法类似，兼顾了类簇无法和分类标记一一对应的问题。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ari_train = 0.687021\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import adjusted_rand_score\n",
    "\n",
    "ari_train = adjusted_rand_score(y_train, kmeans.labels_)\n",
    "print(\"ari_train = %f\" % ari_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given the contingency table:\n",
    "![ARI_ct](images/ARI_ct.png)\n",
    "\n",
    "the adjusted index is:\n",
    "![ARI_define](images/ARI_define.png)\n",
    "\n",
    "* [ARI reference](https://davetang.org/muse/2017/09/21/adjusted-rand-index/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "方法2： 如果被用来评估的数据没有所属类别，则使用轮廓系数(Silhouette Coefficient)来度量聚类结果的质量，评估聚类的效果。轮廓系数同时兼顾了聚类的凝聚都和分离度，取值范围是[-1,1]，轮廓系数越大，表示聚类效果越好。 \n",
    "\n",
    "轮廓系数的具体计算步骤： \n",
    "1. 对于已聚类数据中第i个样本$x_i$，计算$x_i$与其同一类簇内的所有其他样本距离的平均值，记作$a_i$，用于量化簇内的凝聚度 \n",
    "2. 选取$x_i$外的一个簇$b$，计算$x_i$与簇$b$中所有样本的平均距离，遍历所有其他簇，找到最近的这个平均距离，记作$b_i$，用于量化簇之间分离度 \n",
    "3. 对于样本$x_i$，轮廓系数为$sc_i = \\frac{b_i−a_i}{max(b_i,a_i)}$ \n",
    "4. 最后，对所以样本集合$\\mathbf{X}$求出平均值，即为当前聚类结果的整体轮廓系数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.metrics import silhouette_score\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams['figure.figsize']=(10,10)\n",
    "plt.subplot(3,2,1)\n",
    "\n",
    "x1=np.array([1,2,3,1,5,6,5,5,6,7,8,9,7,9])   #初始化原始数据\n",
    "x2=np.array([1,3,2,2,8,6,7,6,7,1,2,1,1,3])\n",
    "X=np.array(list(zip(x1,x2))).reshape(len(x1),2)\n",
    "\n",
    "plt.xlim([0,10])\n",
    "plt.ylim([0,10])\n",
    "plt.title('Instances')\n",
    "plt.scatter(x1,x2)\n",
    "\n",
    "colors=['b','g','r','c','m','y','k','b']\n",
    "markers=['o','s','D','v','^','p','*','+']\n",
    "\n",
    "clusters=[2,3,4,5,8]\n",
    "subplot_counter=1\n",
    "sc_scores=[]\n",
    "for t in clusters:\n",
    "    subplot_counter +=1\n",
    "    plt.subplot(3,2,subplot_counter)\n",
    "    kmeans_model=KMeans(n_clusters=t).fit(X)   #KMeans建模\n",
    "\n",
    "    for i,l in enumerate(kmeans_model.labels_):\n",
    "        plt.plot(x1[i],x2[i],color=colors[l],marker=markers[l],ls='None')\n",
    "\n",
    "    plt.xlim([0,10])\n",
    "    plt.ylim([0,10])\n",
    "\n",
    "    sc_score=silhouette_score(X,kmeans_model.labels_,metric='euclidean')   #计算轮廓系数\n",
    "    sc_scores.append(sc_score)\n",
    "\n",
    "    plt.title('k=%s,silhouette coefficient=%0.03f'%(t,sc_score))\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(clusters,sc_scores,'*-')   #绘制类簇数量与对应轮廓系数关系\n",
    "plt.xlabel('Number of Clusters')\n",
    "plt.ylabel('Silhouette Coefficient Score')\n",
    "\n",
    "plt.show()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to determin the 'k'?\n",
    "\n",
    "利用“肘部观察法”可以粗略地估计相对合理的聚类个数。K-means模型最终期望*所有数据点到其所属的类簇距离的平方和趋于稳定，所以可以通过观察这个值随着K的走势来找出最佳的类簇数量。理想条件下，这个折线在不断下降并且趋于平缓的过程中会有斜率的拐点，这表示从这个拐点对应的K值开始，类簇中心的增加不会过于破坏数据聚类的结构*。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.cluster import KMeans\n",
    "from scipy.spatial.distance import cdist\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "cluster1=np.random.uniform(0.5,1.5,(2,10))\n",
    "cluster2=np.random.uniform(5.5,6.5,(2,10))\n",
    "cluster3=np.random.uniform(3,4,(2,10))\n",
    "\n",
    "X=np.hstack((cluster1,cluster2,cluster3)).T\n",
    "plt.scatter(X[:,0],X[:,1])\n",
    "plt.xlabel('x1')\n",
    "plt.ylabel('x2')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "K=range(1,10)\n",
    "meandistortions=[]\n",
    "\n",
    "for k in K:\n",
    "    kmeans=KMeans(n_clusters=k)\n",
    "    kmeans.fit(X)\n",
    "    meandistortions.append(sum(np.min(cdist(X,kmeans.cluster_centers_,'euclidean'),axis=1))/X.shape[0])\n",
    "\n",
    "plt.plot(K,meandistortions,'bx-')\n",
    "plt.xlabel('k')\n",
    "plt.ylabel('Average Dispersion')\n",
    "plt.title('Selecting k with the Elbow Method')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从上图可见，类簇数量从1降到2再降到3的过程，更改K值让整体聚类结构有很大改变，这意味着新的聚类数量让算法有更大的收敛空间，这样的K值不能反映真实的类簇数量。而当K=3以后再增大K，平均距离的下降速度显著变缓慢，这意味着进一步增加K值不再会有利于算法的收敛，同时也暗示着K=3是相对最佳的类簇数量。"
   ]
  }
 ],
 "metadata": {
  "jupytext_formats": "ipynb,py",
  "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
}