notebooks/05.13-Kernel-Density-Estimation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [深入：高斯混合模型](05.12-Gaussian-Mixtures.ipynb) | [目录](Index.ipynb) | [应用：脸部识别管道](05.14-Image-Features.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/05.13-Kernel-Density-Estimation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In-Depth: Kernel Density Estimation\n",
    "\n",
    "# 深入：核密度估计"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> In the previous section we covered Gaussian mixture models (GMM), which are a kind of hybrid between a clustering estimator and a density estimator.\n",
    "Recall that a density estimator is an algorithm which takes a $D$-dimensional dataset and produces an estimate of the $D$-dimensional probability distribution which that data is drawn from.\n",
    "The GMM algorithm accomplishes this by representing the density as a weighted sum of Gaussian distributions.\n",
    "*Kernel density estimation* (KDE) is in some senses an algorithm which takes the mixture-of-Gaussians idea to its logical extreme: it uses a mixture consisting of one Gaussian component *per point*, resulting in an essentially non-parametric estimator of density.\n",
    "In this section, we will explore the motivation and uses of KDE.\n",
    "\n",
    "在上一节中我们介绍了高斯混合模型（GMM），它是一种介于聚类评估器和密度评估器的混合模型。回忆一下密度评估器的定义，这是一种从$D$维数据集中产生一个$D$维概率分布的算法。GMM算法使用了加权高斯分布和的方式实现了密度评估器。*核密度估计*在某种程度上是一个将高斯混合理念发展到其逻辑层次的算法：其中包含了每个数据点形成的一个高斯成分，最终得到一个基本上无参数的密度评估器。在本节中，我们会讨论核密度分析KDE的原理和应用。\n",
    "\n",
    "> We begin with the standard imports:\n",
    "\n",
    "导入包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Motivating KDE: Histograms\n",
    "\n",
    "## 初探KDE：直方图\n",
    "\n",
    "> As already discussed, a density estimator is an algorithm which seeks to model the probability distribution that generated a dataset.\n",
    "For one dimensional data, you are probably already familiar with one simple density estimator: the histogram.\n",
    "A histogram divides the data into discrete bins, counts the number of points that fall in each bin, and then visualizes the results in an intuitive manner.\n",
    "\n",
    "前面已经讨论过，密度评估器是一种找到样本概率分布的模型，然后用来生成数据集的算法。对于一维数据而言，你应该已经熟悉其中一种简单的密度评估器：直方图。直方图将数据分成离散的桶，计算每个桶中数据点的数量，然后将结果可视化成一张非常直观的图表。\n",
    "\n",
    "> For example, let's create some data that is drawn from two normal distributions:\n",
    "\n",
    "下面我们构建一些数据形成两个正态分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_data(N, f=0.3, rseed=1):\n",
    "    rand = np.random.RandomState(rseed)\n",
    "    x = rand.randn(N)\n",
    "    x[int(f * N):] += 5\n",
    "    return x\n",
    "\n",
    "x = make_data(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We have previously seen that the standard count-based histogram can be created with the ``plt.hist()`` function.\n",
    "By specifying the ``normed`` parameter of the histogram, we end up with a normalized histogram where the height of the bins does not reflect counts, but instead reflects probability density:\n",
    "\n",
    "前面我们已经看到标准的直方图可以使用`plt.hist()`函数绘制。通过设置`density`参数，我们可以将直方图标准化，这时图像的高度不再代表数据点的数量，而是概率密度：\n",
    "\n",
    "译者注：新版Matplotlib已经不再使用normed参数，原文和代码中的参数名称已经修改为density。"
   ]
  },
  {
   "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": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hist = plt.hist(x, bins=30, density=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Notice that for equal binning, this normalization simply changes the scale on the y-axis, leaving the relative heights essentially the same as in a histogram built from counts.\n",
    "This normalization is chosen so that the total area under the histogram is equal to 1, as we can confirm by looking at the output of the histogram function:\n",
    "\n",
    "注意对上图来说，标准化只是修改了y轴的度量，但是每个桶相对高度与使用简单求和构建的直方图是一致的。标准化能够使得直方图的全部面积加起来等于1，可以通过直方图函数的输出结果来进行验证："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density, bins, patches = hist\n",
    "widths = bins[1:] - bins[:-1]\n",
    "(density * widths).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> One of the issues with using a histogram as a density estimator is that the choice of bin size and location can lead to representations that have qualitatively different features.\n",
    "For example, if we look at a version of this data with only 20 points, the choice of how to draw the bins can lead to an entirely different interpretation of the data!\n",
    "Consider this example:\n",
    "\n",
    "使用直方图作为密度评估器的一个问题是桶大小和位置的选择会导致展现出不同的数据特征。例如我们仅仅使用20个数据点的情况下，不同的选择会得到完全不同的数据解释。如下例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = make_data(20)\n",
    "bins = np.linspace(-5, 10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 2, figsize=(12, 4),\n",
    "                       sharex=True, sharey=True,\n",
    "                       subplot_kw={'xlim':(-4, 9),\n",
    "                                   'ylim':(-0.02, 0.3)})\n",
    "fig.subplots_adjust(wspace=0.05)\n",
    "for i, offset in enumerate([0.0, 0.6]):\n",
    "    ax[i].hist(x, bins=bins + offset, density=True)\n",
    "    ax[i].plot(x, np.full_like(x, -0.01), '|k',\n",
    "               markeredgewidth=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> On the left, the histogram makes clear that this is a bimodal distribution.\n",
    "On the right, we see a unimodal distribution with a long tail.\n",
    "Without seeing the preceding code, you would probably not guess that these two histograms were built from the same data: with that in mind, how can you trust the intuition that histograms confer?\n",
    "And how might we improve on this?\n",
    "\n",
    "左边的直方图很明显是一个双峰分布。右边的直方图却是一个单峰分布。如果不是看到了前面的代码，我们可能会猜测这两个直方图是从不同的数据集获得的：在这种情况下，如何能信任直方图给我们关于数据分布的直觉呢？该如何改进这点呢？\n",
    "\n",
    "> Stepping back, we can think of a histogram as a stack of blocks, where we stack one block within each bin on top of each point in the dataset.\n",
    "Let's view this directly:\n",
    "\n",
    "再回头深入考虑一下，我们可以将直方图想象成方块组成的堆，将数据集中的每个数据点都作为一个方块放置到其从属的桶的最上方。我们来看看："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "bins = np.arange(-3, 8)\n",
    "ax.plot(x, np.full_like(x, -0.1), '|k',\n",
    "        markeredgewidth=1)\n",
    "for count, edge in zip(*np.histogram(x, bins)):\n",
    "    for i in range(count):\n",
    "        ax.add_patch(plt.Rectangle((edge, i), 1, 1,\n",
    "                                   alpha=0.5))\n",
    "ax.set_xlim(-4, 8)\n",
    "ax.set_ylim(-0.2, 8);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The problem with our two binnings stems from the fact that the height of the block stack often reflects not on the actual density of points nearby, but on coincidences of how the bins align with the data points.\n",
    "This mis-alignment between points and their blocks is a potential cause of the poor histogram results seen here.\n",
    "But what if, instead of stacking the blocks aligned with the *bins*, we were to stack the blocks aligned with the *points they represent*?\n",
    "If we do this, the blocks won't be aligned, but we can add their contributions at each location along the x-axis to find the result.\n",
    "Let's try this:\n",
    "\n",
    "刚才看到那两个直方图的问题实质在于，方块组成的堆高度通常反映的不是实际的附近数据点密度，而是取决于桶与数据点对齐的选择方式，这具有一定的偶然性。不合适的选择就是我们前面看到不正确的直方图结果的原因。但是如果我们不是将方块叠放到桶上，而是将方块叠放到它们*所代表的数据点*上会怎么样？这样做的话，这些方块不会对齐，我们可以将每个数据点在x轴的每个位置上的贡献累加起来得到结果。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_d = np.linspace(-4, 8, 2000)\n",
    "density = sum((abs(xi - x_d) < 0.5) for xi in x)\n",
    "\n",
    "plt.fill_between(x_d, density, alpha=0.5)\n",
    "plt.plot(x, np.full_like(x, -0.1), '|k', markeredgewidth=1)\n",
    "\n",
    "plt.axis([-4, 8, -0.2, 8]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The result looks a bit messy, but is a much more robust reflection of the actual data characteristics than is the standard histogram.\n",
    "Still, the rough edges are not aesthetically pleasing, nor are they reflective of any true properties of the data.\n",
    "In order to smooth them out, we might decide to replace the blocks at each location with a smooth function, like a Gaussian.\n",
    "Let's use a standard normal curve at each point instead of a block:\n",
    "\n",
    "虽然结果看起来有点乱，但是它能比标准直方图更加健壮地反映数据的特征。然而图中的坚硬边界很不美观，且它们也无法反映数据的真实属性。我们可以考虑使用光滑的函数，如高斯函数，来平滑这个图形。下面我们在每个数据点上使用使用标准正态曲线来取代叠放的方块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import norm\n",
    "x_d = np.linspace(-4, 8, 1000)\n",
    "density = sum(norm(xi).pdf(x_d) for xi in x)\n",
    "\n",
    "plt.fill_between(x_d, density, alpha=0.5)\n",
    "plt.plot(x, np.full_like(x, -0.1), '|k', markeredgewidth=1)\n",
    "\n",
    "plt.axis([-4, 8, -0.2, 5]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This smoothed-out plot, with a Gaussian distribution contributed at the location of each input point, gives a much more accurate idea of the shape of the data distribution, and one which has much less variance (i.e., changes much less in response to differences in sampling).\n",
    "\n",
    "平滑后的图像，在每个输入点上都是高斯分布，能够提供对于数据分布的更加精确的形状，而且具有更少的差异（因为取样不同产生的差异小了许多）。\n",
    "\n",
    "> These last two plots are examples of kernel density estimation in one dimension: the first uses a so-called \"tophat\" kernel and the second uses a Gaussian kernel.\n",
    "We'll now look at kernel density estimation in more detail.\n",
    "\n",
    "后面这两张图就是核密度估计在一维数据上的例子：第一幅图使用的是“高帽”核，第二幅图使用的是高斯核。下面我们详细讨论核密度估计。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kernel Density Estimation in Practice\n",
    "\n",
    "## 实践中使用核密度估计\n",
    "\n",
    "> The free parameters of kernel density estimation are the *kernel*, which specifies the shape of the distribution placed at each point, and the *kernel bandwidth*, which controls the size of the kernel at each point.\n",
    "In practice, there are many kernels you might use for a kernel density estimation: in particular, the Scikit-Learn KDE implementation supports one of six kernels, which you can read about in Scikit-Learn's [Density Estimation documentation](http://scikit-learn.org/stable/modules/density.html).\n",
    "\n",
    "核密度估计中的自由参数是*核*，它设定了分布在每个点的形状以及控制着每个点上核的大小（被称为*核带宽*）的参数。实践中有许多可用的核密度估计：具体来说，Scikit-Learn的KDE实现了其中的6种，读者可以在Scikit-Learn在线文档[密度估计](http://scikit-learn.org/stable/modules/density.html)中查看。\n",
    "\n",
    "> While there are several versions of kernel density estimation implemented in Python (notably in the SciPy and StatsModels packages), I prefer to use Scikit-Learn's version because of its efficiency and flexibility.\n",
    "It is implemented in the ``sklearn.neighbors.KernelDensity`` estimator, which handles KDE in multiple dimensions with one of six kernels and one of a couple dozen distance metrics.\n",
    "Because KDE can be fairly computationally intensive, the Scikit-Learn estimator uses a tree-based algorithm under the hood and can trade off computation time for accuracy using the ``atol`` (absolute tolerance) and ``rtol`` (relative tolerance) parameters.\n",
    "The kernel bandwidth, which is a free parameter, can be determined using Scikit-Learn's standard cross validation tools as we will soon see.\n",
    "\n",
    "虽然Python当中有一些核密度估计的实现（主要是在SciPy和StatsModels包中），作者还是建议使用Scikit-Learn的版本，因为它具有高效和灵活的特性。这些评估器被实现在`sklearn.neighbors.KernelDensity`当中，它们能使用6种核类型以及数十种距离度量计算方法在多维数据中实现KDE。因为KDE方法较为计算密集，Scikit-Learn的评估器在底层使用了树形算法，并且能够使用`atol`（绝对容差）和`rtol`（相对容差）来平衡计算时间与精确度。其中的自由参数核带宽可以使用标准的交叉验证工具决定，我们马上就会看到。\n",
    "\n",
    "> Let's first show a simple example of replicating the above plot using the Scikit-Learn ``KernelDensity`` estimator:\n",
    "\n",
    "下面使用Scikit-Learn的`KernelDensity`评估器重复一下上面的图表，作为一个简单的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.neighbors import KernelDensity\n",
    "\n",
    "# 初始化KDE模型，拟合数据\n",
    "kde = KernelDensity(bandwidth=1.0, kernel='gaussian')\n",
    "kde.fit(x[:, None])\n",
    "\n",
    "# score_samples返回概率密度的对数值\n",
    "logprob = kde.score_samples(x_d[:, None])\n",
    "\n",
    "plt.fill_between(x_d, np.exp(logprob), alpha=0.5)\n",
    "plt.plot(x, np.full_like(x, -0.01), '|k', markeredgewidth=1)\n",
    "plt.ylim(-0.02, 0.22);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The result here is normalized such that the area under the curve is equal to 1.\n",
    "\n",
    "上面的结果已经标准化了，因此曲线下方的面积为1。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selecting the bandwidth via cross-validation\n",
    "\n",
    "### 通过交叉验证选择带宽\n",
    "\n",
    "> The choice of bandwidth within KDE is extremely important to finding a suitable density estimate, and is the knob that controls the bias–variance trade-off in the estimate of density: too narrow a bandwidth leads to a high-variance estimate (i.e., over-fitting), where the presence or absence of a single point makes a large difference. Too wide a bandwidth leads to a high-bias estimate (i.e., under-fitting) where the structure in the data is washed out by the wide kernel.\n",
    "\n",
    "KDE中带宽的选择对于寻找合适的密度估计是至关重要的，同时也是控制偏差的开关，这是密度估计方差的权衡值：太窄的带宽会导致高方差估计（也就是过拟合），也就是一个数据点的存在或缺失会导致巨大的差异。太宽泛的带宽会导致高偏差估计（也就是欠拟合），整个数据的结构被过宽的核给抹平了。\n",
    "\n",
    "> There is a long history in statistics of methods to quickly estimate the best bandwidth based on rather stringent assumptions about the data: if you look up the KDE implementations in the SciPy and StatsModels packages, for example, you will see implementations based on some of these rules.\n",
    "\n",
    "在统计学中，基于数据相当严格的假设来估计最佳带宽有着很长的历史：如果你查看SciPy和StatsModels包中的KDE实现，你可以看到其中一些规则的实现。\n",
    "\n",
    "> In machine learning contexts, we've seen that such hyperparameter tuning often is done empirically via a cross-validation approach.\n",
    "With this in mind, the ``KernelDensity`` estimator in Scikit-Learn is designed such that it can be used directly within the Scikit-Learn's standard grid search tools.\n",
    "Here we will use ``GridSearchCV`` to optimize the bandwidth for the preceding dataset.\n",
    "Because we are looking at such a small dataset, we will use leave-one-out cross-validation, which minimizes the reduction in training set size for each cross-validation trial:\n",
    "\n",
    "在机器学习领域，我们已经知道这样的超参数调整通常可以通过交叉验证方法来实现。因此Scikit-Learn中的`KernelDensity`评估器被设计成可以直接使用Scikit-Learn的标准网格搜索工具。这里我们将使用`GridSearchCV`来对前面的数据集的带宽进行优化。因为这是一个非常小的数据集，我们会使用留出一个的交叉验证方法，这能在每次交叉验证测试中尽量保证训练集的最大样本量：\n",
    "\n",
    "译者注：新版Scikit-Learn已经将GridSearchCV和LeaveOneOut移到了`sklearn.model_selection`包中，并且LeaveOneOut不再需要提供参数。下面的代码做了相应修改。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.model_selection import LeaveOneOut\n",
    "\n",
    "bandwidths = 10 ** np.linspace(-1, 1, 100)\n",
    "grid = GridSearchCV(KernelDensity(kernel='gaussian'),\n",
    "                    {'bandwidth': bandwidths},\n",
    "                    cv=LeaveOneOut())\n",
    "grid.fit(x[:, None]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Now we can find the choice of bandwidth which maximizes the score (which in this case defaults to the log-likelihood):\n",
    "\n",
    "然后就可以得到最大分值的带宽了（本例中分值默认为对数分值）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bandwidth': 1.1233240329780276}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid.best_params_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The optimal bandwidth happens to be very close to what we used in the example plot earlier, where the bandwidth was 1.0 (i.e., the default width of ``scipy.stats.norm``).\n",
    "\n",
    "带宽的最优值正好非常接近我们在前面例子中使用的1.0（也是`scipy.stats.norm`的默认宽度）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: KDE on a Sphere\n",
    "\n",
    "## 例子：球面上的KDE\n",
    "\n",
    "> Perhaps the most common use of KDE is in graphically representing distributions of points.\n",
    "For example, in the Seaborn visualization library (see [Visualization With Seaborn](04.14-Visualization-With-Seaborn.ipynb)), KDE is built in and automatically used to help visualize points in one and two dimensions.\n",
    "\n",
    "KDE最常见的应用可能是数据点分布的图像表示。例如在Seaborn可视化库（参见[使用Seaborn可视化](04.14-Visualization-With-Seaborn.ipynb)）中，KDE是在一维和二维空间中的內建的自动化可视化方法。\n",
    "\n",
    "> Here we will look at a slightly more sophisticated use of KDE for visualization of distributions.\n",
    "We will make use of some geographic data that can be loaded with Scikit-Learn: the geographic distributions of recorded observations of two South American mammals, *Bradypus variegatus* (the Brown-throated Sloth) and *Microryzomys minutus* (the Forest Small Rice Rat).\n",
    "\n",
    "这里我们将要讨论一个稍微复杂一些的KDE进行数据分布可视化的例子：观察记录到两种南美哺乳动物的地理分布情况，棕喉树懒和森林小稻鼠。\n",
    "\n",
    "> With Scikit-Learn, we can fetch this data as follows:\n",
    "\n",
    "使用Scikit-Learn如下获取数据："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_species_distributions\n",
    "\n",
    "data = fetch_species_distributions()\n",
    "\n",
    "# 提取物种ID和位置数据\n",
    "latlon = np.vstack([data.train['dd lat'],\n",
    "                    data.train['dd long']]).T\n",
    "species = np.array([d.decode('ascii').startswith('micro')\n",
    "                    for d in data.train['species']], dtype='int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With this data loaded, we can use the Basemap toolkit (mentioned previously in [Geographic Data with Basemap](04.13-Geographic-Data-With-Basemap.ipynb)) to plot the observed locations of these two species on the map of South America.\n",
    "\n",
    "当数据载入后，我们可以使用Basemap工具集（之前在[使用Basemap创建地理位置图表](04.13-Geographic-Data-With-Basemap.ipynb)中介绍过）来绘制这两个物种在南美洲地图上观测的位置。\n",
    "\n",
    "译者注：译者所用Scikit-Learn版本有个issue，警告species_distributions模块已经过时，master分支已经修复，但未并入发行版，此处保留了该警告，但不影响后续功能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wangy/anaconda3/lib/python3.7/site-packages/sklearn/utils/deprecation.py:144: FutureWarning: The sklearn.datasets.species_distributions module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.datasets. Anything that cannot be imported from sklearn.datasets is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.basemap import Basemap\n",
    "from sklearn.datasets.species_distributions import construct_grids\n",
    "\n",
    "xgrid, ygrid = construct_grids(data)\n",
    "\n",
    "# 使用basemap绘制海岸线\n",
    "m = Basemap(projection='cyl', resolution='c',\n",
    "            llcrnrlat=ygrid.min(), urcrnrlat=ygrid.max(),\n",
    "            llcrnrlon=xgrid.min(), urcrnrlon=xgrid.max())\n",
    "m.drawmapboundary(fill_color='#DDEEFF')\n",
    "m.fillcontinents(color='#FFEEDD')\n",
    "m.drawcoastlines(color='gray', zorder=2)\n",
    "m.drawcountries(color='gray', zorder=2)\n",
    "\n",
    "# 绘制位置\n",
    "m.scatter(latlon[:, 1], latlon[:, 0], zorder=3,\n",
    "          c=species, cmap='rainbow', latlon=True);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Unfortunately, this doesn't give a very good idea of the density of the species, because points in the species range may overlap one another.\n",
    "You may not realize it by looking at this plot, but there are over 1,600 points shown here!\n",
    "\n",
    "不过，上图并没有给出这两种动物的分布密度估计，因为这些点的范围互相重叠了。上图中有很多分布点，实际上有超过1600个数据点绘制在图中。\n",
    "\n",
    "> Let's use kernel density estimation to show this distribution in a more interpretable way: as a smooth indication of density on the map.\n",
    "Because the coordinate system here lies on a spherical surface rather than a flat plane, we will use the ``haversine`` distance metric, which will correctly represent distances on a curved surface.\n",
    "\n",
    "让我们使用核密度估计将这个分布展示成更加有含义的图表：在地图上显示平滑的密度分布情况。因为实际上使用的是球面坐标系统而不是平面坐标系，所以距离度量采取了`haversine`，这是一个能正确表达曲面距离的方法。\n",
    "\n",
    "> There is a bit of boilerplate code here (one of the disadvantages of the Basemap toolkit) but the meaning of each code block should be clear:\n",
    "\n",
    "下面的代码有点冗长（Basemap工具集的缺点之一），但是每个代码块的含义还是很清晰的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 设置地图上的数据网格\n",
    "X, Y = np.meshgrid(xgrid[::5], ygrid[::5][::-1])\n",
    "land_reference = data.coverages[6][::5, ::5]\n",
    "land_mask = (land_reference > -9999).ravel()\n",
    "xy = np.vstack([Y.ravel(), X.ravel()]).T\n",
    "xy = np.radians(xy[land_mask])\n",
    "\n",
    "# 创建两个并排的图表\n",
    "fig, ax = plt.subplots(1, 2)\n",
    "fig.subplots_adjust(left=0.05, right=0.95, wspace=0.05)\n",
    "species_names = ['Bradypus Variegatus', 'Microryzomys Minutus']\n",
    "cmaps = ['Purples', 'Reds']\n",
    "\n",
    "for i, axi in enumerate(ax):\n",
    "    axi.set_title(species_names[i])\n",
    "    \n",
    "    # 使用basemap绘制海岸线和国境线\n",
    "    m = Basemap(projection='cyl', llcrnrlat=Y.min(),\n",
    "                urcrnrlat=Y.max(), llcrnrlon=X.min(),\n",
    "                urcrnrlon=X.max(), resolution='c', ax=axi)\n",
    "    m.drawmapboundary(fill_color='#DDEEFF')\n",
    "    m.drawcoastlines()\n",
    "    m.drawcountries()\n",
    "    \n",
    "    # 构造分布的球面核密度估计\n",
    "    kde = KernelDensity(bandwidth=0.03, metric='haversine')\n",
    "    kde.fit(np.radians(latlon[species == i]))\n",
    "\n",
    "    # 仅计算陆地范围，-9999代表海洋\n",
    "    Z = np.full(land_mask.shape[0], -9999.0)\n",
    "    Z[land_mask] = np.exp(kde.score_samples(xy))\n",
    "    Z = Z.reshape(X.shape)\n",
    "\n",
    "    # 绘制密度的轮廓\n",
    "    levels = np.linspace(0, Z.max(), 25)\n",
    "    axi.contourf(X, Y, Z, levels=levels, cmap=cmaps[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Compared to the simple scatter plot we initially used, this visualization paints a much clearer picture of the geographical distribution of observations of these two species.\n",
    "\n",
    "对比前面我们绘制的简单散点图，上面两个图表很清晰的展示了两种动物的地理位置分布情况。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Not-So-Naive Bayes\n",
    "\n",
    "## 例子：非朴素贝叶斯\n",
    "\n",
    "> This example looks at Bayesian generative classification with KDE, and demonstrates how to use the Scikit-Learn architecture to create a custom estimator.\n",
    "\n",
    "下面这个例子我们来看下使用KDE创建贝叶斯生成分类，并且展示如何使用Scikit-Learn创建自定义的评估器。\n",
    "\n",
    "> In [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb), we took a look at naive Bayesian classification, in which we created a simple generative model for each class, and used these models to build a fast classifier.\n",
    "For Gaussian naive Bayes, the generative model is a simple axis-aligned Gaussian.\n",
    "With a density estimation algorithm like KDE, we can remove the \"naive\" element and perform the same classification with a more sophisticated generative model for each class.\n",
    "It's still Bayesian classification, but it's no longer naive.\n",
    "\n",
    "在[深入：朴素贝叶斯分类](05.05-Naive-Bayes.ipynb)中，我们学习了朴素贝叶斯分类，里面构建了每个类别的简单生成模型并且使用这些模型来构建一个快速分类器。对于高斯朴素贝叶斯来说，生成模型就是简单的沿着坐标轴的高斯函数。使用密度估计算法如KDE，我们可以去除其中的“朴素”成分，然后对每个类别使用更加复杂的生成模型进行相同的分类工作。这仍然是贝叶斯分类，只是不再朴素。\n",
    "\n",
    "> The general approach for generative classification is this:\n",
    "\n",
    ">1. Split the training data by label.\n",
    "2. For each set, fit a KDE to obtain a generative model of the data.\n",
    "   This allows you for any observation $x$ and label $y$ to compute a likelihood $P(x~|~y)$.   \n",
    "3. From the number of examples of each class in the training set, compute the *class prior*, $P(y)$.\n",
    "4. For an unknown point $x$, the posterior probability for each class is $P(y~|~x) \\propto P(x~|~y)P(y)$.\n",
    "   The class which maximizes this posterior is the label assigned to the point.\n",
    "\n",
    "生成分类的通用方法如下：\n",
    "\n",
    "1. 将训练数据依据标签划分成不同类别。\n",
    "2. 对每个类别，使用KDE拟合数据获得一个生成模型。这允许你对于任何观察$x$和标签$y$计算出似然$P(x~|~y)$。\n",
    "3. 对训练集中的每个类别，从样本数量计算得到*类别先验概率*$P(y)$。\n",
    "4. 对一个未知点$x$，每个类别的后验概率是$P(y~|~x) \\propto P(x~|~y)P(y)$。哪个类别具有最大的后验概率值，就将这个点设置为该类别标签。\n",
    "\n",
    "> The algorithm is straightforward and intuitive to understand; the more difficult piece is couching it within the Scikit-Learn framework in order to make use of the grid search and cross-validation architecture.\n",
    "\n",
    "上述算法很直观和易于理解；更困难的部分是将它实现在Scikit-Learn框架当中，这样就能使用网格搜索和交叉验证工具。\n",
    "\n",
    "> This is the code that implements the algorithm within the Scikit-Learn framework; we will step through it following the code block:\n",
    "\n",
    "下面是Scikit-Learn框架中实现这个算法的代码；我们过一遍这些代码片段："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator, ClassifierMixin\n",
    "\n",
    "\n",
    "class KDEClassifier(BaseEstimator, ClassifierMixin):\n",
    "    \"\"\"Bayesian generative classification based on KDE\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    bandwidth : float\n",
    "        the kernel bandwidth within each class\n",
    "    kernel : str\n",
    "        the kernel name, passed to KernelDensity\n",
    "    \"\"\"\n",
    "    def __init__(self, bandwidth=1.0, kernel='gaussian'):\n",
    "        self.bandwidth = bandwidth\n",
    "        self.kernel = kernel\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        self.classes_ = np.sort(np.unique(y))\n",
    "        training_sets = [X[y == yi] for yi in self.classes_]\n",
    "        self.models_ = [KernelDensity(bandwidth=self.bandwidth,\n",
    "                                      kernel=self.kernel).fit(Xi)\n",
    "                        for Xi in training_sets]\n",
    "        self.logpriors_ = [np.log(Xi.shape[0] / X.shape[0])\n",
    "                           for Xi in training_sets]\n",
    "        return self\n",
    "        \n",
    "    def predict_proba(self, X):\n",
    "        logprobs = np.array([model.score_samples(X)\n",
    "                             for model in self.models_]).T\n",
    "        result = np.exp(logprobs + self.logpriors_)\n",
    "        return result / result.sum(1, keepdims=True)\n",
    "        \n",
    "    def predict(self, X):\n",
    "        return self.classes_[np.argmax(self.predict_proba(X), 1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The anatomy of a custom estimator\n",
    "\n",
    "### 自定义评估器代码剖析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Let's step through this code and discuss the essential features:\n",
    "\n",
    "让我们一步一步的分析上面的代码并讨论其中最关键的特性：\n",
    "\n",
    "```python\n",
    "from sklearn.base import BaseEstimator, ClassifierMixin\n",
    "\n",
    "class KDEClassifier(BaseEstimator, ClassifierMixin):\n",
    "    \"\"\"Bayesian generative classification based on KDE\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    bandwidth : float\n",
    "        the kernel bandwidth within each class\n",
    "    kernel : str\n",
    "        the kernel name, passed to KernelDensity\n",
    "    \"\"\"\n",
    "```\n",
    "\n",
    "> Each estimator in Scikit-Learn is a class, and it is most convenient for this class to inherit from the ``BaseEstimator`` class as well as the appropriate mixin, which provides standard functionality.\n",
    "For example, among other things, here the ``BaseEstimator`` contains the logic necessary to clone/copy an estimator for use in a cross-validation procedure, and ``ClassifierMixin`` defines a default ``score()`` method used by such routines.\n",
    "We also provide a doc string, which will be captured by IPython's help functionality (see [Help and Documentation in IPython](01.01-Help-And-Documentation.ipynb)).\n",
    "\n",
    "Scikit-Learn中的每个评估器都是一个类（译者注：Python类），对于评估器类来说最方便的就是继承`BaseEstimator`类以及相应的混合器，它们能提供标准的功能。例如这里`BaseEstimator`包含着代码逻辑当需要使用交叉验证过程时能复制评估器的副本，`ClassifierMixin`定义了默认的`score()`方法给分类器继承。下面是文档字符串，可以被IPython的帮助功能捕获到（参见[IPython的帮助和文档](01.01-Help-And-Documentation.ipynb)）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Next comes the class initialization method:\n",
    "\n",
    "下面是类实例初始化方法：\n",
    "\n",
    "```python\n",
    "    def __init__(self, bandwidth=1.0, kernel='gaussian'):\n",
    "        self.bandwidth = bandwidth\n",
    "        self.kernel = kernel\n",
    "```\n",
    "\n",
    "> This is the actual code that is executed when the object is instantiated with ``KDEClassifier()``.\n",
    "In Scikit-Learn, it is important that *initialization contains no operations* other than assigning the passed values by name to ``self``.\n",
    "This is due to the logic contained in ``BaseEstimator`` required for cloning and modifying estimators for cross-validation, grid search, and other functions.\n",
    "Similarly, all arguments to ``__init__`` should be explicit: i.e. ``*args`` or ``**kwargs`` should be avoided, as they will not be correctly handled within cross-validation routines.\n",
    "\n",
    "这个方法的代码是当对象实例通过`KDEClassifier()`创建完成后初始化执行的部分。在Scikit-Learn中，很重要的一点需要记住，初始化方法除了通过`self`设置对象属性外不能包括其他的操作。这是因为`BaseEstimator`中的代码逻辑在交叉验证、网格搜索和其他功能时需要克隆和修改评估器。类似的，`__init__`方法的参数应该是显式定义的：`*args`或`**kwargs`的定义方式应该避免，同样是因为它们无法被交叉验证过程正确的处理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Next comes the ``fit()`` method, where we handle training data:\n",
    "\n",
    "接下来是`fit()`方法，对训练数据进行拟合：\n",
    "\n",
    "```python \n",
    "    def fit(self, X, y):\n",
    "        self.classes_ = np.sort(np.unique(y))\n",
    "        training_sets = [X[y == yi] for yi in self.classes_]\n",
    "        self.models_ = [KernelDensity(bandwidth=self.bandwidth,\n",
    "                                      kernel=self.kernel).fit(Xi)\n",
    "                        for Xi in training_sets]\n",
    "        self.logpriors_ = [np.log(Xi.shape[0] / X.shape[0])\n",
    "                           for Xi in training_sets]\n",
    "        return self\n",
    "```\n",
    "\n",
    "> Here we find the unique classes in the training data, train a ``KernelDensity`` model for each class, and compute the class priors based on the number of input samples.\n",
    "Finally, ``fit()`` should always return ``self`` so that we can chain commands. For example:\n",
    "\n",
    "首先找出训练数据中所有唯一的分类标签，对每个分类独立训练一个`KernelDensity`模型，然后根据输入样本数量计算每个分类的先验概率。最后`fit()`方法应该永远返回`self`令其支持链式操作。例如：\n",
    "\n",
    "```python\n",
    "label = model.fit(X, y).predict(X)\n",
    "```\n",
    "\n",
    "> Notice that each persistent result of the fit is stored with a trailing underscore (e.g., ``self.logpriors_``).\n",
    "This is a convention used in Scikit-Learn so that you can quickly scan the members of an estimator (using IPython's tab completion) and see exactly which members are fit to training data.\n",
    "\n",
    "注意一下`fit`得到的持久化结果应该保存在后缀下划线名称的属性当中（例如`self.logpriors_`）。这是Scikit-Learn的编码规范方便用户迅速的查看评估器的成员值（使用IPython的制表符补全）并获得已经拟合到训练数据上的成员变量值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Finally, we have the logic for predicting labels on new data:\n",
    "\n",
    "最后我们看到的是在新数据上预测标签的逻辑：\n",
    "\n",
    "```python\n",
    "    def predict_proba(self, X):\n",
    "        logprobs = np.vstack([model.score_samples(X)\n",
    "                              for model in self.models_]).T\n",
    "        result = np.exp(logprobs + self.logpriors_)\n",
    "        return result / result.sum(1, keepdims=True)\n",
    "        \n",
    "    def predict(self, X):\n",
    "        return self.classes_[np.argmax(self.predict_proba(X), 1)]\n",
    "```\n",
    "\n",
    "> Because this is a probabilistic classifier, we first implement ``predict_proba()`` which returns an array of class probabilities of shape ``[n_samples, n_classes]``.\n",
    "Entry ``[i, j]`` of this array is the posterior probability that sample ``i`` is a member of class ``j``, computed by multiplying the likelihood by the class prior and normalizing.\n",
    "\n",
    "因为这是一个概率分类器，我们首先实现了`predict_proba()`方法，它返回新数据在每个分类上的后验概率数组，形状是`[n_samples, n_classes]`。数组中的元素`[i, j]`是样本`i`属于分类`j`的后验概率值，通过将似然值与分类先验概率值相乘并标准化后得到。\n",
    "\n",
    "> Finally, the ``predict()`` method uses these probabilities and simply returns the class with the largest probability.\n",
    "\n",
    "最后`predict()`方法使用这些概率并在其中找到最大值，然后返回分类的标签。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using our custom estimator\n",
    "\n",
    "### 使用我们的自定义评估器\n",
    "\n",
    "> Let's try this custom estimator on a problem we have seen before: the classification of hand-written digits.\n",
    "Here we will load the digits, and compute the cross-validation score for a range of candidate bandwidths using the ``GridSearchCV`` meta-estimator (refer back to [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb)):\n",
    "\n",
    "下面让我们试一下这个自定义评估器，使用前面我们研究过的问题：手写数字分类。我们载入手写数字数据，然后针对一定范围的带宽值使用`GridSearchCV`元评估器计算交叉验证结果（参见[超参数和模型验证](05.03-Hyperparameters-and-Model-Validation.ipynb)）：\n",
    "\n",
    "译者注：下面代码做了修改以适应新版本Scikit-Learn。包括GridSearchCV从属的包，参数cv和结果中使用cv_result_字典取分值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_digits\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "digits = load_digits()\n",
    "\n",
    "bandwidths = 10 ** np.linspace(0, 2, 100)\n",
    "grid = GridSearchCV(KDEClassifier(), {'bandwidth': bandwidths}, cv=5)\n",
    "grid.fit(digits.data, digits.target)\n",
    "\n",
    "scores = grid.cv_results_['mean_test_score']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Next we can plot the cross-validation score as a function of bandwidth:\n",
    "\n",
    "接下来我们可以绘制交叉验证分值与带宽之间的函数图像："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'bandwidth': 6.135907273413174}\n",
      "accuracy = 0.9677298050139276\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.semilogx(bandwidths, scores)\n",
    "plt.xlabel('bandwidth')\n",
    "plt.ylabel('accuracy')\n",
    "plt.title('KDE Model Performance')\n",
    "print(grid.best_params_)\n",
    "print('accuracy =', grid.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We see that this not-so-naive Bayesian classifier reaches a cross-validation accuracy of just over 96%; this is compared to around 80% for the naive Bayesian classification:\n",
    "\n",
    "我们看到这个不那么朴素的贝叶斯分类器达到了交叉验证准确率超过96%；而朴素贝叶斯分类只有大约80%："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8069281956050759"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(GaussianNB(), digits.data, digits.target, cv=5).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> One benefit of such a generative classifier is interpretability of results: for each unknown sample, we not only get a probabilistic classification, but a *full model* of the distribution of points we are comparing it to!\n",
    "If desired, this offers an intuitive window into the reasons for a particular classification that algorithms like SVMs and random forests tend to obscure.\n",
    "\n",
    "上述生成分类器的一个优点是结果的可解释性：对于每个未知的样本，我们不但得到了概率分类，还获得了数据点分布情况的*完整模型*。如果需要的话，还可以给出一个样本具体分类的直观理由，而其他算法像SVM和随机森林在这点上通常是模糊的。\n",
    "\n",
    "> If you would like to take this further, there are some improvements that could be made to our KDE classifier model:\n",
    "\n",
    "> - we could allow the bandwidth in each class to vary independently\n",
    "- we could optimize these bandwidths not based on their prediction score, but on the likelihood of the training data under the generative model within each class (i.e. use the scores from ``KernelDensity`` itself rather than the global prediction accuracy)\n",
    "\n",
    "如果你希望更进一步，下面是我们KDE分类模型可以继续优化的一些建议：\n",
    "\n",
    "- 可以允许每个分类使用独立的带宽值。\n",
    "- 可以优化带宽值，不基于它们的预测分数，而是基于每个分类在生成模型下拟合训练数据的似然值（也就是使用`KernelDensity`本身的分数值来调整带宽，而不是全局的预测准确率）。\n",
    "\n",
    "> Finally, if you want some practice building your own estimator, you might tackle building a similar Bayesian classifier using Gaussian Mixture Models instead of KDE.\n",
    "\n",
    "最后，如果你希望练习构建你自己的评估器，你可以尝试一个相似的贝叶斯分类器，使用高斯混合模型而不是KDE。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [深入：高斯混合模型](05.12-Gaussian-Mixtures.ipynb) | [目录](Index.ipynb) | [应用：脸部识别管道](05.14-Image-Features.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/wangyingsm/Python-Data-Science-Handbook/blob/master/notebooks/05.13-Kernel-Density-Estimation.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}