第06章 其他分类方法.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第六章 其他分类方法\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 二轮总结笔记\n",
    "\n",
    "\n",
    "### 一、近邻法\n",
    "\n",
    "#### 1. 最近邻法\n",
    "\n",
    "##### (1) 判别函数\n",
    "\n",
    "$$\n",
    "g_i(\\mathbf{x}) = \\min\\limits_{\\mathbf{x}_j\\in\\omega_i} \\delta(\\mathbf{x},\\mathbf{x_j}),\\quad i=1,\\cdots,c\n",
    "$$\n",
    "\n",
    "##### (2) 判别规则\n",
    "\n",
    "$$\n",
    "若g_k(\\mathbf{x}) = \\min\\limits_{i=1,\\cdots,c}g_i(\\mathbf{x})，则\\mathbf{x}\\in\\omega_k\n",
    "$$\n",
    "\n",
    "##### (3) 渐进错误率\n",
    "\n",
    "$$\n",
    "P^*\\leqslant \\lim_{N\\rightarrow\\infty}P_N(e) \\leqslant P^*(2-\\frac{c}{c-1}P^*)\n",
    "$$\n",
    "\n",
    "其中$P^*$是**贝叶斯错误率**，即理论上最优错误率。样本有限时不一定满足。\n",
    "\n",
    "#### 2. k-近邻法\n",
    "\n",
    "##### (1) 判别函数\n",
    "\n",
    "$$\n",
    "g_i(\\mathbf{x}) = k_i,\\quad i=1,\\cdots,c\n",
    "$$\n",
    "\n",
    "其中$k_i$是$\\mathbf{x}$的前$k$个近邻中属于$\\omega_i$类的数量。\n",
    "\n",
    "##### (2) 判别规则\n",
    "\n",
    "$$\n",
    "若g_k(\\mathbf{x}) = \\max\\limits_{i=1,\\cdots,c}g_i(\\mathbf{x})，则\\mathbf{x}\\in\\omega_k\n",
    "$$\n",
    "\n",
    "##### (3) 渐进错误率\n",
    "\n",
    "1. 满足最近邻的渐进错误率上界。\n",
    "2. 随着$k$增大，渐进错误率逼近贝叶斯错误率。\n",
    "3. $k\\rightarrow\\infty$，并且$k$是总体样本中很小一部分时，渐进错误率等于贝叶斯错误率。\n",
    "\n",
    "#### 3. 分枝定界算法\n",
    "\n",
    "##### (1) 规则1\n",
    "\n",
    "如果$D(\\mathbf{x},M_p)>B+r_p$，则$\\mathbf{x}_i\\in\\mathscr{X}_p$不可能是$\\mathbf{x}$的最近邻。\n",
    "\n",
    "##### (2) 规则2\n",
    "\n",
    "如果$D(\\mathbf{x},\\mathbf{x}_i) > B + D(\\mathbf{x}_i, M_p)$，其中$\\mathbf{x}_i\\in\\mathscr{X}_p$，则$\\mathbf{x}_i$不是$\\mathbf{x}$的最近邻。\n",
    "\n",
    "#### 4. 剪辑近邻法\n",
    "\n",
    "##### (1) 剪辑近邻法的错误率\n",
    "\n",
    "1. 剪辑阶段用最近邻，分类阶段用最近邻：\n",
    "\n",
    "渐进错误率**近似等于**贝叶斯错误率。\n",
    "\n",
    "2. 剪辑阶段用$k$近邻，分类阶段用最近邻：\n",
    "\n",
    "当$k\\rightarrow\\infty$，并且$k/N\\rightarrow 0$时，渐进错误率**收敛于**贝叶斯错误率。\n",
    "\n",
    "##### (2) MULTIEDIT算法\n",
    "\n",
    "1. 划分：划分成$s$个子集。\n",
    "2. 分类：用后一个子集对前一个子集分类，分类$s$次。\n",
    "3. 剪辑：剪掉每个子集中分错的。\n",
    "4. 混合：把剩下的合并到一起形成新的样本集。\n",
    "5. 迭代：重新划分。\n",
    "\n",
    "#### 5. 压缩近邻法\n",
    "\n",
    "##### (1) CONDENSE算法\n",
    "\n",
    "1. 将样本划分为存储集$\\mathscr{X}_S$和备选集$\\mathscr{X}_G$。\n",
    "2. $\\mathscr{X}_S$中开始只有一个样本，不断用$\\mathscr{X}_S$对$\\mathscr{X}_G$中的样本进行分类，如果分类不正确就把样本移动到$\\mathscr{X}_S$中，直到没有样本需要移动。\n",
    "3. 此时$\\mathscr{X}_S$作为代表样本进行分类。\n",
    "\n",
    "##### (2)与SVM的关系\n",
    "\n",
    "剪辑提高分类面推广能力，压缩寻找较少样本代表样本分类信息。\n",
    "\n",
    "\n",
    "### 二、决策树与随机森林\n",
    "\n",
    "#### 1. 非数值特征\n",
    "\n",
    "1. 名义特征：只能比较相同或不相同。\n",
    "2. 序数特征：不能看作欧氏空间的数值。\n",
    "3. 区间数据：需要分区段处理，可以比较大小，但是比值没有意义。\n",
    "\n",
    "#### 2. 不纯度\n",
    "\n",
    "##### (1) 三种不纯度度量\n",
    "\n",
    "一个事件有$k$种可能的结果，对应的概率为$P(\\omega_i),i=1,\\cdots,k$。$P(\\omega_i)$用$\\omega_i$类在总体样本中的比例计算。则\n",
    "\n",
    "1. 熵不纯度（entropy impurity）\n",
    "\n",
    "$$\n",
    "I(N)=-\\sum_{i=1}^k P(\\omega_i)\\log_2P(\\omega_i)\n",
    "$$\n",
    "\n",
    "$I(n,k)$表示$n$个样本中$k$个为一类，$n-k$个为另外一类的熵不纯度，例如\n",
    "\n",
    "$$\n",
    "I(16,4) = -(\\frac{4}{16}\\log_2\\frac{4}{16}+\\frac{12}{16}\\log_2\\frac{12}{16})\n",
    "$$\n",
    "\n",
    "2. Gini不纯度（方差不纯度）：\n",
    "\n",
    "$$\n",
    "I(N) = \\sum_{m\\neq n}P(\\omega_m)P(\\omega_n) = 1-\\sum_{i=1}^kP^2(\\omega_i)\n",
    "$$\n",
    "\n",
    "3. 误差不纯度：\n",
    "\n",
    "$$\n",
    "I(N) = 1-\\max\\limits_{i}P(\\omega_i)\n",
    "$$\n",
    "\n",
    "##### (2) 信息增益（information gain）\n",
    "\n",
    "某个特征把$N$个样本划分为$m$组，每组$N_m$个样本，则信息增益（熵不纯度减少量）为\n",
    "\n",
    "$$\n",
    "\\Delta I(N) = I(N)-\\left(\\frac{N_1}{N}I(N_1) + \\frac{N_2}{N}I(N_2) + \\cdots + \\frac{N_m}{N}I(N_m)\\right)\n",
    "$$\n",
    "\n",
    "例如$16$个样本中，按某个特征$\\lambda$划分为$2$组，一组$6$个，另外一组$10$个。第一组中$\\omega_1$类有$1$个，$\\omega_2$类有$2$个；第二组中$\\omega_1$类有$3$个，$\\omega_2$类有$7$个。则熵不纯度的信息增益为\n",
    "\n",
    "$$\\Delta I_\\lambda(16) = I(16,4) - \\left(\\frac{6}{16}I(6,1) + \\frac{10}{16}I(10,3)\\right)$$\n",
    "\n",
    "##### (3) 性质\n",
    "\n",
    "1. 两类情况下，不纯度在$P(\\omega_i)=0.5$时取最大值$1$，在$P(\\omega_i)=0$或$1$时取最小值$0$。不纯度图像关于$P(\\omega_i)=0.5$对称。\n",
    "2. 采用不同的不纯度度量对分类结果的影响不大。\n",
    "\n",
    "#### 3. 决策树\n",
    "\n",
    "##### (1) ID3算法\n",
    "\n",
    "从根节点逐级寻找**信息增益最大**的特征进行分类，直到每个节点都是**纯的样本**，即叶节点。\n",
    "\n",
    "##### (2) C4.5算法\n",
    "\n",
    "1. 用**信息增益率**代替信息增益：\n",
    "\n",
    "$$\n",
    "\\Delta I_R(N) = \\frac{\\Delta I(N)}{I(N)}\n",
    "$$\n",
    "\n",
    "2. 处理连续数值特征：\n",
    "\n",
    "对样本中的连续数值特征进行二值划分，若连续数值特征$x$在训练样本上有$n$个取值，则有$n-1$种不同的划分方式。选取其中**信息增益率最大**的方案将连续数值特征**离散化**为**二值特征**。\n",
    "\n",
    "##### (3) CART算法\n",
    "\n",
    "1. 每个节点都采用二分法。\n",
    "2. CART既可以用于分类问题，也可以用于构造回归树对连续变量进行回归。\n",
    "\n",
    "#### 4. 决策树的剪枝\n",
    "\n",
    "##### (1) 先剪枝\n",
    "\n",
    "1. 数据划分法：\n",
    "\n",
    "用训练样本训练，在测试样本上分类错误率最小时停止生长。采用交叉验证。\n",
    "\n",
    "2. 阈值法：\n",
    "\n",
    "设定信息增益阈值，在信息增益小于阈值时停止生长。\n",
    "\n",
    "3. 信息增益的统计显著性分析：\n",
    "\n",
    "用**卡方检验**考察已有节点的信息增益和继续生长的信息增益的显著性。\n",
    "\n",
    "##### (2) 后剪枝\n",
    "\n",
    "1. 减少分类错误修剪法：\n",
    "\n",
    "用独立的**剪枝集**估计剪枝前后分类错误率的改变。\n",
    "\n",
    "2. 最小代价与复杂性的折中：\n",
    "\n",
    "对合并分枝导致的**错误率增加**和**复杂性减少**进行折中考虑。\n",
    "\n",
    "3. 最小描述长度（MDL）准则：\n",
    "\n",
    "通过剪枝得到**编码最短**的决策树。\n",
    "\n",
    "##### (5) 性质\n",
    "\n",
    "1. 有限样本下，决策树超过一定规模后，**训练错误率减小**但**测试错误率增加**。\n",
    "2. 先剪枝缺乏**后效性**考虑，可能导致树生长提前终止。\n",
    "3. 后剪枝更成功，但是数据量较大时计算代价大。\n",
    "\n",
    "#### 5. 随机森林\n",
    "\n",
    "##### (1) 步骤\n",
    "\n",
    "1. 训练样本采样：对训练样本进行bootstrap重采样，获得$N$个样本集。\n",
    "2. 特征采样：每个样本集随机抽取$m$个特征。\n",
    "3. 每个样本集生成决策树，对输出结果进行投票。\n",
    "\n",
    "##### (2) 性质\n",
    "\n",
    "对**训练样本**和**特征**都进行采样，保证所有决策树的**独立性**，使投票结果更**无偏**。\n",
    "\n",
    "\n",
    "### 三、罗杰斯特回归\n",
    "\n",
    "#### 1. 判别函数\n",
    "\n",
    "对数几率比\n",
    "\n",
    "$$\n",
    "\\text{logit}(\\mathbf{x}) = \\ln\\left(\\frac{P(y|\\mathbf{x})}{1-P(y|\\mathbf{x})}\\right) = \\beta_0 + \\beta_1x_1 + \\cdots + \\beta_mx_m\n",
    "$$\n",
    "\n",
    "其中，$P(y|\\mathbf{x})$使样本属于$y=1$的概率\n",
    "\n",
    "$$\n",
    "P(y|\\mathbf{x}) = \\frac{e^{\\beta_0 + \\beta_1x_1 + \\cdots + \\beta_mx_m}}{1+e^{\\beta_0 + \\beta_1x_1 + \\cdots + \\beta_mx_m}}\n",
    "$$\n",
    "\n",
    "#### 2. 判别规则\n",
    "\n",
    "$$\n",
    "若\\text{logit}(\\mathbf{x}) \\gtrless 0，则\\mathbf{x}\\in\\begin{cases}\\omega_1\\\\\\omega_2\\end{cases}\n",
    "$$\n",
    "\n",
    "#### 3. 最大似然估计求解\n",
    "\n",
    "$$\\begin{aligned}\n",
    "\\sum_{i=1}^n(y_i-P(y_i|\\mathbf{x}_i)) &= 0\\\\\n",
    "\\sum_{i=1}^n\\mathbf{x}_i(y_i-P(y_i|\\mathbf{x}_i)) &= 0\n",
    "\\end{aligned}$$\n",
    "\n",
    "\n",
    "### 四、Boosting方法\n",
    "\n",
    "#### 1. AdaBoost\n",
    "\n",
    "##### (1) 思想\n",
    "\n",
    "对$N$个训练样本，构造$M$个弱分类器。对每个样本和分类器都加权，样本权值根据分类错误率迭代更新，分类器权值根据分类错误率计算。\n",
    "\n",
    "##### (2) 算法\n",
    "\n",
    "1. 初始化样本权重$\\displaystyle w_i=\\frac{1}{N},i=1,\\cdots,N$。\n",
    "2. 对于$m=1\\rightarrow M$，重复以下迭代：\n",
    "+ 用加权后的样本构造弱分类器$f_m(\\mathbf{x})\\in\\{-1,1\\}$。\n",
    "+ 计算加权后样本的分类错误率$e_m$，令$\\displaystyle c_m=\\log\\frac{1-e_m}{e_m}$。\n",
    "+ 更新样本权重$w_i=w_i\\exp\\{c_m1_{(y_i\\neq f_m(\\mathbf{x}_i))}\\}$，并归一化使$\\displaystyle \\sum_{i=1}^Nw_i=1$。\n",
    "3. 最终的分类器输出为$\\displaystyle\\text{sgn}\\left\\{\\sum_{m=1}^Mc_mf_m(\\mathbf{x})\\right\\}$\n",
    "\n",
    "#### 2. 性质\n",
    "\n",
    "1. 对弱分类器采用Boosting方法有明显提高。\n",
    "2. 迭代次数（即采用的弱分类器数）较大时，Boosting方法不会导致严重的过学习。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 一轮学习笔记（包含代码实现）\n",
    "\n",
    "这一章介绍了不通过设计判别函数进行分类的分类方法。\n",
    "\n",
    "### 一、k-近邻法\n",
    "\n",
    "k-近邻法的思想非常简单，就是找到和待分类数据**最近的**（或者**最相似的**）$k$个已知样本。在这$k$个样本中，哪个类别最多，就把待分类的数据分类到这个最多的类别。\n",
    "\n",
    "这里的**最近的**或者**最相似的**是通过设定函数来计算远近或者相似程度的。比如如果设定欧氏距离为距离函数，那么最近的样本就是欧氏距离最小的样本。\n",
    "\n",
    "可以证明当样本趋于无穷时，k-近邻法的错误率在贝叶斯错误率的一倍到两倍之间。而且当$k$也趋于无穷并且是样本数的低阶无穷小时，k-近邻法的错误率逼近于贝叶斯错误率。\n",
    "\n",
    "最简单的k-近邻法当然是对每个样本都进行比较，找出最近的$k$个样本。但是这样在样本数量巨大的时候运算非常慢，书上介绍了两种快速算法。\n",
    "\n",
    "#### 1. 树搜索算法\n",
    "\n",
    "树搜索算法的目的是为了快速的找到距离考察数据最近的样本。\n",
    "\n",
    "书上介绍的树搜索算法采用了分治的思想，通过逐层搜索减少查询次数。书上给的例子是三叉树，并且每个子树是通过聚类来划分的。\n",
    "\n",
    "但是实际应用中都会使用二叉树，也叫KD-tree。而且划分方式也不是聚类，而是通过方差来进行划分，具体算法书上没有介绍，我也就不说了。\n",
    "\n",
    "另外KD-tree在高维样本下会失效，效率很低（20维以内效率很高）。高维的情况一般用ball-tree搜索最近样本，效率最高。在sklearn中有写好的库可以用KD-tree或ball-tree进行索引查询。\n",
    "\n",
    "书上的树搜索算法第一不是主流算法，第二需要用到还没学的聚类，这里也就不实现了。\n",
    "\n",
    "#### 2. 剪辑近邻法\n",
    "\n",
    "剪辑近邻法的思想是：把样本分为训练集和测试集（书上叫考试集），用训练集的样本对测试集进行k-近邻划分，删除掉测试集中分错的部分。\n",
    "\n",
    "这样一来可以使不同类别的分界面更为清晰，最终使错误率收敛于贝叶斯错误率。\n",
    "\n",
    "具体实现算法使用MULTIEDIT算法，步骤如下：\n",
    "\n",
    "1. 将样本随机划分成$s$个子集\n",
    "2. 用第$i+1$个样本对第$i$个样本进行k-近邻分类，并删除掉分错的样本。\n",
    "3. 把剩下的样本再混合，变成新的样本集，再回到第一步。\n",
    "4. 如果经过了若干次迭代之后，每次迭代都没有样本别删掉，就判断为收敛，剪辑完成。\n",
    "\n",
    "实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier as KNN\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面生成数据，这里人为的生成了线性不可分的数据（两类中间有重叠），这样来验证最终剪辑的效果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.r_[np.random.randn(1000, 2) - [1.5, 1.5], np.random.randn(1000, 2) + [1.5, 1.5]]\n",
    "y = np.array(1000 * [1] + 1000 * [-1])\n",
    "\n",
    "for i in range(2000):\n",
    "    if y[i] == -1:\n",
    "        plt.scatter(X[i][0], X[i][1], c='b')\n",
    "    else:\n",
    "        plt.scatter(X[i][0], X[i][1], c='r')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为数据量比较大，图像需要运行一会才会显示出来。\n",
    "\n",
    "通过上面的散点图可以明显看出两类数据有重叠，是线性不可分的。这样的数据很适合用剪辑法。\n",
    "\n",
    "下面实现剪辑法的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第 1 次迭代，删除了 44 个样本\n",
      "第 2 次迭代，删除了 10 个样本\n",
      "第 3 次迭代，删除了 6 个样本\n",
      "第 4 次迭代，删除了 3 个样本\n",
      "第 5 次迭代，删除了 1 个样本\n",
      "第 6 次迭代，删除了 0 个样本\n",
      "第 7 次迭代，删除了 1 个样本\n",
      "第 8 次迭代，删除了 0 个样本\n",
      "第 9 次迭代，删除了 1 个样本\n",
      "第 10 次迭代，删除了 0 个样本\n",
      "第 11 次迭代，删除了 1 个样本\n",
      "第 12 次迭代，删除了 0 个样本\n",
      "第 13 次迭代，删除了 0 个样本\n",
      "第 14 次迭代，删除了 0 个样本\n",
      "第 15 次迭代，删除了 0 个样本\n",
      "第 16 次迭代，删除了 0 个样本\n",
      "迭代完成，次数： 16\n"
     ]
    }
   ],
   "source": [
    "iters_without_edit = 0  # 存储最近有多少次迭代没有样本被剪掉，用于判断是否收敛\n",
    "iters = 0               # 存储总的迭代轮数\n",
    "\n",
    "while iters_without_edit < 5:\n",
    "\n",
    "    # 将样本分为十个子类\n",
    "    N = X.shape[0]  # N为当前一轮的样本总数（经过裁剪）\n",
    "    X_split = []    # X_split是随机分割后的样本列表\n",
    "    y_split = []    # y_split是随即分割后的真实类别列表\n",
    "    indexes = np.random.permutation(N)\n",
    "    for i in range(9):\n",
    "        X_split.append(X[indexes[N // 10 * i:N // 10 * (i + 1)]])\n",
    "        y_split.append(y[indexes[N // 10 * i:N // 10 * (i + 1)]])\n",
    "    X_split.append(X[indexes[N // 10 * 9:]])  # 最后一组单独处理，防止漏掉不能被10整除的部分\n",
    "    y_split.append(y[indexes[N // 10 * 9:]])\n",
    "\n",
    "    # 开始剪辑\n",
    "    knn = KNN(n_neighbors=10)\n",
    "\n",
    "    deleted_samples = 0  # 用于记录一轮迭代剪掉了几个样本\n",
    "\n",
    "    for i in range(10):\n",
    "        j = i + 1 if i + 1 < 10 else 0\n",
    "        knn.fit(X_split[j], y_split[j])\n",
    "        y_predict = knn.predict(X_split[i])\n",
    "        correct = []  # correct用于记录当前子集分类正确的序号\n",
    "        for m in range(y_predict.shape[0]):\n",
    "            if y_predict[m] == y_split[i][m]:\n",
    "                correct.append(m)\n",
    "            else:\n",
    "                deleted_samples += 1\n",
    "        X_split[i] = X_split[i][correct]\n",
    "        y_split[i] = y_split[i][correct]\n",
    "\n",
    "\n",
    "    X = X_split[0]\n",
    "    y = y_split[0]\n",
    "    for i in range(1, len(X_split)):\n",
    "        X = np.concatenate((X, X_split[i]))\n",
    "        y = np.concatenate((y, y_split[i]))\n",
    "\n",
    "    if deleted_samples == 0:\n",
    "        iters_without_edit += 1\n",
    "    else:\n",
    "        iters_without_edit = 0\n",
    "\n",
    "    iters += 1\n",
    "    print(\"第\", iters, \"次迭代，删除了\", deleted_samples, \"个样本\")\n",
    "\n",
    "print(\"迭代完成，次数：\", iters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "\n",
    "for i in range(X.shape[0]):\n",
    "    if y[i] == -1:\n",
    "        plt.scatter(X[i][0], X[i][1], c='b')\n",
    "    else:\n",
    "        plt.scatter(X[i][0], X[i][1], c='r')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的图像也要等一会才能显示出来。\n",
    "\n",
    "根据剪辑后的图像可以明显看出，两类样本的界限变得非常清晰，这就是剪辑的作用。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. 压缩近邻法\n",
    "\n",
    "压缩近邻法可以大大减少训练样本数目，从而大幅提高分类速度。\n",
    "\n",
    "具体算法是：\n",
    "\n",
    "1. 将样本集分为**储存集**和**备选集**，储存集初始化为只有一个样本（我的理解是每个类都有一个样本，不然无法分类），其他都在备选集中。\n",
    "2. 遍历每一个备选集的样本，用储存集对这个样本进行k-近邻分类，如果分类错误就把这个样本移动到储存集中。\n",
    "3. 以此类推，直到没有样本需要移动。\n",
    "\n",
    "压缩近邻法和剪辑近邻法一起使用会取得很好的效果，所以下面的数据用的是上面剪辑近邻处理过的。需要先跑一遍上面的代码再运行下面的。\n",
    "\n",
    "算法实现如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "压缩完成，还剩 2 个样本\n"
     ]
    }
   ],
   "source": [
    "X_s = np.concatenate(([X[0]], [X[-1]]))  # 储存集\n",
    "y_s = np.concatenate(([y[0]], [y[-1]]))\n",
    "X_g = X[1:-1]  # 备选集\n",
    "y_g = y[1:-1]\n",
    "\n",
    "is_all_samples_of_X_g_done = False  # 判断是否没有样本需要移动了\n",
    "\n",
    "knn = KNN(n_neighbors=1)\n",
    "\n",
    "while is_all_samples_of_X_g_done:\n",
    "    iter_order = np.random.permutation(X_g.shape[0])\n",
    "    is_all_samples_of_X_g_done = True\n",
    "    for i in iter_order:\n",
    "        knn.fit(X_s, y_s.reshape(y_s.shape[0]))\n",
    "        if knn.predict(X_g[i]) != y_g[i]:\n",
    "            X_s = np.concatenate((X_s, [X_g[i]]))\n",
    "            y_s = np.concatenate((y_s, [y_g[i]]))\n",
    "            if i == X_g.shape[0] - 1:\n",
    "                X_g = X_g[:-1]\n",
    "                y_g = y_g[:-1]\n",
    "            elif i == 0:\n",
    "                X_g = X_g[1:]\n",
    "                y_g = y_g[1:]\n",
    "            else:\n",
    "                X_g = np.concatenate((X_g[:i], X_g[i + 1:]))\n",
    "                y_g = np.concatenate((y_g[:i], y_g[i + 1:]))\n",
    "            is_all_samples_of_X_g_done = False\n",
    "            break\n",
    "\n",
    "print(\"压缩完成，还剩\", X_s.shape[0], \"个样本\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.clf()\n",
    "\n",
    "for i in range(X_s.shape[0]):\n",
    "    if y_s[i] == -1:\n",
    "        plt.scatter(X_s[i][0], X_s[i][1], c='b')\n",
    "    else:\n",
    "        plt.scatter(X_s[i][0], X_s[i][1], c='r')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由上面的图片可以很清楚的看到算法最终把两千个样本压缩到了只剩两个！\n",
    "\n",
    "因为我们最开始生成数据的时候两类样本分别以$(-1.5,-1.5)$和$(1.5,1.5)$为中心，并且服从正态分布。\n",
    "\n",
    "那么显然如果人为划分分界线，应该划分为$x_1 + x_2 = 0$。这个分界线严格符合最小贝叶斯错误率分类。\n",
    "\n",
    "所以尽管样本被压缩到只有两个，但是按照k-近邻算法进行分类，最终的分界线几乎就是我们画出来的最小贝叶斯错误率分界线。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 二、决策树与随机森林\n",
    "\n",
    "决策树用于解决样本特征是非数值特征的分类问题。这种问题下样本特征只能比较相同或不相同，不是连续的数值。\n",
    "\n",
    "#### 1. 决策树\n",
    "\n",
    "决策树的思想是；\n",
    "\n",
    "把样本逐级分类，每次分类的标准是找到**一个**特征，按照这个特征的不同取值将样本分类。\n",
    "\n",
    "寻找这个特征的方法是找到最大的**信息增益**，也叫**不纯度减少量**，信息增益是按照香农的信息熵公式求出的（也可以用Gini不纯度和误差不纯度运算）。\n",
    "\n",
    "这样把每组样本都按照一个特征分类，直到最后每组样本的类别都相同，分无可分。\n",
    "\n",
    "这样的分类最终会形成一棵树，所以叫决策树。\n",
    "\n",
    "为了抑制过拟合，决策树引入了很多方法。书上介绍了先剪枝、后剪枝和随机森林的算法。\n",
    "\n",
    "决策树较为简单，我这里直接引用吴恩达网课的实验，见 [点击跳转到实验](./资料/7.Practice%20lab%20decision%20trees/C2_W4_Decision_Tree_with_Markdown.ipynb)。\n",
    "\n",
    "实验里一步步引导你构建出决策树，并且每一步都有相应的测试检验是否正确。\n",
    "\n",
    "吴恩达的网课里面实验质量还是很高的，但是一定要用浏览器打开，PyCharm里面运行会由很多地方显示出错。\n",
    "\n",
    "#### 2. 随机森林\n",
    "\n",
    "随即森林的思想也很简单，就是通过把原始样本集合通过自举重采样（即含有$N$个样本的集合中有放回的抽取$N$个样本），得到多个重采样样本。\n",
    "\n",
    "然后将每个重采样样本构造一个决策树，最终再进行投票得到最终结果。\n",
    "\n",
    "这个方法是通过多次采样来避免样本的偶然性，很容易理解，代码实现也很简单，我就不写了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 三、罗杰斯特回归\n",
    "\n",
    "这个就是吴恩达网课最开始讲的逻辑回归。教材作者在新出的第四版中说他认为logistic regression不应该被翻译成逻辑回归，因为logistic和logic没有词源关系，所以作者音译为罗杰斯特回归。\n",
    "\n",
    "书中只是通过最大似然估计的方式求出了理论解，具体的求法书中也没给，只是提了一下要用梯度下降。\n",
    "\n",
    "这里我也引用吴恩达的网课实验，见 [点击跳转到实验](./资料/9.Week%203%20practice%20lab%20logistic%20regression/C1_W3_Logistic_Regression.ipynb)。\n",
    "\n",
    "在这个实验中介绍了逻辑回归的梯度下降解法并且一步步引导你自己实现，还有测试，推荐做一下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 四、Boosting方法\n",
    "\n",
    "书中介绍的是AdaBoosting算法，思想如下：\n",
    "\n",
    "1. 对每个样本进行加权，并使加权系数归一化。书中没介绍如何归一化，我猜是Softmax算法。\n",
    "2. 构建多个弱分类器，计算每个样本在这些弱分类器上的错误率。\n",
    "3. 根据错误率更新样本的加权系数。\n",
    "4. 最终按照这些加权系数对待分类数据进行分类。\n",
    "\n",
    "书上只是简单的介绍了一下思想，实际上的Boosting方法极为复杂，有很多细节要考虑，这里我就不实现了。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}