7. Ensemble Learning and Random Forests-集合学习和随机森林.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ensemble Learning and Random Forests-集合学习和随机森林\n",
    "\n",
    "假设你向成千上万个随机人提出一个复杂的问题，然后汇总他们的答案。在许多情况下，你会发现这个汇总的答案比专家的答案更好。这被称为**人群的智慧**。同样，对于一组预测样本，汇总一批预测器的预测结果，往往要好于一个单独的预测器。这一组预测器称为**集成（ensemble）**，这种技术称为**集成学习**，一个集合学习算法称为**集成方法**。\n",
    "\n",
    "随机森林就是一种集成学习，其中包含了多个决策树。例如，你希望用决策树做一个分类器，每个子树都在训练集不同的随机子集上训练。每个子树都有自己的预测结果，决策树的将所有单个树的预测的预测结果统计，然后选择**最多选票**的类别（参见第6章的最后一个练习）。这样的决策树集合被称为随机森林，尽管它很简单，但它是当今最强大的机器学习算法之一。\n",
    "\n",
    "而且，正如我们在第2章中讨论的那样，一旦你已经构建了一些好的预测器，你就会经常在项目使用Ensemble方法，将它们组合成一个更好的预测器。 事实上，机器学习竞赛中获胜的解决方案通常涉及多种Ensemble方法（最着名的是Netflix奖竞赛）。\n",
    "\n",
    "在本章中，我们除了讨论随机森林，也将讨论最流行的集成方法，包括bagging, boosting, stacking等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To support both python 2 and python 3\n",
    "# 让这份笔记同步支持 python 2 和 python 3\n",
    "from __future__ import division, print_function, unicode_literals\n",
    "\n",
    "# Common imports\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "# to make this notebook's output stable across runs\n",
    "# 让笔记全程输入稳定\n",
    "np.random.seed(42)\n",
    "\n",
    "# To plot pretty figures\n",
    "# 导入绘图工具\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['axes.labelsize'] = 14\n",
    "plt.rcParams['xtick.labelsize'] = 12\n",
    "plt.rcParams['ytick.labelsize'] = 12\n",
    "\n",
    "# Where to save the figures\n",
    "# 设定图片保存路径，这里写了一个函数，后面直接调用即可\n",
    "PROJECT_ROOT_DIR = \"F:\\ML\\Machine learning\\Hands-on machine learning with scikit-learn and tensorflow\"\n",
    "CHAPTER_ID = \"07_Ensemble Learning and Random Forests\"\n",
    "IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, \"images\", CHAPTER_ID)\n",
    "\n",
    "def save_fig(fig_id, tight_layout=True, fig_extension=\"png\", resolution=300):\n",
    "    path = os.path.join(IMAGES_PATH, fig_id + \".\" + fig_extension)\n",
    "    print(\"Saving figure\", fig_id)\n",
    "    if tight_layout:\n",
    "        plt.tight_layout()\n",
    "    plt.savefig(path, format=fig_extension, dpi=resolution)\n",
    "\n",
    "# Ignore useless warnings (see SciPy issue #5998)\n",
    "# 忽略无用警告\n",
    "import warnings\n",
    "warnings.filterwarnings(action=\"ignore\", message=\"^internal gelsd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Voting Classifiers-投票分类器\n",
    "\n",
    "假设我们已经训练了一些分类器，每个分类器的准确率达到约80％。你可能有一个Logistic回归分类器，一个SVM分类器，一个随机森林分类器，K-Nearest Neighbors分类器，也许还有一些别的（见下图）\n",
    "\n",
    "图7-1.\n",
    "\n",
    "创建一个更好的分类器的一种非常简单的方法是聚合每个分类器的预测结果并**选择获得最多选票的类作为预测结果**。这种多数表决分类器称为硬投票分类器（见下图）。\n",
    "\n",
    "图7-2\n",
    "\n",
    "令人惊讶的是，这种投票分类器通常比集合中的最佳分类器具有更高的准确度。事实上，即使每个分类器都是弱学习者（意味着它只比随机猜测稍微好一些），整体仍然可以成为一个强大的学习者（达到高准确度），只要有足够数量的弱学习者并且他们足够多样化。\n",
    "\n",
    "这怎么可能？ 以下类比可以帮助揭示这个谜团。假设你有一个稍微有偏见的硬币，有51％的机会出现正面，并有49％的机会出现反面。如果你扔1000次（1000个训练样本），你通常会得到或多或少510正和490反，因此大多数是正。如果你有10多个这样的硬币（10个预测器），每个都扔1000次，我相信大多数硬币出现正面的次数会更多。如果你有10,000个这样的硬币，我们每个抛100次，正面出现多的硬币数量/硬币总数 将接近于97%（集成学习的预测准确率将达到97%）。 \n",
    "\n",
    "这是由于大数定律：当你不停地掷硬币时，正面的比例越来越接近51％。图7-3显示了10种偏见硬币投掷。你可以看到，随着投掷次数的增加，正面的比例接近51％。 最终所有10个硬币正面朝上的比例接近51％，并且一直高于50％。\n",
    "\n",
    "图7-3\n",
    "\n",
    "看着非常直观吧，本身只是准确率仅仅为51%的弱分类器，10000多个联合在一起竟然也可以实现准确率为97%的强分类器，可以说是非常amazing了！但是，这里有个前提，即每个分类器必须**完全独立**，才可以达到理论的最高水平。换言之，我们希望不同的分类器有不同的关注点，从不同的角度分类数据。使用**完全不同的算法**训练数据是一种有效的集成学习方法，这增加了他们制造完全不同类型错误的机会，从而提高了整体的准确性。\n",
    "\n",
    "以下代码在Scikit-Learn中创建并训练投票分类器，包含三种不同的分类器（训练集是moons dataset，在第5章介绍过的）：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import make_moons\n",
    "\n",
    "X,y = make_moons(n_samples=500, noise=0.30, random_state=42)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\ensemble\\forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "VotingClassifier(estimators=[('lr',\n",
       "                              LogisticRegression(C=1.0, class_weight=None,\n",
       "                                                 dual=False, fit_intercept=True,\n",
       "                                                 intercept_scaling=1,\n",
       "                                                 l1_ratio=None, max_iter=100,\n",
       "                                                 multi_class='warn',\n",
       "                                                 n_jobs=None, penalty='l2',\n",
       "                                                 random_state=None,\n",
       "                                                 solver='warn', tol=0.0001,\n",
       "                                                 verbose=0, warm_start=False)),\n",
       "                             ('rf',\n",
       "                              RandomForestClassifier(bootstrap=True,\n",
       "                                                     class_weight=None,\n",
       "                                                     criterion='gini',...\n",
       "                                                     oob_score=False,\n",
       "                                                     random_state=None,\n",
       "                                                     verbose=0,\n",
       "                                                     warm_start=False)),\n",
       "                             ('svc',\n",
       "                              SVC(C=1.0, cache_size=200, class_weight=None,\n",
       "                                  coef0=0.0, decision_function_shape='ovr',\n",
       "                                  degree=3, gamma='auto_deprecated',\n",
       "                                  kernel='rbf', max_iter=-1, probability=False,\n",
       "                                  random_state=None, shrinking=True, tol=0.001,\n",
       "                                  verbose=False))],\n",
       "                 flatten_transform=True, n_jobs=None, voting='hard',\n",
       "                 weights=None)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "log_clf = LogisticRegression()\n",
    "rnd_clf = RandomForestClassifier()\n",
    "svm_clf = SVC()\n",
    "voting_clf = VotingClassifier(\n",
    "estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],\n",
    "voting='hard')\n",
    "voting_clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogisticRegression 0.864\n",
      "RandomForestClassifier 0.904\n",
      "SVC 0.888\n",
      "VotingClassifier 0.896\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\ensemble\\forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "for clf in (log_clf,rnd_clf,svm_clf,voting_clf):\n",
    "    clf.fit(X_train,y_train)\n",
    "    y_pred = clf.predict(X_test)\n",
    "    print(clf.__class__.__name__,accuracy_score(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "投票分类器略微优于所有单独的分类器。\n",
    "\n",
    "如果所有分类器都能够估计类概率（即，他们有一个predict_proba（）方法），那么你可以告诉Scikit-Learn预测具有最高等级概率的类，对所有单个分类器进行平均。这称为软投票。 它通常比硬投票获得更高的性能，因为它给予高度自信的投票更多的权重。你需要做的就是用voting =“soft”替换voting =“hard”，并确保所有分类器都可以估计类概率。默认情况下，SVC类不是估计概率，因此需要将其概率超参数设置为True （这将使SVC类使用交叉验证来估计类概率，减慢训练，并且它将添加predict_proba（）方法）。如果修改前面的代码以使用软投票，您会发现投票分类器的准确率达到91％以上！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bagging and Pasting \n",
    "正如刚才所讲，集成学习效果好的前提是每个预测器是**独立**的。但是这是有缺陷的，我们未必能找到这么多独立的预测器，如何在数量有限的预测器中，完成我们的集成学习呢？\n",
    "答案是**用训练集的子集训练每个预测器**。\n",
    "如果一个训练集能分出 n 个训练子集，每个预测器在这 n 个子集都完成了训练，那么意味着预测器的数量翻了 n 倍。我们通过这种方式增加了预测器的数量，解决了集成学习预测器数量不足的问题。\n",
    "可以通过下图进一步理解这种思想。\n",
    "\n",
    "图7-1\n",
    "\n",
    "那么如何分数据就是我们需要考虑的了。有以下两种思路可供选择：Bagging和Pasting。\n",
    "* Bagging：有放回采样\n",
    "* Pasting：无放回采样\n",
    "\n",
    "举个例子：500个数据样本，计划每个子集为100个。\n",
    "Bagging先随机拿出100个样本，训练现有的预测器（有SVM，逻辑回归器等等），训练完事儿后，将这100个样本再丢回原先的数据集，再次抽取100个随机样本。\n",
    "Pasting则拿出100个样本，训练完事儿后，再从剩下的400个训练样本中抽取。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.1  Bagging and Pasting in Scikit-Learn\n",
    "Scikit-Learn提供了一个简单的API使用BaggingClassifier类（或 BaggingRegressor 进行回归）进行Bagging and Pasting。以下代码训练500个决策树分类器的集合。如果你想使用Pasting，只需设置bootstrap = False。\n",
    "\n",
    "参数 n_jobs告诉Scikit-Learn用于训练和预测的CPU核心数（ -1 告诉Scikit-Learn使用所有可用核心）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "bag_clf = BaggingClassifier(\n",
    "    DecisionTreeClassifier(random_state=42),#  基类预测器\n",
    "    n_estimators = 500,\n",
    "    max_samples = 100, \n",
    "    bootstrap = True,\n",
    "    n_jobs = -1,\n",
    "    random_state=42\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "bag_clf.fit(X_train,y_train)\n",
    "y_pred = bag_clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.904\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "print(accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.856\n"
     ]
    }
   ],
   "source": [
    "tree_clf = DecisionTreeClassifier(random_state=42)\n",
    "tree_clf.fit(X_train, y_train)\n",
    "y_pred_tree = tree_clf.predict(X_test)\n",
    "print(accuracy_score(y_test, y_pred_tree))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from matplotlib.colors import ListedColormap\n",
    "import numpy as np\n",
    "def plot_decision_boundary(clf, X, y, axes=[-1.5, 2.5, -1, 1.5], alpha=0.5, contour=True):\n",
    "    x1s = np.linspace(axes[0], axes[1], 100)\n",
    "    x2s = np.linspace(axes[2], axes[3], 100)\n",
    "    x1, x2 = np.meshgrid(x1s, x2s)\n",
    "    X_new = np.c_[x1.ravel(), x2.ravel()]\n",
    "    y_pred = clf.predict(X_new).reshape(x1.shape)\n",
    "    custom_cmap = ListedColormap(['#fafab0','#9898ff','#a0faa0'])\n",
    "    plt.contourf(x1, x2, y_pred, alpha=0.3, cmap=custom_cmap)\n",
    "    if contour:\n",
    "        custom_cmap2 = ListedColormap(['#7d7d58','#4c4c7f','#507d50'])\n",
    "        plt.contour(x1, x2, y_pred, cmap=custom_cmap2, alpha=0.8)\n",
    "    plt.plot(X[:, 0][y==0], X[:, 1][y==0], \"yo\", alpha=alpha)\n",
    "    plt.plot(X[:, 0][y==1], X[:, 1][y==1], \"bs\", alpha=alpha)\n",
    "    plt.axis(axes)\n",
    "    plt.xlabel(r\"$x_1$\", fontsize=18)\n",
    "    plt.ylabel(r\"$x_2$\", fontsize=18, rotation=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decision_tree_without_and_with_bagging_plot\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(11,4))\n",
    "plt.subplot(121)\n",
    "plot_decision_boundary(tree_clf, X, y)\n",
    "plt.title(\"Decision Tree\", fontsize=14)\n",
    "plt.subplot(122)\n",
    "plot_decision_boundary(bag_clf, X, y)\n",
    "plt.title(\"Decision Trees with Bagging\", fontsize=14)\n",
    "print(\"decision_tree_without_and_with_bagging_plot\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "图7-5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "左图是一个决策树的决策边界（显然有点过拟合对吧），右边是使用500棵决策树的Bagging集合的决策边界（很圆润的边界）。如果我们进一步描述的话，可以认为集成学习的结果**方差较小**从而使整体决策边界很“圆润”。原因是因为？？？？"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Bagging 和 Pasting方法为每个训练集引用了更多的多样性，但是大家更多的采用bagging方法，因为他带来了更多的随机性，如果您有空闲时间和CPU功率，则可以使用交叉验证来评估Bagging和Pasting，并选择效果最佳的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Out-of-Bag Evaluation\n",
    "对于任何给定的预测器，有些实例可能会被采样而其他实例可能根本没有被抽中。未采样的训练实例称为out-of-bag (oob)实例。\n",
    "\n",
    "由于预测器在训练期间从不会看到 oob 实例，因此可以在这些实例上进行评估，无需单独的验证集或交叉验证。你可以通过平均每个预测器的 oob 评估来评估整体本身。\n",
    "\n",
    "在Scikit-Learn中，你可以在创建BaggingClassifier时设置oob_score = True要求在训练后进行自动oob评估。 以下代码演示了这一点。最终的评估分数可通过oob_score_变量获得："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9013333333333333"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bag_clf = BaggingClassifier(\n",
    "    DecisionTreeClassifier(random_state=42),#  基类预测器\n",
    "    n_estimators=500,\n",
    "    bootstrap = True,\n",
    "    n_jobs = -1,\n",
    "    oob_score=True,\n",
    "    random_state=40\n",
    ")\n",
    "\n",
    "bag_clf.fit(X_train,y_train)\n",
    "bag_clf.oob_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "根据这个oob评估，BaggingClassifier可能在测试集上达到约91.2％的准确度。 我们来验证一下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.912"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "y_pred = bag_clf.predict(X_test)\n",
    "accuracy_score(y_test,y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "每个训练实例的oob决策特征也可以通过oob_decision_function_变量获得。在这种情况下（由于基类估计器具有predict_proba（）方法），决策函数返回每个训练实例的类概率。例如，oob评估估计第二个训练实例有65.89％属于positive class的概率（和属于negative class的34.11％）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.31746032, 0.68253968],\n",
       "       [0.34117647, 0.65882353],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.08379888, 0.91620112],\n",
       "       [0.31693989, 0.68306011],\n",
       "       [0.02923977, 0.97076023],\n",
       "       [0.97687861, 0.02312139],\n",
       "       [0.97765363, 0.02234637],\n",
       "       [0.74404762, 0.25595238],\n",
       "       [0.        , 1.        ],\n",
       "       [0.71195652, 0.28804348],\n",
       "       [0.83957219, 0.16042781],\n",
       "       [0.97777778, 0.02222222],\n",
       "       [0.0625    , 0.9375    ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.97297297, 0.02702703],\n",
       "       [0.95238095, 0.04761905],\n",
       "       [1.        , 0.        ],\n",
       "       [0.01704545, 0.98295455],\n",
       "       [0.38947368, 0.61052632],\n",
       "       [0.88700565, 0.11299435],\n",
       "       [1.        , 0.        ],\n",
       "       [0.96685083, 0.03314917],\n",
       "       [0.        , 1.        ],\n",
       "       [0.99428571, 0.00571429],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.64804469, 0.35195531],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.13402062, 0.86597938],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.36065574, 0.63934426],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.27093596, 0.72906404],\n",
       "       [0.34146341, 0.65853659],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.00531915, 0.99468085],\n",
       "       [0.98265896, 0.01734104],\n",
       "       [0.91428571, 0.08571429],\n",
       "       [0.97282609, 0.02717391],\n",
       "       [0.97029703, 0.02970297],\n",
       "       [0.        , 1.        ],\n",
       "       [0.06134969, 0.93865031],\n",
       "       [0.98019802, 0.01980198],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.97790055, 0.02209945],\n",
       "       [0.79473684, 0.20526316],\n",
       "       [0.41919192, 0.58080808],\n",
       "       [0.99473684, 0.00526316],\n",
       "       [0.        , 1.        ],\n",
       "       [0.67613636, 0.32386364],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.87356322, 0.12643678],\n",
       "       [1.        , 0.        ],\n",
       "       [0.56140351, 0.43859649],\n",
       "       [0.16304348, 0.83695652],\n",
       "       [0.67539267, 0.32460733],\n",
       "       [0.90673575, 0.09326425],\n",
       "       [0.        , 1.        ],\n",
       "       [0.16201117, 0.83798883],\n",
       "       [0.89005236, 0.10994764],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.995     , 0.005     ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.07272727, 0.92727273],\n",
       "       [0.05418719, 0.94581281],\n",
       "       [0.29533679, 0.70466321],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.81871345, 0.18128655],\n",
       "       [0.01092896, 0.98907104],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.22513089, 0.77486911],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.9368932 , 0.0631068 ],\n",
       "       [0.76536313, 0.23463687],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.17127072, 0.82872928],\n",
       "       [0.65306122, 0.34693878],\n",
       "       [0.        , 1.        ],\n",
       "       [0.03076923, 0.96923077],\n",
       "       [0.49444444, 0.50555556],\n",
       "       [1.        , 0.        ],\n",
       "       [0.02673797, 0.97326203],\n",
       "       [0.98870056, 0.01129944],\n",
       "       [0.23121387, 0.76878613],\n",
       "       [0.5       , 0.5       ],\n",
       "       [0.9947644 , 0.0052356 ],\n",
       "       [0.00555556, 0.99444444],\n",
       "       [0.98963731, 0.01036269],\n",
       "       [0.25641026, 0.74358974],\n",
       "       [0.92972973, 0.07027027],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.80681818, 0.19318182],\n",
       "       [1.        , 0.        ],\n",
       "       [0.0106383 , 0.9893617 ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.98181818, 0.01818182],\n",
       "       [1.        , 0.        ],\n",
       "       [0.01036269, 0.98963731],\n",
       "       [0.97752809, 0.02247191],\n",
       "       [0.99453552, 0.00546448],\n",
       "       [0.01960784, 0.98039216],\n",
       "       [0.18367347, 0.81632653],\n",
       "       [0.98387097, 0.01612903],\n",
       "       [0.29533679, 0.70466321],\n",
       "       [0.98295455, 0.01704545],\n",
       "       [0.        , 1.        ],\n",
       "       [0.00561798, 0.99438202],\n",
       "       [0.75138122, 0.24861878],\n",
       "       [0.38624339, 0.61375661],\n",
       "       [0.42708333, 0.57291667],\n",
       "       [0.86315789, 0.13684211],\n",
       "       [0.92964824, 0.07035176],\n",
       "       [0.05699482, 0.94300518],\n",
       "       [0.82802548, 0.17197452],\n",
       "       [0.01546392, 0.98453608],\n",
       "       [0.        , 1.        ],\n",
       "       [0.02298851, 0.97701149],\n",
       "       [0.96721311, 0.03278689],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.01041667, 0.98958333],\n",
       "       [0.        , 1.        ],\n",
       "       [0.0326087 , 0.9673913 ],\n",
       "       [0.01020408, 0.98979592],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.93785311, 0.06214689],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.99462366, 0.00537634],\n",
       "       [0.        , 1.        ],\n",
       "       [0.38860104, 0.61139896],\n",
       "       [0.32065217, 0.67934783],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.31182796, 0.68817204],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.00588235, 0.99411765],\n",
       "       [0.        , 1.        ],\n",
       "       [0.98387097, 0.01612903],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.62264151, 0.37735849],\n",
       "       [0.92344498, 0.07655502],\n",
       "       [0.        , 1.        ],\n",
       "       [0.99526066, 0.00473934],\n",
       "       [1.        , 0.        ],\n",
       "       [0.98888889, 0.01111111],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.06451613, 0.93548387],\n",
       "       [1.        , 0.        ],\n",
       "       [0.05154639, 0.94845361],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.03278689, 0.96721311],\n",
       "       [1.        , 0.        ],\n",
       "       [0.95808383, 0.04191617],\n",
       "       [0.79532164, 0.20467836],\n",
       "       [0.55665025, 0.44334975],\n",
       "       [0.        , 1.        ],\n",
       "       [0.18604651, 0.81395349],\n",
       "       [1.        , 0.        ],\n",
       "       [0.93121693, 0.06878307],\n",
       "       [0.97740113, 0.02259887],\n",
       "       [1.        , 0.        ],\n",
       "       [0.00531915, 0.99468085],\n",
       "       [0.        , 1.        ],\n",
       "       [0.44623656, 0.55376344],\n",
       "       [0.86363636, 0.13636364],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.00558659, 0.99441341],\n",
       "       [0.        , 1.        ],\n",
       "       [0.96923077, 0.03076923],\n",
       "       [0.        , 1.        ],\n",
       "       [0.21649485, 0.78350515],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.98477157, 0.01522843],\n",
       "       [0.8       , 0.2       ],\n",
       "       [0.99441341, 0.00558659],\n",
       "       [0.        , 1.        ],\n",
       "       [0.08379888, 0.91620112],\n",
       "       [0.98984772, 0.01015228],\n",
       "       [0.01142857, 0.98857143],\n",
       "       [0.        , 1.        ],\n",
       "       [0.02747253, 0.97252747],\n",
       "       [1.        , 0.        ],\n",
       "       [0.79144385, 0.20855615],\n",
       "       [0.        , 1.        ],\n",
       "       [0.90804598, 0.09195402],\n",
       "       [0.98387097, 0.01612903],\n",
       "       [0.20634921, 0.79365079],\n",
       "       [0.19767442, 0.80232558],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.20338983, 0.79661017],\n",
       "       [0.98181818, 0.01818182],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.98969072, 0.01030928],\n",
       "       [0.        , 1.        ],\n",
       "       [0.48663102, 0.51336898],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.07821229, 0.92178771],\n",
       "       [0.11176471, 0.88823529],\n",
       "       [0.99415205, 0.00584795],\n",
       "       [0.03015075, 0.96984925],\n",
       "       [1.        , 0.        ],\n",
       "       [0.40837696, 0.59162304],\n",
       "       [0.04891304, 0.95108696],\n",
       "       [0.51595745, 0.48404255],\n",
       "       [0.51898734, 0.48101266],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.59903382, 0.40096618],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.24157303, 0.75842697],\n",
       "       [0.81052632, 0.18947368],\n",
       "       [0.08717949, 0.91282051],\n",
       "       [0.99453552, 0.00546448],\n",
       "       [0.82142857, 0.17857143],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.125     , 0.875     ],\n",
       "       [0.04712042, 0.95287958],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.89150943, 0.10849057],\n",
       "       [0.1978022 , 0.8021978 ],\n",
       "       [0.95238095, 0.04761905],\n",
       "       [0.00515464, 0.99484536],\n",
       "       [0.609375  , 0.390625  ],\n",
       "       [0.07692308, 0.92307692],\n",
       "       [0.99484536, 0.00515464],\n",
       "       [0.84210526, 0.15789474],\n",
       "       [0.        , 1.        ],\n",
       "       [0.99484536, 0.00515464],\n",
       "       [0.95876289, 0.04123711],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.26903553, 0.73096447],\n",
       "       [0.98461538, 0.01538462],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.00574713, 0.99425287],\n",
       "       [0.85142857, 0.14857143],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.76506024, 0.23493976],\n",
       "       [0.8969697 , 0.1030303 ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.73333333, 0.26666667],\n",
       "       [0.47727273, 0.52272727],\n",
       "       [0.        , 1.        ],\n",
       "       [0.92473118, 0.07526882],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.87709497, 0.12290503],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.74752475, 0.25247525],\n",
       "       [0.09146341, 0.90853659],\n",
       "       [0.44329897, 0.55670103],\n",
       "       [0.22395833, 0.77604167],\n",
       "       [0.        , 1.        ],\n",
       "       [0.87046632, 0.12953368],\n",
       "       [0.78212291, 0.21787709],\n",
       "       [0.00507614, 0.99492386],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.02884615, 0.97115385],\n",
       "       [0.96571429, 0.03428571],\n",
       "       [0.93478261, 0.06521739],\n",
       "       [1.        , 0.        ],\n",
       "       [0.49756098, 0.50243902],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.01604278, 0.98395722],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.96987952, 0.03012048],\n",
       "       [0.        , 1.        ],\n",
       "       [0.05747126, 0.94252874],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.98989899, 0.01010101],\n",
       "       [0.01675978, 0.98324022],\n",
       "       [1.        , 0.        ],\n",
       "       [0.13541667, 0.86458333],\n",
       "       [0.        , 1.        ],\n",
       "       [0.00546448, 0.99453552],\n",
       "       [0.        , 1.        ],\n",
       "       [0.41836735, 0.58163265],\n",
       "       [0.11309524, 0.88690476],\n",
       "       [0.22110553, 0.77889447],\n",
       "       [1.        , 0.        ],\n",
       "       [0.97647059, 0.02352941],\n",
       "       [0.22826087, 0.77173913],\n",
       "       [0.98882682, 0.01117318],\n",
       "       [0.        , 1.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [1.        , 0.        ],\n",
       "       [0.96428571, 0.03571429],\n",
       "       [0.33507853, 0.66492147],\n",
       "       [0.98235294, 0.01764706],\n",
       "       [1.        , 0.        ],\n",
       "       [0.        , 1.        ],\n",
       "       [0.99465241, 0.00534759],\n",
       "       [0.        , 1.        ],\n",
       "       [0.06043956, 0.93956044],\n",
       "       [0.97619048, 0.02380952],\n",
       "       [1.        , 0.        ],\n",
       "       [0.03108808, 0.96891192],\n",
       "       [0.57291667, 0.42708333]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bag_clf.oob_decision_function_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Patches and Random Subspaces\n",
    "对训练实例和特征进行采样称为Random Patches。\n",
    "对特征采样被称为随机子空间方法。\n",
    "\n",
    "采样特征导致预测器更多的多样性。\n",
    "\n",
    "## Random Forests\n",
    "正如我们所讨论的，随机森林是决策树的集合，通常通过Bagging方法（或有时Pasting）训练。\n",
    "您可以改为使用RandomForestClassifier类，而不是构建BaggingClassifier并将其传递给DecisionTreeClassifier，这样更方便并针对Decision Trees 进行了优化 （类似地，有一个RandomForestRegressor类用于回归任务）。以下代码使用所有可用的CPU核心训练具有500棵树（每个限制为最多16个节点）的随机森林分类器："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "                       max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=10,\n",
       "                       n_jobs=None, oob_score=False, random_state=None,\n",
       "                       verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "rdn_clf = RandomForestClassifier\n",
    "rnd_clf.fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_rf = rnd_clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.928"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(y_pred == y_pred_rf) / len(y_pred)  # almost identical predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extra-Trees\n",
    "前文提到，在随机森林的基础上，特征也可以随机提取，对每个特征使用随机阈值而不是搜索最佳可能阈值（如常规决策树那样）时，可以使树更加随机。\n",
    "即**决策树多样 + 数据集随机 + 特征随机**\n",
    "这种树称为**极端随机树(Extremely Randomized Trees ensemble)** 简称Extra-Trees。这种策略会导致每个决策树之间方差减小，偏差变大。Extra-Trees比常规随机森林更快地训练。\n",
    "\n",
    "你可以使用Scikit-Learn的ExtraTreesClassifier类创建Extra-Trees分类器。它的API与RandomForestClassifier类相同。同样，Extra TreesRegressor 类与RandomForestRegressor类具有相同的API。\n",
    "\n",
    "事先很难判断RandomForestClassifier的性能是否比ExtraTreesClassifier更好或更差。通常，要知道的唯一方法是尝试两者并使用交叉验证（同时使用网格搜索调整超参数）来比较它们。\n",
    "\n",
    "\n",
    "###  Feature Importance\n",
    "最后，如果你查看一个决策树可能会发现，重要特征可能看起来更接近树的根，而不重要的特征通常会更接近叶子（或根本不显示）。因此，可以通过计算特征在森林中所有树木中出现的平均深度来估计特征的重要性。Scikit-Learn会在训练后自动为每个特征计算。 你可以使用feature_importances_变量访问结果。\n",
    "\n",
    "例如，以下代码训练鸢尾花数据集上的RandomForestClassifier（在第4章中介绍）并输出每个特征的重要性。似乎最重要的特征是花瓣长度（44％）和宽度（42％），而萼片的长度和宽度相比较不重要（分别为11％和2％）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sepal length (cm) 0.11189970757963477\n",
      "sepal width (cm) 0.02222675933160177\n",
      "petal length (cm) 0.4333470159801416\n",
      "petal width (cm) 0.43252651710862194\n"
     ]
    }
   ],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "iris = load_iris()\n",
    "rnd_clf = RandomForestClassifier(n_estimators=500,n_jobs = -1)\n",
    "rnd_clf.fit(iris[\"data\"],iris[\"target\"])\n",
    "for name,score in zip(iris[\"feature_names\"],rnd_clf.feature_importances_):\n",
    "    print(name,score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同样，如果你在MNIST数据集上训练随机森林分类器（在第3章中介绍）并绘制每个像素的重要性，得到图7-6中所示的图像。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Boosting-提升\n",
    "提升（Boosting，最初称为假设增强）指的是可以将几个弱学习者组合成强学习者的集成方法。对于大多数的提升方法的思想就是按顺序去训练分类器，每一个都要尝试修正前面的分类。现如今已经有很多的提升方法了，但最著名的就是 Adaboost（适应性提升，是 Adaptive Boosting 的简称） 和 Gradient Boosting（梯度提升）。让我们先从 Adaboost 说起。\n",
    "\n",
    "### AdaBoost\n",
    "新预测器纠正其前身的一种方法是更多地关注之前的预测器欠拟合的训练实例。 这导致新的预测器越来越关注**比较难的实例**。这是AdaBoost使用的技术。\n",
    "\n",
    "举个例子，去构建一个 Adaboost 分类器，先训练第一个基类分类器（例如一个决策树），然后拿来在训练集上做预测，然后增加错误分类的训练实例的**相对权重**。 使用更新后的权重训练第二个分类器，并再次对训练集进行预测，更新权重，以此类推。如图7-7\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "图7-7\n",
    "\n",
    "图7-8显示了 moons 数据集上五个连续预测器的决策边界（在此示例中，每个预测器是一个使用RBF内核的高度正则化的SVM分类器）。 第一个分类器导致许多实例错误，所以他们的权重得到提升。 因此，第二个分类器在这些实例上做得更好，直到第5个可以准确划分。\n",
    "\n",
    "右边的图表代表了相同的预测器序列，但学习率减半。正如你所看到的，这种顺序学习技术与Gradient Descent有一些相似之处，AdaBoost为整体增加了预测器，逐渐使其变得更好。\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "图7-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "D:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "m = len(X_train)\n",
    "\n",
    "plt.figure(figsize=(11, 4))\n",
    "for subplot, learning_rate in ((121, 1), (122, 0.5)):\n",
    "    sample_weights = np.ones(m)\n",
    "    plt.subplot(subplot)\n",
    "    for i in range(5):\n",
    "        svm_clf = SVC(kernel=\"rbf\", C=0.05, random_state=42)\n",
    "        svm_clf.fit(X_train, y_train, sample_weight=sample_weights)\n",
    "        y_pred = svm_clf.predict(X_train)\n",
    "        sample_weights[y_pred != y_train] *= (1 + learning_rate)\n",
    "        plot_decision_boundary(svm_clf, X, y, alpha=0.2)\n",
    "        plt.title(\"learning_rate = {}\".format(learning_rate), fontsize=16)\n",
    "    if subplot == 121:\n",
    "        plt.text(-0.7, -0.65, \"1\", fontsize=14)\n",
    "        plt.text(-0.6, -0.10, \"2\", fontsize=14)\n",
    "        plt.text(-0.5,  0.10, \"3\", fontsize=14)\n",
    "        plt.text(-0.4,  0.55, \"4\", fontsize=14)\n",
    "        plt.text(-0.3,  0.90, \"5\", fontsize=14)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下代码使用Scikit-Learn的**AdaBoostClassifier**类训练基于200个决策树桩的AdaBoost分类器（正如你所料，还有一个AdaBoostRegressor类）。决策树桩是具有max_depth = 1的决策树 ——换句话说，是由单个决策节点加上两个叶节点组成的树。 这是AdaBoostClassifier类的默认基类估算器：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AdaBoostClassifier(algorithm='SAMME.R',\n",
       "                   base_estimator=DecisionTreeClassifier(class_weight=None,\n",
       "                                                         criterion='gini',\n",
       "                                                         max_depth=1,\n",
       "                                                         max_features=None,\n",
       "                                                         max_leaf_nodes=None,\n",
       "                                                         min_impurity_decrease=0.0,\n",
       "                                                         min_impurity_split=None,\n",
       "                                                         min_samples_leaf=1,\n",
       "                                                         min_samples_split=2,\n",
       "                                                         min_weight_fraction_leaf=0.0,\n",
       "                                                         presort=False,\n",
       "                                                         random_state=None,\n",
       "                                                         splitter='best'),\n",
       "                   learning_rate=0.5, n_estimators=200, random_state=42)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "\n",
    "ada_clf = AdaBoostClassifier(\n",
    "    DecisionTreeClassifier(max_depth=1), \n",
    "    n_estimators=200,\n",
    "    algorithm=\"SAMME.R\", \n",
    "    learning_rate=0.5, \n",
    "    random_state=42)\n",
    "\n",
    "ada_clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "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": [
    "plot_decision_boundary(ada_clf, X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你的AdaBoost集合过拟合训练集，您可以尝试减少估算器的数量，或者强调更正则化的预测器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient Boosting\n",
    "另一个非常流行的Boosting算法是**Gradient Boosting**。就像AdaBoost一样，Gradient Boosting通过在一个集合中**依次添加预测器来进行工作，每一个都纠正它的前任**。 但是，这种方法不是像AdaBoost那样在每次迭代时调整实例权重，而是**尝试将新预测器拟合到先前预测器所产生的残差**。\n",
    "\n",
    "\n",
    "让我们通过一个简单的回归示例，使用决策树作为基础预测器（当然，梯度提升也适用于回归任务）。 这称为渐变树增强（Gradient Tree Boosting）或渐变增强回归树（Gradient Boosted Regression Trees）（GBRT）。 首先，让DecisionTreeRegressor拟合训练集（例如，嘈杂的二次训练集）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "X = np.random.rand(100, 1) - 0.5\n",
    "y = 3*X[:, 0]**2 + 0.05 * np.random.randn(100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=2, max_features=None,\n",
       "                      max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "                      min_impurity_split=None, min_samples_leaf=1,\n",
       "                      min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "                      presort=False, random_state=None, splitter='best')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeRegressor\n",
    "\n",
    "tree_reg1 = DecisionTreeRegressor(max_depth= 2)\n",
    "tree_reg1.fit(X,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "现在训练第二个DecisionTreeRegressor来解决第一个预测器遗留的残差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=2, max_features=None,\n",
       "                      max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "                      min_impurity_split=None, min_samples_leaf=1,\n",
       "                      min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "                      presort=False, random_state=None, splitter='best')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y2 = y - tree_reg1.predict(X)\n",
    "tree_reg2 = DecisionTreeRegressor(max_depth = 2)\n",
    "tree_reg2.fit(X,y2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后我们训练第三个DecisionTreeRegressor来处理第二个预测器产生的残差："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeRegressor(criterion='mse', max_depth=2, max_features=None,\n",
       "                      max_leaf_nodes=None, min_impurity_decrease=0.0,\n",
       "                      min_impurity_split=None, min_samples_leaf=1,\n",
       "                      min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
       "                      presort=False, random_state=42, splitter='best')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "y3 = y2 - tree_reg2.predict(X)\n",
    "tree_reg3 = DecisionTreeRegressor(max_depth=2, random_state=42)\n",
    "tree_reg3.fit(X, y3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在我们有一个包含三棵树的集合。它可以简单地通过累加所有树的预测来对新实例进行预测："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.75026781])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_new = np.array([[0.8]])\n",
    "\n",
    "y_pred = sum(tree.predict(X_new) for tree in (tree_reg1, tree_reg2, tree_reg3))\n",
    "\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x792 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_predictions(regressors, X, y, axes, label=None, style=\"r-\", data_style=\"b.\", data_label=None):\n",
    "    x1 = np.linspace(axes[0], axes[1], 500)\n",
    "    y_pred = sum(regressor.predict(x1.reshape(-1, 1)) for regressor in regressors)\n",
    "    plt.plot(X[:, 0], y, data_style, label=data_label)\n",
    "    plt.plot(x1, y_pred, style, linewidth=2, label=label)\n",
    "    if label or data_label:\n",
    "        plt.legend(loc=\"upper center\", fontsize=16)\n",
    "    plt.axis(axes)\n",
    "\n",
    "plt.figure(figsize=(11,11))\n",
    "\n",
    "plt.subplot(321)\n",
    "plot_predictions([tree_reg1], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label=\"$h_1(x_1)$\", style=\"g-\", data_label=\"Training set\")\n",
    "plt.ylabel(\"$y$\", fontsize=16, rotation=0)\n",
    "plt.title(\"Residuals and tree predictions\", fontsize=16)\n",
    "\n",
    "plt.subplot(322)\n",
    "plot_predictions([tree_reg1], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label=\"$h(x_1) = h_1(x_1)$\", data_label=\"Training set\")\n",
    "plt.ylabel(\"$y$\", fontsize=16, rotation=0)\n",
    "plt.title(\"Ensemble predictions\", fontsize=16)\n",
    "\n",
    "plt.subplot(323)\n",
    "plot_predictions([tree_reg2], X, y2, axes=[-0.5, 0.5, -0.5, 0.5], label=\"$h_2(x_1)$\", style=\"g-\", data_style=\"k+\", data_label=\"Residuals\")\n",
    "plt.ylabel(\"$y - h_1(x_1)$\", fontsize=16)\n",
    "\n",
    "plt.subplot(324)\n",
    "plot_predictions([tree_reg1, tree_reg2], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label=\"$h(x_1) = h_1(x_1) + h_2(x_1)$\")\n",
    "plt.ylabel(\"$y$\", fontsize=16, rotation=0)\n",
    "\n",
    "plt.subplot(325)\n",
    "plot_predictions([tree_reg3], X, y3, axes=[-0.5, 0.5, -0.5, 0.5], label=\"$h_3(x_1)$\", style=\"g-\", data_style=\"k+\")\n",
    "plt.ylabel(\"$y - h_1(x_1) - h_2(x_1)$\", fontsize=16)\n",
    "plt.xlabel(\"$x_1$\", fontsize=16)\n",
    "\n",
    "plt.subplot(326)\n",
    "plot_predictions([tree_reg1, tree_reg2, tree_reg3], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label=\"$h(x_1) = h_1(x_1) + h_2(x_1) + h_3(x_1)$\")\n",
    "plt.xlabel(\"$x_1$\", fontsize=16)\n",
    "plt.ylabel(\"$y$\", fontsize=16, rotation=0)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "图7-9（即上图）表示左列中这三棵树的预测，以及右栏中集合的预测。\n",
    "\n",
    "* 在第一行中，集合只有一棵树，因此它的预测与第一棵树的预测完全相同。\n",
    "\n",
    "* 在第二行中，对第一棵树的残差错误训练新树。在右侧，你可以看到集合的预测等于前两棵树的预测总和。\n",
    "\n",
    "* 类似地，在第三行中，对第二树的残留错误训练另一棵树。你可以看到，随着树木被添加到整体中，集合的预测逐渐变得更好。\n",
    "\n",
    "训练GBRT集合的一种更简单的方法是使用Scikit-Learn的GradientBoostingRegressor类。与RandomForestRegressor类非常相似，它具有：\n",
    "\n",
    "* 控制决策树增长的超参数（例如，max_depth，min_samples_leaf等），\n",
    "\n",
    "* 控制集合训练的超参数，例如树的数量（n_estimators）。以下代码创建与前一个相同的集合：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,\n",
       "                          learning_rate=1.0, loss='ls', max_depth=2,\n",
       "                          max_features=None, max_leaf_nodes=None,\n",
       "                          min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                          min_samples_leaf=1, min_samples_split=2,\n",
       "                          min_weight_fraction_leaf=0.0, n_estimators=3,\n",
       "                          n_iter_no_change=None, presort='auto',\n",
       "                          random_state=42, subsample=1.0, tol=0.0001,\n",
       "                          validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "\n",
    "gbrt = GradientBoostingRegressor(\n",
    "    max_depth=2, \n",
    "    n_estimators=3, \n",
    "    learning_rate=1.0, \n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "gbrt.fit(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "learning_rate超参数缩放每棵树的贡献。如果将其设置为较低的值，例如0.1，你需要更多的树木才能适应训练集，但预测通常会更好地概括。 这是一种称为shrinkage的正则化技术。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,\n",
       "                          learning_rate=0.1, loss='ls', max_depth=2,\n",
       "                          max_features=None, max_leaf_nodes=None,\n",
       "                          min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                          min_samples_leaf=1, min_samples_split=2,\n",
       "                          min_weight_fraction_leaf=0.0, n_estimators=3,\n",
       "                          n_iter_no_change=None, presort='auto',\n",
       "                          random_state=42, subsample=1.0, tol=0.0001,\n",
       "                          validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gbrt_slow_1 = GradientBoostingRegressor(\n",
    "    max_depth=2, \n",
    "    n_estimators=3, \n",
    "    learning_rate=0.1, \n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "gbrt_slow_1.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,\n",
       "                          learning_rate=0.1, loss='ls', max_depth=2,\n",
       "                          max_features=None, max_leaf_nodes=None,\n",
       "                          min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                          min_samples_leaf=1, min_samples_split=2,\n",
       "                          min_weight_fraction_leaf=0.0, n_estimators=200,\n",
       "                          n_iter_no_change=None, presort='auto',\n",
       "                          random_state=42, subsample=1.0, tol=0.0001,\n",
       "                          validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gbrt_slow_2 = GradientBoostingRegressor(\n",
    "    max_depth=2, \n",
    "    n_estimators=200, \n",
    "    learning_rate=0.1, \n",
    "    random_state=42\n",
    ")\n",
    "\n",
    "gbrt_slow_2.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'gbrt_slow' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-89e3e5c6ad9b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m122\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mplot_predictions\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mgbrt_slow_2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxes\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0.5\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m0.1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0.8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"learning_rate={}, n_estimators={}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgbrt_slow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlearning_rate\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgbrt_slow\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn_estimators\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfontsize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m14\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'gbrt_slow' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(11,4))\n",
    "\n",
    "plt.subplot(121)\n",
    "plot_predictions([gbrt_slow_1], X, y, axes=[-0.5, 0.5, -0.1, 0.8], label=\"Ensemble predictions\")\n",
    "plt.title(\"learning_rate={}, n_estimators={}\".format(gbrt.learning_rate, gbrt.n_estimators), fontsize=14)\n",
    "\n",
    "plt.subplot(122)\n",
    "plot_predictions([gbrt_slow_2], X, y, axes=[-0.5, 0.5, -0.1, 0.8])\n",
    "plt.title(\"learning_rate={}, n_estimators={}\".format(gbrt_slow.learning_rate, gbrt_slow.n_estimators), fontsize=14)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "图7-10（即上图）显示了以低学习率训练的两个GBRT集合：左边的那个没有足够的树来拟合训练集，而右边的那个有太多的树并且过拟合训练集。\n",
    "\n",
    "####  Gradient Boosting with Early stopping\n",
    "为了找到最佳树木数量，您可以使用提前停止-**Early stopping**（见第4章）。 实现这一点的一种简单方法是使用staged_predict（）方法：它返回一个迭代器，该迭代器覆盖整个训练阶段的集合所做的预测（有一棵树，两棵树等）。\n",
    "\n",
    "以下代码训练带有120棵树的GBRT集合，然后测量每个训练阶段的**验证误差**以找到最佳树木数量，最后使用最佳树木数量训练另一个GBRT集合："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,\n",
       "                          learning_rate=0.1, loss='ls', max_depth=2,\n",
       "                          max_features=None, max_leaf_nodes=None,\n",
       "                          min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                          min_samples_leaf=1, min_samples_split=2,\n",
       "                          min_weight_fraction_leaf=0.0, n_estimators=55,\n",
       "                          n_iter_no_change=None, presort='auto',\n",
       "                          random_state=42, subsample=1.0, tol=0.0001,\n",
       "                          validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "X_train, X_val, y_train, y_val = train_test_split(X, y, random_state=49)\n",
    "\n",
    "gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=120, random_state=42)\n",
    "gbrt.fit(X_train, y_train)\n",
    "\n",
    "errors = [mean_squared_error(y_val, y_pred)\n",
    "          for y_pred in gbrt.staged_predict(X_val)]\n",
    "\n",
    "bst_n_estimators = np.argmin(errors)\n",
    "\n",
    "gbrt_best = GradientBoostingRegressor(max_depth=2,n_estimators=bst_n_estimators, random_state=42)\n",
    "gbrt_best.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.002712853325235463\n"
     ]
    }
   ],
   "source": [
    "\n",
    "min_error = np.min(errors)\n",
    "print(min_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(11, 4))\n",
    "\n",
    "plt.subplot(121)\n",
    "plt.plot(errors, \"b.-\")\n",
    "plt.plot([bst_n_estimators, bst_n_estimators], [0, min_error], \"k--\")\n",
    "plt.plot([0, 120], [min_error, min_error], \"k--\")\n",
    "plt.plot(bst_n_estimators, min_error, \"ko\")\n",
    "plt.text(bst_n_estimators, min_error*1.2, \"Minimum\", ha=\"center\", fontsize=14)\n",
    "plt.axis([0, 120, 0, 0.01])\n",
    "plt.xlabel(\"Number of trees\")\n",
    "plt.title(\"Validation error\", fontsize=14)\n",
    "\n",
    "plt.subplot(122)\n",
    "plot_predictions([gbrt_best], X, y, axes=[-0.5, 0.5, -0.1, 0.8])\n",
    "plt.title(\"Best model (%d trees)\" % bst_n_estimators, fontsize=14)\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "验证错误显示在图7-11的左侧，最佳模型的预测显示在右侧。\n",
    "\n",
    "实际中也可以通过早期停止训练来实现早期停止（而不是先培养大量树木，然后回头寻找最佳数量）。你可以通过设置warm_start = True来实现，这使得Scikit-Learn在调用fit（）方法时保留现有树，从而允许增量训练。 当验证错误连续五次迭代没有改进时，以下代码停止训练："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "gbrt = GradientBoostingRegressor(max_depth=2, warm_start=True, random_state=42)\n",
    "\n",
    "min_val_error = float(\"inf\")\n",
    "error_going_up = 0\n",
    "for n_estimators in range(1, 120):\n",
    "    gbrt.n_estimators = n_estimators\n",
    "    gbrt.fit(X_train, y_train)\n",
    "    y_pred = gbrt.predict(X_val)\n",
    "    val_error = mean_squared_error(y_val, y_pred)\n",
    "    if val_error < min_val_error:\n",
    "        min_val_error = val_error\n",
    "        error_going_up = 0\n",
    "    else:\n",
    "        error_going_up += 1\n",
    "        if error_going_up == 5:\n",
    "            break  # early stopping\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "61\n"
     ]
    }
   ],
   "source": [
    "print(gbrt.n_estimators)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum validation MSE: 0.002712853325235463\n"
     ]
    }
   ],
   "source": [
    "print(\"Minimum validation MSE:\", min_val_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**GradientBoostingRegressor**类还支持子样本超参数，它指定用于训练每棵树的**训练实例的百分数**。例如，如果subsample = 0.25，则每个树在25％的训练实例上进行训练，随机选择。 正如你现在可能猜到的那样，**对于较低的方差，这会产生较高的偏差**。 它还大大加快了训练速度。 这种技术称为**随机梯度增强**（Stochastic Gradient Boosting）。\n",
    "\n",
    "可以使用Gradient Boosting和其他成本函数。这由损失超参数控制（有关详细信息，请参阅Scikit-Learn的文档）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stacking\n",
    "我们在本章讨论的最后一个Ensemble方法称为**堆叠**（叠加泛化的简称）。它基于一个简单的想法：为什么我们不**训练模型**来执行这种聚合？而不是使用简单的函数（如硬投票）来聚合集合中所有预测器的预测， 图7-12显示了这样一个集合在新实例上执行回归任务。\n",
    "* 底部三个预测变量中的每一个预测不同的值（3.1,2.7和2.9），\n",
    "\n",
    "* 然后最终预测器（称为混合器或元学习器--blender, or a meta learner）将这些预测作为输入并进行最终预测（3.0）。\n",
    "\n",
    "为了训练混合器或元学习器，一种常见的方法是使用hold-out set。让我们看看它是如何工作的。\n",
    "\n",
    "首先，训练集分为两个子集。 第一个子集用于训练第一层中的预测器（有三个）（见图7-13）。\n",
    "\n",
    "接下来，第一层预测器被用于在第二个子集进行预测（hold-out）（见图7-14）。 这可以确保预测“干净”，因为预测器在训练期间从未见过这些实例。\n",
    "\n",
    "现在，对于 hold-out 集中的每个实例，有三个预测值。 我们可以使用这些预测值作为输入特征（这使得这个新的训练集为三维）创建一个新的训练集，并保持目标值。 混合器或元学习器在这个新的训练集上训练，因此它基于第一层的预测结果，学习预测目标值。\n",
    "\n",
    "\n",
    "实际上可以用这种方式训练几种不同的搅拌器（例如，一个使用线性回归，另一个使用随机森林回归，等等）：我们得到一整层搅拌器。 诀窍是将训练集分成三个子集：\n",
    "\n",
    "* 第一个用于训练第一层，\n",
    "* 第二个用于创建用于训练第二层的训练集（使用由第一层的预测器做出的预测）\n",
    "* 第三个用于创建训练集以训练第三层（使用第二层预测器的预测）。\n",
    "完成此操作后，我们可以按顺序遍历每个层来预测新实例，如图7-15所示。\n",
    "\n",
    "\n",
    "不幸的是，Scikit-Learn不支持直接堆叠，但是推出自己的实现并不太难（参见以下练习）。 或者，你可以使用Brew等开源实现 （可在[https://github.com/viisar/brew] 获得）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "值得注意的是，可以使用Gradient Boosting的优化实现在流行的**python库XGBoost**中，该库代表Extreme Gradient Boosting。\n",
    "\n",
    "此软件包最初是由Tianqi Chen作为Distributed（Deep）的一部分开发的机器学习社区（DMLC），旨在实现极快，可扩展的\n",
    "和便携式。 实际上，XGBoost通常是获胜的重要组成部分ML竞赛中的参赛作品。 XGBoost的API与Scikit-Learn的API非常相似：\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting xgboot\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  ERROR: Could not find a version that satisfies the requirement xgboot (from versions: none)\n",
      "ERROR: No matching distribution found for xgboot\n"
     ]
    }
   ],
   "source": [
    "! pip install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    import xgboost\n",
    "except ImportError as ex:\n",
    "    print(\"Error: the xgboost library is not installed.\")\n",
    "    xgboost = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation MSE: 0.00400040950714611\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if xgboost is not None:  # not shown in the book\n",
    "    xgb_reg = xgboost.XGBRegressor(random_state=42)\n",
    "    xgb_reg.fit(X_train, y_train)\n",
    "    \n",
    "    y_pred = xgb_reg.predict(X_val)\n",
    "    val_error = mean_squared_error(y_val, y_pred)\n",
    "    print(\"Validation MSE:\", val_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\tvalidation_0-rmse:0.22834\n",
      "Will train until validation_0-rmse hasn't improved in 2 rounds.\n",
      "[1]\tvalidation_0-rmse:0.16224\n",
      "[2]\tvalidation_0-rmse:0.11843\n",
      "[3]\tvalidation_0-rmse:0.08760\n",
      "[4]\tvalidation_0-rmse:0.06848\n",
      "[5]\tvalidation_0-rmse:0.05709\n",
      "[6]\tvalidation_0-rmse:0.05297\n",
      "[7]\tvalidation_0-rmse:0.05129\n",
      "[8]\tvalidation_0-rmse:0.05155\n",
      "[9]\tvalidation_0-rmse:0.05211\n",
      "Stopping. Best iteration:\n",
      "[7]\tvalidation_0-rmse:0.05129\n",
      "\n",
      "Validation MSE: 0.0026308690413069744\n"
     ]
    }
   ],
   "source": [
    "if xgboost is not None:  # not shown in the book\n",
    "    xgb_reg.fit(X_train, y_train,\n",
    "                eval_set=[(X_val, y_val)], \n",
    "                early_stopping_rounds=2\n",
    "               )\n",
    "    y_pred = xgb_reg.predict(X_val)\n",
    "    val_error = mean_squared_error(y_val, y_pred)\n",
    "    print(\"Validation MSE:\", val_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.9 ms ± 240 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit xgboost.XGBRegressor().fit(X_train, y_train) if xgboost is not None else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.8 ms ± 305 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit GradientBoostingRegressor().fit(X_train, y_train)"
   ]
  }
 ],
 "metadata": {
  "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}