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": 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": 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 = [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": 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, 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": 6,
   "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": 7,
   "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": 7,
     "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": 8,
   "metadata": {
    "lines_to_next_cell": 2
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bushuhui/virtualenv/dl/lib/python3.6/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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n",
      "/home/bushuhui/virtualenv/dl/lib/python3.6/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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  after removing the cwd from sys.path.\n",
      "/home/bushuhui/virtualenv/dl/lib/python3.6/site-packages/ipykernel_launcher.py:5: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"\n"
     ]
    }
   ],
   "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": 9,
   "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": 10,
   "metadata": {
    "lines_to_end_of_cell_marker": 2,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#获取样本数据\n",
    "datamat = dataset.loc[:, ['sepal-length', 'sepal-width']]\n",
    "# 真实的标签\n",
    "labels = dataset.loc[:, ['class']]\n",
    "#原始数据显示\n",
    "originalDatashow(datamat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def distEclud(vecA, vecB):\n",
    "    \"\"\"算距离, 两个向量间欧式距离\"\"\"\n",
    "    return sqrt(sum(power(vecA - vecB, 2))) #la.norm(vecA-vecB)\n",
    "\n",
    "\n",
    "def kMeans(dataSet, k):\n",
    "    # 样本总数\n",
    "    m = shape(dataSet)[0]\n",
    "    # 分配样本到最近的簇：存[簇序号,距离的平方] (m行 x 2 列)\n",
    "    clusterAssment = mat(zeros((m, 2)))\n",
    "\n",
    "    # step1: 通过随机产生的样本点初始化聚类中心\n",
    "    centroids = randChosenCent(dataSet, k)\n",
    "    print('最初的中心=', centroids)\n",
    "\n",
    "    # 标志位，如果迭代前后样本分类发生变化值为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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最初的中心= [[4.6 3.6]\n",
      " [4.9 3. ]\n",
      " [5.8 2.7]]\n",
      "the SSE of 1th iteration is 93.220000\n",
      "the SSE of 2th iteration is 50.840500\n",
      "the SSE of 3th iteration is 47.318230\n",
      "the SSE of 4th iteration is 45.338455\n",
      "the SSE of 5th iteration is 44.384855\n",
      "the SSE of 6th iteration is 43.591498\n",
      "the SSE of 7th iteration is 41.904928\n",
      "the SSE of 8th iteration is 39.066514\n",
      "the SSE of 9th iteration is 38.316500\n",
      "the SSE of 10th iteration is 37.912536\n",
      "the SSE of 11th iteration is 37.423306\n",
      "the SSE of 12th iteration is 37.136261\n",
      "the SSE of 13th iteration is 37.123702\n"
     ]
    }
   ],
   "source": [
    "# 进行k-means聚类\n",
    "k = 3  # 用户定义聚类数\n",
    "mycentroids, clusterAssment = kMeans(datamat, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def datashow(dataSet, k, centroids, clusterAssment):  # 二维空间显示聚类结果\n",
    "    from matplotlib import pyplot as plt\n",
    "    num, dim = shape(dataSet)  # 样本数num ,维数dim\n",
    "\n",
    "    if dim != 2:\n",
    "        print('sorry,the dimension of your dataset is not 2!')\n",
    "        return 1\n",
    "    marksamples = ['or', 'ob', 'og', 'ok', '^r', '^b', '<g']  # 样本图形标记\n",
    "    if k > len(marksamples):\n",
    "        print('sorry,your k is too large,please add length of the marksample!')\n",
    "        return 1\n",
    "        # 绘所有样本\n",
    "    for i in range(num):\n",
    "        markindex = int(clusterAssment[i, 0])  # 矩阵形式转为int值, 簇序号\n",
    "        # 特征维对应坐标轴x,y；样本图形标记及大小\n",
    "        plt.plot(dataSet.iat[i, 0], dataSet.iat[i, 1], marksamples[markindex], markersize=6)\n",
    "\n",
    "    # 绘中心点\n",
    "    markcentroids = ['o', '*', '^']  # 聚类中心图形标记\n",
    "    label = ['0', '1', '2']\n",
    "    c = ['yellow', 'pink', 'red']\n",
    "    for i in range(k):\n",
    "        plt.plot(centroids[i, 0], centroids[i, 1], markcentroids[i], markersize=15, label=label[i], c=c[i])\n",
    "        plt.legend(loc='upper left')  #图例\n",
    "    plt.xlabel('sepal length')\n",
    "    plt.ylabel('sepal width')\n",
    "\n",
    "    plt.title('k-means cluster result')  # 标题\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# 画出实际图像\n",
    "def trgartshow(dataSet, k, labels):\n",
    "    from matplotlib import pyplot as plt\n",
    "\n",
    "    num, dim = shape(dataSet)\n",
    "    label = ['0', '1', '2']\n",
    "    marksamples = ['ob', 'or', 'og', 'ok', '^r', '^b', '<g']\n",
    "    # 通过循环的方式，完成分组散点图的绘制\n",
    "    for i in range(num):\n",
    "        plt.plot(datamat.iat[i, 0], datamat.iat[i, 1], marksamples[int(labels.iat[i, 0])], markersize=6)\n",
    "    for i in range(0, num, 50):\n",
    "        plt.plot(datamat.iat[i, 0], datamat.iat[i, 1], marksamples[int(labels.iat[i, 0])], markersize=6,\n",
    "                 label=label[int(labels.iat[i, 0])])\n",
    "    plt.legend(loc='upper left')\n",
    "    \n",
    "    # 添加轴标签和标题\n",
    "    plt.xlabel('sepal length')\n",
    "    plt.ylabel('sepal width')\n",
    "    plt.title('iris true result')  # 标题\n",
    "\n",
    "    # 显示图形\n",
    "    plt.show()\n",
    "    # label=labels.iat[i,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘图显示\n",
    "datashow(datamat, k, mycentroids, clusterAssment)\n",
    "trgartshow(datamat, 3, labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 利用sklearn进行分类\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 17,
   "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": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAJOCAYAAAB1IEnpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzs3XmcXGWZ9//PNwlIOgECmgkmkAS3AAMK2CqKOCAqgqgMbjABAZe4PI7oT3HAOCMqERwYR2fcpgUBoQcXjKi4oCNE5FHRDtGJgFEfSAKBhACGrYOEcP3+uO9OKpXu6lpO19bf9+tVr666z6m6r3P6nKuuOqsiAjMzMzNr3IRWB2BmZmbWLVxYmZmZmRXEhZWZmZlZQVxYmZmZmRXEhZWZmZlZQVxYmZmZmRXEhZWZWZuStFLSy9ogjtmSHpY0Mb9eIult+fmpkm5obYTtS9JkSd+T9ICkb+a2cyTdK2lt+byt8DmHSVrRnKitES6sxqlGE7aTqVn7k/QkSRdJWiXpIUm/lXR0rZ8TEasjYmpEbB6LOOsh6WxJl5e1bSn42sjrgRnAkyPiDZJmAx8A9ouIPaqdtxHx84iYV0RAjeR/SQdKWippMP89sIr3PFPSo6X/L0kfzgXl0GOjpCckPSUPf6OkX+R+ltQTa6u4sDIz616TgDuAvwN2BT4CfEPS3BbGNN7MAf4YEY/n17OB+yLinhbGVBdJOwLfAS4HdgMuBb6T2yv5PPCb0oaI+GQuKKdGxFTgU8CSiLg3j3I/8BngvCKnoRlcWI1zQ1ueJF0g6S+Sbi/9RZuH35Z/7d4uab6kfYEvAS/MvzQ25HFfJWmZpAcl3SHp7JLPmSspJJ0iaXXeDL6wZPjE/Avm/+W+lkraKw/bR9JPJN0vaYWkN5a87xhJt+T3rJH0wSbMNrOmk7RvXgdPrPY9EfFIRJwdESsj4omIuBq4HXjuCH08X9JAXofXSfp0bh9afydViG+kHDJT0nfz+vtnSW8vGXaJpHNKXh8u6c6y935L0vr8ue/N7a8EPgy8Keeg30laBBwGfC63fS6PO2L+GGYadpd0saS78rRcVTLs7Tn++/P0zCwZNmwfkj4G/EtJnO8AfgLMzK8vKZ+3I8VQ7bzJw86W9A1JX8258WZJvXnYZaTi7ns5hg+NND+GcTipWP9MRPw1Iv4DEPDSCvP0BGAD8NMK4wh4M6lQAyAi/icivgHcVUN87SEi/BiHD2Al8DLgVGAT8HZgIvAu0oIsYArwIDAvv+epwN/m56cCN5R95uHAAaSC/dnAOuC4PGwuEMCXgcnAc4C/Avvm4WcAy4F5ue/nAE/OMdwBnEZaoQ8C7iVtRge4GzgsP98NOLjV89YPP4p6lKynBwOrgWNLhl1N+sIa7nH1CJ83A3gU2GeE4b8ETs7PpwKH5OdD6++k/HoJ8Lb8fMQckodfD3wB2Ak4EFgPvDQPuwQ4p6T/w4E78/MJwFJSYbIj8DTgNuCoPPxs4PKy+LfElV9XzB/DTP/3ga/nXLID8He5/aX5fQcDTwL+E7i+mj7K4yydxhHm7Ugx1DpvHgWOyf+Tc4FflS9XZdM+0rK0ATgzj/N+4Idl77sa+MAI83MX4I/AnsP9v0rGewnwMDB1mGFvI23Javn6WO3DW6wMYFVEfDnSPv5LSQXUjDzsCWB/SZMj4u6IuHmkD4mIJRGxPNIv4/8FriDtgij1sYjYGBG/A35HKqAgrTwfiYgVkfwuIu4DjgVWRsTFEfF4RCwDvgW8Ib9vE7CfpF0i4i8RcVPjs8OsrRwGfBd4c6QtTgBExLERMW2Ex7HlHyJpB6AfuDQi/jBCX5uAZ0h6SkQ8HBG/qjLGYXNI3up8KPBPEfFoRPwWuJC0dWI0zwOmR8THI+KxiLiN9MPshCpjgtHzxxaSngocDbwz55JNEfGzPHg+8JWIuCki/gqcRdpiP7eWPkYzSgylqpk3N0TED/L/5DK25tphVViWpkXE0O64qcADZW99ANh5hI/9BHBRRNw5wvAhpwBXRsTDo4zXEVxYGcDaoScRMZifTo2IR4A3Ae8E7pb0fUn7jPQhkl4g6bq8afqB/L6njNQXMEhaUQH2Av7fMB87B3iBpA1DD1KS2yMPfx3pV9kqST+T9MJqJtisg7wT+EVELKn3AyRNIH25Pga8p8KobwWeBfxB0m8kbVegjWDYHALMBO6PiIdKxl0FzKriM+eQdpmVrvsfZuuPvmqMlj9K7ZVj/csww2bmuAHIBcB9eTpq6WM0lWIoVc28Kc+1O1XalVulh0lboUrtAjxUPqLSQe0vA/690gdK6iEVoZdWGq+TuLCyiiLimoh4OekX6B9Iv4ogbbou99+kX9Z7RcSupOOwVGVXdwBPH6H9Z2W/nqZGxLtyfL+JiNcCfwNcBXyj2mkz6xDvBGZL2uYLStIPte1ZVaWPH5aMJ+Ai0pfu6yJi00gdRcSfIuJE0vr0KeBKSVMaiP0uYHdJpVs0ZgNr8vNHgJ6SYaXFyB3A7WXr/s4RccxQuMNNQtnrivljmHF3lzRthOmYM/Qiz5Mn5+mopY/RVIqhfLxK82Y02827CsvSw5I+nEe7GXh2XqaGPDu3lzuctJtztaS1wAeB10kq36vw96QD1ZdUGXvbc2FlI5I0Q9JrcxL5K+nXyhN58DpgT217NsjOpF9bj0p6PvAPNXR3IfAJpdNyJenZkp5M2n//LEknS9ohP56ndCDvjkoH0++avyweLInPrFs8BLwSeImkLWdIRcTRUXJWVdmj9JIKXwT2BV4dERvLPzwfOH14fn6SpOkR8QTp2BpoYJ2KiDuAXwDnStpJ0rNJW8WGTrv/LXBMPmB7D+B9JW//NfCQpH9SuhbUREn7S3peHr4OmJu3xlHS9rSS1yPmj2FivRv4IfAFSbvlcV+SB18BnKZ0qYEnAZ8EboyIlbX0UcX8qhRDqdHmzWjK5xMVlqWpEfHJPNoSYDPwXqVLeQxt/bx2mD76SD+WD8yPL5GOHzuqbLxTgK9GxDbFXp6mnUjHrU3Iy88OVU5fS7mwskomAP8f6dfa/aTjpYZ+hV1L+pWyVtLQ6bHvBj4u6SHSQZW1bD36dB7/x6QC6SJgct6F8ArSsQN3kTZvf4p0ACnAycBKSQ+SftnPr30yzdpbRGwAXg4cLekT1b5P0hzgHaQvtrUlWyDm5+F7kQq35fktrwRulvQw8FnghOGKsRqdSNpycRfwbeCjEfE/edhlpGMtV5LW/a8PvSkfG3Rsjv120gHhF5IuGwHwzfz3vpKtIJ8FXq90Nt1/VJE/yp1MOs7sD8A95EIvx/vPpGOn7iYVDCfkYbX2MZphYyhVxbwZzbnAR/JuxKrPpI6Ix4DjSMfIbQDeQjpB6THYcm2qH+ZxByNi7dCD9MP80YhYP/R5kmaRTgz46jDdnQxsJP0wOCw///Iw47UdlRWJZmY2Tkg6iXSm71mtjsWsW7iwMjMzMyvIqLsCJX1F0j2Sfl/StrvSxdD+lP/uNrZhmpnVxznMzJqpmmOsLiHtdy91JvDTiHgm6WqqZxYcl5lZUS7BOczMmqSqXYFKF0G7OiL2z69XAIdHxN1KFzRbEgXdHNLMrGjOYWbWLPVeLGxGPi0U0hkQI16wTdICYAHAlClTnrvPPiNeX9LMuszSpUvvjYjprY5jGFXlMOcvs/GtnhzW6FVYiYiQNOJmr4joI13Pgt7e3hgYGGi0SzPrEJJWjT5Wa1XKYc5fZuNbPTms3utYrcubz4fubXRPnZ9jZtYKzmFmNibqLay+S7paKvnvd4oJx8ysKZzDzGxMVHO5hSuAXwLzJN0p6a3AecDLJf2JdJPF8yp9hplZqziHmVkzjXqMVb4h53COLDgWM7PCOYeZWTP5XoFmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBWmosJL0fkk3S/q9pCsk7VRUYNYdrlq2hkPPu5a9z/w+h553LVctW9PqkMy2cA6zSvr7Ye5cmDAh/e3vb3VE1gnqLqwkzQLeC/RGxP7AROCEogKzznfVsjWctXg5azZsJIA1GzZy1uLlLq6sLTiHWSX9/bBgAaxaBRHp74IFLq5sdI3uCpwETJY0CegB7mo8JOsW51+zgo2bNm/TtnHTZs6/ZkWLIjLbjnOYDWvhQhgc3LZtcDC1m1VSd2EVEWuAC4DVwN3AAxHx4/LxJC2QNCBpYP369fVHah3nrg0ba2o3a6Zqcpjz1/i1enVt7WZDGtkVuBvwWmBvYCYwRdJJ5eNFRF9E9EZE7/Tp0+uP1DrOzGmTa2o3a6Zqcpjz1/g1e3Zt7WZDGtkV+DLg9ohYHxGbgMXAi4oJy7rBGUfNY/IOE7dpm7zDRM44al6LIjLbhnOYjWjRIujp2batpye1m1XSSGG1GjhEUo8kAUcCtxYTlnWD4w6axbnHH8CsaZMRMGvaZM49/gCOO2hWq0MzA+cwq2D+fOjrgzlzQEp/+/pSu1klk+p9Y0TcKOlK4CbgcWAZ0FdUYNYdjjtolgspa0vOYTaa+fNdSFnt6i6sACLio8BHC4rFzKypnMPMrGi+8rqZmZlZQVxYmZmZmRXEhZWZmZlZQVxYmZmZmRXEhZWZmZlZQVxYmZmZmRXEhZWZmZlZQVxY2Zi6atkaDj3vWvY+8/scet61XLVsTUf2YWbjT38/zJ0LEyakv/39ndmHNVdDFwg1q+SqZWs4a/FyNm7aDMCaDRs5a/FygMKuxt6MPsxs/OnvhwULYHAwvV61Kr2G4q7G3ow+rPm8xcrGzPnXrNhS8AzZuGkz51+zoqP6MLPxZ+HCrQXPkMHB1N5JfVjzubCyMXPXho01tbdrH2Y2/qxeXVt7u/ZhzefCysbMzGmTa2pv1z7MbPyZPbu29nbtw5rPhZWNmTOOmsfkHSZu0zZ5h4mccdS8jurDzMafRYugp2fbtp6e1N5JfVjzubCyMXPcQbM49/gDmDVtMgJmTZvMuccfUOhB5c3ow8zGn/nzoa8P5swBKf3t6yv2oPJm9GHNp4hoWme9vb0xMDDQtP7MrLUkLY2I3lbHUQTnL7Pxp54c5i1WZmZmZgVxYWVmZmZWEBdWZmZmZgVxYWVmZmZWEBdWZmZmZgVxYWVmZmZWEBdWZmZmZgVxYWVmZmZWkIYKK0nTJF0p6Q+SbpX0wqICs+5w1bI1HHretex95vc59LxruWrZmo7sw7qTc5hV0t8Pc+fChAnpb39/Z/ZhzTWpwfd/FvhRRLxe0o5Az2hvsPHjqmVrOGvxcjZu2gzAmg0bOWvxcoDCbjnTjD6sqzmH2bD6+2HBAhgcTK9XrUqvobhbzjSjD2u+urdYSdoVeAlwEUBEPBYRG4oKzDrf+des2FLwDNm4aTPnX7Oio/qw7uQcZpUsXLi14BkyOJjaO6kPa75GdgXuDawHLpa0TNKFkqaUjyRpgaQBSQPr169voDvrNHdt2FhTe7v2YV1r1Bzm/DV+rV5dW3u79mHN10hhNQk4GPhiRBwEPAKcWT5SRPRFRG9E9E6fPr2B7qzTzJw2uab2du3DutaoOcz5a/yaPbu29nbtw5qvkcLqTuDOiLgxv76SlKTMADjjqHlM3mHiNm2Td5jIGUfN66g+rGs5h9mIFi2CnrIj7np6Unsn9WHNV3dhFRFrgTskDX2DHQncUkhU1hWOO2gW5x5/ALOmTUbArGmTOff4Awo9qLwZfVh3cg6zSubPh74+mDMHpPS3r6/Yg8qb0Yc1nyKi/jdLBwIXAjsCtwGnRcRfRhq/t7c3BgYG6u7PzDqLpKUR0dvqOEZSSw5z/jIbf+rJYQ1dbiEifgu0bdI0M6vEOczMiuYrr5uZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVxIWVmZmZWUFcWJmZmZkVpOHCStJEScskXV1EQGZmzeL8ZWZFK2KL1enArQV8jplZszl/mVmhGiqsJO0JvAq4sJhwzMyaw/nLzMZCo1usPgN8CHhipBEkLZA0IGlg/fr1DXZnZlYY5y8zK1zdhZWkY4F7ImJppfEioi8ieiOid/r06fV2Z2ZWGOcvMxsrjWyxOhR4jaSVwNeAl0q6vJCozMzGlvOXmY2JuguriDgrIvaMiLnACcC1EXFSYZGZmY0R5y8zGyu+jpWZmZlZQSYV8SERsQRYUsRnmZk1k/OXmRXJW6zMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMClLIdazGk6uWreH8a1Zw14aNzJw2mTOOmsdxB81qdVhmVfMyPH7198PChbB6NcyeDYsWwfz5rY7KrDp7XLAH6x5Zt137jCkzWPvBtS2IaHgurGpw1bI1nLV4ORs3bQZgzYaNnLV4OYC/mKwjeBkev/r7YcECGBxMr1etSq/BxZV1huGKqkrtreJdgTU4/5oVW76QhmzctJnzr1nRoojMauNlePxauHBrUTVkcDC1m1lxXFjV4K4NG2tqN2s3XobHr9Wra2s3s/q4sKrBzGmTa2o3azdehsev2bNrazez+riwqsEZR81j8g4Tt2mbvMNEzjhqXosiMquNl+Hxa9Ei6OnZtq2nJ7WbWXFcWNXguINmce7xBzBr2mQEzJo2mXOPP8AH/VrH8DI8fs2fD319MGcOSOlvX58PXLfOMWPKjJraW0UR0bTOent7Y2BgoGn9mVlrSVoaEb2tjqMIzl9m4089OcxbrMzMzMwK4sLKzMzMrCAurMzMzMwK4sLKzMzMrCAurMzMzMwK4sLKzMzMrCAurMzMzMwK4sLKzMzMrCB1F1aS9pJ0naRbJN0s6fQiA6vVVcvWcOh517L3md/n0POu5apla1oZTkO6aVqsNv7fN0+75bD+fpg7FyZMSH/7+1sZTf26ZTqsNntcsAf6mLZ77HHBHq0OrekmNfDex4EPRMRNknYGlkr6SUTcUlBsVbtq2RrOWrycjZs2A7Bmw0bOWrwcoONu1dFN02K18f++6domh/X3w4IFMDiYXq9alV5DZ91yplumw2q37pF1NbV3s7q3WEXE3RFxU37+EHAr0JLsf/41K7Z8GQ3ZuGkz51+zohXhNKSbpsVq4/99c7VTDlu4cGsxMmRwMLV3km6ZDrNGFHKMlaS5wEHAjcMMWyBpQNLA+vXri+huO3dt2FhTezvrpmmx2vh/3zoj5bBm5C+A1atra29X3TIdZo1ouLCSNBX4FvC+iHiwfHhE9EVEb0T0Tp8+vdHuhjVz2uSa2ttZN02L1cb/+9aolMOakb8AZs+urb1ddct0mDWiocJK0g6khNQfEYuLCal2Zxw1j8k7TNymbfIOEznjqHktiqh+3TQtVhv/75uvXXLYokXQ07NtW09Pau8k3TIdZo1o5KxAARcBt0bEp4sLqXbHHTSLc48/gFnTJiNg1rTJnHv8AR15wG83TYvVxv/75mqnHDZ/PvT1wZw5IKW/fX2dd8B3t0yH1W7GlBk1tXczRUR9b5ReDPwcWA48kZs/HBE/GOk9vb29MTAwUFd/ZtZ5JC2NiN5WxzGcWnOY85fZ+FNPDqv7cgsRcQOget9vZtZKzmFmNhZ85XUzMzOzgriwMjMzMyuICyszMzOzgriwMjMzMyuICyszMzOzgriwMjMzMyuICyszMzOzgtR9Hat2c9WyNZx/zQru2rCRmdMmc8ZR83zFaivMR65azhU33sHmCCZKnPiCvTjnuANaHVZdvK60p/5+WLgw3bB49ux0GxhfsdyKMPFjE3liyzVwt5rABDZ/dHMLIqrPHhfswbpH1m3XPmPKDNZ+cG0LIhpeVxRWVy1bw1mLl7NxU1pA1mzYyFmLlwP4C8Ma9pGrlnP5r1Zveb05YsvrTiuuvK60p/5+WLAABgfT61Wr0mtwcWWNG66oqtTeroYrqiq1t0pX7Ao8/5oVW74ohmzctJnzr1nRooism1xx4x01tbczryvtaeHCrUXVkMHB1G5mnaUrCqu7Nmysqd2sFptHuJ/mSO3tzOtKe1q9urZ2M2tfXVFYzZw2uaZ2s1pM1PC3kxupvZ15XWlPs2fX1m5m7asrCqszjprH5B0mbtM2eYeJnHHUvBZFZN3kxBfsVVN7O/O60p4WLYKenm3benpSu5l1lq4orI47aBbnHn8As6ZNRsCsaZM59/gDfDCuFeKc4w7gpENmb9lCNVHipENmd9yB6+B1pV3Nnw99fTBnDkjpb1+fD1y3YkwY4at+pPZ2NWPKjJraW0XRxONEent7Y2BgoGn9mVlrSVoaEb2tjqMIzl9m4089OayzylUzMzOzNubCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgDRVWkl4paYWkP0s6s6igzMyawTnMzIpWd2ElaSLweeBoYD/gREn7FRWYmdlYcg4zs7HQyBar5wN/jojbIuIx4GvAa4sJy8xszDmHmVnhJjXw3lnAHSWv7wReUD6SpAXAgvzyr5J+30Cf7eQpwL2tDqIA3TId4GlpR/NaHUAFo+Yw56+O0C3T0i3TAd01LTXnsEYKq6pERB/QByBpoFtuyNot09It0wGelnYkqaPvWuz81f66ZVq6ZTqg+6al1vc0sitwDbBXyes9c5uZWSdwDjOzwjVSWP0GeKakvSXtCJwAfLeYsMzMxpxzmJkVru5dgRHxuKT3ANcAE4GvRMTNo7ytr97+2lC3TEu3TAd4WtpR205HHTmsbaelDp6W9tMt0wHjfFoUEWMRiJmZmdm44yuvm5mZmRXEhZWZmZlZQZpSWHXLbSMk7SXpOkm3SLpZ0umtjqlRkiZKWibp6lbH0ghJ0yRdKekPkm6V9MJWx1QPSe/Py9bvJV0haadWx1QtSV+RdE/ptZ4k7S7pJ5L+lP/u1soY69UNOcz5q311S/4C5zBoQmHVZbeNeBz4QETsBxwC/J8OnpYhpwO3tjqIAnwW+FFE7AM8hw6cJkmzgPcCvRGxP+mA6hNaG1VNLgFeWdZ2JvDTiHgm8NP8uqN0UQ5z/mpfHZ+/wDlsSDO2WHXNbSMi4u6IuCk/f4i08M9qbVT1k7Qn8CrgwlbH0ghJuwIvAS4CiIjHImJDa6Oq2yRgsqRJQA9wV4vjqVpEXA/cX9b8WuDS/PxS4LimBlWMrshhzl/tqcvyFziHNaWwGu62ER27Mg+RNBc4CLixtZE05DPAh4AnWh1Ig/YG1gMX590CF0qa0uqgahURa4ALgNXA3cADEfHj1kbVsBkRcXd+vhaY0cpg6tR1Ocz5q610Rf4C57AhPni9DpKmAt8C3hcRD7Y6nnpIOha4JyKWtjqWAkwCDga+GBEHAY/QmbucdiP9OtobmAlMkXRSa6MqTqRru/j6Li3m/NV2uiJ/gXPYkGYUVl112whJO5CSUn9ELG51PA04FHiNpJWkXRsvlXR5a0Oq253AnREx9Ov7SlKi6jQvA26PiPURsQlYDLyoxTE1ap2kpwLkv/e0OJ56dE0Oc/5qS92Sv8A5DGhOYdU1t42QJNJ+8Fsj4tOtjqcREXFWROwZEXNJ/5NrI6Ijf1lExFrgDklDdyE/ErilhSHVazVwiKSevKwdSYcexFriu8Ap+fkpwHdaGEu9uiKHOX+1py7KX+AcBjRwS5tq1Xnrm3Z1KHAysFzSb3PbhyPiBy2MyZJ/BPrzF99twGktjqdmEXGjpCuBm0hncC2jg24NIekK4HDgKZLuBD4KnAd8Q9JbgVXAG1sXYX26KIc5f7Wvjs9f4By25XN8SxszMzOzYnT1weuSVkp6WRvEMVvSw/l6OEhaIult+fmpkm5obYTtS9JkSd+T9ICkb+a2cyTdK2lt+byt8DmHSVrRnKjNitFGOWyb9ac0Lklnd/DxTWNO0gxJ10t6SNK/KblY0l8k/bra3CRpvqROP8NuXOjqwqoIki6XdLekByX9caggqkVErI6IqRGxeSxirMdwybC04Gsjryed3vrkiHiDpNnAB4D9ImKPaudtRPw8IuZVGqdajXzZSTpQ0lJJg/nvgRXGfbjssVnSf+ZhhyhdBfh+SeslfXPoAMs8/AylKx8/JOl2SWfUE691D0nPlPRoPUVQketPUSRdIumcsra2KETLLADuBXaJiA8ALwZeDuwZEc+vdt5GRH9EvKKIgCSFpGfU+d4jla4QP6h0Jf85o4x/es5BjyhdVf5Zw4zzlZFiamS5bRUXVqM7F5gbEbsArwHOkfTcFsc0nswB/hgRj+fXs4H7IqLjzi7Lx098B7gc2I10sbnv5Pbt5IJxakRMBfYANgLfzIN3Ix27MJc0jx4CLi7tDnhzHu+VwHskddIVkK14nycdiG/NNQe4JbYedzMHWBkRj7QwprpIegrpTL9/BnYHBoCvVxj/bcBbSRdynQocSyoyS8d5MfD0Ct123nIbEV37AFYCL8vP9wVuB05s4PPmkS569sYRhj+ftKA9CKwDPp3b55KufTEpv14CvC0/PxW4gXRRtb/kGI8u+cyZpLMS7gf+DLy9ZNglwDklrw8nnbZb+t5vkS4+dzvw3tz+SuAxYBPwMPA7YBGwGXg0t30uj7sP8JPc/4qRpj2Puzvpy/2uPC1XlQx7e47//jw9M0uGDdsH8LGyON9BKi6eyK8vGWbeDhtDtfMmDzsb+AbwVVLBcjPpFg0Al+X+N+YYPlTD8vMK0mn6KmlbDbyyiveeQjqoVSMMPxh4qML7/wP4z1avk37U9qCgHEY6c+4bedm+vMJ4x5DOSHsoL6sfzO3l60+rLVj9AAAgAElEQVRpXCOuLyVxLwE25GGvKRm2hJwL8+tTgRtKXo+UGxbkvPBYXg+/N9K6Sbp9zy9y/78DDq8w/XuRCof1wH1szYMTgI+QDl6+J0/rriXvG7YPUo4qjfMdpBy7Ob/+2DDzdqQYqpo3Jf1+Hvh+/p/cCDw9D7uelDMfyTG8qYblaAHwi5LXU/L83meYcSeQLqx7ZIXPm0Q6wP3ZOaZn1LPcttuj5QGM6cTllZ/0pbMaOLZk2NV5JRjucXXZ53wBGMz/+JuAqSP090vg5Px8KnBIfj6XyoXVJlLhMRF4F6koGDqx4Prc/07AgXlle2kedgkjFFZ5oV4K/AuwI/A00hfzUXn4dgsq2ye5KXnFOC2vAAeRfm3sN8L0f5/062U3YAfg73L7S/P7DgaeBPwncH01fZTHyfZJqHzejhRDrfPmUdKXzETSVstflS9XZdM+0rK0ATgzj/N+4Idl77uadP+20Zbla4GzKwx/X2mMZcNESl7vbPU66UdtDwrIYcAuwB9J19/abr0v6+9u4LD8fDfg4Py8fL3bsg5UWl/yOvhn4MN5XXsp6Yt+Xh6+hBEKK0bPDZdQkv/K48qvZ5GKk2Pyev/y/Hr6MNM+kVQU/XvueyfgxXnYW/J0PI2U2xcDl1XTR3mcbF8gbZm3o8RQ67y5j/RjfxLQD3ytpM9tihjSnoBKOewf8nifJV3ItHS+/R543TDzc3bu5/Qc6+2kQnJCyThnAJ8dIaaql9t2e4yHXYGHkbaQvDkittwBPSKOjYhpIzyOLf2AiHg3sHP+rMXAX0foaxPwDElPiYiHI+JXVca4KiK+HOk4oUuBpwIzJO1FOkX6nyLi0Yj4Lem+WG+u4jOfR1qxPx7p3lO3AV+mthtiHkvaZH1xRDweEctIW3neUD5iPr7naNKX918iYlNE/CwPnk86Rf2miPgrcBbwQqXbalTdx2hGiaFUNfPmhoj4Qf6fXEa6MeqIKixL0yLivDzaVOCBsrc+QFq2Kk3XHODv2Hq/qvLhzyYViSMdR3U2KeFfXKkfa1uN5rBPABdFxJ1V9LUJ2E/SLnkduqnKGEdaXw4hLffn5XXtWlJBeGIVn1lEbjgJ+EGO7YmI+Alpr8Ixw4z7fNKW7DMi4pGcc4dOLJpP2gNxW0Q8TMphJyjdD6+WPkZTKYZS1cybb0fEryMdRtFP+mE+rEjHqlbKYf+dR60lh+2Z/74COAA4gvR/fytA/n57Byl3DaeW5batjIfC6p2kTZdLGvmQiNicF/A9SVuVhvNW4FnAHyT9Rum2C9VYW9LPYH46lbSC3R/phqlDVlHdfcrmADMlbRh6kH411nKvtjnAC8o+Yz7peJ9ye+VY/zLMsJk5bgByYrovT0ctfYymUgylqpk3a0ueDwI75STaiIdJv8JK7UL6BV/JyaQvrtvLB+SDPX8InB4RPx9m+HtIhfirclFrnafuHJZPjngZaQtINV5HKghWSfqZpBdW+b6R1peZwB0RUXo/v1pyWKO5YQ7whrLPeDHpx2u5vUg/ch8fZtg2OSw/n0TKGbX0MZpKMZSqZt6U/0+m1hFPuVpy2Mb8918jYkNErAT+i60F52eAj0dEeaFWz3LbVsb8AqFt4J3AP0n694h4/1CjpB+SfgkO5+cRcfQIwyYxwoF2EfEn4ERJE4DjgSslPbn+0LkL2F3SziXF1Wy23k7jEdLdw4eUrlR3kG4t8MwRPjuqaLsD+FlEvLyKWO/IsU6L7e/MfhcpEQCgdIPRJ5Omo5Y+GomhfLxK82Y02807SQ9XGP+TEfFJ0vElH5CkiBj6jGeTjoWo5M2ki9SV9zkH+B/gExFx2TDD30K659hLOvFXn23RSA47nLS7fLUkSF+uEyXtFxHb3TYlIn4DvFbp1jfvIR3fslf5eDW4C9hL0oSS4mo2aRcPjJ7DKuWGanPYZRHx9ipivQOYLWnSMIXNNjmMNA2Pk46lraWPRmIoH6+ovEk+27rS1d7fERH9pBx2Ssn7ppC+D4e7YO4K0rFlpf+T0udHAi+W9K8lbb+UdDrwN9Sw3Lab8bDF6iHSwdovkbTlyykijo6Ss67KHkcDSPobSSdImippoqSjSJsyfzr0OfkU0cPz85MkTc8JZOiLve47r0fEHaQDIs+VtFPe5fNW0lllAL8FjpG0u6Q9SMfZDPk18JCkf1K6FtRESftLel4evg6Ym4tAStqeVvL6auBZkk6WtEN+PE/SvsPEejdpy8kXJO2Wx31JHnwFcJrSpQaeBHwSuDH/gqm6jyrmV6UYSo02b0ZTPp+osCxNzUUVpONJNgPvlfSkvDUJ0vFTw5L0ItKv+2+Wtc/K7/tcRHxpmPfNJ83nl0fa1Wmdq+4cRjpz9Omk3UAHAl8iHYd4FICkuTmHzZW0o9K1knaNdJ+3B2kgf2U3kraWfCivj4cDrybd3w9SDjte6RYozyDvJspGyw3brYfDtF0OvFrSUXk930nS4ZL2ZHu/Jh1jdp6kKXncQ/OwK4D3K93WaCpp3fp6Ln5q6WM0lWIo1Wje3GY+xdbL1oz06M+jfhvYX9LrJO1E2o33vxHxh/IO8t6Xr5P+9zvn+bEgxw5p785z2LpsQlo2vs0oy227Gw+FFXnrxcuBoyV9opa3knb73Uk6w+wC0h3hvwtb9hE/BCzP478SuDlvvfgscEJEbNzuU2tzIqlyv4u0wH00Iv4nD7uMdKDjSuDHlJz2GulYh2NJC+XtpAMbLwR2zaMMfVHfJ2noOIrPAq9XunDdf+StZK8gHXt0F2nT8qdIB6AP52TSMRp/IJ05874cy/+QTs/9FilpPD1/JnX0MZphYyhVxbwZzbnAR5Q2wX+w2sAi4jHgONIWqA2kA2KPy+1I+nDeClHqFGBx2e5ggLeREuPZKrnWVcnwc0hbBX9TMny7Asw6Q705LCIGI2Lt0IO0K+fRiFifR9mLtFtraCv4ycBKSQ+StpTNbzDux0hflkeT1rMvkI4VG/oi/nfSVo11pGMI+0veO1puuIh0PNgGSVfltm3Wzfzj9LWkXf3rSVt6zmCY776cF14NPIN0osCdwJvy4K+Q8u31pJzxKOk2NNTSRxXzq1IMpeM1mjfPBi7N86nq20zl5eZ1pLPI/wK8gJJjUyV9qSzPvIe0zN1FOrnrv0nzkoi4p2zZBLg3IjZWsdy2Nd/SpgGSTgL+NiLOanUsZma1kvQRYH1E/FerYzHrFi6szMzMzAoy6qZKpUvN3yPp9yVtuyvdTuNP+e9uYxummVl9nMPMrJmq2Qd8CenYoVJnAj/NZ1X9NL82M2tHl+AcZmZNUtWuQKULOV4dEfvn1ytIl+y/W+mijEuizW7QaWY2xDnMzJql3utYzcintkM6G2HEi05KWkA6xZIpU6Y8d5999qmzSzPrNEuXLr03Iqa3Oo5hVJXDnL/Mxrd6cljDFwiNiJA04maviOgjXZOC3t7eGBgYaLRLM+sQklaNPlZrVcphzl9m41s9Oaze61ity5vPh+7Pdk+dn2Nm1grOYWY2JuotrL7L1svanwJ8p5hwzMyawjnMzMZENZdbuIJ0xdR5ku6U9FbSfcteLulPpBslbncfMzOzduAcZmbNNOoxVhFx4giDjiw4FjOzwjmHmVkzjYt7BZqZmZk1gwsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMriAsrMzMzs4K4sDIzMzMryKRG3izp/cDbgACWA6dFxKNFBGadb48L9mDdI+u2a58xZQZrP7i2BRGZbcs5zEbi/GX1qnuLlaRZwHuB3ojYH5gInFBUYNb5hktKldrNmsk5zCpx/rJ6NborcBIwWdIkoAe4q/GQzMyaxjnMzApVd2EVEWuAC4DVwN3AAxHx4/LxJC2QNCBpYP369fVHamZWoGpymPOXmdWqkV2BuwGvBfYGZgJTJJ1UPl5E9EVEb0T0Tp8+vf5IzcwKVE0Oc/4ys1o1sivwZcDtEbE+IjYBi4EXFROWmdmYcw4zs8I1UlitBg6R1CNJwJHArcWEZd1gxpQZNbWbNZlzmI3I+cvqVfflFiLiRklXAjcBjwPLgL6iArPO51OSrZ05h1klzl9Wr4auYxURHwU+WlAsZmZN5RxmZkXzldfNzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCtLQdazMKtnjgj1Y98i67dpnTJlR2MX3mtGHmY0/zl9WL2+xsjEzXMKo1N6ufZjZ+OP8ZfVyYWVmZmZWEBdWZmZmZgVxYWVmZmZWEBdWZmZmZgVxYWVjZsaUGTW1t2sfZjb+OH9ZvXy5BRszzThd2Kckm9lYcP6yenmLlZmZmVlBXFiZmZmZFcSFlZmZmVlBXFiZmZmZFcSFlZmZmVlBXFiZmZmZFcSFlZmZmVlBXFiZmZmZFaShC4RKmgZcCOwPBPCWiPhlEYFZ59vjgj1Y98i67dpnTJlR2IXxmtGHdS/nMBuJ85fVq9Err38W+FFEvF7SjkBPATFZlxguYVRqb9c+rKs5h9mwnL+sXnUXVpJ2BV4CnAoQEY8BjxUTlpnZ2HIOM7Ox0MgxVnsD64GLJS2TdKGkKeUjSVogaUDSwPr16xvozsysUKPmMOcvM6tVI4XVJOBg4IsRcRDwCHBm+UgR0RcRvRHRO3369Aa6MzMr1Kg5zPnLzGrVSGF1J3BnRNyYX19JSlJmZp3AOczMCld3YRURa4E7JM3LTUcCtxQSlXWFGVNm1NTern1Yd3IOs0qcv6xejZ4V+I9Afz6b5jbgtMZDsm7RjNOFfUqyNcg5zIbl/GX1aqiwiojfAr0FxWJm1lTOYWZWNF953czMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgLqzMzMzMCuLCyszMzKwgDRdWkiZKWibp6iICMjNrFucvMytaEVusTgduLeBzzMyazfnLzArVUGElaU/gVcCFxYRjZtYczl9mNhYa3WL1GeBDwBMjjSBpgaQBSQPr169vsDszs8I4f5lZ4eourCQdC9wTEUsrjRcRfRHRGxG906dPr7c7M7PCOH+Z2VhpZIvVocBrJK0Evga8VNLlhURlZja2nL/MbEzUXVhFxFkRsWdEzAVOAK6NiJMKi8zMbIw4f5nZWPF1rMzMzMwKMqmID4mIJcCSIj7LzKyZnL/MrEjeYmVmZmZWEBdWZmZmZgVxYWVmZmZWEBdWZmZmZgVxYWVmZmZWEBdWZmZmZgVxYVWP666DuXPTXzOzTuL8ZTamXFjV6rrr4NhjYdWq9NfJyTpMf3/6Xp0wIf3t7291RNY0zl/W4Tohf7mwqsVQUhocTK8HB52crKP098OCBel7NSL9XbCgPZOTFcz5yzpcp+QvF1bVKk9KQ5ycrIMsXDj8IrxwYWvisSZx/rIu0Cn5y4VVtU47bfv/6JDBwTTcrM2tXl1bu3UJ5y/rAp2Sv1xYVevii6GnZ/hhPT1puFmbmz27tnbrEs5f1gU6JX+5sKrWEUfA1Vdvn5x6elL7EUe0Ji6zGixaNPwivGhRa+KxJnH+si7QKfnLhVUtypOTk5J1mPnzoa8P5swBKf3t60vt1uWcv6zDdUr+UkQ0rbPe3t4YGBhoWn9j5rrr0jEJF1/spGRWgaSlEdHb6jiK4PxlNv7Uk8MmjVUwXe2II2DlylZHYWZWO+cvszHlXYFmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlaQ7iqsrrsO5s7tjhuKdtO0mFl1umW975bpMKtD3YWVpL0kXSfpFkk3Szq9yMBqNnT39lWrOv9u7d00LVaT/v70fTRhQvrb39/qiLqXc9gY6ZbpsJo5f2URUdcDeCpwcH6+M/BHYL9K73nuc58bY+LaayN6eiJg66OnJ7V3mm6aFqvJ5ZcP/6+//PJWR1Y/YCDqzDFj/ag1h41Z/oronvW+W6bDataN+SuivhxW9xariLg7Im7Kzx8CbgVm1ft5dRv6dTQ4uG374GDn/Vrqpmmxmi1cOPy/fuHC1sTT7ZzDCtYt02F1cf7aqpB7BUqaC1wP7B8RD5YNWwAsAJg9e/ZzV61a1XB/25g7N21yHsmcOZ1z+4Zumhar2YQJ6XdeOQmeeKL58RShU+4VOFIOG/P8Bd2z3nfLdFhdujF/QX05rOGD1yVNBb4FvK+8qAKIiL6I6I2I3unTpzfa3fYuvnjr3drL9fSk4Z2im6bFajZ7dm3tVoxKOWzM8xd0z3rfLdNhdXH+2qqhwkrSDqSE1B8Ri4sJqUZHHAFXX739Ct3Tk9o76e7t3TQtVrNFi4b/1y9a1Jp4xgPnsAJ1y3RYXZy/tmrkrEABFwG3RsSniwupDuUrdCevyN00LVaT+fOhry/tMZHS376+1G7Fcw4bA90yHVYz56+t6j7GStKLgZ8Dy4GhPagfjogfjPSe3t7eGBgYqKu/qlx3HZx2Wtrk3OkrcjdNi41b7XyMVa05bMzzF3TPet8t02HjXj05rJCD16vVlMRkZm2jnQurWjl/mY0/LTl43czMzMwSF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBXFhZWZmZlYQF1ZmZmZmBemuwuq669L9qnyzTzPrRM5hZh2vewqroTurr1rlO6lb4d79bpg0KV1ReNKk9LpT9fen7+4JE9Lf/v5WR2SAc5iNmck/+xlasmS7x+Sf/azVodWsE/JXdxRWQwlpcDC9Hhx0YrLCvPvd8MUvwubN6fXmzel1JxZX/f2wYEH67o5IfxcsaM/kNK44h9kYevrkyTW1t6tOyV+dX1iVJ6QhTkxWkL6+2trb2cKFw68qCxe2Jh7DOczG3OX77jts+3+P0N6uOiV/dX5hddpp28/pIYODabhZA4a2VFXb3s5Wr66t3ZrAOczG2IE778zfDt0YO/vbnh6evfPOLYqoPp2Svzq/sLr44q13Ui/X05OGmzVg4sTa2tvZ7Nm1tVsTOIdZE5Rvteq0rVXQOfmr8wurI46Aq6/ePjH19KR231ndGrRgQW3t7WzRouFXlUWLWhOP4RxmTVG61aoTt1ZB5+Svzi+sYPvE5IRkBfrCF+Bd79q6hWrixPT6C19obVz1mD8/HRs2Z046w3HOnPR6/vxWRzbOOYdZE1y+777sOnFiR26tgs7JX4qIpnXW29sbAwMDY9fBddel4xEuvtgJyawNSFoaEb2tjqMIY56/wDnMrM3Uk8MmjVUwLXHEEbByZaujMDOrj3OYWcfrjl2BZmZmZm3AhZWZmZlZQVxYmZmZmRXEhZWZmZlZQVxYmZmZmRXEhZWZmZlZQVxYmZmZmRWkocJK0islrZD0Z0lnFhWUmVkzOIeZWdHqLqwkTQQ+DxwN7AecKGm/ogIzMxtLzmFmNhYa2WL1fODPEXFbRDwGfA14bTFhmZmNOecwMytcI7e0mQXcUfL6TuAF5SNJWgAsyC//Kun3DfTZTp4C3NvqIArQLdMBnpZ2NK/VAVQwag5z/uoI3TIt3TId0F3TUnMOG/N7BUZEH9AHIGmgW27I2i3T0i3TAZ6WdiRpjO9aPLacv9pft0xLt0wHdN+01PqeRnYFrgH2Knm9Z24zM+sEzmFmVrhGCqvfAM+UtLekHYETgO8WE5aZ2ZhzDjOzwtW9KzAiHpf0HuAaYCLwlYi4eZS39dXbXxvqlmnplukAT0s7atvpqCOHte201MHT0n66ZTpgnE+LImIsAjEzMzMbd3zldTMzM7OCuLAyMzMzK0hTCqtuuW2EpL0kXSfpFkk3Szq91TE1StJEScskXd3qWBohaZqkKyX9QdKtkl7Y6pjqIen9edn6vaQrJO3U6piqJekrku4pvdaTpN0l/UTSn/Lf3VoZY726IYc5f7Wvbslf4BwGTSisuuy2EY8DH4iI/YBDgP/TwdMy5HTg1lYHUYDPAj+KiH2A59CB0yRpFvBeoDci9icdUH1Ca6OqySXAK8vazgR+GhHPBH6aX3eULsphzl/tq+PzFziHDWnGFquuuW1ERNwdETfl5w+RFv5ZrY2qfpL2BF4FXNjqWBohaVfgJcBFABHxWERsaG1UdZsETJY0CegB7mpxPFWLiOuB+8uaXwtcmp9fChzX1KCK0RU5zPmrPXVZ/gLnsKYUVsPdNqJjV+YhkuYCBwE3tjaShnwG+BDwRKsDadDewHrg4rxb4EJJU1odVK0iYg1wAbAauBt4ICJ+3NqoGjYjIu7Oz9cCM1oZTJ26Loc5f7WVrshf4Bw2xAev10HSVOBbwPsi4sFWx1MPSccC90TE0lbHUoBJwMHAFyPiIOAROnOX026kX0d7AzOBKZJOam1UxYl0bRdf36XFnL/aTlfkL3AOG9KMwqqrbhshaQdSUuqPiMWtjqcBhwKvkbSStGvjpZIub21IdbsTuDMihn59X0lKVJ3mZcDtEbE+IjYBi4EXtTimRq2T9FSA/PeeFsdTj67JYc5fbalb8hc4hwHNKay65rYRkkTaD35rRHy61fE0IiLOiog9I2Iu6X9ybUR05C+LiFgL3CFp6C7kRwK3tDCkeq0GDpHUk5e1I+nQg1hLfBc4JT8/BfhOC2OpV1fkMOev9tRF+Qucw4AGbmlTrTpvfdOuDgVOBpZL+m1u+3BE/KCFMVnyj0B//uK7DTitxfHULCJulHQlcBPpDK5ldNCtISRdARwOPEXSncBHgfOAb0h6K7AKeGPrIqxPF+Uw56/21fH5C5zDtnyOb2ljZmZmVoyuPnhd0kpJL2uDOA6TtKLk9Za4JJ3dwccGjDlJMyRdL+khSf+m5GJJf5H06/J5W+Fz5kvq9LNTbJxplxwGIOlhSU/Lzy+RdE5+fnj+dW/DKM9Zue1dktblefrk0nlb4XNm5/EmNidyq1dXF1ZFkLRE0qN5gX64mi/xchHx84iYN/qYzVOaGEva2iaJl1gA3AvsEhEfAF4MvBzYMyKeX+28jYj+iHhFEQFJCknPqPO9RypdXXlQ6SrYcyqMu1LSxpJl78clw06VtLlk2MOSDq/mvTa+SJor6Qf5i32tpM8pXWOoJhExNSJuG4sY65HXgRvK2rbLa21gm5yVTyD4NPCKPE/vq2beRsTqPN7mRgPK32tvq/O9c3PuGsy5bMTvDEn/KukOSQ9KWiXpwyOM9+acV99W0iZJn5J0X358SpLqibnZXFhV5z15gZ7abgXSODAHuCW27rOeA6yMiEdaGFNdJD2FdJbMPwO7AwPA10d526tLlr3ywvCXJcOmRsSSGt5r48cXSGcyPRU4EPg74N0tjWh8Kc9ZM4CdgE48Tg/gCtKxU08GFgJXSpo+wrgXAftExC6kswPnSzq+dASlSzR8mO3nxwLSxTifAzwbeDXwjqImYiyNm8JK0r6Sbpd04hj2cYzSfbgekrRG0gdz+2ibyneU9NX8vpsl9ZbFvUTShjzsNSXDtvnVUf4LTtI+Svc2ul/pPmdvzO0LgPnAh/LWjO9JugyYDXwvt30oj3uIpF/k/n9XulVkmOnfS9JiSevzL4zP5fYJkj6Sf7Hck6d115L3DduHpEtIZ2EMxfkO0lWWX5hff6x83laIoap5M9SvpM9L+n7+n9wo6el52PV5tN/lGN5U4f9a7njg5oj4ZkQ8CpwNPEfSPjV8ho1TDeSwvYFvRMSj+Qy0HwF/O0Ifz5D0M0kPSLpX0tdLhlXcUivpA3n9vlvSaSXtu+Z1fn3OAR+RNCEP2+ZQCKWtIaG8RS2/96L8mWsknaN0f8B9gS+xNRdsGC6v5c+YKelbuf/bJb23wjRMVjrkYFWeBzdImpyHvSbn4A059+5b8r5h+1A64Lk0Z10BDO312CDp2vJ5O1IM1c6bPOzU/L4LlLZU3i7p6DxsEXAY8Lkc0+dGmh/DzJ9nkS4F8dGI2BgR3wKWA68bbvyIWFH2I/gJoHwZOhf4D9KeiVKnAP8WEXfmC4/+G3BqtbG2VER07QNYSbquxsGk00CPLRl2NbBhhMfVJeMtIV0V917g/wKHV+jvbuCw/Hw34OD8/HDSdUq2iSs/Pxt4FDiGdMbRucCv8rAdgD+TqvkdgZcCDwHzSmJ7W8nnngrckJ9PIV0t+jTS2Z8H5WnYLw+/BDhnuPlV8noWcF+ObQJpc/Z9wPRhpn0i8Dvg33PfOwEvzsPekqfjacBU0laby6rpozzO0mksn7ejxFDrvLmPdCuTSUA/8LWSPgN4Rsnr2Yy8LG0A/iGP91nSRQBL59vvgddVWH7XkZa/HwPPKZsPj+S4/0jaCjapmvf60TkPislh7wC+Srq9yKy8zP39CP1dQdoKMaF0/cnDtiz3petlXgcfBz5OylnHAIPAbnn4V0mnqO8MzM3L61vzsLOBy0v6mJv7mZRffxv4r7zO/g3wa+AdediplOSC8rjy6wnAUuBfSDn0aaSz7o4aYfo/T8qrs0j55EXAk4Bn5fXt5XkaP0TKaTuO1kd5nOXTOMy8HSmGWufNJuDt+TPeRbq1zNAJa0so+e7Ibf/LyMvTF/I4f0+6XEfp+z4H/GeFZfhM4OEc+22kXaJDw55P2nI/oTwm4AHgBSWve4GHWr1OVvMYD1usDiNdh+LNEbHlDugRcWxETBvhcWzJ+/+JtKLMIp02+r2hrRfD2ATsJ2mXiPhL5PtyVaerxccAABrxSURBVOGGiPhBpH3nl5E2fUK6UepU4LxI94+6lpRMq/nFeixp8/PFEfF4RCwjXRjwDVXGBHAS8IMc2xMR8RPSSnDMMOM+n3Sl3TMi4pFIv46HthDNBz4d6V5rDwNnASfkX1619DGaSjGUqmbefDsifh0Rj5MKqwNH6jTSsQ8jLUvTIuK/86hTScmi1AOkL5zhzCcl0znAdcA1kqblYdcD+5MS6utIy8QZVb7XOkujOex60haqB0kXoxwArhqhr02kZWZmhfVnpPd9PCI2Rbp8w8PAvLwF5QTgrIh4KCJWkrY8nDzaB0qaQcoD78vr8z2kH0213NT3eaQfaR/POfQ24MvDfUbeivYW4PSIWBMRmyPiFxHxV+BNwPcj4ieRLnx5ATCZVPRU3UcV01wphtLxqpk3qyLiy/l75VLSruARb8cSEc+usDwN7TquNYcREefl4QeTvt8eyNMwkbSb+j0RMdxticr7egCYKrX/cVbjobB6J/CL2P74k6pExI05Ifw1Ii4lbbUa6Uv/dXnYqrw5/YVVdrO25PkgsFMuOmYCd5QtdKuo7j5lc4AX5M3WGyRtIH3Z7lFlTEOf8Yayz3gxaQUttxdpRX58mGEzc9yl0zCJtJLX0sdoKsVQqpp5U/4/mVpHPOUeBnYpa9uFtBVyOxHxfyNtbh+MiHNJvxwPy8Nui4jbczG6nLS14PXVvNc6Tt05LH9R/4i0lXgK8BTS1vRPjfCWDwH6/9u7/yi5yvqO459vdklgN7Bgk5PlR5Kl1ipJDoJdFEgOELEtHBPR1nKowWqg3dZSBNRafpSTcCiWnoOitfVHDhI4hxXxIK02VWsPLlIqxWzYgAlosbBJID9YfphAVhPjfvvHcyc7meyvmfvM3Jk779c5e2bnzp293zs7873fee5zn0fSj5LTXpdNcVMvl3zuCp+ZWQotPKWf/6nmsCMk7Sj6nH5Z4cvEVM2XdELJZ/16jV1gzFJopfu/MR47JIclOXlbsh/lbGMyE8VQbCqvzcEc5u7Dya9p81hZOaxo+558gf2FpJuSxX8p6Ul3/58pbusYSa+7e92PEdUshdU8M7u9eKGZfccOvaKq+Oc7E/w9V0g8hz/gvt7dL1J4c/+rpK+njH27pLmF/giJeRqdTmOvQvN+QXFhsE3SD0q+dcx0948U7cdhu1Byf5vCKbviv9GefAMptU3hdR7raqPtComgeB8OKJyqKmcbk5kohtL1JnptymKjl0GP97MiWXWzRlsjZWGi1Tdq6p1Yx33vTfLYVB5H/UqTw96g8Hn7p+TL4cuS1mqcL4fuvtPd/8zdT1A4hfgFq/AK2MRLGm0FKygnh+2TNKvoc3qMuxf6h001hz1X8lk/2t3H2v+XFLpljHVG4pAclrSazE32o5xtTGaiGEr3a6LXZjKHvXZJIT3e++lLyWqbJf2mmRW3UL1VU89hrRrdt/Mlvc/Clao7FVr/Pl3U5+uQfFnmdjLVDIXVa5IukHSOmR08WLv7hX7oFVXFP4VOfsea2e+b2ZFm1pocIM9R+AZY3NGyy8ymWxgrqSNpKt6j9LOuP6bwze+TZnaEhU7dyxXmxpKkjZL+wML0Ab8l6fKi566T9Ntm9sHkuUeY2Rk22uFyl8IpzmKly+6RtDx5DVqS1+E8MztpjFh/pNDH7FYza0/WXZw8dq+kayxMCTJT0qck3Zd8wy1nG5OZKIZik702kznkdfLRy6DH++lNVv0XSYvM7A/N7EiFPhlPuvtPSjeQFGuLk/fVkWb21wrfZv87efxCC6cDZKHz+41KplqY7LloOBXnMHd/SdJzkj6S5LBjFToFP1n4OxaG5vhw8vsfFX32XlU4AFecx5LTUF+XdIuZHW1heJGPKXzupZDDzknesx0K3QQKz92h0D/w02Z2jIWLYN5oZucmq+ySdJKF0cpVtKw4h/1I0mtm9jcWOoC3mNkiMztjjFhHJN0p6TMWOqO3mNlZZjYj2Yd3Wxgu5QhJH1cobH5Yzjam8HpNFEPxepO9NpM5LP+7+8IJ3k9/kazzvwr/s1VJbnmfwhV73yjdQBLTn5vZcRa8XdIVkh5MVvmwpFMUulmcpnCK+iaFPn5S6Jv3MTM70cxOUHjN75ri/mWqGQorufvPFTodXmhmN5fx1CMk/Z1GO69fKem9yZtLSk49afTb1wclDZrZHoVvmSuUgrvvVyikLky2/wWFfhaFA/HtkvYrfEjuVugLVHjua5J+T+Gc+3aFZuF/UOgEKYXLYBdYaEYu9Lf4e0l/myz7hLtvU5ip/PrkNdim0I/nsPdNkkCXK1zxsVWhL0fhirk7Fc6tP6yQ5H+p8FqqnG1M4fWaKIbi9SZ7bSazWtLdyes05Sla3H1I4XTxLQoHrXeoqE+EmX2p6Jvh0ZK+mKz3gsKB9cKkxUEK3/aeNLO9kr6tcKrnU1N8LhpMihwmhatRL1D4fP1MoQXpGklKipLfkFQ4HXOGpMfM7HWFfl1Xefqxq65UaJl6VtIjkr6qkBPkoU/lfQqF3gaFLz3F/kShQ/hTCu/n+zXaTeD7Ci0YO82scEXZIXktyQnLFA7czynk0TskdWhsn1C4ym29pFcU8sI0d/+pQn/Qzyd/Y7nCcCb7K9jGZMaMYYz1JnptJvM5Se+3cMXgP5YZ3yUKHclfVZju5f1JbisMxFzcqvQ+hdOarykU059PfuTuP09aSHd6uFp1v6Q97l7oV/VlSf+m8FpskvTvybK6x5Q2KZjZ30oacveG+GcDQDEzWyLpCnev2jA0QLOhsAIAAIhk0tMtZnanhUHfNhUte4OFwRWfSW6Pq26YAFAZchiAWppKP5a7FM7PF7tW0oPu/iaFjmjXRo4LAGK5S+QwADUypVOBZtalMJLvouT+TxVGIN9hZsdLesiZQw9AnSKHAaiVsmc4T8xJLveUwhVV4w6EZmH+ph5Jam9v/523vIVp0YBmsWHDhpfcfbwJWrM0pRxG/gKaWyU5rNLC6iB3dzMbt9nL3dcoTAWj7u5u7+/vT7tJAA3CzLZMvla2Jsph5C+guVWSwyodx2pX0nyu5PbFCv8OAGSBHAagKiotrL6lMHqvkttvxgkHAGqCHAagKqYy3MK9kh5VmKn8eTO7XGG01d81s2ckvSu5DwB1hxwGoJYm7WM1wYi850eOBQCiI4cBqKWmmCsQAACgFiisAAAAIqGwAgAAiITCCgAAIBIKKwAAgEgorAAAACKhsAIAAIiEwgoAACASCisAAIBIKKwAAAAiobACAACIhMIKAAAgEgorAACASCisAAAAIqGwAgAAiITCCgAAIBIKKwAAgEgorAAAACKhsAIAAIiEwgoAACASCisAAIBIKKwAAAAiobACAACIpDXNk83sGkl/Kskl/VjSSnf/ZYzA0Pg6b+vUrr27Dls+p32Odn5iZwYRAYcih2Ei7r/Wtm23a+vWWzVv3nWaO/dqmbVkHRbqXMUtVmZ2oqSPSup290WSWiRdEiswNL6xiqqJlgO1RA7DRIaHn1F/f7cGB1frwIGXNTi4Shs2nKHh4WeyDg11Lu2pwFZJR5lZq6Q2SdvThwQANUMOw5gGBhZr794nNTKyV5I0MrJXr7/+hAYGFmccGepdxYWVu78g6TZJWyXtkLTb3b9Xup6Z9ZhZv5n1Dw0NVR4pAEQ0lRxG/mpe7e0LJY2ULB1Re/uiLMJBA0lzKvA4SRdJOlnSCZLazezS0vXcfY27d7t79+zZsyuPFAAimkoOI381r87Oy9XSMvOQZS0tM9XZeVlGEaFRpDkV+C5Jz7n7kLv/StIDks6OExYAVB05DOOaNWu5whniUWatmjVreUYRoVGkuSpwq6QzzaxN0i8knS+pP0pUyIU57XPGvSoQqAPkMIyrtbVDS5a8mnUYaEAVF1bu/piZ3S/pcUkHJA1IWhMrMDQ+hlRAPSOHAaiGVONYufsqSasixQIANUUOAxAbI68DAABEQmEFAAAQCYUVAABAJBRWAAAAkVBYAQAAREJhBQAAEAmFFQAAQCSpxrECJtJ5W+e4I6/HGjy0FtsA0Jzcf61t227X1q23at686zR37tUya4n298lf+USLFapmrIQx0fJ63QaA5jM8/Iz6+7s1OLhaBw68rMHBVdqw4QwNDz8TbRvkr3yisAIAoMTAwGLt3fukRkb2SpJGRvbq9def0MDA4owjQ72jsAIAoER7+0JJIyVLR9TeviiLcNBAKKwAACjR2Xm5WlpmHrKspWWmOjsvyygiNAoKKwAASsyatVxmh17fZdaqWbOWZxQRGgVXBaJq5rTPGfeKl0baBoDm09raoSVLXq3qNshf+URhhaqpxeXCXJIMoFGRv/KJU4EAAACRUFgBAABEQmEFAAAQCYUVAABAJBRWAAAAkVBYAQAAREJhBQAAEAmFFQAAQCSpBgg1s2Ml3SFpkSSXdJm7PxojMDS+zts6xx1VONbAeLXYBvKLHIbxkL9QqbQjr39O0nfd/f1mNl1SW4SYkBNjJYyJltfrNpBr5DCMifyFSlVcWJlZh6RzJH1Yktx9v6T9ccICgOoihwGohjR9rE6WNCRprZkNmNkdZtZeupKZ9ZhZv5n1Dw0NpdgcAEQ1aQ4jfwEoV5rCqlXS2yR90d1Pl7RX0rWlK7n7Gnfvdvfu2bNnp9gcAEQ1aQ4jfwEoV5rC6nlJz7v7Y8n9+xWSFAA0AnIYgOgqLqzcfaekbWb25mTR+ZKeihIVcmFO+5yyltfrNpBP5DBMhPyFSqW9KvBKSb3J1TTPSlqZPiTkRS0uF+aSZKREDsOYyF+oVKrCyt03SuqOFAsA1BQ5DEBsjLwOAAAQCYUVAABAJBRWAAAAkVBYAQAAREJhBQAAEAmFFQAAQCQUVgAAAJFQWAEAAERCYQUAABAJhRUAAEAkFFYAAACRUFgBAABEQmEFAAAQCYUVAABAJBRWAAAAkVBYAQAAREJhBQAAEAmFFQAAQCQUVgAAAJFQWAEAAERCYQUAABAJhRUAAEAkFFYAAACRpC6szKzFzAbMbF2MgACgVshfAGKL0WJ1laSnI/wdAKg18heAqFIVVmZ2kqR3S7ojTjgAUBvkLwDVkLbF6rOSPilpZLwVzKzHzPrNrH9oaCjl5gAgGvIXgOgqLqzMbJmkF919w0Trufsad+929+7Zs2dXujkAiIb8BaBa0rRYLZb0HjMblPQ1Se80s3uiRAUA1UX+AlAVFRdW7n6du5/k7l2SLpH0fXe/NFpkAFAl5C8A1cI4VgAAAJG0xvgj7v6QpIdi/C0AqCXyF4CYaLECAACIhMIKAAAgEgorAACASCisAAAAIqGwAgAAiITCCgAAIBIKK6AZ9fVJXV3hFgAQDYVVmXp7w/Fo2rRw29ubdURAmfr6pGXLpC1bwi3FVdMgfyEvVq/OOoLxUViVobdX6ukJxyP3cNvTQ3JCAykUVcPD4f7wMMVVkyB/IU9uuinrCMZHYVWGG24YPR4VDA+H5UDdKy2qCiiumgL5C6gNCqsybN1a3nKgrqxcefiRtWB4ODyO3CJ/odGtXi2ZhR9p9Pd6Oy1IYVWGefPKWw7UlbVrpba2sR9rawuPI7fIX2h0q1eH09ju4X7hdwqrBnbLLYcfl9rawnKg7i1dKq1bN/abeN268Dhyi/wF1AaFVRlWrJDWrJHmzw/Nj/Pnh/srVmQdGTBFpcUVRVXTIH8hT1atyjqC8ZkX2tRqoLu72/v7+2u2PQDj6OsLfarWrq1qUWVmG9y9u2obqCHyF9B8KslhrdUKBkAdW7pUGhzMOgoAyB1OBQIAAERCYQUAABAJhRUAAEAkFFYAAACRUFgBAABEQmEFAAAQCYUVUG/6+qSuLiZFBoAGVHFhZWZzzazPzJ4ys81mdlXMwCqxb8c+DZw7oH0792UdSiq9veG4Om1auO3tzToi1Exfn7RsmbRlS7iluKqaesphp69fL3voocN+Tl+/PquQKkb+am55OQ6nkabF6oCkj7v7AklnSrrCzBbECasygzcPavcju7Xl5i1ZhpFKb6/U0xOOq+7htqeH5NQUCkXV8HC4PzxMcVVddZPDzjrmGE03O2TZdDOd3dGRRTgVI38hD8fhtCourNx9h7s/nvz+mqSnJZ0YK7By7duxT7vW7pJGpJ1rdzZstXzDDaPH1YLh4bAcOVZaVBVQXFVNPeWwG7u6NK2ksGox043z52cRTsXIX80tL8fhtKL0sTKzLkmnS3psjMd6zKzfzPqHhoZibG5MgzcPykfCvIf+a2/Yannr1vKWIydWrjz8iFQwPBweR9WMl8Nqlb+OnzFDK+fMOdhqNd1MKzs71TljRtW2WQ3kr+aWl+NwWqkLKzObKekbkq529z2lj7v7Gnfvdvfu2bNnp93cmApVsu9P/qH7vWGr5XnzyluOnFi7VmprG/uxtrbwOKpiohxWi/xVUNxq1YitVRL5q5nl6TicVqrCysyOUEhIve7+QJyQyldcJRc0arV8yy2HH1/b2sJy5NjSpdK6dWP/89etC48junrJYdJoq9U0qSFbqyTyVzPL03E4rTRXBZqkr0h62t0/Ey+k8u15dM/BKrnA97t2/3B3RhFVbsUKac0aaf58ySzcrlkTliPnSosriqqqqqccVnBjV5eWdHQ0ZGuVRP5qZnk6Dqdl7j75WmM90WyJpP+S9GNJI8ni69392+M9p7u72/v7+yvaHtA0+vpCn6q1axu+qDKzDe7enXUcYyk3h5G/gOZTSQ5rrXRj7v6IJJt0RQDlWbpUGhzMOorcI4cBqAZGXgcAAIiEwgoAACASCisAAIBIKKwAAAAiobACAACIhMIKAAAgEgoroBn19UldXUzuDKDx1Hn+qngcq3q0b8c+PXXJU1pw3wLN6Gy86SBQn476wQ/0yzEG0j3STL8499wMIkqpr09atixM7rxsGaO714HT16/Xxr17D1t+Wnu7Bs44I4OIkEcbN27Ueeedp4cfflinnnpq1uFUpgHyV65arAZvHtTuR3Y35dxEqJ43HnVUWcvrWnFSkkaTU51+82sWZx1zjKbboWOVTjfT2R0dGUWEPLr00ku1e/dufeADH8g6lMo0SP7KTWFVmFlbI2raGbVRHfeccsqYy786zvK6VZqUCuo0OTWTG7u6NK2ksGoxa9g5A1FfzExmps2bN0uSNm/efHBZw2ig/JWbwqp4Zu1mnVEb1XHa0UdrYWFi5MTCtjadevTRGUVUoZUrD09KBcPD4XFk4vgZM7RyzpyDrVbTzbSys1OdM+jSgPQGBgY0v6RI7+rq0hNPPJFRRBVooPyVi8Kq0FpVmFnb9zutVoiqtNWq4VqrpDCpc0mBeFBbW3gcmSlutaK1CjGddtppam9vP2RZe3t7Y/WzaqD8lYvCqri1qoBWK8RU3GrVkK1VUujguW7d4cmpra0uO4A2m0Kr1TSJ1ipE9+qrr2rhwoW67777tHDhQr3yyitZh1SeBspfuSis9jy652BrVYHvd+3+4e6MIkIe3XPKKepoaWnM1qqC0uRUh0mpmd3Y1aUlHR20ViG67du3a9OmTbr44ou1adMmbd++PeuQytcg+ct8jMvIq6W7u9v7+/trtj0A4+jrC30S1q6talIysw3u3l21DdQQ+QuoEzXKX1JlOSxX41gBmKKlS6XBwayjAIDy1Xn+ysWpQAAAgHpAYQUAABAJhRUAAEAkFFYAAACRUFgBAABEQmEFAAAQCYUVAABAJKkKKzO7wMx+amY/M7NrYwUFALVADgMQW8WFlZm1SPpnSRdKWiDpj81sQazAAKCayGEAqiFNi9XbJf3M3Z919/2SvibpojhhAUDVkcMARJdmSpsTJW0ruv+8pHeUrmRmPZJ6krv7zGxTim3Wk1mSXso6iAjysh8S+1KP3px1ABOYNIeRvxpCXvYlL/sh5Wtfys5hVZ8r0N3XSFojSWbWn5cJWfOyL3nZD4l9qUdm1tCzFpO/6l9e9iUv+yHlb1/KfU6aU4EvSJpbdP+kZBkANAJyGIDo0hRW6yW9ycxONrPpki6R9K04YQFA1ZHDAERX8alAdz9gZn8l6T8ktUi60903T/K0NZVurw7lZV/ysh8S+1KP6nY/KshhdbsvFWBf6k9e9kNq8n0xd69GIAAAAE2HkdcBAAAiobACAACIpCaFVV6mjTCzuWbWZ2ZPmdlmM7sq65jSMrMWMxsws3VZx5KGmR1rZveb2U/M7GkzOyvrmCphZtck761NZnavmR2ZdUxTZWZ3mtmLxWM9mdkbzOw/zeyZ5Pa4LGOsVB5yGPmrfuUlf0nkMKkGhVXOpo04IOnj7r5A0pmSrmjgfSm4StLTWQcRweckfdfd3yLprWrAfTKzEyV9VFK3uy9S6FB9SbZRleUuSReULLtW0oPu/iZJDyb3G0qOchj5q341fP6SyGEFtWixys20Ee6+w90fT35/TeHNf2K2UVXOzE6S9G5Jd2QdSxpm1iHpHElfkSR33+/uP882qoq1SjrKzFoltUnannE8U+buD0t6pWTxRZLuTn6/W9J7axpUHLnIYeSv+pSz/CWRw2pSWI01bUTDfpgLzKxL0umSHss2klQ+K+mTkkayDiSlkyUNSVqbnBa4w8zasw6qXO7+gqTbJG2VtEPSbnf/XrZRpTbH3Xckv++UNCfLYCqUuxxG/qoruchfEjmsgM7rFTCzmZK+Ielqd9+TdTyVMLNlkl509w1ZxxJBq6S3Sfqiu58uaa8a85TTcQrfjk6WdIKkdjO7NNuo4vEwtgvju2SM/FV3cpG/JHJYQS0Kq1xNG2FmRygkpV53fyDreFJYLOk9ZjaocGrjnWZ2T7YhVex5Sc+7e+Hb9/0KiarRvEvSc+4+5O6/kvSApLMzjimtXWZ2vCQlty9mHE8lcpPDyF91KS/5SyKHSapNYZWbaSPMzBTOgz/t7p/JOp403P06dz/J3bsU/iffd/eG/Gbh7jslbTOzwizk50t6KsOQKrVV0plm1pa8185Xg3ZiLfItSR9Kfv+QpG9mGEulcpHDyF/1KUf5SyKHSUoxpc1UVTj1Tb1aLOmDkn5sZhuTZde7+7czjAnBlZJ6kwPfs5JWZhxP2dz9MTO7X9LjCldwDaiBpoYws3slnSdplpk9L2mVpFslfd3MLpe0RdLF2UVYmRzlMPJX/Wr4/CWRww7+Haa0AQAAiIPO6wAAAJFQWAEAAERCYQUAABAJhRUAAEAkFFYAAACRUFgBAABEQmEFAAAQyf8D3jvvISUEK3kAAAAASUVORK5CYII=\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
}