【03】机器学习算法——分类算法总结

分类算法

0.对比

（1）逻辑回归LR与SVM

①相同点

• LR和SVM都是分类算法。
• LR和SVM都是监督学习算法。
• LR和SVM都是判别模型。
• 如果不考虑核函数，LR和SVM都是线性分类算法，也就是说他们的分类决策面都是线性的。
• 说明：LR也是可以用核函数的.但LR通常不采用核函数的方法。（计算量太大）

②不同点

• LR采用log损失，SVM采用合页(hinge)损失。

  • 逻辑回归的损失函数：
    $$J(\theta )=-\frac{1}{m}\sum _{i=1}^m\left[y^{i}log{h}_{\theta }(x^i)+(1-y^i)log(1-h_{\theta }(x^i))\right]$$

  • 支持向量机的目标函数:
    $$L(w,n,a)=\frac{1}{2}||w|{|}^2-\sum _{i=1}^n{\alpha }_i\left(y_i(w^T{x}_i+b)-1\right)$$
    逻辑回归方法基于概率理论，假设样本为1的概率可以用sigmoid函数来表示，然后通过极大似然估计的方法估计出参数的值。

    支持向量机基于几何边界最大化原理，认为存在最大几何边界的分类面为最优分类面。

• LR对异常值敏感，SVM对异常值不敏感。

  • 支持向量机只考虑局部的边界线附近的点，而逻辑回归考虑全局。
    • LR模型找到的那个超平面，是尽量让所有点都远离他
    • 而SVM寻找的那个超平面，是只让最靠近中间分割线的那些点尽量远离，即只用到那些支持向量的样本。
  • 支持向量机改变非支持向量样本并不会引起决策面的变化。
  • 逻辑回归中改变任何样本都会引起决策面的变化。

• 计算复杂度不同。对于海量数据，SVM的效率较低，LR效率比较高

  • 当样本较少，特征维数较低时，SVM和LR的运行时间均比较短，SVM较短一些。准确率的话，LR明显比SVM要高。当样本稍微增加些时，SVM运行时间开始增长，但是准确率赶超了LR。SVM时间虽长，但在可接受范围内。当数据量增长到20000时，特征维数增长到200时，SVM的运行时间剧烈增加，远远超过了LR的运行时间。但是准确率却和LR相差无几。(这其中主要原因是大量非支持向量参与计算，造成SVM的二次规划问题)

• 对非线性问题的处理方式不同

  • LR主要靠特征构造，必须组合交叉特征，特征离散化。SVM也可以这样，还可以通过核函数kernel（因为只有支持向量参与核计算，计算复杂度不高）。由于可以利用核函数，SVM则可以通过对偶求解高效处理。LR则在特征空间维度很高时，表现较差。

• SVM的损失函数就自带正则。

  • 损失函数中的1/2||w||^2项，这就是为什么SVM是结构风险最小化算法的原因！！！而LR必须另外在损失函数上添加正则项！！！

• SVM自带结构风险最小化，LR则是经验风险最小化。

• SVM会用核函数而LR一般不用核函数。

（2）逻辑回归与朴素贝叶斯区别

• 逻辑回归是判别模型， 朴素贝叶斯是生成模型，所以生成和判别的所有区别它们都有。

• 朴素贝叶斯属于贝叶斯，逻辑回归是最大似然，两种概率哲学间的区别。

• 朴素贝叶斯需要条件独立假设。

• 逻辑回归需要求特征参数间是线性的。

1.Sklearn转换器与估计器

（1）转换器

• 特征工程的步骤

  • 实例化 (实例化的是一个转换器类(Transformer))

  • 调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

• 特征工程的接口称之为转换器，其中转换器调用有这么几种形式

  • fit_transform

  • fit

  • transform

• fit_transform的作用相当于transform加上fit。

• 举例使用原来的std2来进行标准化看看

from sklearn.preprocessing import StandardScaler
std1 = StandardScaler()
a = [[1,2,3], [4,5,6]]
std1.fit_transform(a)
"""
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])
"""
std2 = StandardScaler()
std2.fit(a)
StandardScaler(copy=True, with_mean=True, with_std=True)
std2.transform(a)
"""
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])
"""

（2）估计器(sklearn机器学习算法的实现)

在sklearn中，估计器(estimator)是一个重要的角色，是一类实现了算法的API

• 1、用于分类的估计器：
  • sklearn.neighbors k-近邻算法
  • sklearn.naive_bayes 贝叶斯
  • sklearn.linear_model.LogisticRegression 逻辑回归
  • sklearn.tree 决策树与随机森林
• 2、用于回归的估计器：
  • sklearn.linear_model.LinearRegression 线性回归
  • sklearn.linear_model.Ridge 岭回归
• 3、用于无监督学习的估计器
  • sklearn.cluster.KMeans 聚类

（3）模型加载和保存

• 应用joblib实现模型的保存与加载

①sklearn模型的保存和加载API

• from sklearn.externals import joblib
  • 保存：joblib.dump(rf, ‘test.pkl’)
  • 加载：estimator = joblib.load(‘test.pkl’)

②线性回归的模型保存加载案例

• 保存

# 使用线性模型进行预测
# 使用正规方程求解
lr = LinearRegression()
# 此时在干什么？
lr.fit(x_train, y_train)
# 保存训练完结束的模型
joblib.dump(lr, "test.pkl")

• 加载

# 通过已有的模型去预测房价
model = joblib.load("test.pkl")
print("从文件加载进来的模型预测房价的结果：", std_y.inverse_transform(model.predict(x_test)))

2.K-近邻算法

• 目标
  • 说明K-近邻算法的距离公式
  • 说明K-近邻算法的超参数K值以及取值问题
  • 说明K-近邻算法的优缺点
  • 应用KNeighborsClassifier实现分类
  • 了解分类算法的评估标准准确率
• 应用
  • Facebook签到位置预测

（1）定义

如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

（2）距离公式

两个样本的距离可以通过如下公式计算，又叫欧式距离

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OYvK9UmC-1668859849021)(/Users/duanyuqing/Library/Application Support/typora-user-images/image-20221112161441095.png)]

（3）API

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')

• n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数

• algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

（4）分析

• 对于数据做一些基本处理（这里所做的一些处理不一定达到很好的效果，我们只是简单尝试，有些特征我们可以根据一些特征选择的方式去做处理）

  • 缩小数据集范围 DataFrame.query()

  • 删除没用的日期数据 DataFrame.drop（可以选择保留）

  • 将签到位置少于n个用户的删除

  • place_count = data.groupby(‘place_id’).count()

    • tf = place_count[place_count.row_id > 3].reset_index()

  • data = data[data[‘place_id’].isin(tf.place_id)]

• 分割数据集

• 标准化处理

• k-近邻预测

def knncls():
    """
    K近邻算法预测入住位置类别
    :return:
    """
    # 一、处理数据以及特征工程
    # 1、读取收，缩小数据的范围
    data = pd.read_csv("./data/FBlocation/train.csv")
    # 数据逻辑筛选操作 df.query()
    data = data.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")
    # 删除time这一列特征
    data = data.drop(['time'], axis=1)
    print(data)
    # 删除入住次数少于三次位置
    place_count = data.groupby('place_id').count()
    tf = place_count[place_count.row_id > 3].reset_index()
    data = data[data['place_id'].isin(tf.place_id)]
    
    # 3、取出特征值和目标值
    y = data['place_id']
    # y = data[['place_id']]
    x = data.drop(['place_id', 'row_id'], axis=1)

    # 4、数据分割与特征工程?
    # （1）、数据分割
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
    # (2)、标准化
    std = StandardScaler()
    # 队训练集进行标准化操作
    x_train = std.fit_transform(x_train)
    print(x_train)
    # 进行测试集的标准化操作
    x_test = std.fit_transform(x_test)

    # 二、算法的输入训练预测
    # K值：算法传入参数不定的值    理论上：k = 根号(样本数)
    # K值：后面会使用参数调优方法，去轮流试出最好的参数[1,3,5,10,20,100,200]
    knn = KNeighborsClassifier(n_neighbors=1)
    # 调用fit()
    knn.fit(x_train, y_train)
    # 预测测试数据集，得出准确率
    y_predict = knn.predict(x_test)
    print("预测测试集类别：", y_predict)
    print("准确率为：", knn.score(x_test, y_test))
    return None

（5）优缺点

• 优点：
  • 简单，易于理解，易于实现，无需训练

• 缺点：
  • 懒惰算法，对测试样本分类时的计算量大，内存开销大
  • 必须指定K值，K值选择不当则分类精度不能保证
• 使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试

3.逻辑回归

（1）逻辑回归的应用场景

• 用于概率预测。用于可能性预测时，得到的结果有可比性。

  • 比如根据模型进而预测在不同的自变量情况下，发生某病或某种情况的概率有多大。

• 用于分类。实际上跟预测有些类似，也是根据模型，判断某人属于某病或属于某种情况的概率有多大，也就是看一下这个人有多大的可能性是属于某病。进行分类时，仅需要设定一个阈值即可，可能性高于阈值是一类，低于阈值是另一类。

• 寻找危险因素。寻找某一疾病的危险因素等。

• 仅能用于线性问题。只有当目标和特征是线性关系时，才能用逻辑回归。在应用逻辑回归时注意两点：

  • 当知道模型是非线性时，不适用逻辑回归；
  • 当使用逻辑回归时，应注意选择和目标为线性关系的特征。

• 各特征之间不需要满足条件独立假设，但各个特征的贡献独立计算。

看到上面的例子，我们可以发现其中的特点，那就是都属于两个类别之间的判断。逻辑回归就是解决二分类问题的利器

（2）逻辑回归的原理

① 输入

• 逻辑回归的输入就是一个线性回归的结果

假设逻辑回归模型：
$$P(y=1|x;\theta )=\frac{1}{1+e^{-{\theta }^{T}x}}$$
假设逻辑回归模型的概率分布是伯努利分布，其概率质量函数为：
$$P(X=n)=\{\begin{array}{l}1-p,n=0\\ p,n=1\end{array}$$

②激活函数sigmoid

• 分析
  • 回归的结果输入到sigmoid函数当中
  • 输出结果：[0, 1]区间中的一个概率值，默认为0.5为阈值

逻辑回归最终的分类是通过属于某个类别的概率值来判断是否属于某个类别，并且这个类别默认标记为1(正例),另外的一个类别会标记为0(反例)。（方便损失计算）

• 输出结果解释(重要)：假设有两个类别A，B，并且假设我们的概率值为属于A(1)这个类别的概率值。现在有一个样本的输入到逻辑回归输出结果0.6，那么这个概率值超过0.5，意味着我们训练或者预测的结果就是A(1)类别。那么反之，如果得出结果为0.3那么，训练或者预测结果就为B(0)类别

③损失

• 其似然函数为：
  $$L(\theta )=\prod _{i=1}^{m}P(y=1|x_i{)}^{y_i}P(y=0|x_i{)}^{1-y_i}$$

• 对数似然函数为：
  $$\begin{gathered} \ln L(\theta )=\sum _{i=1}^m[y_i\ln P(y=1|x_i)+(1-y_i)\ln P(y=0|x_i)] \\ =\sum _{i=1}^m[y_i\ln P(y=1|x_i)+(1-y_i)\ln (1-P(y=1|x_i))] \end{gathered}$$

• 对数函数在单个数据点上的定义为：
  $$cost(y,p(y|x))=-y\ln p(y|x)-(1-y)\ln (1-p(y|x))$$

• 则全局样本损失函数为：
  $$cost(y,p(y|x))=-\sum _{i=1}^m[y_i\ln p(y_i|x_i)+(1-y_i)\ln (1-p(y_i|x_i))]$$

• 由此可看出，对数损失函数与极大似然估计的对数似然函数本质上是相同的。所以逻辑回归直接采用对数损失函数。

④优化

同样使用梯度下降优化算法，去减少损失函数的值。

这样去更新逻辑回归前面对应算法的权重参数，提升原本属于1类别的概率，降低原本是0类别的概率。

（3）逻辑回归API

• sklearn.linear_model.LogisticRegression(solver=‘liblinear’, penalty=‘l2’, C = 1.0)
  • solver:优化求解方式（默认开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数）
    • sag：根据数据集自动选择，随机平均梯度下降
  • penalty：正则化的种类
  • C：正则化力度

默认将类别数量少的当做正例

• LogisticRegression方法相当于 SGDClassifier(loss=“log”, penalty=" "),SGDClassifier实现了一个普通的随机梯度下降学习，也支持平均随机梯度下降法（ASGD），可以通过设置average=True。而使用LogisticRegression(实现了SAG)

4.朴素贝叶斯

（1）概率(Probability)定义

• 概率定义为一件事情发生的可能性
  • 扔出一个硬币，结果头像朝上
  • 某天是晴天
• P(X) : 取值在[0, 1]

（2） 条件概率与联合概率

• 联合概率：包含多个条件，且所有条件同时成立的概率
  • 记作：P(A,B)
  • 特性：P(A, B) = P(A)P(B)
• 条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
  • 记作：P(A|B)
  • 特性：P(A1,A2|B) = P(A1|B)P(A2|B)

注意：此条件概率的成立，是由于A1,A2相互独立的结果(记忆)

（3）极大似然估计原理

• 最大似然估计的目的就是：利用已知的样本结果，反推最有可能（最大概率）导致这样结果的参数值。
• 极大似然估计是建立在极大似然原理的基础上的一个统计方法。
  • 极大似然估计提供了一种给定观察数据来评估模型参数的方法，即：“模型已定，参数未知”。
  • 通过若干次试验，观察其结果，利用试验结果得到某个参数值能够使样本出现的概率为最大，则称为极大似然估计。
• 由于样本集中的样本都是独立同分布，可以只考虑一类样本集$D$，来估计参数向量$\vec{\theta }$。记已知的样本集为：

$$D={\vec{x}}_1,{\vec{x}}_2,...,{\vec{x}}_n$$

• 似然函数（likelihood function）：联合概率密度函数$p(D|\vec{\theta })$称为相对于${\vec{x}}_1,{\vec{x}}_2,...,{\vec{x}}_n$的$\vec{\theta }$的似然函数。

$$l(\vec{\theta })=p(D|\vec{\theta })=p({\vec{x}}_1,{\vec{x}}_2,...,{\vec{x}}_n|\vec{\theta })=\prod _{i=1}^{n}p({\vec{x}}_i|\vec{\theta })$$

• 如果$\hat{\vec{\theta }}$是参数空间中能使似然函数$l(\vec{\theta })$最大的$\vec{\theta }$值，则$\hat{\vec{\theta }}$应该是“最可能”的参数值，那么$\hat{\vec{\theta }}$就是$\theta$的极大似然估计量。它是样本集的函数，记作：

$$\hat{\vec{\theta }}=d(D)={\mathrm{argmax}}_{\vec{\theta }}l(\vec{\theta })$$

$\hat{\vec{\theta }}({\vec{x}}_1,{\vec{x}}_2,...,{\vec{x}}_n)$称为极大似然函数估计值。

（4）贝叶斯分类器基本原理

• 贝叶斯决策论通过相关概率已知的情况下利用误判损失来选择最优的类别分类。

• 假设有$N$种可能的分类标记，记为 Y = { c 1 , c 2 , . . . , c N } Y=\{c_1,c_2,...,c_N\} Y={c1​,c2​,...,cN​}，那对于样本$\mathbf{x}$，它属于哪一类呢？

• 计算步骤如下：

  • step 1. 算出样本$\mathbf{x}$属于第i个类的概率，即$P(c_i|x)$；
  • step 2. 通过比较所有的$P(c_i|\mathbf{x})$，得到样本$\mathbf{x}$所属的最佳类别。
  • step 3. 将类别$c_i$和样本$\mathbf{x}$代入到贝叶斯公式中，得到：

$$P(c_i|\mathbf{x})=\frac{P(\mathbf{x}|c_i)P(c_i)}{P(\mathbf{x})}.$$

一般来说，$P(c_i)$为先验概率，$P(\mathbf{x}|c_i)$为条件概率，$P(\mathbf{x})$是用于归一化的证据因子。

对于$P(c_i)$可以通过训练样本中类别为$c_i$的样本所占的比例进行估计；

此外，由于只需要找出最大的$P(\mathbf{x}|c_i)$，因此我们并不需要计算$P(\mathbf{x})$。

为了求解条件概率，基于不同假设提出了不同的方法，以下将介绍朴素贝叶斯分类器和半朴素贝叶斯分类器。

①朴素贝叶斯分类器

• 假设样本$\mathbf{x}$包含$d$个属性，即 x = { x 1 , x 2 , . . . , x d } \boldsymbol{x}=\{ x_1,x_2,...,x_d\} x={x1​,x2​,...,xd​}。于是有：

$$P(\mathbf{x}|c_i)=P(x_1,x_2,\cdots ,x_d|c_i)$$

• 这个联合概率难以从有限的训练样本中直接估计得到。
  • 于是，朴素贝叶斯（Naive Bayesian，简称NB）采用了**“属性条件独立性假设”**：对已知类别，假设所有属性相互独立。于是有：

$$P(x_1,x_2,\cdots ,x_d|c_i)=\prod _{j=1}^{d}P(x_j|c_i)$$

• 这样的话，我们就可以很容易地推出相应的判定准则了：

$$h_{nb}(\mathbf{x})={\mathrm{argmax}}_{c_i\in Y}P(c_i)\prod _{j=1}^{d}P(x_j|c_i)$$

条件概率$P(x_j|c_i)$的求解

如果$x_j$是标签属性，那么我们可以通过计数的方法估计$P(x_j|c_i)$
$$P(x_j|c_i)=\frac{P(x_j,c_i)}{P(c_i)}\approx \frac{\#(x_j,c_i)}{\#(c_i)}$$
其中，$\#(x_j,c_i)$表示在训练样本中$x_j$与$c_i$共同出现的次数。

如果$x_j$是数值属性，通常我们假设类别中$c_i$的所有样本第$j$个属性的值服从正态分布。我们首先估计这个分布的均值$\mu$和方差$\sigma$，然后计算$x_j$在这个分布中的概率密度$P(x_j|c_i)$。

②半朴素贝叶斯分类器

朴素贝叶斯采用了“属性条件独立性假设”，半朴素贝叶斯分类器的基本想法是适当考虑一部分属性间的相互依赖信息。独依赖估计（One-Dependence Estimator，简称ODE）是半朴素贝叶斯分类器最常用的一种策略。顾名思义，独依赖是假设每个属性在类别之外最多依赖一个其他属性，即：
$$P(\mathbf{x}|c_i)=\prod _{j=1}^{d}P(x_j|c_i,{\mathrm{p}\mathrm{a}}_j)$$
其中$p{a}_j$为属性$x_i$所依赖的属性，成为$x_i$的父属性。假设父属性$p{a}_j$已知，那么可以使用下面的公式估计$P(x_j|c_i,{\mathrm{p}\mathrm{a}}_j)$
$$P(x_j|c_i,{\mathrm{p}\mathrm{a}}_j)=\frac{P(x_j,c_i,{\mathrm{p}\mathrm{a}}_j)}{P(c_i,{\mathrm{p}\mathrm{a}}_j)}$$

###（5）拉普拉斯平滑系数

目的：防止计算出的分类概率为0
$$\begin{gathered} P(F1|C)=\frac{Ni+\alpha }{N+\alpha m} \\ \alpha 为指定的系数，一半为1，m为特征词个数 \end{gathered}$$

P(娱乐|影院,支付宝,云计算) =P(影院,支付宝,云计算|娱乐)P(娱乐) =P(影院|娱乐)*P(支付宝|娱乐)*P(云计算|娱乐)P(娱乐)=(56+1/121+4)(15+1/121+4)(0+1/121+1*4)(60/90) = 0.00002

• API

  sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
  

  • 朴素贝叶斯分类
  • alpha：拉普拉斯平滑系数

（6）案例

• 分割数据集
• tfidf进行的特征抽取
• 朴素贝叶斯预测

def nbcls():
    """
    朴素贝叶斯对新闻数据集进行预测
    :return:
    """
    # 获取新闻的数据，20个类别
    news = fetch_20newsgroups(subset='all')
    # 进行数据集分割
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.3)
    # 对于文本数据，进行特征抽取
    tf = TfidfVectorizer()
    x_train = tf.fit_transform(x_train)
    # 这里打印出来的列表是：训练集当中的所有不同词的组成的一个列表
    print(tf.get_feature_names())
    # print(x_train.toarray())
    # 不能调用fit_transform
    x_test = tf.transform(x_test)
    # estimator估计器流程
    mlb = MultinomialNB(alpha=1.0)
    mlb.fit(x_train, y_train)
    # 进行预测
    y_predict = mlb.predict(x_test)
    print("预测每篇文章的类别：", y_predict[:100])
    print("真实类别为：", y_test[:100])
    print("预测准确率为：", mlb.score(x_test, y_test))
    return None

（7）优缺点

优点：

• 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
• 对缺失数据不太敏感，算法也比较简单，常用于文本分类。
• 分类准确度高，速度快

缺点：

• 由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

5.决策树（Decision Tree）

决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-then结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

（1）决策树三要素

一棵决策树的生成过程主要分为下3个部分：

• 特征选择：从训练数据中众多的特征中选择一个特征作为当前节点的分裂标准，如何选择特征有着很多不同量化评估标准，从而衍生出不同的决策树算法。

• 决策树生成：根据选择的特征评估标准，从上至下递归地生成子节点，直到数据集不可分则决策树停止生长。树结构来说，递归结构是最容易理解的方式。

• 剪枝：决策树容易过拟合，一般来需要剪枝，缩小树结构规模、缓解过拟合。剪枝技术有预剪枝和后剪枝两种。

（2）原理

• 决策树（Decision Tree）是一种分而治之的决策过程。
  • 一个困难的预测问题，通过树的分支节点，被划分成两个或多个较为简单的子集，从结构上划分为不同的子问题。
  • 将依规则分割数据集的过程不断递归下去（Recursive Partitioning）。
  • 随着树的深度不断增加，分支节点的子集越来越小，所需要提的问题数也逐渐简化。
  • 当分支节点的深度或者问题的简单程度满足一定的停止规则（Stopping Rule）时, 该分支节点会停止分裂，此为自上而下的停止阈值（Cutoff Threshold）法；有些决策树也使用自下而上的剪枝（Pruning）法。

（3）信息熵

• H的专业术语称之为信息熵，单位为比特。

• 熵：度量随机变量的不确定性。

• 定义：

  • 假设随机变量X的可能取值有$x_1,x_2,...,x_n$，
  • 对于每一个可能的取值$x_i$，其概率为$P(X=x_i)=p_i,i=1,2...,n$。随机变量的熵为：

  $$H(X)=-\sum _{i=1}^n{p}_{i}lo{g}_2{p}_i$$

  • 对于样本集合，假设样本有k个类别，每个类别的概率为$\frac{|C_k|}{|D|}$，其中 $|C_k|$为类别为k的样本个数，$|D|$为样本总数。
  • 样本集合D的熵为：

  $$H(D)=-\sum _{k=1}^k\frac{|C_k|}{|D|}lo{g}_2\frac{|C_k|}{|D|}$$

（4）决策树的划分依据之一------信息增益

①定义与公式

• 定义：以某特征划分数据集前后的熵的差值。
• 熵可以表示样本集合的不确定性，熵越大，样本的不确定性就越大。
  • 因此可以使用划分前后集合熵的差值来衡量使用当前特征对于样本集合D划分效果的好坏。 ​
• 假设划分前样本集合D的熵为H(D)。使用某个特征A划分数据集D，计算划分后的数据子集的熵为H(D|A)。
  • 则信息增益为：

$$g(D,A)=H(D)-H(D|A)$$

• *注：*在决策树构建的过程中我们总是希望集合往最快到达纯度更高的子集合方向发展，因此我们总是选择使得信息增益最大的特征来划分当前数据集D。

②思想

• 计算所有特征划分数据集D，得到多个特征划分数据集D的信息增益，从这些信息增益中选择最大的，因而当前结点的划分特征便是使信息增益最大的划分所使用的特征。

• 另外这里提一下信息增益比相关知识：
  $$信息增益比=惩罚参数\times 信息增益$$

  • 信息增益比本质：信息增益乘上一个惩罚参数。特征个数较多时, 惩罚参数较小;特征个数比较small时,惩罚参数较大。
  • 惩罚参数：数据集D以特征A作为随机变量的熵的倒数。
  • 注：信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度

（5）决策树的三种算法实现

当然决策树的原理不止信息增益这一种，还有其他方法。但是原理都类似，我们就不去举例计算。

• ID3
  • 信息增益 最大的准则
• C4.5
  • 信息增益比 最大的准则
• CART
  • 分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
  • 优势：划分更加细致

（6）决策树API

class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)

• 决策树分类器

• criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’

• max_depth:树的深度大小

• random_state:随机数种子

• 其中会有些超参数：max_depth:树的深度大小

  • 其它超参数我们会结合随机森林讲解

（7）案例

• 选择我们认为重要的几个特征 [‘pclass’, ‘age’, ‘sex’]
• 填充缺失值
• 特征中出现类别符号，需要进行one-hot编码处理(DictVectorizer)
  • x.to_dict(orient=“records”) 需要将数组特征转换成字典数据
• 数据集划分
• 决策树分类预测

def decisioncls():
    """决策树进行乘客生存预测 """
    # 1、获取数据
    titan = pd.read_csv("http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")
    # 2、数据的处理
    x = titan[['pclass', 'age', 'sex']]
    y = titan['survived']
    # print(x , y)
    # 缺失值需要处理，将特征当中有类别的这些特征进行字典特征抽取
    x['age'].fillna(x['age'].mean(), inplace=True)
    # 对于x转换成字典数据x.to_dict(orient="records")
    # [{"pclass": "1st", "age": 29.00, "sex": "female"}, {}]
    dict = DictVectorizer(sparse=False)
    x = dict.fit_transform(x.to_dict(orient="records"))
    print(dict.get_feature_names())
    print(x)

    # 分割训练集合测试集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
    # 进行决策树的建立和预测
    dc = DecisionTreeClassifier(max_depth=5)
    dc.fit(x_train, y_train)
    print("预测的准确率为：", dc.score(x_test, y_test))
    return None

由于决策树类似一个树的结构，我们可以保存到本地显示

（8） 保存树的结构到dot文件

sklearn.tree.export_graphviz() # 该函数能够导出DOT格式
tree.export_graphviz(estimator,out_file='tree.dot’,feature_names=[‘’,’’])

• 工具:(能够将dot文件转换为pdf、png)
  • 安装graphviz
  • ubuntu:sudo apt-get install graphviz Mac:brew install graphviz
• 运行命令
  • 然后我们运行这个命令
  • dot -Tpng tree.dot -o tree.png

export_graphviz(dc, out_file="./tree.dot", feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', '女性', '男性'])

（9）决策树优缺点

决策树算法的优点：

• 决策树算法易理解，机理解释起来简单。
• 决策树算法可以用于小数据集。
• 决策树算法的时间复杂度较小，为用于训练决策树的数据点的对数。
• 相比于其他算法智能分析一种类型变量，决策树算法可处理数字和数据的类别。
• 能够处理多输出的问题。
• 对缺失值不敏感。
• 可以处理不相关特征数据。
• 效率高，决策树只需要一次构建，反复使用，每一次预测的最大计算次数不超过决策树的深度。

决策树算法的缺点：

• 对连续性的字段比较难预测。
• 容易出现过拟合。
• 当类别太多时，错误可能就会增加的比较快。
• 在处理特征关联性比较强的数据时表现得不是太好。
• 对于各类别样本数量不一致的数据，在决策树当中，信息增益的结果偏向于那些具有更多数值的特征。

改进：

• 减枝cart算法(决策树API当中已经实现，随机森林参数调优有相关介绍)
• 随机森林

注：企业重要决策，由于决策树很好的分析能力，在决策过程应用较多， 可以选择特征

（10）剪枝处理的作用及策略

​ 剪枝处理是决策树学习算法用来解决过拟合问题的一种办法。

​ 在决策树算法中，为了尽可能正确分类训练样本， 节点划分过程不断重复， 有时候会造成决策树分支过多，以至于将训练样本集自身特点当作泛化特点， 而导致过拟合。 因此可以采用剪枝处理来去掉一些分支来降低过拟合的风险。

​ 剪枝的基本策略有预剪枝（pre-pruning）和后剪枝（post-pruning）。

​ 预剪枝：在决策树生成过程中，在每个节点划分前先估计其划分后的泛化性能， 如果不能提升，则停止划分，将当前节点标记为叶结点。

​ 后剪枝：生成决策树以后，再自下而上对非叶结点进行考察， 若将此节点标记为叶结点可以带来泛化性能提升，则修改之。

6.集成学习方法之随机森林

• 说名随机森林每棵决策树的建立过程
• 知道为什么需要随机有放回(Bootstrap)的抽样
• 说明随机森林的超参数

（1）什么是集成学习方法

集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。

（2）什么是随机森林

在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。

（3）随机森林原理过程

学习算法根据下列算法而建造每棵树：

• 用N来表示训练用例（样本）的个数，M表示特征数目。
  • 1、一次随机选出一个样本，重复N次， （有可能出现重复的样本）
  • 2、随机去选出m个特征, m <<M，建立决策树
• 采取bootstrap抽样

（4）为什么采用BootStrap抽样

• 为什么要随机抽样训练集？
  • 如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
• 为什么要有放回地抽样？
  • 如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。

（5）API

• class sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=’gini’, max_depth=None, bootstrap=True, random_state=None, min_samples_split=2)

  • 随机森林分类器
  • n_estimators：integer，optional（default = 10）森林里的树木数量120,200,300,500,800,1200
  • criteria：string，可选（default =“gini”）分割特征的测量方法
  • max_depth：integer或None，可选（默认=无）树的最大深度 5,8,15,25,30
  • max_features="auto”,每个决策树的最大特征数量
    • If “auto”, then max_features=sqrt(n_features).
    • If “sqrt”, then max_features=sqrt(n_features) (same as “auto”).
    • If “log2”, then max_features=log2(n_features).
    • If None, then max_features=n_features.
  • bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样
  • min_samples_split:节点划分最少样本数
  • min_samples_leaf:叶子节点的最小样本数

• 超参数：n_estimator, max_depth, min_samples_split,min_samples_leaf

（6）案例

# 随机森林去进行预测
rf = RandomForestClassifier()
param = {"n_estimators": [120,200,300,500,800,1200], "max_depth": [5, 8, 15, 25, 30]}
# 超参数调优
gc = GridSearchCV(rf, param_grid=param, cv=2)
gc.fit(x_train, y_train)
print("随机森林预测的准确率为：", gc.score(x_test, y_test))

• 总结

  • 在当前所有算法中，具有极好的准确率

  • 能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维

  • 能够评估各个特征在分类问题上的重要性

7.支持向量机

• 支持向量：在求解的过程中，会发现**只根据部分数据就可以确定分类器，这些数据称为支持向量**。
• 支持向量机（Support Vector Machine，SVM）：其含义是通过支持向量运算的分类器。
• 在一个二维环境中，其中点R，S，G点和其它靠近中间黑线的点可以看作为支持向量，它们可以决定分类器，即黑线的具体参数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TVEq3NCt-1668859849024)(/Users/duanyuqing/Desktop/Python语言书籍/面试/DeepLearning-500-questions-master 2/ch02_机器学习基础/img/ch2/2-6.png)]

• 支持向量机是一种二分类模型，它的目的是寻找一个超平面来对样本进行分割，分割的原则是边界最大化，最终转化为一个凸二次规划问题来求解。由简至繁的模型包括：
  • 当训练样本线性可分时，通过硬边界（hard margin）最大化，学习一个线性可分支持向量机；
  • 当训练样本近似线性可分时，通过软边界（soft margin）最大化，学习一个线性支持向量机；
  • 当训练样本线性不可分时，通过核技巧和软边界最大化，学习一个非线性支持向量机；

（1）支持向量机能解决哪些问题

①线性分类

• 在训练数据中，每个数据都有n个的属性和一个二分类类别标志，我们可以认为这些数据在一个n维空间里。

• 我们的目标是找到一个n-1维的超平面，这个超平面可以将数据分成两部分，每部分数据都属于同一个类别。

• 这样的超平面有很多，假如我们要找到一个最佳的超平面。

  • 此时，增加一个约束条件：要求这个超平面到每边最近数据点的距离是最大的，成为最大边距超平面。
  • 这个分类器即为最大边距分类器。

②非线性分类

• SVM的一个优势是支持非线性分类。它结合使用拉格朗日乘子法（Lagrange Multiplier）和KKT（Karush Kuhn Tucker）条件，以及核函数可以生成非线性分类器。

（3）核函数特点及其作用

• 引入核函数目的：把原坐标系里线性不可分的数据用核函数Kernel投影到另一个空间，尽量使得数据在新的空间里线性可分。
• 核函数方法的广泛应用，与其特点是分不开的：
  • 1）核函数的引入避免了“维数灾难”，大大减小了计算量。而输入空间的维数n对核函数矩阵无影响。因此，核函数方法可以有效处理高维输入。
  • 2）无需知道非线性变换函数Φ的形式和参数。
  • 3）核函数的形式和参数的变化会隐式地改变从输入空间到特征空间的映射，进而对特征空间的性质产生影响，最终改变各种核函数方法的性能。
  • 4）核函数方法可以和不同的算法相结合，形成多种不同的基于核函数技术的方法，且这两部分的设计可以单独进行，并可以为不同的应用选择不同的核函数和算法。

（4）SVM为什么引入对偶问题

• 对偶问题将原始问题中的约束转为了对偶问题中的等式约束，对偶问题往往更加容易求解。
• 可以很自然的引用核函数（拉格朗日表达式里面有内积，而核函数也是通过内积进行映射的）。
• 在优化理论中，目标函数 f(x) 会有多种形式：如果目标函数和约束条件都为变量 x 的线性函数，称该问题为线性规划；如果目标函数为二次函数，约束条件为线性函数，称该最优化问题为二次规划；如果目标函数或者约束条件均为非线性函数，称该最优化问题为非线性规划。每个线性规划问题都有一个与之对应的对偶问题，对偶问题有非常良好的性质，以下列举几个：
  • 对偶问题的对偶是原问题；
  • 无论原始问题是否是凸的，对偶问题都是凸优化问题；
  • 对偶问题可以给出原始问题一个下界；
  • 当满足一定条件时，原始问题与对偶问题的解是完全等价的。

（5）如何理解SVM中的对偶问题

在硬边界支持向量机中，问题的求解可以转化为凸二次规划问题。

• 假设优化目标为

KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ &\min_{\boldsy…

• step 1. 转化问题：

$$\underset{\mathbf{w},b}{\min }\underset{{\alpha }_i⩾0}{\max }\left\{\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))\right\}\text{\hspace{1em}(2)}$$

上式等价于原问题，因为若满足(1)中不等式约束，则(2)式求max时,${\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))$必须取0，与(1)等价；若不满足(1)中不等式约束，(2)中求max会得到无穷大。 交换min和max获得其对偶问题:
$$\underset{{\alpha }_i⩾0}{\max }\underset{\mathbf{w},b}{\min }\left\{\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))\right\}$$
交换之后的对偶问题和原问题并不相等，上式的解小于等于原问题的解。

• step 2.现在的问题是如何找到问题(1) 的最优值的一个最好的下界?

$$\begin{gathered} \frac{1}{2}||\mathbf{w}|{|}^2<v \\ 1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b)⩽0\text{\hspace{1em}(3)} \end{gathered}$$

若方程组(3)无解， 则v是问题(1)的一个下界。若(3)有解， 则
$$\forall \mathbf{\alpha }>0,\underset{\mathbf{w},b}{\min }\left\{\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))\right\}<v$$
由逆否命题得：若
$$\exists \mathbf{\alpha }>0,\underset{\mathbf{w},b}{\min }\left\{\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))\right\}⩾v$$
则(3)无解。

那么v是问题(1)的一个下界。
要求得一个好的下界，取最大值即可
$$\underset{{\alpha }_i⩾0}{\max }\underset{\mathbf{w},b}{\min }\left\{\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))\right\}$$

• step 3. 令

$$L(\mathbf{w},b,\mathbf{a})=\frac{1}{2}||\mathbf{w}|{|}^2+\sum _{i=1}^m{\alpha }_i(1-y_i({\mathbf{w}}^T{\mathbf{x}}_i+b))$$

$p^{\ast }$为原问题的最小值，对应的$w,b$分别为$w^{\ast },b^{\ast }$,则对于任意的$a>0$:
$$p^{\ast }=\frac{1}{2}||{\mathbf{w}}^{\ast }|{|}^2⩾L({\mathbf{w}}^{\ast },b,\mathbf{a})⩾\underset{\mathbf{w},b}{\min }L(\mathbf{w},b,\mathbf{a})$$
则 ${\min }_{\mathbf{w},b}L(\mathbf{w},b,\mathbf{a})$是问题（1）的一个下界。

此时，取最大值即可求得好的下界，即
$$\underset{{\alpha }_i⩾0}{\max }\underset{\mathbf{w},b}{\min }L(\mathbf{w},b,\mathbf{a})$$

（6）常见的核函数有哪些

核函数	表达式	备注
Linear Kernel线性核	$k(x,y)=x^{t}y+c$
Polynomial Kernel多项式核	$k(x,y)=(a{x}^{t}y+c{)}^d$	$d⩾1$为多项式的次数
Exponential Kernel指数核	$k(x,y)=exp(-\frac{|x-y|}{2{\sigma }^2})$	$\sigma >0$
Gaussian Kernel高斯核	$k(x,y)=exp(-\frac{{|x-y|}^2}{2{\sigma }^2})$	$\sigma$为高斯核的带宽，$\sigma >0$,
Laplacian Kernel拉普拉斯核	$k(x,y)=exp(-\frac{|x-y|}{\sigma })$	$\sigma >0$
ANOVA Kernel	$k(x,y)=exp(-\sigma (x^k-y^k{)}^2{)}^d$
Sigmoid Kernel	$k(x,y)=tanh(a{x}^{t}y+c)$	$tanh$为双曲正切函数，$a>0,c<0$

（7）SVM主要特点

• SVM方法的理论基础是非线性映射，SVM利用内积核函数代替向高维空间的非线性映射。
• SVM的目标是对特征空间划分得到最优超平面，SVM方法核心是最大化分类边界。
• 支持向量是SVM的训练结果，在SVM分类决策中起决定作用的是支持向量。
• SVM是一种有坚实理论基础的新颖的适用小样本学习方法。它基本上不涉及概率测度及大数定律等，也简化了通常的分类和回归等问题。
• SVM的最终决策函数只由少数的支持向量所确定，计算的复杂性取决于支持向量的数目，而不是样本空间的维数，这在某种意义上避免了“维数灾难”。
• 少数支持向量决定了最终结果，这不但可以帮助我们抓住关键样本、“剔除”大量冗余样本,而且注定了该方法不但算法简单，而且具有较好的“鲁棒性”。这种鲁棒性主要体现在：
  • ①增、删非支持向量样本对模型没有影响;
  • ②支持向量样本集具有一定的鲁棒性;
  • ③有些成功的应用中，SVM方法对核的选取不敏感
• SVM学习问题可以表示为凸优化问题，因此可以利用已知的有效算法发现目标函数的全局最小值。而其他分类方法（如基于规则的分类器和人工神经网络）都采用一种基于贪心学习的策略来搜索假设空间，这种方法一般只能获得局部最优解。
• SVM通过最大化决策边界的边缘来控制模型的能力。尽管如此，用户必须提供其他参数，如使用核函数类型和引入松弛变量等。
• SVM在小样本训练集上能够得到比其它算法好很多的结果。SVM优化目标是结构化风险最小，而不是经验风险最小，避免了过拟合问题，通过margin的概念，得到对数据分布的结构化描述，减低了对数据规模和数据分布的要求，有优秀的泛化能力。
• 它是一个凸优化问题，因此局部最优解一定是全局最优解的优点。

（8）SVM主要缺点

①SVM算法对大规模训练样本难以实施

• SVM的空间消耗主要是存储训练样本和核矩阵，由于SVM是借助二次规划来求解支持向量，而求解二次规划将涉及m阶矩阵的计算（m为样本的个数），当m数目很大时该矩阵的存储和计算将耗费大量的机器内存和运算时间。 ​
• 如果数据量很大，SVM的训练时间就会比较长，如垃圾邮件的分类检测，没有使用SVM分类器，而是使用简单的朴素贝叶斯分类器，或者是使用逻辑回归模型分类。

② 用SVM解决多分类问题存在困难

• 经典的支持向量机算法只给出了二类分类的算法，而在实际应用中，一般要解决多类的分类问题。可以通过多个二类支持向量机的组合来解决。主要有一对多组合模式、一对一组合模式和SVM决策树；再就是通过构造多个分类器的组合来解决。
• 主要原理是克服SVM固有的缺点，结合其他算法的优势，解决多类问题的分类精度。如：与粗糙集理论结合，形成一种优势互补的多类问题的组合分类器。

③对缺失数据敏感，对参数和核函数的选择敏感

支持向量机性能的优劣主要取决于核函数的选取，所以对于一个实际问题而言，如何根据实际的数据模型选择合适的核函数从而构造SVM算法。目前比较成熟的核函数及其参数的选择都是人为的，根据经验来选取的，带有一定的随意性。在不同的问题领域，核函数应当具有不同的形式和参数，所以在选取时候应该将领域知识引入进来，但是目前还没有好的方法来解决核函数的选取问题。