machinelearning_notebook/1_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": 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": [
    "% 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": 5,
   "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": 8,
   "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": 11,
   "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": 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",
    "\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": null,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [],
   "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": null,
   "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": null,
   "metadata": {
    "lines_to_end_of_cell_marker": 2,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#获取样本数据\n",
    "datamat = dataset.loc[:, ['sepal-length', 'sepal-width']]\n",
    "# 真实的标签\n",
    "labels = dataset.loc[:, ['class']]\n",
    "#原始数据显示\n",
    "originalDatashow(datamat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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": 15,
   "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": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最初的中心= [[5.  3.5]\n",
      " [4.9 2.4]\n",
      " [7.1 3. ]]\n",
      "the SSE of 1th iteration is 68.800000\n",
      "the SSE of 2th iteration is 41.374283\n",
      "the SSE of 3th iteration is 38.641949\n",
      "the SSE of 4th iteration is 38.030526\n",
      "the SSE of 5th iteration is 37.513984\n",
      "the SSE of 6th iteration is 37.174201\n",
      "the SSE of 7th iteration is 37.136261\n",
      "the SSE of 8th iteration is 37.123702\n"
     ]
    }
   ],
   "source": [
    "# 进行k-means聚类\n",
    "k = 3  # 用户定义聚类数\n",
    "mycentroids, clusterAssment = kMeans(datamat, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3XucXHV9//HXO7uRuHKrEKsS2IVieUBAblGgWhU2VgUEK1bxt21F8bd1452CVumPWxsVrYoVE92qLZItqFQrIKICar1UMNwhiGJNIKmtMSoXwyXZfH5/nLObze7MnjO7Z86c2Xk/H4957M53znzP55xM5rvnfC8fRQRmZmYA81odgJmZVYcbBTMzG+dGwczMxrlRMDOzcW4UzMxsnBsFMzMb50bB2oKkuyW9aJrX3yvp0yWGVHmS1kpa2uo4rL10tzoAszwiYnHG6++bSb2S1gJvjIjrZvL+diHpPGD/iPjzVsdi1eYrBWt7kpr2x00z6y6jfrNGuVGwtjDxVoik8yRdIWmVpIeA09KyVenrC9LXNkn6raQfSfr9GnVeCuwDXCXpEUnvktQnKSSdLul+4AZJL5K0fpp45kn6G0k/S/f5BUlPrXMcL5K0XtK7Jf0P8M9p+YmSbkvj/YGkZ094z7slbZD0sKR7JfWn5f8i6e8n111jny8F3gu8Jj3O2xs6+dZR3ChYuzoZuALYHRiZ9NrrgN2AvYE9gDcBj06uICL+ArgfeHlE7BwRH5zw8guBA4GX5IjlrcAr0vc8E/gN8Ilptn868FSgFxiUdDjwWeCv0ng/BVwpaSdJBwBvAZ4TEbuk8azNEdO4iLgWeB/w+fQ4D23k/dZZ3ChYu/rPiPj3iNgWEZO/8LeQfLnuHxGjEXFzRDzUYP3nRcTvatRdy5uAsyNifUQ8DpwHvGqaW0PbgHMj4vG0/kHgUxFxYxrvJcDjwNHAKLATcJCk+RGxNiJ+1uCxmOXmRsHa1QPTvHYp8HXgckn/LemDkuYXWP9kvcCX01s/vwXuIfkyn3LLKrUxIh6b9P6/Hnt/WsfewDMj4j7gHSQNzS8lXS7pmQ0ei1lubhSsXdVd3jcitkTE+RFxEPBHwInAXzZYz8Ty3wE9Y08kdQELJ7z+APCyiNh9wmNBRGzIuc8HgOWT3t8TEZelx/OvEfF8ksYjgAtrxUVyW6oeL4dsubhRsDlH0rGSDkm/vB8iuZ20rc7m/wvsl1HlT4AFkk5Irzj+luSWzphPAssl9ab7Xyjp5AZC/ifgTZKOUuIp6b52kXSApOMk7QQ8RtI3MnYstwHHS3qqpKeTXFHU879AnyT/n7dp+QNic9HTSTqhHyK5lfMdkltKtbwf+Nv0ts2ZtTaIiAeBZcCngQ0kf6FPHOXzMeBK4BuSHgZ+CByVN9iIWA38X+Bikk7q+4DT0pd3Aj4A/Ar4H+BpwHvS1y4FbifpeP4G8PlpdvPF9OcmSbfkjc06j5xkx8zMxvhKwczMxrlRMDOzcW4UzMxsXNMbBUldkm6VdHWN106TtDGd3n+bpDc2Ox4zM6uvjMW43k4yAmTXOq9/PiLekreyPffcM/r6+oqIy8ysY9x8882/ioiFWds1ewXIRcAJwHLgjCLq7OvrY/Xq1UVUZWbWMSSty7Nds28fXQS8i/oThwBOkXRHuurl3rU2kDQoabWk1Rs3bmxKoGZm1sRGQdKJwC8j4uZpNrsK6IuIZwPfBC6ptVFEDEfEkohYsnBh5tWPmZnNUDOvFJ4HnJRmtrocOG5svfsxEbEpXVUSktmiRzYxHjMzy9C0PoWIeA/pdPw0t+6Zk1MBSnpGRPwifXoSSYd0w7Zs2cL69et57LHHsjduoQULFrBo0SLmz290wU4zs3KUngpQ0gXA6oi4EnibpJOArcCv2b7eS0PWr1/PLrvsQl9fH5KKC7ZAEcGmTZtYv349++67b6vDMTOrqZTJaxHx7Yg4Mf39nLRBICLeExGLI+LQiDg2In48k/ofe+wx9thjj8o2CACS2GOPPSp/NdNuRkagrw/mzUt+jkzOwWZmDZkzScOr3CCMaYcY28nICAwOwubNyfN165LnAAMDrYvLrJ15mQtrW2efvb1BGLN5c1JuZjPjRqFA1157LQcccAD7778/H/jAB1odzpx3//2NlZtZto5sFJpxH3p0dJQ3v/nNfO1rX2PNmjVcdtllrFmzZvYVW1377NNYuZll67hGYew+9Lp1ELH9PvRsG4abbrqJ/fffn/32248nPelJnHrqqXzlK18pJmirafly6OnZsaynJyk3s5npuEahWfehN2zYwN57b1+lY9GiRWzYUC9vuxVhYACGh6G3F6Tk5/CwO5nNZmPOjD7Ky/eh55aBATcCZkXquCuFZt2H3muvvXjggQfGn69fv5699tprdpWamZWs4xqFZt2Hfs5znsNPf/pTfv7zn/PEE09w+eWXc9JJJ82uUjOzknVco9Cs+9Dd3d1cfPHFvOQlL+HAAw/k1a9+NYsXLy4maDOzknRcnwI07z708ccfz/HHH198xWZmJem4KwUzM6vPjYKZmY1zo2BmZuPcKJiZ2Tg3CmZmNs6NgrWME+SYVY8bhYK84Q1v4GlPexoHH3xwq0NpC81amNDMZqczG4Um/Il62mmnce211866nk7hBDlm1dR5k9ealMPxBS94AWvXrp19fB3CCxOaVVPnXSn4T9RKcIIcs2rqvEbBf6JWghPkmFVT5zUK/hO1Epwgx6yaOq9R8J+olTEwAGvXwrZtyU83CGat13mNQpP+RH3ta1/LMcccw7333suiRYv4zGc+U1DAreE5BGadqfNGH0FT1s6+7LLLCq2vlZo0QMvM2kDnXSlYJg/QMutcbhRsCg/QMutcbhRsCg/QMutcbhRsCg/QMutcbhRsCs8hMOtcnTn6yDI1YYCWmbWBpl8pSOqSdKukq2u8tpOkz0u6T9KNkvqaHU+zPPDAAxx77LEcdNBBLF68mI997GOtDsnwfAuzRpVx++jtwD11Xjsd+E1E7A98FLiwhHgYuXOEvov6mHf+PPou6mPkztl/U3R3d/PhD3+YNWvW8MMf/pBPfOITrFmzpoBobaacs8GscU1tFCQtAk4APl1nk5OBS9LfrwD6JamZMY3cOcLgVYOse3AdQbDuwXUMXjU464bhGc94BkcccQQAu+yyCwceeCAbNmwoImSbIc+3MGtcs68ULgLeBWyr8/pewAMAEbEVeBDYY/JGkgYlrZa0euPGjbMK6Ozrz2bzlh2/KTZv2czZ1xf3TbF27VpuvfVWjjrqqMLqtMZ5voVZ45rWKEg6EfhlRNw827oiYjgilkTEkoULF86qrvsfrP2NUK+8UY888ginnHIKF110EbvuumshddrMeL6FWeOaeaXwPOAkSWuBy4HjJK2atM0GYG8ASd3AbsCmJsbEPrvV/kaoV96ILVu2cMoppzAwMMArX/nKWddns+P5FmaNa1qjEBHviYhFEdEHnArcEBF/PmmzK4HXpb+/Kt0mmhUTwPL+5fTM3/Gbomd+D8v7Z/dNERGcfvrpHHjggZxxxhmzqsuK4fkWZo0rffKapAsknZQ+/Qywh6T7gDOAv2n2/gcOGWD45cP07taLEL279TL88mEGDpndN8X3v/99Lr30Um644QYOO+wwDjvsMK655pqCoraZcs4Gs8aoyX+YF27JkiWxevXqHcruueceDjzwwBZF1Jh2inU2li1L/iofHYWurmQo6IoVrY7KrHNJujkilmRt5xnNVrhly2Dlyu3PR0e3P3fDYFZtXvvICjc83Fi5mVXHnGkU2uE2WDvEWITR0cbKzaw65kSjsGDBAjZt2lTpL92IYNOmTSxYsKDVoTRdV1dj5WZWHXOiT2HRokWsX7+e2c52brYFCxawaNGiVofRdIODO/YpTCw3s2qbE43C/Pnz2XfffVsdhqXGOpM9+sis/cyJRsGqZ8UKNwJm7WhO9CmYmVkx3Ch0oKVLk2Ufxh5Ll7Y6oplzEh2ruiLytzQjB0w9vn3UYZYuheuv37Hs+uuT8uuua01MMzWWRGcsZ8JYEh3wchZWDWP5W8aW6x/L3wLkXlqniDoaMSeWubD8pkth1GYfBfr6koZgst7eZJ0js1bru6iPdQ9O/ZD27tbL2nesLa0OyL/MhW8fWdtyEh2ruiLytzQ7B8xkbhSsbTmJjlVdEflbmpkDphY3Ch2mv7+x8ipzEh2ruiLytzQrB0w9bhQ6zHXXTW0A+vvbr5MZnETHqq+I/C3NygFTjzuazcw6gDuara4ixvZn1eH5A2btyfMUOkwRY/uz6vD8AbP25dtHHaaIsf1ZdXj+gFn1+PaR1VTE2P6sOjx/wKx9uVHoMEWM7c+qw/MHzNqXG4UOU8TY/qw6PH/ArH25UegwRYztz6rD8wfM2pc7ms3MOoA7mlugKmPzqxKHWTOVmWOgk3ieQkGqMja/KnGYNVPZOQY6iW8fFaQqY/OrEodZMxWVY6CT+PZRyaoyNr8qcZg1U9k5BjqJG4WCVGVsflXiMGumsnMMdBI3CgWpytj8qsRh1kxl5xjoJG4UClKVsflVicOsmcrOMdBJ3NFsZtYBWt7RLGmBpJsk3S7pbknn19jmNEkbJd2WPt7YrHg6ybJl0N2dXCl0dyfPJ1q6NHlt7LF06dQ6ypjr4PkUZhUUEU15AAJ2Tn+fD9wIHD1pm9OAixup98gjjwyrb2goAqY+hoaS1/v7a7/e37+9jlWrInp6dny9pycpL0oZ+zCz7YDVkeM7NvP2kaSdgFOAPiZMdouIC/I2PJJ6gO8BQxFx44Ty04AlEfGWvHX59tH0urthdHRqeVcXbN2aXBnUM/ZRKGOug+dTmJWryNtHXwFOBrYCv5vwyBNEl6TbgF8C35zYIExwiqQ7JF0hae869QxKWi1p9caNG/PsumPVahCmK6+ljLkOnk9hVk15lrlYFBEvnUnlETEKHCZpd+DLkg6OiLsmbHIVcFlEPC7pr4BLgONq1DMMDENypTCTWDpFV1f9K4W89tmn9l/xRc51KGMfZta4PFcKP5B0yGx2EhG/Bb4FvHRS+aaIeDx9+mngyNnsx7avc1SvvL+/9usTy8uY6+D5FGbVVLdRkHSnpDuA5wO3SLo3vc0zVj4tSQvTKwQkPRl4MfDjSds8Y8LTk4B7ZnIQtt2KFTA0tP3KoKsreb5iRfL8uuumNgz9/Un5mDLmOng+hVk11e1oltQ73RsjosbF/w7vfzbJ7aAuksbnCxFxgaQLSHrBr5T0fpLGYCvwa5KO6B/XrRR3NJuZzUTejuY8o48ujYi/yCorixsFM7PGFTn6aPGkirvwvf+aipiMlTXxrIg68sQ522Mp4jgqo4B/2DwJYZw0xiqh3gQG4D3AwyS3dh5KHw8Dm4D355kE0YxHVSevFTEZK2viWRF15IlztsdSxHFURgH/sKvuWBU9y3uC8xh/9CzviVV3rGpoG7PZoMDJa++PiPc0tWVqQFVvHxUxGStr4lkRdeSJc7bHUsRxVEYB/7B5EsI4aYw1W97bR3XnKUg6Iv31ixN+HxcRt8wivjmniMlYRUw8y6ojT5yzPZYijqMyCviHzZMQxkljrCqm61P4cPr4BMm6RcPAP6W/f6L5obWXIpLb1Jtg1sjEs6w68sQ522Mp4jgqo4B/2DwJYZw0xqqibqMQEcdGxLHAL4AjImJJRBwJHA5sKCvAdlHEZKysiWdF1JEnztkeSxHHURkF/MPmSQjjpDFWGVmdDsDdecrKelS1ozki6Xvs7Y2Qkp8zWfFzaCiiqyvpz+zqmlnnbFYdeeKc7bEUcRyVUcA/7Ko7VkXvR3tD5yl6P9pbswM5zzZmM0WBHc2XkSyAtyotGiBZEvu1zWuq6qtqR7OZWZUVOU/h9cDdwNvTx5q0zCoqa1i9k9tU07KPLKX7XKHzRPe5YtlHamQ/anYMX11G9wXd6HzRfUE3y77azhNMbCacjnOOGRlJ7t1v3ry9rKdn+7pCWa9bayz7yFJWPnR9kppqTMDQrv2sOOO6uu8rNIavLmPl6pVTyoeWDLHihBWlxGDNM+tlLiR9ISJeLelOYMpGEfHs2YfZODcK08saVu/kNtXUfa4YrXHd3rUNtp5fzh9u3Rd0MxpTxw13qYut57TbBBObbNbzFEhuFQGcWExIVoasYfVOblNNo3Uy4tUrb0oMNRqE6cptbppuSOov0l+XAk+KiHUTH+WEZ43KGlZfxHwKK15XnYuBeuVNiUG1J5LUK7e5KU9H8z7ApyT9l6QvSnqrpMOaHZjNTNaweie3qabB3fqn3qSNtLysGI6sPZGkXrnNTZmNQkScGxHHkayW+l3gLODmZgdmM5OVvMbJbappxRnXMbRrP13bgEj6EsrsZAZYccIKhpYMjV8ZdKnLncwdKM88hb8FngfsDNwKfA/47oTbS6VyR7OZWeOKnKfwSmAP4DrgS8BXWtUgNFMRY/ez6igrx4DnITSoTU7YyMpl9J3VzbzzRN9Z3Yys3PEDVFY+hqz95IqjgP8Mzj/RJHmmPQO7Ai8DlgM/Ab6X533NeDRjmYsiciFk1VFWjoEijqWjtMkJW7ViKHrOZsd8C2cTq1YkH6Cy8jFk7SdXHAX8Z3D+icZR4DIXBwN/DLwQWAI8QHL76JwmtlV1NeP2URFj97PqKCvHgOchNKhNTljfWd2s23nqB6j3kS7WfmhrafkYsvaTK44C/jM4/0TjipinMOYDwH8A/wj8KCK2zDa4qili7H5WHWXlGPA8hAa1yQm7/ym1Pyhj5WXlY8jaT644CvjP4PwTzZNn9NGJEfHBiPjBXGwQoJix+1l1lJVjwPMQGtQmJ2yf39X+oIyVl5WPIWs/ueIo4D+D8080T56O5jmviLH7WXWUlWPA8xAa1CYnbPl+g/RM+pOsZ0tSDuXlY8jaT644CvjP4PwTTZSn46FKj2blUygiF0JWHWXlGCjiWDpKm5ywVSuGovfMrtC5RO+ZXeOdzOOvl5SPIWs/ueIo4D+D8080hqI6mqvG8xTMzBo363kKkq6SdGW9R7Hhzg1lzHVYujQZ2j32WFr+kvvWImWMyx85Yyl971QyF+KdYuSMxj9gVcgLYTM33dLZL5zujRHxnaZElKGqVwpF5CnIqmPpUrj++qnv6++H68pbDcFaYOTOEQavGmTzlu0fjp75PQy/fJiBQ4pZo2TkjKUMPvl6Nj9pe1nPEzD8aD8DH8n3AatCXgirbdb5FKqqqo1CGXMdNM0yym32z2gNKmNcft87xbrdp5b3/hbWfjTfB6wKeSGstsLmKUh6FvB+4CBgwVh5ROw3qwjnmDLmOljnKmNc/v27NVZeSxXyQtjs5BmS+s/ASmArcCzwOWBVM4NqR2XMdbDOVca4/H0ebKy8lirkhbDZydMoPDkirie51bQuIs4DTmhuWO2njLkO/XWW1q9XbnNHGePyl6ufnid2LOt5IinPqwp5IWx28jQKj0uaB/xU0lsk/SnJMto2QRF5CrLquO66qQ2AO5k7w8AhAwy/fJje3XoRone33kI7mQEGPnIdw4/20/tbUCR9CY10MkM18kLY7ORZEO85wD3A7sDfAbsBH4yIHzY/vKmq2tFsZlZlhXU0R8SP0grnAW+LiIdzBrCAZCG9ndL9XBER507aZieSPoojgU3AayJibZ76zcyseJm3jyQtkXQncAdwp6TbJR2Zo+7HgeMi4lDgMOClko6etM3pwG8iYn/go8CFjYWfT55JZVXJs5KVe6RtjqWIIPIkYilgP0Ukr8mqowxLP7cUna/xx9LP1Zg0lnG+8hxHKZPo8pzzCiTZaZc4G5K1DgZJY/DHE54/H7gjzxoaE97TA9wCHDWp/OvAMenv3cCvSG9p1Xs0uvZRnhwqVcmzkpV7pG2OpYgg8iRiKWA/RSSvyaqjDP2X9O+w/7FH/yX9Ew52+vOV5zjKSG6T65xXIMlOu8Q5hgKT7NwaEYdPKrslIo7IanAkdQE3A/sDn4iId096/S7gpRGxPn3+s7Th+FW9OhvtU8gzqawqeVayco+0zbEUEUSeRCwF7KeI5DVZdZRB59efCBDnpv/HM85XnuMoZRJdnnNegSQ77RLnmCJzNH9H0qckvUjSCyWtAL4t6QhJ0zYMETEaEYcBi4DnplncGiZpUNJqSas3btzY0HvzTAiryqSxrNwjbXMsRQSRJxFLAfspInlNVh2VkXG+8hxHKZPo8pzzCiTZaZc4G5WnUTgU+EPgXOA84EDgcODDwD/k2UlE/Bb4FvDSSS9tAPYGkNRNMrJpU433D0fEkohYsnDhwjy7HJdnQlhVJo1l5R5pm2MpIog8iVgK2E8RyWuy6qiMjPOV5zhKmUSX55xXIMlOu8TZqDyZ146d5nFcvfdJWihp9/T3JwMvBn48abMrgdelv78KuCGy7mc1KM+ksqrkWcnKPdI2x1JEEHkSsRSwnyKS12TVUYb+fWtPDtuhPON85TmOUibR5TnnFUiy0y5xNiyr0wH4feAzwNfS5wcBp+d437OBW0k6qu8CzknLLwBOSn9fAHwRuA+4Cdgvq96ZJNnJk0OlKnlWsnKPtM2xFBFEnkQsBeyniOQ1WXWUYXJn8w6dzOOBTn++8hxHGcltcp3zCiTZaZc4I4rtaP4ayfpHZ0fEoeltnlsj4pBCW6ecPHnNzKxxRXY07xkRXwC2AUTEVqBiPWizV4mx/bajqkzKKCKOHHVkjmcvI4vTHNJ28wOqIutSAvg2sAdwS/r8aOA7eS5DmvFoRo7mSozttx1VZVJGEXHkqCNzPHsRx9pBH/QqzQ+oCgq8fXQE8HHgYJK+gYXAqyLijqa1VNNoxu2jSozttx1VZVJGEXHkqCNzPHsZWZzmkCrND6iKQjOvpf0IB5Ak2bs3IrZkvKVpmtEozJtXO3OZBNu2FboryyvPP0oZ/3BFxJGjjnnnzyOmrDkNQmw7N18dhRzLHJF5PjtQYX0Kkv6MJKfC3cArgM9nTVprN5UY2287qsqkjCLiyFFH5nh2Z3FqSDvOD6iKPB3N/y8iHpb0fKCfZHjqyuaGVa5KjO23HVVlUkYRceSoI3M8exlZnOaQtpwfUBVZnQ4kw08hydP8fyaWteLRjI7miIqM7bcdVWVSRhFx5Kgjczx7EcfaQR/0qswPqAoK7Gi+mmQ5ihcDRwCPAjdFsiR26TxPwcyscUXOU3g1yRLXL4lkDaOnAmfNMj6zTLnGmWfkXChtrHoBcWRts+yry+i+oBudL7ov6GbZV2eQbKMIc2iuQ1VyQ1RKnsuJKj2adfvIqiXXOPOMnAuljVUvII6sbYauHqqZL2Ho6gaSbRRhDs11qEpuiLJQ1O2jqvHto86Qa5x5Rs6F0saqFxBH1jbdF3QzGlP30aUutp6TM9lGEebQXIeq5IYoS5G3j8xKl2sd+oycC6WtZV9AHFnb1GoQdigvK5FGJRJ2FKMquSGqxo2CVVKuceYZORdKG6teQBxZ23Sp9j7Gy8uagzCH5jpUJTdE1bhRsErKNc48I+dCaWPVC4gja5vBI2vvY7y8rDkIc2iuQ1VyQ1ROno6HKj3c0dw5co0zz8i5UNpY9QLiyNpm6Oqh6Dq/KziP6Dq/a3sn83gFJc1BmENzHaqSG6IMuKPZzMzGuKPZZqcKY9ELiGHZuxfTfY7QeaL7HLHs3YtbEkeu3WSMZ2+78e7WlrpbHYBV0MhIcj988+bk+bp12++bDwy0TQzL3r2YlU9ek6ztC4x2kTx/92JWXHh3aXHk2s2dIwxeNcjmLcl+1j24jsGrkv0MHDKQ+bpZUXz7yKaqwlj0AmLoPkeM1hi00zUKWy/I+bkv6VxkjWev0nh3a0++fWQzV4Wx6AXEMFrn012vvFlx5NpNxnj2dhzvbu3JjYJNVYWx6AXE0FUnl0q98mbFkWs3GePZ23G8u7UnNwo2VRXGohcQw+DjBzEl+Vak5SXGkWs3GePZ23K8u7UlNwo21cAADA8n982l5OfwcHmdzAXFsOLCuxl69CC6RoFI+hKGHj0ofydzQXHk2s0hAwy/fJje3XoRone3XoZfPjzeiZz1ullR3NFsZtYB3NFs1VfE+P+sOioyx8A6V7t9NjxPwVqjiPH/WXVUZI6Bda52/Gz49pG1RhHj/7PqqMgcA+tcVfps+PaRVVsR4/+z6qjIHAPrXO342XCjYK1RxPj/rDoqMsfAOlc7fjbcKFhrFDH+P6uOiswxsM7Vlp+NPOtrV+nhfApzSBHr8mfVUdLa/1VZM9+qpyqfDZxPwczMxrij2czMGta0RkHS3pK+JWmNpLslvb3GNi+S9KCk29LHOc2KZ64oZCJMFRLo5IkjR5ztNjFoOiMrl9F3VjfzzhN9Z3UzsnJZ+THMofNpM9PMyWtbgb+OiFsk7QLcLOmbEbFm0nbfjYgTmxjHnFHIRJgqJNDJE0eOONtxYlA9IyuXMbhhJZt3Tp6v23mUwQ0rYSUMDK0oJ4Y5dD5t5krrU5D0FeDiiPjmhLIXAWc20ih0cp9CIRNhqpBAJ08cOeKs0sSg2eo7q5t1O49OKe99pIu1H9paTgxz6HzaVJXqU5DUBxwO3Fjj5WMk3S7pa5JqJtCVNChptaTVGzdubGKk1VbIRJgqJNDJE0eOONtxYlA99z9laoMwXXlTYphD59NmrumNgqSdgX8D3hERD016+RagNyIOBT4O/HutOiJiOCKWRMSShQsXNjfgCitkIkwVEujkiSNHnO04MaiefX5XI2/oNOVNiWEOnU+buaY2CpLmkzQIIxHxpcmvR8RDEfFI+vs1wHxJezYzpnZWyESYKiTQyRNHjjjbcmJQHcv3G6Rny45lPVuS8tJimEPn02Yhz2SGmTwAAZ8DLppmm6ezvV/jucD9Y8/rPTp98lohE2FKmtA16zhyxFmViUFFWLViKHrP7AqdS/Se2RWrVgyVH8McOp+2I1o9eU3S84HvAncCY1lx3wvskzZGn5T0FmCIZKTSo8AZEfGD6ert5I5mM7OZanlHc0R8LyIUEc+OiMPSxzUR8cmI+GS6zcURsTgiDo2Io7MaBKM6cwyKsGwZdHcnaS67u5PnZtZSTrLTTqoyx6AIy5bBypXbn4+Obn++opxx+WY2ldc+aieb27pLAAAKwElEQVRVmWNQhO7upCGYrKsLtpYzLt+sk7T89pE1QVXmGBShVoMwXbmZlcKNQjupyhyDInTVGX9fr9zMSuFGoZ1UZY5BEQbrjL+vV25mpXCj0E4GBmB4OOlDkJKfw8Pt18kMSWfy0ND2K4OuruS5O5nNWsodzWZmHcAdzQVrq+kB7RJsu8RZFp8Pq4I8056r9GjFMherVkX09ETA9kdPT+tWh5hWuwTbLnGWxefDmoxWL3PRLK24fdRW0wPaJdh2ibMsPh/WZHlvH7lRyGHevORPt8kk2LZtanlLtUuw7RJnWXw+rMncp1Cgtpoe0C7BtkucZfH5sIpwo5BDW00PaJdg2yXOsvh8WEW4UcihraYHtEuw7RJnWXw+rCLcp2Bm1gHcp2BWkJGVy+g7q5t554m+s7oZWTmDvA+eg2Btwo2C2TRGVi5jcMNK1u08SgjW7TzK4IaVjTUMY3kw1q1LRhiN5cFww2AV5NtHZtPoO6ubdTtPXc6795Eu1n4oZ94Hz0GwCvDtI7MC3P+U2vkd6pXX3ngO5cGwOc+Ngtk09vld7fwO9cprb+w5CNY+3CiYTWP5foP0bNmxrGdLUp6/Es9BsPbhRsFsGgNDKxjea4jeR7pQJH0Jw3sNMTDUQN4Hz0GwNuKOZjOzDuCOZjMza5gbBTMzG+dGwczMxrlRMDOzcW4UzMxsnBsFMzMb50bBzMzGuVEwM7NxbhTMzGxc0xoFSXtL+pakNZLulvT2GttI0j9Kuk/SHZKOaFY8HcUJXcxshrqbWPdW4K8j4hZJuwA3S/pmRKyZsM3LgGelj6OAlelPm6mxhC6bNyfPxxK6gNfaMbNMTbtSiIhfRMQt6e8PA/cAe03a7GTgc5H4IbC7pGc0K6aOcPbZ2xuEMZs3J+VmZhlK6VOQ1AccDtw46aW9gAcmPF/P1IYDSYOSVktavXHjxmaFOTc4oYuZzULTGwVJOwP/BrwjIh6aSR0RMRwRSyJiycKFC4sNcK5xQhczm4WmNgqS5pM0CCMR8aUam2wA9p7wfFFaZjPlhC5mNgvNHH0k4DPAPRHxkTqbXQn8ZToK6WjgwYj4RbNi6ghO6GJms9DM0UfPA/4CuFPSbWnZe4F9ACLik8A1wPHAfcBm4PVNjKdzDAy4ETCzGWlaoxAR3wOUsU0Ab25WDGZm1hjPaDYzs3FuFMzMbJwbBTMzG+dGwczMxinp620fkjYC61oYwp7Ar1q4/0a0S6yOs1jtEie0T6xzIc7eiMic/dt2jUKrSVodEUtaHUce7RKr4yxWu8QJ7RNrJ8Xp20dmZjbOjYKZmY1zo9C44VYH0IB2idVxFqtd4oT2ibVj4nSfgpmZjfOVgpmZjXOjYGZm49woTENSl6RbJV1d47XTJG2UdFv6eGOLYlwr6c40htU1Xpekf5R0n6Q7JB3RijjTWLJifZGkByec03NaFOfukq6Q9GNJ90g6ZtLrlTinOeKsyvk8YEIMt0l6SNI7Jm3T8nOaM86qnNN3Srpb0l2SLpO0YNLrO0n6fHo+b0yzX+bSzKWz54K3k+SW3rXO65+PiLeUGE89x0ZEvQkrLwOelT6OAlamP1tlulgBvhsRJ5YWTW0fA66NiFdJehIwKWtRZc5pVpxQgfMZEfcCh0HyhxZJIq0vT9qs5ec0Z5zQ4nMqaS/gbcBBEfGopC8ApwL/MmGz04HfRMT+kk4FLgRek6d+XynUIWkRcALw6VbHMksnA5+LxA+B3SU9o9VBVZWk3YAXkCSIIiKeiIjfTtqs5ec0Z5xV1A/8LCImr0rQ8nM6Sb04q6IbeLKkbpI/Bv570usnA5ekv18B9KeJzzK5UajvIuBdwLZptjklvdS9QtLe02zXTAF8Q9LNkgZrvL4X8MCE5+vTslbIihXgGEm3S/qapMVlBpfaF9gI/HN66/DTkp4yaZsqnNM8cULrz+dkpwKX1SivwjmdqF6c0OJzGhEbgH8A7gd+QZKx8huTNhs/nxGxFXgQ2CNP/W4UapB0IvDLiLh5ms2uAvoi4tnAN9neKpft+RFxBMnl95slvaBFceSRFestJOuzHAp8HPj3sgMk+QvsCGBlRBwO/A74mxbEkSVPnFU4n+PSW1wnAV9sZRxZMuJs+TmV9HskVwL7As8EniLpz4uq341Cbc8DTpK0FrgcOE7SqokbRMSmiHg8ffpp4MhyQxyPY0P685ck9z+fO2mTDcDEq5hFaVnpsmKNiIci4pH092uA+ZL2LDnM9cD6iLgxfX4FyZfvRFU4p5lxVuR8TvQy4JaI+N8ar1XhnI6pG2dFzulS4OcRsTEitgBfAv5o0jbj5zO9xbQbsClP5W4UaoiI90TEoojoI7mMvCEidmiJJ93vPImkQ7pUkp4iaZex34E/Ae6atNmVwF+mozuOJrnU/EXJoeaKVdLTx+57Snouyecz1we5KBHxP8ADkg5Ii/qBNZM2a/k5zRNnFc7nJK+l/i2Zlp/TCerGWZFzej9wtKSeNJZ+pn7/XAm8Lv39VSTfYblmKnv0UQMkXQCsjogrgbdJOgnYCvwaOK0FIf0+8OX0M9oN/GtEXCvpTQAR8UngGuB44D5gM/D6FsSZN9ZXAUOStgKPAqfm/SAX7K3ASHob4b+A11f0nGbFWZXzOfaHwIuBv5pQVrlzmiPOlp/TiLhR0hUkt7K2ArcCw5O+nz4DXCrpPpLvp1Pz1u9lLszMbJxvH5mZ2Tg3CmZmNs6NgpmZjXOjYGZm49womJnZODcKZg1KV8qstXJuzfIC9vcKSQdNeP5tSZVPIm/tyY2CWfW9AjgocyuzArhRsDknnT391XTRsrskvSYtP1LSd9IF+b4+Nis9/cv7Y0rWx78rnamKpOdK+s90wbkfTJg9nDeGz0q6KX3/yWn5aZK+JOlaST+V9MEJ7zld0k/S9/yTpIsl/RHJjPkPpfH9Qbr5n6Xb/UTSHxd06sw8o9nmpJcC/x0RJ0CyzLSk+SQLmJ0cERvThmI58Ib0PT0RcVi6SN9ngYOBHwN/HBFbJS0F3geckjOGs0mWFniDpN2BmyRdl752GHA48Dhwr6SPA6PA/yNZv+hh4Abg9oj4gaQrgasj4or0eAC6I+K5ko4HziVZD8ds1two2Fx0J/BhSReSfJl+V9LBJF/030y/VLtIlh0ecxlARPyHpF3TL/JdgEskPYtk2e/5DcTwJySLKp6ZPl8A7JP+fn1EPAggaQ3QC+wJfCcifp2WfxH4w2nq/1L682agr4G4zKblRsHmnIj4iZJ0jscDfy/pepJVWe+OiGPqva3G878DvhURf6okneG3GwhDwClpNq/thdJRJFcIY0aZ2f/DsTpm+n6zmtynYHOOpGcCmyNiFfAhklsy9wILleYxljRfOyZIGet3eD7JCp0Pkiw3PLZ882kNhvF14K0TVtQ8PGP7HwEvlPR7SpY6nnib6mGSqxazpnOjYHPRIST38G8jud/+9xHxBMkKlxdKuh24jR3XoH9M0q3AJ0ny2wJ8EHh/Wt7oX+N/R3K76Q5Jd6fP60pzTbwPuAn4PrCWJFsWJDk9zko7rP+gdg1mxfAqqdbxJH0bODMiVrc4jp0j4pH0SuHLwGcjolbieLOm8ZWCWXWcl17d3AX8nBanz7TO5CsFMzMb5ysFMzMb50bBzMzGuVEwM7NxbhTMzGycGwUzMxv3/wE8oH4Q8PsYzwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "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": 21,
   "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": 31,
   "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": 34,
   "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": 37,
   "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": 38,
   "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
}