machinelearning_notebook/3_kmeans/1-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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 10,
   "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": 10,
     "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": 12,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "list indices must be integers or slices, not Series",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-8ca54c156256>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mdataset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m==\u001b[0m\u001b[1;34m'Iris-setosa'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      7\u001b[0m \u001b[0mdataset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m==\u001b[0m\u001b[1;34m'Iris-versicolor'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mdataset\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m==\u001b[0m\u001b[1;34m'Iris-virginica'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: list indices must be integers or slices, not Series"
     ]
    }
   ],
   "source": [
    "#对类别进行编码，3个类别分别赋值0，1，2\n",
    "\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": 13,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "source": [
    "def originalDatashow(dataSet):\n",
    "    #绘制原始的样本点\n",
    "    num,dim=shape(dataSet)\n",
    "    marksamples=['ob'] #Sample graphic marking\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": 14,
   "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": {},
     "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": 15,
   "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",
    "    # 标志位，如果迭代前后样本分类发生变化值为True，否则为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",
    "            # 获取该簇所有的样本点,nonzero[0]表示A == cent的元素所在的行，如果没有[0],列也会表示\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": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'kMeans' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-16-e15ec3d8a107>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 进行k-means聚类\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mk\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m  \u001b[1;31m# 用户定义聚类数\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mmycentroids\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mclusterAssment\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mkMeans\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdatamat\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'kMeans' is not defined"
     ]
    }
   ],
   "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": [
    "## 利用sklearn进行分类\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": [
    "## 如何确定K\n",
    "\n",
    "利用“肘部观察法”可以粗略地估计相对合理的聚类个数。K-means模型最终期望*所有数据点到其所属的类簇距离的平方和趋于稳定，所以可以通过观察这个值随着K的走势来找出最佳的类簇数量。理想条件下，这个折线在不断下降并且趋于平缓的过程中会有斜率的拐点，这表示从这个拐点对应的K值开始，类簇中心的增加不会过于破坏数据聚类的结构*。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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'),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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}