machinelearning_notebook/3_kmeans/k-means.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# k-Means"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 方法\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": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAEICAYAAAB/Dx7IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAFYlJREFUeJzt3X+U3XV95/Hnm0kGCbHQ3bhpgQmD1UUpHIWE1pHanXHctayi5+w5ZW2RHM160vasgkU2qyLUVSmttVTtWntYTVlg1mwOup6CWHUnc/donbJJkF1+RM6hMGQAXbHKj4CdScJ7//je4U5CkrkDc/O9n5nn45x7Zr7f+73f+7qf3Lzudz73znwjM5EkleOYugNIkubH4pakwljcklQYi1uSCmNxS1JhLG5JKozFrY6KiDdExH01Z/hwRHyhzgwvVkRkRLyi7hzqDha3AIiI90bEjoiYiojr53G7iYh40+Guz8xvZ+bp7W7/YkXEYEQ8fFCGP8zM93TqPo+2iLg+Ij5Rdw7VZ1ndAdQ1HgU+AbwZOK7mLIcUEQFEZj5bd5ZDiYhlmbmv7hxa/DziFgCZ+ZXM/CrwDwdfFxGrIuLWiHg8In4SEd+OiGMi4kZgDXBLROyJiE2HuO1zR8CH2z4iXhcR323u//9ExOCs2zci4uqI+FvgGeDlEfHuiNgVEU9FxAMR8TvNbY8Hvg6c1Nz/nog4KSI+GhE3zdrn2yLinub9NSLi1bOum4iIyyPi/0bEExHx3yPiJYcas4h4V0T8bUT8WUT8A/DR5voNzXw/jYhvRMSpzfXR3PZHEfFkRNwVEWfOepzvOWjf3znEfW4ELgI2NR/fLc31/zEiHmmOyX0RMXyozFokMtOLl+cuVEfd1x+07hrgL4HlzcsbqI58ASaANx1hf4PAw7OWD9geOJnqxeJfUx1I/Mvm8sua1zeA3cAvU/2EuBx4C/BLQAD/gqrQzznU/TXXfRS4qfn9Pweebt7PcmATcD/QOyvf/wZOAv4JsAv43cM8tncB+4D3NbMdB7y9ub9XN9d9BPhuc/s3AzuBE5vZXw384qzH+Z6D9v2dWcsJvKL5/fXAJ2ZddzowCZzUXO4Hfqnu55KXzl084lY79gK/CJyamXuzmrdeqD9y807gtsy8LTOfzcxvATuoinzG9Zl5T2bua97/1zLz77Pyv4BvUr2YtOPfAl/LzG9l5l7gU1SF+/pZ23w2Mx/NzJ8AtwCvPcL+Hs3MP29m+xnwu8A1mbkrq2mTPwRe2zzq3gu8FHgV1Qvfrsz8QZu5j2Q/cCxwRkQsz8yJzPz7BdivupTFrXb8CdVR5DebUxMfXMB9nwr8ZnPa4vGIeBz4NaoXihmTs28QEedHxN81p20epyr5VW3e30nAQzMLWc2XT1Id+c/44azvnwFWHmF/kwctnwp8ZtZj+QnV0fXJmbkN+M/A54AfRcR1EfFzbeY+rMy8H3g/1U8WP4qILRFx0ovdr7qXxa05ZeZTmfmBzHw58DbgsllzqPM98j54+0ngxsw8cdbl+Mz8o0PdJiKOBb5MdaS8OjNPBG6jKsd28jxKVa4z+wugD3hkno/jedmaJoHfOejxHJeZ3wXIzM9m5lrgDKppm//QvN3TwIpZ+/mFedwnmfnfMvPXqB5bAn/8wh6OSmBxC6g+EdF8E64H6ImIl0TEsuZ1b42IVzRL7gmqH81nPtnx/4CXz+OuDt7+JuCCiHhzRMzc72BEnHKY2/dSTQs8BuyLiPOBf3XQ/v9pRJxwmNtvBd4SEcMRsRz4ADAFfHcej+FI/hL4UET8MkBEnBARv9n8/tyI+NXm/T4N/COtcbwT+DcRsSKqz2v/uyPcxwFjGBGnR8Qbmy9q/wj8bNZ+tQhZ3JrxEar/8B+kmnf+WXMdwCuB/wnsAcaBv8jMseZ11wAfaU4NXN7G/RywfWZOUr2h92GqMp6kOgo95HMzM58CLqEq4J8Cvw389azrvw98CXigeR8nHXT7+5qP78+BHwMXABdk5nQb2eeUmf+D6mh3S0Q8CdwNnN+8+ueA/9LM/RDVm7B/0rzuz4BpqlL+r8DIEe7mi1Tz2Y9HxFepXsj+qPl4fgj8M+BDC/F41J1mPhkgSSqER9ySVBiLW5IKY3FLUmEsbkkqTEf+yNSqVauyv7+/E7tu29NPP83xxx9fa4Zu4Vi0OBYtjkVLN4zFzp07f5yZL2tn244Ud39/Pzt27OjErtvWaDQYHBysNUO3cCxaHIsWx6KlG8YiIh6ae6uKUyWSVBiLW5IKY3FLUmEsbkkqjMUtSYWxuCWpMBa3JBXG4pakwljcklQYi1uSCmNxS1JhLG5JKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUmLaKOyJ+PyLuiYi7I+JLEfGSTgeT1AGf/CSMjR24bmysWq9izFncEXEycAmwLjPPBHqAd3Q6mKQOOPdcuPDCVnmPjVXL555bby7NS7vnnFwGHBcRe4EVwKOdiySpY4aGYOtWuPBC+s8/H77+9Wp5aKjuZJqHyMy5N4q4FLga+Bnwzcy86BDbbAQ2AqxevXrtli1bFjjq/OzZs4eVK1fWmqFbOBYtjkWlf/Nm+m+8kYmLL2Ziw4a649SuG54XQ0NDOzNzXVsbZ+YRL8DPA9uAlwHLga8C7zzSbdauXZt1GxsbqztC13AsWhyLzNy2LXPVqnzw4oszV62qlpe4bnheADtyjj6eubTz5uSbgAcz87HM3At8BXj9C3hBkVS3mTntrVurI+3mtMnz3rBUV2unuHcDr4uIFRERwDCwq7OxJHXE9u0HzmnPzHlv315vLs3LnG9OZubtEXEzcAewD/gecF2ng0nqgE2bnr9uaMg3JwvT1qdKMvMPgD/ocBZJUhv8zUlJKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUGItbkgpjcUtSYSxuSSqMxS1JhbG4JakwFrckFcbilqTCWNzqHM8o3uJYaAFZ3Ooczyje4lg8z/jkONd8+xrGJ8drzzGye6T2HPPR7lnepfmbdUZxfu/34POfX7pnFHcsDjA+Oc7wDcNM75+mt6eX0fWjDPQN1JZjat8UI5MjteWYL4+41VlDQ1VRffzj1dclWlSAYzFLY6LB9P5p9ud+pvdP05ho1JrjWZ6tNcd8WdzqrLGx6ujyyiurr0v5pLSOxXMG+wfp7emlJ3ro7ellsH+w1hzHcEytOebLqRJ1zqwzij93XsPZy0uJY3GAgb4BRteP0phoMNg/WNv0xEyOzWOb2TC0oYhpErC41UlHOqP4Uisrx+J5BvoGuqIoB/oGmFoz1RVZ2mVxq3M8o3iLY6EF5By3JBXG4pakwljcklQYi1uSCmNxS1JhLG5JKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUGItbi9OhThV2OJ5CTIWxuLU4HXyqsMPxFGIqUFvFHREnRsTNEfH9iNgVEeX8/UMtTbNPFXa48j74b2RLhWj3iPszwN9k5quA1wC7OhdJWiAz5X3BBXDttQded+211XpLWwWa8+9xR8QJwK8D7wLIzGlgurOxpAUyNAQf+xhcfnm1fM45VWlffjl86lOWtorUzokUTgMeA/4qIl4D7AQuzcynO5pMWiiXXVZ9vfxyXnvmmXD33VVpz6yXChOZeeQNItYBfwecl5m3R8RngCcz88qDttsIbARYvXr12i1btnQocnv27NnDypUra83QLRyLymsvuYQT77qLx886izs/+9m649TO50VLN4zF0NDQzsxc19bGmXnEC/ALwMSs5TcAXzvSbdauXZt1GxsbqztC13AsMvNP/zQzIn961lmZEdXyEufzoqUbxgLYkXP08cxlzqmSzPxhRExGxOmZeR8wDNz7Ql9VpKNu1pz2neecw+Add7TmvJ0uUYHaPVnw+4CRiOgFHgDe3blI0gIaG4OrrmrNaTcarbK+6io4+2zfoFRx2iruzLwTaG/uReoWM5/TvuWW55fzZZdVpe3nuFUgf3NSi1M7v1zTzi/pSF3I4tbitH17e0fSM+W9ffvRySUtgHbnuKWybNrU/rZDQ06VqCgecUtSYSxuSSqMxS1JhbG4JakwFrckFcbilqTCWNySVBiLW5IKY3FLUmEsbkkqjMUtHSUjd43Q/+l+jvlPx9D/6X5G7hqpO5IK5d8qkY6CkbtG2HjLRp7Z+wwADz3xEBtv2QjARWddVGe02oxPjtOYaDDYP8hA30DdcYpicUtHwRWjVzxX2jOe2fsMV4xesSSLe3xynOEbhpneP01vTy+j60ct73lwqkQ6CnY/sXte6xe7xkSD6f3T7M/9TO+fpjHRqDtSUSxu6ShYc8Kaea1f7Ab7B+nt6aUneujt6WWwf7DuSEWxuKWj4Orhq1mxfMUB61YsX8HVw1fXlKheA30DjK4f5eNDH3ea5AVwjls6Cmbmsa8YvYLdT+xmzQlruHr46iU5vz1joG/Awn6BLG7pKLnorIuWdFFr4ThVIkmFsbglqTAWtyQVxuKWpMJY3JJUGItbkgpjcUtSYSxuSSqMxS1JhbG4JakwFrckFcbilqTCWNySVBiLW5IK03ZxR0RPRHwvIm7tZKBF4ZOfhLGxA9eNjVXrJelFms8R96XArk4FWVTOPRcuvLBV3mNj1fK559abS9Ki0FZxR8QpwFuAL3Q2ziIxNARbt1ZlfdVV1detW6v1kvQiRWbOvVHEzcA1wEuByzPzrYfYZiOwEWD16tVrt2zZssBR52fPnj2sXLmy1gz9mzfTf+ONTFx8MRMbNtSWoxvGols4Fi2ORUs3jMXQ0NDOzFzX1saZecQL8FbgL5rfDwK3znWbtWvXZt3GxsbqDbBtW+aqVZlXXll93battii1j0UXcSxaHIuWbhgLYEfO0a0zl3amSs4D3hYRE8AW4I0RcdP8X0+WkJk57a1b4WMfa02bHPyGpSS9AHMWd2Z+KDNPycx+4B3Atsx8Z8eTlWz79gPntGfmvLdvrzeXpEXBs7x3wqZNz183NOSbk5IWxLyKOzMbQKMjSSRJbfE3JyWpMBa3JBXG4pakwljcklQYi1uSCmNxS1JhLG5JKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUGItbkgpjcUtSYSxuddz45DjXfPsaxifH644iLQqeSEEdNT45zvANw0zvn6a3p5fR9aMM9A3UHUsqmkfc6qjGRIPp/dPsz/1M75+mMdGoO5JUPItbHTXYP0hvTy890UNvTy+D/YN1R5KK51SJOmqgb4DR9aM0JhoM9g86TSItAItbHTfQN2BhSwvIqRJJKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUGItbkgpjcUtSYSxuSSqMxS1JhbG4JakwFrckFcbilqTCWNySVJg5izsi+iJiLCLujYh7IuLSoxFMknRo7fw97n3ABzLzjoh4KbAzIr6Vmfd2OJsk6RDmPOLOzB9k5h3N758CdgEndzqYFsb45Dgju0c8w7q0iMxrjjsi+oGzgds7EUYLa+YM65sf3MzwDcOWt7RItH3qsohYCXwZeH9mPnmI6zcCGwFWr15No9FYqIwvyJ49e2rPULeR3SNM7ZviWZ5lat8Um8c2M7Vmqu5YtfJ50eJYtJQ2FpGZc28UsRy4FfhGZl471/br1q3LHTt2LEC8F67RaDA4OFhrhrrNHHFP7Zvi2GXHMrp+dMmf+9HnRYtj0dINYxEROzNzXTvbtvOpkgC+COxqp7TVPWbOsL7htA2WtrSItDNVch5wMXBXRNzZXPfhzLytc7G0UAb6BphaM2VpS4vInMWdmd8B4ihkkSS1wd+clKTCWNySVBiLW5IKY3FLUmEsbkkqjMUtSYWxuCWpMBa3JBXG4pakwljcklQYi1uSCmNxS1JhLG5JKozFLUmFsbglqTAWtyQVxuKWpMJY3JJUGItbkgpjcUtSYSxuSSqMxS1JhbG4JakwFrckFcbilqTCWNySVBiLW5IKY3FLUmEsbkkqjMUtSYWxuCWpMBa3JBXG4pakwljcklQYi1uSCtNWcUfEb0TEfRFxf0R8sNOhJEmHN2dxR0QP8DngfOAM4Lci4oxOB3sxxifHGdk9wvjkeN1RJGnBtXPE/SvA/Zn5QGZOA1uAt3c21gs3PjnO8A3DbH5wM8M3DFvekhadZW1sczIwOWv5YeBXD94oIjYCGwFWr15No9FYiHzzNrJ7hKl9UzzLs0ztm2Lz2Gam1kzVkqVb7Nmzp7Z/j27jWLQ4Fi2ljUU7xd2WzLwOuA5g3bp1OTg4uFC7npdjJ49lZLIq72OXHcuGoQ0M9A3UkqVbNBoN6vr36DaORYtj0VLaWLQzVfII0Ddr+ZTmuq400DfA6PpRNpy2gdH1o0u+tCUtPu0ccW8HXhkRp1EV9juA3+5oqhdpoG+AqTVTlrakRWnO4s7MfRHxXuAbQA+wOTPv6XgySdIhtTXHnZm3Abd1OIskqQ3+5qQkFcbilqTCWNySVBiLW5IKY3FLUmEsbkkqjMUtSYWxuCWpMBa3JBXG4pakwljcklQYi1uSCmNxS1JhLG5JKozFLUmFsbglqTCRmQu/04jHgIcWfMfzswr4cc0ZuoVj0eJYtDgWLd0wFqdm5sva2bAjxd0NImJHZq6rO0c3cCxaHIsWx6KltLFwqkSSCmNxS1JhFnNxX1d3gC7iWLQ4Fi2ORUtRY7Fo57glabFazEfckrQoWdySVJhFWdwR8RsRcV9E3B8RH6w7T10ioi8ixiLi3oi4JyIurTtTnSKiJyK+FxG31p2lThFxYkTcHBHfj4hdETFQd6a6RMTvN/9v3B0RX4qIl9SdqR2Lrrgjogf4HHA+cAbwWxFxRr2parMP+EBmngG8Dvj3S3gsAC4FdtUdogt8BvibzHwV8BqW6JhExMnAJcC6zDwT6AHeUW+q9iy64gZ+Bbg/Mx/IzGlgC/D2mjPVIjN/kJl3NL9/iuo/6Mn1pqpHRJwCvAX4Qt1Z6hQRJwC/DnwRIDOnM/PxelPVahlwXEQsA1YAj9acpy2LsbhPBiZnLT/MEi2r2SKiHzgbuL3eJLX5NLAJeLbuIDU7DXgM+KvmtNEXIuL4ukPVITMfAT4F7AZ+ADyRmd+sN1V7FmNx6yARsRL4MvD+zHyy7jxHW0S8FfhRZu6sO0sXWAacA3w+M88GngaW5PtAEfHzVD+NnwacBBwfEe+sN1V7FmNxPwL0zVo+pbluSYqI5VSlPZKZX6k7T03OA94WERNUU2dvjIib6o1Um4eBhzNz5ievm6mKfCl6E/BgZj6WmXuBrwCvrzlTWxZjcW8HXhkRp0VEL9WbDX9dc6ZaRERQzWXuysxr685Tl8z8UGaekpn9VM+HbZlZxJHVQsvMHwKTEXF6c9UwcG+Nkeq0G3hdRKxo/l8ZppA3apfVHWChZea+iHgv8A2qd4k3Z+Y9Nceqy3nAxcBdEXFnc92HM/O2GjOpfu8DRpoHNg8A7645Ty0y8/aIuBm4g+oTWN+jkF9991feJakwi3GqRJIWNYtbkgpjcUtSYSxuSSqMxS1JhbG4JakwFrckFeb/AyaUIWRb0bIhAAAAAElFTkSuQmCC\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": "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\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": 12,
   "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": 12,
     "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",
    "import random\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": 9,
   "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": 10,
   "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": 11,
   "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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def randChosenCent(dataSet,k):\n",
    "    \"\"\"初始化聚类中心：通过在区间范围随机产生的值作为新的中心点\"\"\"\n",
    "\n",
    "    # 样本数\n",
    "    m=shape(dataSet)[0]\n",
    "    # 初始化列表\n",
    "    centroidsIndex=[]\n",
    "    \n",
    "    #生成类似于样本索引的列表\n",
    "    dataIndex=list(range(m))\n",
    "    if False:\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",
    "    else:\n",
    "        random.shuffle(dataIndex)\n",
    "        centroidsIndex = dataIndex[:k]\n",
    "    \n",
    "    #根据索引获取样本\n",
    "    centroids = dataSet.iloc[centroidsIndex]\n",
    "    return mat(centroids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最初的中心= [[6.2 2.2]\n",
      " [6.3 2.5]\n",
      " [7.7 3.8]]\n",
      "the SSE of 1th iteration is 189.420000\n",
      "the SSE of 2th iteration is 70.447978\n",
      "the SSE of 3th iteration is 56.041643\n",
      "the SSE of 4th iteration is 49.785857\n",
      "the SSE of 5th iteration is 45.985699\n",
      "the SSE of 6th iteration is 43.078623\n",
      "the SSE of 7th iteration is 40.594295\n",
      "the SSE of 8th iteration is 37.791783\n",
      "the SSE of 9th iteration is 37.235470\n",
      "the SSE of 10th iteration is 37.201302\n",
      "the SSE of 11th iteration is 37.155048\n",
      "the SSE of 12th iteration is 37.141172\n"
     ]
    }
   ],
   "source": [
    "# 进行k-means聚类\n",
    "k = 3  # 用户定义聚类数\n",
    "mycentroids, clusterAssment = kMeans(datamat, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 9,
   "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": 27,
   "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": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\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": 29,
   "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": 12,
   "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": 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": [
    "%matplotlib inline\n",
    "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": 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": [
    "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(\\\n",
    "            sum(np.min(cdist(X,kmeans.cluster_centers_,'euclidean'),\\\n",
    "                       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
}