机器学习百度云笔记

线性回归

概念：
假如我们有这样一个实例：银行会根据你的工资和年龄来决定贷款给你多少钱，这样工资和年龄就是特征，而贷款金额就是标签，而工资和年龄对于贷款金额的影响是不同的，也就是说权重不同，这样我们就能够得到一个线性方程，这就是线性回归。从图像上来看，我们可以将特征的实例看成是坐标空间中一个个的点，而线性回归的目的就是找到一条能够很好拟合这些数据点的线或者（一个平面）。
拟合方程如下：
$$h_{\theta }\left(x\right)={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2$$（其中 ${\theta }_0$ 表示偏置项）
整合之后：
$$\Rightarrow h_{\theta }\left(x\right)=\sum _{i=1}^m{\theta }_i{x}_i={\mathbf{\theta }}^T\mathbf{x}$$
误差：
构建完成拟合函数之后，我们需要确定这个函数中的参数 $\mathbf{\theta }$，如果需要解决这个问题，我们这里要再介绍一下误差的概念。这里的误差是指：我们通过函数预测的值与真实值之间肯定存在差异。
$$y^{\left(i\right)}={\mathbf{\theta }}^T{x}^{\left(i\right)}+{\epsilon }^{\left(i\right)}$$
误差里面有几个点需要记住：

• 误差是独立同分布的，并且服从均值为0，方差为 ${\mathbf{\theta }}^2$ 的高斯分布。独立同分布要理解
• 高斯分布，也就是特殊的正态分布。用例子来讲就是，我们认为绝大多数情况下，误差的浮动不会太大，极小情况下会有较大偏差，这样是符合现实情况的。

似然函数：
了解误差之后，我们将通过误差来求解分布参数 $\mathbf{\theta }$ ，这样我们就能够求解回归方程了。
误差公式：
$$y^{\left(i\right)}={\mathbf{\theta }}^T{x}^{\left(i\right)}+{\epsilon }^{\left(i\right)}$$
并且误差服从高斯分布：
$$p\left({\epsilon }^{\left(i\right)}\right)=\frac{1}{\sqrt{2\pi }\sigma }exp\left(-\frac{{\left({\epsilon }^i\right)}^2}{2{\sigma }^2}\right)$$
两式合并之后，得到：
$$p\left(y^{\left(i\right)}|x^{\left(i\right)}:\mathbf{\theta }\right)=\frac{1}{\sqrt{2\pi }\sigma }exp\left(-\frac{{\left(y^{\left(i\right)}-{\mathbf{\theta }}^T{x}^{\left(i\right)}\right)}^2}{2{\sigma }^2}\right)$$
接下来我们就可以通过似然函数求解分布参数 $\mathbf{\theta }$ 。假如给定一个概率分布，同时我们知道概率密度函数（连续分布）或者概率质量函数（离散分布），同时有一个分布参数 $\theta$ ，那么我们可以从这个分布中抽取一个包含 n 个值的采样，从这个采样中我们估计出最有可能的 $\theta$ 的值。为了实现这个方法，我们构建了似然函数，也就是 n 个值的概率相乘，就能够得到一个包含 $\theta$ 的函数，令一阶导数为0，就能得到函数的最大值，也就是概率最大的情况下的 $\theta$ 的值。这个 $\theta$ 我们称为是最大似然估计。
似然函数：
$$L\left(\mathbf{\theta }\right)=\prod _{i=1}^{n}p\left(y^{\left(i\right)}|x^{\left(i\right)}:\mathbf{\theta }\right)=\prod _{i=1}^n\frac{1}{\sqrt{2\pi }\sigma }exp\left(-\frac{{\left(y^{\left(i\right)}-{\mathbf{\theta }}^T{x}^{\left(i\right)}\right)}^2}{2{\sigma }^2}\right)$$
(这里可以这样解释，通过似然函数求解的 $\mathbf{\theta }$ 能够最大概率的抽样结果和我们的抽样一致）
以上函数是乘积形式，为了方便求导数，我们两边取对数：
$$logL\left(\mathbf{\theta }\right)=log\prod _{i=1}^n\frac{1}{\sqrt{2\pi }\sigma }exp\left(-\frac{{\left(y^{\left(i\right)}-{\mathbf{\theta }}^T{x}^{\left(i\right)}\right)}^2}{2{\sigma }^2}\right)$$
推导求解公式：
将上面的对数函数化简之后能够得到：
$$\begin{gathered} \log L\left(\mathbf{\theta }\right)=\sum _{i=1}^n\log \frac{1}{\sqrt{2\pi }\sigma }exp\left(-\frac{{\left(y^{\left(i\right)}-{\mathbf{\theta }}^T{x}^{\left(i\right)}\right)}^2}{2{\sigma }^2}\right) \\ =m\log \frac{1}{\sqrt{2\pi }\sigma }-\frac{1}{{\sigma }^2}\cdot \frac{1}{2}\sum _{i=1}^n{\left(y^{\left(i\right)}-{\mathbf{\theta }}^{\mathbf{T}}{x}^{\left(i\right)}\right)}^2 \end{gathered}$$
由上式可以看出，前面是一个常数项，后面是一个恒为正数的多项式，这样要使函数值最大（表示可能性最大），就要使得后面的多项式最小，如下所示：
$$J\left(\theta \right)=\frac{1}{2}\sum _{i=1}^n{\left(y^{\left(i\right)}-{\mathbf{\theta }}^{\mathbf{T}}{x}^i\right)}^2$$
这样就将问题转化成求解上面所示函数的最小值，进行如下求解：
$$J\left(\theta \right)=\frac{1}{2}\sum _{i=1}^n{\left(h_{\theta }\left(x^{\left(i\right)}\right)-y^{\left(i\right)}\right)}^2=\frac{1}{2}{\left(\mathbf{X}\mathbf{\theta }-y\right)}^T\left(\mathbf{X}\mathbf{\theta }-y\right)$$
为了求解函数的最小值，我们对左右两边同时求导：
$$\begin{gathered} \nabla J\left(\theta \right)=\nabla \left(\frac{1}{2}{\left(\mathbf{X}\mathbf{\theta }-y\right)}^T\left(\mathbf{X}\mathbf{\theta }-y\right)\right)=\nabla \left(\frac{1}{2}\left({\mathbf{\theta }}^T{\mathbf{X}}^T-y^T\right)\left(\mathbf{X}\mathbf{\theta }-y\right)\right) \\ =\nabla \left(\frac{1}{2}\left({\mathbf{\theta }}^T{\mathbf{X}}^T\mathbf{X}\mathbf{\theta }-{\mathbf{\theta }}^T{\mathbf{X}}^{T}y-y^T\mathbf{X}\mathbf{\theta }+y^{T}y\right)\right) \\ =\frac{1}{2}\left(2{\mathbf{X}}^T\mathbf{X}\mathbf{\theta }-\mathbf{X}y-{\left(y^T\mathbf{X}\right)}^T\right)={\mathbf{X}}^T\mathbf{X}\mathbf{\theta }-{\mathbf{X}}^{T}y \end{gathered}$$
令函数偏导数为0，这样就能够得到 $\theta$ 的表达式：
$$\mathbf{\theta }={\left({\mathbf{X}}^T\mathbf{X}\right)}^{-1}{\mathbf{X}}^{T}y$$
如此我们就求解出 $\theta$ 了。
（机器学习中有一个退优化的概念，普遍情况下我们都认为得到的函数是一个凸函数，这样所求的极值点都是极小值点）

逻辑回归

所谓逻辑回归就是将线性回归的结果，通过sigmoid函数映射到 [0,1] 区间之间，这样就能够将数值结果转化为概率结果，通过概率能够进行分类。
sigmoid函数：
公式如下：
$$g\left(z\right)\frac{1}{1+e^{-z}}$$
图像如下：

线性回归$\to$逻辑回归：
$$h_{\theta }\left(x\right)=g\left({\mathbf{\theta }}^{T}x\right)=\frac{1}{1+e^{-{\mathbf{\theta }}^{T}x}}$$
其中 ${\theta }_0+{\theta }_1{x}_1+\cdots +{\theta }_i{x}_i={\sum }_{i=1}^m{\theta }_i{x}_i={\mathbf{\theta }}^T\mathbf{X}$
（预测函数）
$$\begin{gathered} P\left(y=1|x;\theta \right)=h_{\theta }\left(x\right) \\ P\left(y=0|x;\theta \right)=1-h_{\theta }\left(x\right) \\ \Rightarrow P\left(y|x;\theta \right)={\left(h_{\theta }\left(x\right)\right)}^y{\left(1-h_{\theta }\left(x\right)\right)}^{1-y} \end{gathered}$$（分类任务）
逻辑回归求解：
同样和线性回归一样，采用似然函数求解：
$$L\left(\theta \right)=\prod _{i=1}^{m}P\left(y_i|x;\theta \right)=\prod _{i=1}^m{\left(h_{\theta }\left(x_i\right)\right)}^{y_i}{\left(1-h_{\theta }\left(x_i\right)\right)}^{1-y_i}$$
$$\Rightarrow l\left(\theta \right)=\log L\left(\theta \right)=\prod _{i=1}^m\left(y_i\log h_{\theta }\left(x_i\right)+\left(1-y_i\right)\log \left(1-h_{\theta }\left(x_i\right)\right)\right)$$
这时求解问题变成了求函数的最大值，但是机器学习中常把梯度上升问题转化成梯度下降问题来求解。
$$J\left(\theta \right)=-\frac{1}{m}l\left(\theta \right)$$
这里说明一下梯度上升和梯度下降：
（所谓梯度下降是这样的：
如果实值函数 $F\left(x\right)$ 在点 $a$ 处可微且有定义，那么函数 $F\left(x\right)$ 在$a$ 点沿着梯度相反方向 $-\nabla F\left(x\right)$ 下降最快，如果有：
$$b=a-\gamma \nabla F\left(x\right)$$（对于 $\gamma >0$ 为一个足够小的数值时候成立，则有$F\left(a\right)\ge F\left(b\right)$)
这样如果我们从函数局部极小值出发，有序列$x_0,x_1,x_2,\cdots$ ,我们可以使得：
$$x_{n+1}=x_n-{\gamma }_n\nabla F\left(x_n\right)$$
则可以得到：
$$F\left(x_0\right)\ge F\left(x_1\right)\ge F\left(x_2\right)\ge \cdots$$
如此就能够期望收敛到函数极值，每次迭代的步长为 $\gamma$ )
之后我们需要化简和求导：
$$l\left(\theta \right)=\log \left(y_i\log h_{\theta }\left(x_i\right)+\left(1-y_i\right)\log \left(1-h_{\theta }\left(x_i\right)\right)\right)$$
$$\frac{\delta }{{\delta }_{{\theta }_j}}J\left(\theta \right)=-\frac{1}{m}\sum _{i=1}^m\left(y_i\frac{1}{h_{\theta }\left(x_i\right)}\frac{\delta }{{\delta }_{{\theta }_j}}{h}_{\theta }\left(x_i\right)-\left(1-y_i\right)\frac{1}{1-h_{\theta }\left(x_i\right)}\frac{\delta }{{\delta }_{{\theta }_j}}{h}_{\theta }\left(x_i\right)\right)$$
\\
$$=-\frac{1}{m}\sum _{i=1}^m\left(y_i\frac{1}{g\left({\mathbf{\theta }}^T{x}_i\right)}-\left(1-y_i\right)\frac{1}{1-g\left({\mathbf{\theta }}^T{x}_i\right)}\right)\frac{\delta }{{\delta }_{{\theta }_j}}g\left({\mathbf{\theta }}^T{x}_i\right)$$
\\
$$=-\frac{1}{m}\sum _{i=1}^m\left(y_i\frac{1}{g\left({\mathbf{\theta }}^T{x}_i\right)}-\left(1-y_i\right)\frac{1}{1-g\left({\mathbf{\theta }}^T{x}_i\right)}\right)g\left({\mathbf{\theta }}^T{x}_i\right)\left(1-g\left({\mathbf{\theta }}^T{x}_i\right)\right)\frac{\delta }{{\delta }_{{\theta }_j}}{\mathbf{\theta }}^T{x}_i$$
$$=-\frac{1}{m}\sum _{i=1}^m\left(y_i\left(1-g\left({\mathbf{\theta }}^T{x}_i\right)\right)-\left(1-y_i\right)g\left({\mathbf{\theta }}^T{x}_i\right)\right)x_i^j$$
\\
$$=-\frac{1}{m}\sum _{i=1}^m\left(y_i-g\left({\mathbf{\theta }}^T{x}_i\right)\right)x_i^j$$
$$=-\frac{1}{m}\sum _{i=1}^m\left(h_{\theta }\left(x_i\right)-y_i\right)x_i^j$$
得到了函数偏导数表达式（也就是下降的方向），我们就可以进行求解了：
$${\theta }_j:={\theta }_j-\alpha \frac{1}{m}\sum _{i=1}^m\left(h_{\theta }\left(x_i\right)-y_i\right)x_i^j$$（参数更新，其中 $\alpha$ 表示学习率）

回归算法的实现：

见附页

决策树

也就是从一个树的跟节点开始，每一个根节点都是一个判断条件，慢慢从根节点一步一步到叶子节点。
利用决策树进行测试的时候很简单，只需要将数据集从树模型从上到下走一遍就行了，决策树的难点在于如何构建。
如何切分特征，也就是如何选择特征和节点的对应关系，哪些在上面，哪些在下面。那么划分节点的衡量标准又是什么？
熵值
熵：表示随机变量的不确定性的度量（也就是物体内部的混乱程度）
我们来看一个例子：
A集合[1,1,1,1,1,1,1,2,2]
B集合[1,2,3,4,5,6,7,8,9]
明显A集合熵值要低，因为A中只有两类，相对稳定一点。而B中类别太多了，熵值就大得多。在分类任务中我们肯定希望分支后的数据类别的熵值小一些。
信息增益：表示特征使得类别的不确定性减少的程度。
我们在划分节点的时候，可以将数据都使用每一个特征遍历一次，看哪个特征的信息增益最大，最大的那个就是根节点，其他的依次往后排。
接下来我们通过一个实例来计算一次信息增益：

outlook	temperature	humidity	windy	play
sunny	hot	high	false	no
sunny	hot	high	true	no
overcast	hot	high	false	yes
rainy	mild	high	false	yes
rainy	cool	normal	false	yes
rainy	cool	normal	true	no
overcast	cool	normal	true	yes
sunny	mild	high	false	no
sunny	cool	normal	false	yes
rainy	mild	normal	false	yes
sunny	mild	normal	false	yes
overcast	mild	high	true	yes
overcast	hot	normal	false	yes
rainy	mild	high	true	no

以上是一个小数据集，通过这个数据集我们能看出，影响打不打球的因素有四个：天气、温度、湿度、有无风。我们需要根据各自的信息增益来判断谁是根结点。
信息增益计算：

• 历史数据中有9天打球，5天不打球，当前系统的熵值：
  $$-\frac{9}{14}\log \frac{9}{14}-\frac{5}{14}\log \frac{5}{14}=0.940$$

• 接下来我们需要逐一计算四个特征的熵值，（将特征中不同状态进行划分合并，相同状态归并在一起）以 outlook 为例，outlook=sunny时，有两天是yes，有三天是no，所以熵值为0.971（计算方式和上式相同，熵值计算公式为：$-a\log a$)；outlook=overcast时候，熵值为0，因为都是每一天都是yes；outlook=rainy时候，熵值为0.971。

• 计算出某一个特征不同状态的熵值之后，根据状态出现的概率来计算该特征的信息增益：
  sunny、overcast、rainy的概率分别是5/14、4/14、5/14，这样outlook下的熵值为：
  $$\frac{5}{14}\ast 0.971+\frac{4}{14}\ast 0+\frac{5}{14}\ast 0.971=0.693$$
  这样，该特征的信息增益就是：$0.940-0.693=0.247$

• 按照上面的方法，计算其他特征的信息增益，然后根据增益来判断，哪个特征是老大、哪个特征是老二。

信息增益率

上面使用信息增益的方法来划分特征是有问题的，比如，如果样本中多了一个特征——ID，这样，每个ID里面的值都不一样。根据上面的算法，将特征里面的不同状态进行划分的话，每一个类里面都只有一个，也就是每一类的熵值都是0，这样的话，最终这个特征的熵值就是为0

（这里就有一个问题：上面不是说样本越混乱，那么样本的熵值也就越高吗）
（上面说的熵值为0，表示的是某个特征中某个状态的熵值，也就是熵值都是通过样本的标签分布来计算，而不是通过特征中状态的分布来计算，特征的状态分布只是在最后计算总的熵值分配权值的时候需要用到。问题中说到的，样本越混乱，样本熵值越高，这里说的熵值是指样本自身的熵值。两者是不同的）

由于上面的问题，提出了信息增益率，在信息增益的基础上还考虑自身熵。 信息增益率就是信息增益比上自身的熵值，而像上面的样本来说，自身的熵值就很高。
还有一种利用GINI系数来作为衡量标准，这个和熵的衡量标准很像，公式如下：
$$Gini\left(p\right)=\sum _{k=1}^K{p}_k\left(1-p_k\right)=1-\sum _{k=1}^K{p}_k^2$$（其中p表示概率）
上面提到的都是离散的数据，对于连续的数据来说可以采用离散化的方式来转化成上面的形式（这里的连续数据教程里面没有说明白，碰到相应的问题再说吧）

决策树的剪枝策略

剪枝的原因：
决策树很容易出现过拟合的现象，因为如果决策树够大的话，能够将每一个样本都分到一个叶子结点当中，这样每个叶子结点中就是唯一类别的，这样必然导致过拟合现象
为了避免出现这种现象，决策树需要进行剪枝处理，一般来说有两种策略：一种是预剪枝，另一种是后剪枝。预剪枝就是说先限制树的深度，换句话来说就是不使用全部的特征来进行分类。也可以限制叶子结点的数量。后剪枝就是规定一个衡量标准，在每一个结点的地方使用衡量标准进行判断是否进行划分，如果划分之后反而不好，那就不进行划分。

决策树实战

首先这里是使用python下第三方库sklearn来实现各种算法，sklearn是机器学习中常用的Python的第三方模块，里面对常用的机器学习算法进行了封装，只需要简单调用里面的模块就能够实现大多数机器学习算法任务。
构建决策树的时候，首先实例化树模型，然后创建同时需要传入树模型的参数，有以下几种：criterion gini or entropy、splitter best(遍历所有特征） or random（遍历部分）、max_features None（所有）、max_depth（树的最大深度）、min_samples_split（限制叶子节点最少的样本数，也就是叶子节点划分之后样本数量小于这个数的话就不进行分支）、min_samples_leaf、min_weight_fraction_leaf、max_leaf_nodes（限制叶子节点最大数量）、class_weight、class_weight、min_impurity_split、n_estimators。其中很多参数都是进行决策树的剪枝的。

from sklearn import tree
dtr=tree.DecisionTreeRegressor(max_depth=2)//树模型的实例化
dtr.fit(housing.data[:,[6,7],housing.target)
//函数相当于构造一个树模型，第一个参数表示是数据集里面第六列和第七列，
//第二个参数是标签，也就是一个x，一个

#可视化显示，首先要安装 graphviz
dot_data=\
        tree.export_graphviz(
        dtr,
        out_file=None,
        feature_names=housing.feature_names[6:8],
        filled=True,
        impurity=False,
        rounded=True
        )
 #pip install pydotplus,将上面生成的文件变成图片显示出来
 import pydotplus
 graph=pydotplus.graph_from_dot_data(dot_data)
 graph.get_nodes()[7].set_fillcolor("#FFF2DD")
 from IPython.display import Image
 Image(graph.create_png())
 graph.write_png("dtr_write_background.png") //将图片保存下来

以上代码就完成了一个决策树的构建和可视化

//在构建模型之前，我们还需要对数据集进行切分，将一个数据集变成一个训练集
//和一个测试集
from sklearn.model_selection import train_test_split
data_train,data_test,target_train,target_test=\
     train_test_split(housing.data,housing.target,test_size=0.1,random_state=42)
dtr=tree.DecisionTreeRegressor(random_state=42)
dtr.fit(data_train,target_train)
dtr.score(data_test,target_test)

sklearn里面有一个非常有用的模块，在我们构建模型的时候，我们不知道选择什么样的参数合适，这时候GridSearchCV模块就非常有用了，它可以将不同参数的组合进行遍历，找到最好的。

from sklearn.grid_search import GridSearchCV
tree_param_grid={'min_samples_split':list((3,6,9)),'n_estimtors':list((10,50,100))}
grid=GridSearchCV(RandomForestRegressor(),param_grid=tree_param_grid,cv=5)
grid.fit(data_train,target_train)
grid.grid_scores_,grid.best_params_,grid.best_score_

集成算法-随机森林

上面讲过决策树是利用一棵树进行分类，那么多加几棵树行不行了，这里就引入了一个集成算法的概念。集成算法的目的就是让机器学习的效果更好，一种机器学习算法不行，那就融合多个。下面有几种典型的集成算法：
Bagging模型：
全称是：bootstrap aggregation。它是并行训练多个分类器，然后把结果进行加权合并，最典型的就是随机森林，也就是多个决策树放在一起。（随机森林中采样有放回随机，特征选择随机）
优点：
能够处理高维度的数据，不用做特征选择；
训练完之后能够给出哪些特征比较重要；
（方法：假设样本集的特征有三个，我利用这三个特征的数据构建了一个模型，然后计算错误率。之后我破坏掉其中一个特征的数据，也就是将数据用一些随机的数进行替换，总之就是把某一个特征的数据变成噪声数据，再用三个特征当前的数据构建模型，并计算错误率。比较两次错误率的大小，这样就能够比较出哪个特征比较重要）
容易做成并行化方法，速度比较快；
可以进行可视化展示，便于分析。
（相比于神经网络这种黑盒子的模型，神经网路当中很多参数）
也有其他的集成算法，例如KNN模型，但是这种模型的泛化能力不好，所以一般来说说到集成算法，我们就想到基础模型是树模型。随机森林中理论上树越多越好，但是实际上超过一定数量精度就上下浮动了。
Boosting模型
从弱学习器开始加强，通过加权来进行训练。这种集成算法和上面的不同，它是采用串行的方法来训练模型。也就是我们先构建出第一棵树，然后计算出残差；根据残差来构架第二棵树，使得残差变小 ；按照同样的方法构建第三棵树。最终将所有的树集成成森林。
Boosting中典型的模型有：AdaBoost、Xgboost
Adaboost：它会根据前一次的分类效果调整数据权值，也就是假设有5个数据，开始都是分配的0.2，然后分类结果中只有第三个数据分类错误，这样在下一次时候就增加第三个数据的权值。最终每个分类器根据自身的准确性来确定各自的权值来集成。
stacking模型
将各种分类器堆叠在一起。第一阶段，选择需要集成的分类器，并得到多次预测结果；第二阶段，将第一阶段的的预测结果和样本标签作为一个输入，再使用分类器进行训练，得到最终的结果。这种算法确定能够使得准确率提升，但是速度是一个很大的问题。

集成算法实战

略

贝叶斯算法

为了解决逆向概率的问题，所以诞生了贝叶斯方法。首先我们要了解正向概率和逆向概率。用例子来说，正向概率就是：假设袋子里面有N个白球，M个黑球，摸一个球出来，这时摸出黑球的概率；而逆向概率则是：事先不清楚袋子里面黑白球的比例，我们摸出一个或者几个球，要求我们求解出袋子里面黑白球的比例。
贝叶斯求解实例：
假设学校里面男生六成，剩下的是女生。并且我们还知道男生都穿长裤，女生一半穿长裤，一半穿裙子。现在迎面走来一个穿长裤的人，问这个人是女生的概率？
\\
\\
\\
\\
\\
\\
所以贝叶斯公式表示成如下格式，也就是我们将B的情况下A发生的概率问题，转化成A的情况下B发生的概率。
$$P\left(A|B\right)=\frac{P\left(B|A\right)P\left(A\right)}{P\left(B\right)}$$
模型比较理论：
最大似然估计：最符合观测数据 $P\left(D|h\right)$ 的最有优势，也就是 $P\left(D|h\right)$ 最大的。
（前面有说过极大似然估计，那是样本满足一个高斯分布，同时给每一个参数一个权值 $\theta$ ，构建一个极大似然函数，也就是n个样本的概率密度函数乘积形式，通过对极大似然函数求偏导，得到函数的极大值确定这个权值）
奥卡姆剃刀：对于N个点，我们能够利用二阶线性拟合用直线来拟合数据点，同样我们也能够利用多阶多项式来拟合，n-1阶能够完美拟合n个数据点。但是高阶上会出现过拟合现象。
奥卡姆剃刀就说明了为什么我们使用低阶多项式来拟合，奥卡姆剃刀就是越高阶越不常见，也就是 ：$P\left(N-1\right)<P\left(N-1\right)\cdots <P\left(2\right)$。
垃圾邮件过滤实例：
给定一封邮件，用 D 来表示这个邮件，同时这个邮件由 N 个单词组成，我们用 h+ 来表示垃圾邮件，h- 表示正常邮件。
\\
\\
\\
\\
\\
\\
\\
这里涉及到将贝叶斯问题变成朴素贝叶斯。

文本分析：通常来说，我们进行文本分析时候，是根据TF-IDF来判断文章的特征和关键字。所谓TF（词频）也就是某个词在文章中出现的次数/文章中总的词的个数；而IDF（逆文档频率）表示语料库的文档总数/（包含该词的文档数+1）的对数，这是值越大表示该词在文章中越重要。而TF-IDF=TF x IDF，也就是表示关键词的重要程度。

聚类算法

K-MEANS算法

上面说到的算法的数据集都是有标签的，现在变了，现在数据里面没有标签了，也就是算法变成了无监督学习。聚类算法也就是将相似的东西分到一类中，这种算法的难点在于：评估和调参。
K-MEANS算法算法聚类算法中最简单的，下面有几个概念需要理解一下：
K值：这个算法需要给定一个K值，这个值表示数据最后将分成K类。
质心：也就是一个数据的均值，也就是数据在各个维度上取得均值，最后这个位置也就是质心。
距离的度量：常用的是欧几里得距离和余弦相似度（都需要先标准化，指的是数据的不同维度的标准化）
优化目标：每一个类都需要优化，每个类中要求所有数据到质心的距离和是最小的，用公式表示如下：
$$\min \sum _{k=1}^K\sum _{x\in C_i}dist{\left(c_i,x\right)}^2$$
K-MEANS算法流程：

1. 首先设定 K 的数值，现在假定 K 的值为2.
2. 然后初始化两个质心，表示不同类的质心；
3. 比较数据集中样本点与两个质心的距离，从而划分不同类别。划分之后我们会发现，相同簇里面会有两种数据样本。
4. 因为开始的质心是随机选择的，所以会出现上述情况，这时候更新质心，然后再次聚类就行了
5. 重新比较样本数据点同质心的距离，划分出两类数据点。

可视化操作：
https://www.naftaliharris.com/blog/visualizing-k-means-clustering/
这个网址可以进行K-MEANS的可视化演示，通过里面的演示能够更好理解K-MEANS算法，同时我们会发现，初始化的质心对于最后的结果会有很大的影响，所以一般来说，我们会进行多次然后取平均值的方法。并且对于数据集类别不清楚的情况下，算法很难对数据进行分类。

DBSCAN算法

这个算法是一个很厉害的聚类算法，效果大部分情况比K-MEANS要好。相关概念：
核心对象：以某个点为中心，如果一定半径内的点的个数达到设定的阈值，就认为这个点是核心对象；
邻域的距离阈值：设定的半径；
直接密度可达：假如某点p在q的邻域内，并且q是核心点，则说p和q是直接密度可达的；
密度可达：现在有一个点q0、q1、…qk，对于任意的qi~qi-1都是直接密度可达的，那么称q0到qk是密度可达的；
密度相连：从某个核心点p出发，点q和点k都是密度可达的，称点q和点k是密度相连的；
边界点：核心点边界上的点；
噪声点：不属于任何族的点。
算法流程：

1. 首先设定参数：指定半径、密度阈值
2. 将所有的对象定位unvisited，然后随机选择一个对象p标记为visited，如果这个点半径内的对象数量达到了密度阈值，我们就创建一个族，并将p添加到里面。
3. 然后将2中邻域内的点标记为visited，同时对这些点进行2中的操作，也就是不断扩大这个族，直到所有的新增点都不是核心对象了。
4. 构建好一个族时候，重头开始，再选择一个unvisited对象。

优势：
不需要指定族的个数；可以发现任意形状的族；擅长找离群点；只需要设定两个参数。
劣势：
高维数据有些困难（可以做降维）；参数难以选择；sklearn中效率很慢（数据削减策略）
（可视化操作可以看这个网站里面的演示：
https://www.naftaliharris.com/blog/visualizing-dbscan-clustering/ ）
此外还有BIRCH（速度很快，相比于DBSCAN）、MEAN-SHIFT.

主成分分析

这是降维中最常用的手段，目的是为了提取最有用的信息，在低维度中更好概括数据，但是降维之后数据的意义将无从得知，简称PCA。
数学回顾：
向量内积、内积解释（如果向量B的模为1，那么A与B 的内积表示B向A所在直线投影的矢量长度）、基变换（线性无关、相互垂直）
PCA其实就是做内积运算，两矩阵相乘的意义在这里表示将右边矩阵中的每一列列向量变换到左边矩阵中每一行行向量为基所表示的空间中。
变换规律清除之后，我们需要知道如何确定这个基。我们需要选择能够尽量多的保留原始信息的基，寻找一个基，使得所有数据变换到这个基上的坐标表示之后，方差值最大。 方差表示一个数据的离散程度，而协方差表示两个数据之间的相关程度。在PCA中加入协方差的概念是因为，如果我们要将一个6维的数据降到2维，那么我们选择的第一个轴一定是方差最大的那个，之后我们选择的第二个轴肯定是一个和第一个轴非常接近的。因此，为了让两个字段尽可能表示更多的原始信息，我们不希望他们之间存在线性相关性，所以引入协方差。
PCA求解：
目标：将一组N维向量降到K维，目标是选择K个单位正交基，使原始数据变换到这组基上后，各字段两两协方差为0，并且字段的方差尽可能大。协方差矩阵如下：
$$\mathbf{X}=\left[\begin{array}{cccc}{a}_1& a_2& \cdots & a_m\\ b_1& b_2& \cdots & b_m\end{array}\right]$$
$$\mathbf{C}=\frac{1}{m}\mathbf{X}{\mathbf{X}}^T=\left[\begin{array}{cc}\frac{1}{m}{\sum }_{i=1}^m{a}_i^2& \frac{1}{m}{\sum }_{i=1}^m{a}_i{b}_i\\ & \\ \frac{1}{m}{\sum }_{i=1}^m{a}_i{b}_i& \frac{1}{m}{\sum }_{i=1}^m{b}_i^2\end{array}\right]$$
其中矩阵对角线上的两个元素分别是两个字段的方差，而其他元素是两个字段的协方差。要满足要求，也就是要将协方差矩阵进行对角化，这样就能够使得协方差为0，并且能够直观比较方差的大小。
实对称矩阵：一个n行n列的实对称矩阵一定可以找到n个单位正交特征向量
$$\mathbf{E}=\left(e_1{e}_2\cdots e_n\right)$$
实对称矩阵对角化：
$${\mathbf{E}}^T\mathbf{C}\mathbf{E}=\Lambda =\left[\begin{array}{cccc}{\lambda }_1& & & \\ & {\lambda }_2& & \\ & & \ddots & \\ & & & {\lambda }_n\end{array}\right]$$
根据特征值的大小，将特征向量从上到下排列，用前K行组成的矩阵乘以原始数据矩阵X，就得到了我们需要的降维后的数据矩阵Y。下面有个简单的示例：

PCA实例：
求解两个特征之间的协方差
$${\sigma }_{jk}=\frac{1}{n-1}\sum _{i=1}^n\left(x_{ij}-{\bar{x}}_j\right)\left(x_{ik}-{\bar{x}}_k\right)$$
求解协方差矩阵
$$\sum =\frac{1}{n-1}\left({\left(\mathbf{X}-\bar{\mathbf{X}}\right)}^T\left(\mathbf{X}-\bar{\mathbf{X}}\right)\right)$$其中：$\bar{\mathbf{X}}=\frac{1}{n}{\sum }_{k=1}^n{x}_i$
下面是利用程序实现以上的矩阵计算：

mean_vec=np.mean(X_std,axis=0)
cov_mat=(X_std-mean_vec).T.dot((X_std-mean_vec))/(X_std.shape[0]-1)
print('Covariance matrix \n%s'  %cov_mat)
print('Numpy covariance matrix：\n%s'  %np.cov(X_std.T)
//如果不想用上面的方法，用这个也行