机器学习一般迭代多少次 机器学习算法

机器学习之算法

• 一、k-近邻算法（knn算法）

• 1.算法原理
• 2.算法参数
• 3.示例：使用k-近邻算法进行分类
• 4.示例：使用k-近邻算法进行回归拟合
• 5.实例：糖尿病预测

• 二、线性回归算法

• 1.单变量线性回归算法

• 成本函数
• 梯度下降算法
• 模型优化

• 1.多项式与线性回归
• 2.数据归一化

• 2.多元线性回归算法

• 三、逻辑回归算法

• 1.预测函数
• 2.判定边界
• 3.Logistic 分布函数
• 4.Logistic 分类模型
• 5.边界函数

• 四、决策树

• 算法原理

• （1）信息增益
• （2）决策树的创建

• 决策树创建基本步骤

• 离散化
• 正则项
• 基尼不纯度

• （3）剪枝算法

• 1.前剪枝
• 2.后剪枝

• 随机森林
• 五、支持向量机

• 1.算法原理

• 大间距分类算法
• 松弛系数

• 2.核函数

• 最简单的核函数

• 六、朴素贝叶斯算法

• 算法原理

• 朴素贝叶斯分类法
• 举例

• 七、PCA 算法

• 算法原理

• 数据归一化和缩放
• 举例

• 八、k-均值算法

• 算法原理

• 1.k-均值算法成本函数
• 2.随机初始化聚类中心点
• 3.选择聚类的个数

一、k-近邻算法（knn算法）

k-近邻算法也称为knn算法，它是一个有监督的机器学习算法。可以解决分类问题，也可以解决回归问题。

1.算法原理

knn算法的核心思想是未标记样本的类别，由距离其最近的k个邻居投票来决定。
假设，我们有一个已经标记的数据集，即己经知道了数据集中每个样本所属的类别。此时，有一个未标记的数据样本，我们的任务是预测出这个数据样本所属的类别 ，knn算法的原理是，计算待标记的数据样本和数据集中每个样本的距离，取距离最近的k个样本。待标记的数据样本所属的类别，就由这k个距离最近的样本投票产生。
假设 X_test 为待标记的数据样本，X_train 为已标记的数据集，算法原理的伪代码如下：

• 遍历 X_train 中的所有样本，计算每个样本与X_test 的距离，井把距离保存在 Distance 数组中。
• 对 Distance数组进行排序，取距离最近的k个点，记为X_knn。
• 在X_knn中统计每个类别的个数，即class()在X_knn中有几个样本， class1在X_knn 中有几个样本等。
• 待标记样本的类别，就是在X_knn中样本个数最多的那个类别。

通用步骤
计算距离（常用欧几里得距离或者马氏距离）
升序排列
取前K个
加权平均

2.算法参数

其算法参数是k，参数选择需要根据数据来决定。k值越大，模型的偏差越大，对噪声数据越不敏感 ，当k值很大时，可能造成模型欠拟合（高偏差）；k值越小，模型的方差就会越大，当k值太小， 就会造成模型过拟合（高方差）。

3.示例：使用k-近邻算法进行分类

在scikit-learn里，使用k-近邻算法进行分类处理的是 sk learn.neighbors.KNeighbors Classifier类。

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

（1）生成已标记的数据集：

from sklearn.datasets.samples_generator import make_blobs
# 生成数据
centers = [[-2, 2], [2, 2], [0, 4]]
X, y = make_blobs(n_samples=60, centers=centers, random_state=0, cluster_std=0.60)

使用 sklearn .datasets. samples_generator 包下 make blobs（） 函数来生成数据集，上面代码中，生成 60 个训练样本，这60个样本分布在以 centers 参数指定中心点周围。cluster_std 是标准差，用来指明生成的点分布的松散程度。生成的训练数据集放在变量X里面，数据集的类别标记放在y里面。
可以把X和Y的值打印出来查看，一个更直观的方法是使用 matplotlib 库，它可以很容易地把生成的点画

#画出数据
plt.figure(figsize=(16, 10))
c = np.array(centers)
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, cmap='cool');         # 画出样本
plt.scatter(c[:, 0], c[:, 1], s=100, marker='^', c='orange');   # 画出中心点

这些点的分布情况在坐标轴上一目了然， 其中三角形的点即各个类别的中心节点，如图：

（2）使用 KNeighborsClassifier 来对算法进行训练，我们选择的参数是 k= 5:

from sklearn.neighbors import KNeighborsClassifier
# 模型训练
k = 5
clf = KNeighborsClassifier(n_neighbors=k)
clf.fit(X, y);

(3)对一个新的样本进行预测

# 进行预测
X_sample = [0, 2]
X_sample = np.array(X_sample).reshape(1, -1)
y_sample = clf.predict(X_sample);
neighbors = clf.kneighbors(X_sample, return_distance=False);

我们要预测的样本是 [0,2]，使用 kneighbors()方法，把这个样本周围距离最近的5个点取出来。取出来的点是训练样本X里的索引，从0开始计算。
(4)把待预测的样本以及和其最近的5个点标记出来：

# 画出示意图
plt.figure(figsize=(16, 10))
plt.scatter(X[:, 0], X[:, 1], c=y, s=100, cmap='cool')    # 样本
plt.scatter(c[:, 0], c[:, 1], s=100, marker='^', c='k')   # 中心点
plt.scatter(X_sample[0][0], X_sample[0][1], marker="x", 
            s=100, cmap='cool')    # 待预测的点

for i in neighbors[0]:
    # 预测点与距离最近的 5 个样本的连线
    plt.plot([X[i][0], X_sample[0][0]], [X[i][1], X_sample[0][1]], 
             'k--', linewidth=0.6);

我们可以清楚地看到k-近邻算法的原理，如上图所示。

4.示例：使用k-近邻算法进行回归拟合

分类问题的预测值是离散的，我们也可以用k-近邻算法在 连续区间内对数值进行预测，进行回归拟合。在 scikit-learn 里，使用k-近邻算法进行回归拟合的算法是sklearn.neighbors.KNeighborsRegressor 类。

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

(1)生成数据集，它在余弦曲线的基础上加入了噪声：

# 生成训练样本
n_dots = 40
X = 5 * np.random.rand(n_dots, 1)
y = np.cos(X).ravel()

# 添加一些噪声
y += 0.2 * np.random.rand(n_dots) - 0.1

(2)使用 KNeighborsRegressor 训练模型：

# 训练模型
from sklearn.neighbors import KNeighborsRegressor
k = 5
knn = KNeighborsRegressor(k)
knn.fit(X, y);

我们要怎么样来进行回归拟合呢？
一个方法是，在X轴上的指定区间内生成足够多的点，针对这些足够密集的点，使用训练出来的模型进行预测，得到预测值 y_pred ，然后在坐标轴上，把所有的预测点连接起来，这样就画出了拟合曲线。
我们针对足够密集的点进行预测：

# 生成足够密集的点并进行预测
T = np.linspace(0, 5, 500)[:, np.newaxis]
y_pred = knn.predict(T)
knn.score(X, y)

可以用 score() 方法计算拟合曲线针对训练样本的拟合准确性，输出结果为：

0.9818500931894661

(3)把这些预测点连起来，构成拟合曲线：

# 画出拟合曲线
plt.figure(figsize=(16, 10))
plt.scatter(X, y, c='g', label='data', s=100)         # 画出训练样本
plt.plot(T, y_pred, c='k', label='prediction', lw=4)  # 画出拟合曲线
plt.axis('tight')
plt.title("KNeighborsRegressor (k = %i)" % k)
plt.show()

最终生成的拟合曲线以及训练样本数据如图：

5.实例：糖尿病预测

本节使用k-近邻算法及其变种，对 Pima 印第安人的糖尿病进行预测。数据来源kaggle.com ，网址为 https://www .kaggle. com/ iml/pim -indian s- diabete -database ，可自行前往 ，也 使用随书代码里下载好的 code dataet pima indidiabetes

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

(1) 加载数据
使用 pandas 加载数据:

# 加载数据
data = pd.read_csv('datasets/pima-indians-diabetes/diabetes.csv')
print('dataset shape {}'.format(data.shape))
data.head()

输出为：

dataset shape (768, 9)
Pregnancies Glucose BloodPressure SkinThickness Insulin BMI DiabetesPedigreeFunction Age Outcome
0 6 148 72 35 0 33.6 0.627 50 1
1 1 85 66 29 0 26.6 0.351 31 0
2 8 183 64 0 0 23.3 0.672 32 1
3 1 89 66 23 94 28.1 0.167 21 0
4 0 137 40 35 168 43.1 2.288 33 1

从输出可以看到，总共有 768 个样本、8个特征，其中Outcome为标记值，0表示没有糖尿病， 1表示有糖尿病，8个特征分别如下：
• Pregnancies：怀孕的次数。
• Glucose： 血浆葡萄糖浓度，采用2小时口服葡萄糖耐量试验测得。
• BloodPressure：舒张压（毫米京柱）。
• SkinThickness：肱三头肌皮肤褶皱厚度（毫米）。
• Insulin：两个小时血清胰岛素 (µU／毫升)。
• BMI：身体质量指数，体重除以身高的平方。
• Diabetes Pedigree Function：糖尿病血统指数，糖尿病和家庭遗传相关。
•Age：年龄。Diabetes Pedigree Function
我们可以进一步观察数据集里阳性和阴性样本的个数：

data.groupby("Outcome").size()

输出为：

Outcome
0 500
1 268
dtype: int64

其中阴性样本 500 例，阳性样本 268 例。接着，需要对数据集进行简单处理，把8个特征值分离出来，作为训练数据集，把 Outcome 分离出来作为目标值。然后，把数据集划分为训练数据集和测试数据集。

X = data.iloc[:, 0:8]
Y = data.iloc[:, 8]
print('shape of X {}; shape of Y {}'.format(X.shape, Y.shape))
from sklearn.model_selection import train_test_split
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2);

shape of X (768, 8); shape of Y (768,)

(2)模型比较
使用普通的 k-均值算法、带权重的k-均值算法以及指定半径的 k-均值算法分别对数据集进行拟合并计算评分：

from sklearn.neighbors import KNeighborsClassifier, RadiusNeighborsClassifier

# 构造3个模型
models = []
models.append(("KNN", KNeighborsClassifier(n_neighbors=2)))
models.append(("KNN with weights", KNeighborsClassifier(
    n_neighbors=2, weights="distance")))
models.append(("Radius Neighbors", RadiusNeighborsClassifier(
    n_neighbors=2, radius=500.0)))

# 分别训练3个模型，并计算评分
results = []
for name, model in models:
    model.fit(X_train, Y_train)
    results.append((name, model.score(X_test, Y_test)))
for i in range(len(results)):
    print("name: {}; score: {}".format(results[i][0],results[i][1]))

输出为：

name: KNN; score: 0.6753246753246753
name: KNN with weights; score: 0.7272727272727273
name: Radius Neighbors; score: 0.6038961038961039

权重算法，我们选择了距离越近，权重越高。RadiusNeighborsClassifier 模型的半径，选择了 500。从输出可以看出，普通的 k-均值算法性能还是最好。问题来了，这个判断准确么？答案是不准确 。因为我们的训练样本和测试样本是随机分配的，不同的训练样本和测试样本组合可能导致计算出来的算法准确性是有差异 。可以试着多次运行示例代码，观察一下输出值是否有变化。
怎么样更准确地对比算法准确性呢？一个方法是，多次随机分配训练数据集和交叉验证数据集，然后求模型准确性评分的平均值。所幸 ，我们不需要从头实现这个过程，我们可以利用scikit-learn 提供的 KFold和cross_vaI_score()函数来处理：

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

results = []
for name, model in models:
    kfold = KFold(n_splits=10)
    cv_result = cross_val_score(model, X, Y, cv=kfold)
    results.append((name, cv_result))
for i in range(len(results)):
    print("name: {}; cross val score: {}".format(
        results[i][0],results[i][1].mean()))

name: KNN; cross val score: 0.7147641831852358
name: KNN with weights; cross val score: 0.6770505809979495
name: Radius Neighbors; cross val score: 0.6497265892002735

上述代码中，我们通过 KFold 把数据集分成 10 份，其中1份会作为交叉验证数据集来计算模型准确性，剩余的9份作为训练数据集。 cross_val_score ()函数总共计算出10次不同训练数据集和交叉验证数据集组合得到的模型准确性评分，最后求平均值。这样的评价结果相对更准确一些。
(3)模型训练及分析
看起来，还是普通的k-均值算法性能更优一些。接下来，我们就使用普通k-均值算法模型对数据集进行训练，井查看对训练样本的拟合情况以及对测试样本的预测准确性情况：

knn = KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train, Y_train)
train_score = knn.score(X_train, Y_train)
test_score = knn.score(X_test, Y_test)
print("train score: {}; test score: {}".format(train_score, test_score))

train score: 0.8420195439739414; test score: 0.6493506493506493

从这个输出中可以看到两个问题。一是对训练样本的拟合情况不佳，评分才 0.84多一些，这说明算法模型太简单了，无法很好地拟合训练样本。二是模型的准确性欠佳，不到73% 的预测准确性。我们可以进一步画出学习曲线，证实结论。

from sklearn.model_selection import ShuffleSplit
from common.utils import plot_learning_curve

knn = KNeighborsClassifier(n_neighbors=2)
cv = ShuffleSplit(n_splits=10, test_size=0.2, random_state=0)
plt.figure(figsize=(10, 6))
plot_learning_curve(plt, knn, "Learn Curve for KNN Diabetes", 
                    X, Y, ylim=(0.0, 1.01), cv=cv);

从图中可以看出来，训练样本评分较低，且测试样本与训练样本距离较大，这是典型的欠拟合（高偏差）现象。 k-均值算法没有更好的措施来解决欠拟合问题，可以试着用其他算法（ 逻辑回归算法、支持向量机等）来对比不同模型的准确性情况。

(4)特征选择及数据可视化

一个直观的办法是把数据画出来，可是我们有8个特征，无法在这么高的维度里画出数据，并直观地观察。一个解决办法是特征选择，即只选择2个与输出值相关性最大的特征，这样就可以在二维平面上画出输入特征值与输出值的关系了。

scikit-learn 在sklearn.feature_selection 包里提供了丰富 的特征选择方法。我们使用 SelectKBest 来选择相关性最大的两个特征：

from sklearn.feature_selection import SelectKBest

selector = SelectKBest(k=2)
X_new = selector.fit_transform(X, Y)
X_new[0:5]

把相关性最大的两个特征放在 X_new 变量里，同时输出了前5个数据样本。输出结果为：

array([[148. , 33.6],
[ 85. , 26.6],
[183. , 23.3],
[ 89. , 28.1],
[137. , 43.1]])

对比一下数据即可知道，相关性最大的两个特征它们分别是Glucose(血糖浓度)和BMI(身体质量指数)。
如果只使用这2个相关性最高的特征的话，3种不同的k-均值算法哪个准确性更高：(使用 new 作为输入)

results = []
for name, model in models:
    kfold = KFold(n_splits=10)
    cv_result = cross_val_score(model, X_new, Y, cv=kfold)
    results.append((name, cv_result))
for i in range(len(results)):
    print("name: {}; cross val score: {}".format(
        results[i][0],results[i][1].mean()))

name: KNN; cross val score: 0.725205058099795
name: KNN with weights; cross val score: 0.6900375939849623
name: Radius Neighbors; cross val score: 0.6510252904989747

从输出可以看出来，还是普通的k-均值模型准确性较高。这也侧面证明了 SelectKBest 特征选择的准确性。
回到目标上来，我们是想看看为什么k-均值无法很好拟合 训练样本。现在我只有2个特征，可以很方便地在二维坐标上画出所有的训练样本，观察这些数据的分布情况：

# 画出数据
plt.figure(figsize=(10, 6))
plt.ylabel("BMI")
plt.xlabel("Glucose")
# 画出 Y==0 的阴性样本，用圆圈表示
plt.scatter(X_new[Y==0][:, 0], X_new[Y==0][:, 1], c='r', s=20, marker='o');         # 画出样本
# 画出 Y==1 的阳性样本，用三角形表示
plt.scatter(X_new[Y==1][:, 0], X_new[Y==1][:, 1], c='g', s=20, marker='^');         # 画出样本

横坐标是血糖值，纵坐标是 BMI 值，反映身体肥胖情况。 从图中可以看出，在中间数据集密集的区域，阳性样本和阴性样本几乎重叠在一起了。假设现在有一个待预测的样本在中间密集区域，它的阳性邻居多还是阴性邻居多呢？这真的很难说。这样就可以直观地看到，k-均值算法在这个糖尿病预测问题上，无法达到很高的预测准确性。

二、线性回归算法

线性回归算法是使用线性方程对数据集进行拟合的算法，是一个非常常见的回归算法。笔者将首先从最简单的单变量线性回归算法开始介绍然后介绍多变量线性回归算法，其中成本函数以及梯度下降算法的推导过程会用到部分线性代数和偏导数；接着重点介绍了梯度下降算法的求解步骤以及性能优化方面的内容；最后通过一个房价预测模型，介绍了线性回归算法性能优化的些常用步骤和方法。

• 单变量线性回归算法的原理
• 多变量线性回归算法的原理
• 梯度下降算法的原理及步骤
• 一个房价预测的模型及其性能优化

1.单变量线性回归算法

线性回归的含义表示用函数曲线拟合数据集，使得函数的预测值和数据集真实值之间的误差越小越好。

如图举例：通过线性回归找出算法工程师和程序员之间的工资关系。

由图可见，它们之间大致是一个线性关系，这时候，我们就可以试着用一元线性回归去拟合（fit）他们之间的关系。

成本函数

最好地拟合数据集：当拟合成本最小时，即找到了最好的拟合函数。

梯度下降算法

为了求解模型参数θ_0，θ_1 的值，这时梯度下降算法就派上了用场。

我们的任务是找到合适的θ_0、θ_1 ，使得成本函数J(θ_0,θ_1)最小，我们换到三维空间来描述这个任务。在一个三维空间里，以θ_0作为x轴，以θ_1作为y轴，以成本函数J(θ_0,θ_1)为z轴，那么我们的任务，就是要找出当z轴上的值最小的时候所对应的x轴上的值和y轴上的值。

梯度下降算法的原理是，先随机选择θ_0，θ_1，同时选择一个参数a作为移动的步幅。然后，让x轴上的θ_0和y轴上的θ_1分别向特定的方向移动一小步，这个步幅的大小就由参数a指定。经过多次选代之后，x轴和y轴上的值决定的点就慢慢地靠近z轴上的最小值处，如图 梯度下降等高线 示。

这是个等高线图，就是说在我们描述的三维空间里，你的视角在正上方，看到一圈一圈z轴值相同的点构成的线。

轴值相同的点构成的线。在图 梯度下降等高线 中，随机选择的点在 Xo 处，经过多次选代后，慢慢地靠近圆心处，即z轴上最小值附近。

问题来了， Xo （由 [θ_0,θ_1] 描述〉怎么知道往哪个方向移动，才能靠近z轴上最小值附近？答案是往成本函数逐渐变小的方向移动 。怎么表达成本函数逐渐变小的方向呢？答案是偏导数（斜率）。

模型优化

所介绍线性回归模型常用的优化方法，包括增加多项式特征以及数据归一化处理等

1.多项式与线性回归

当线性回归模型太简单导致欠拟合时，我们可以增加特征多项式来让线性回归模型更好地拟合数据。比如有两个特征 X1,X2 ，可以增加两特征的乘积X1,X2 作为新特征 X3 。我们还可以增加 X1^2 作为另外一个新特征 X4 。
在scikit-learn 里，线性回归是由类 sklearn.linear_model .LinearRegression实现， 多项式由类 klearn. preprocessing. PolynomialFeatures 实现。那么要怎么添加多项式特征呢？我们需要用一个管道把两个类串起来，即用sklearn.pipeline.Pipeline 把两个模型串起来。

比如下面的函数可以创 个多项式拟合：

def polynomal model (degree=l) : 
polynomial_features = PolynomialFeatures(degree=degree, include bias=False) 
linear regression = LinearRegression()
＃这是一个流水线，先增加多项式阶数 然后再用线性回归算法来拟合数据
pipeline= Pipeline([ (” polynomial_features ”, polynomial_features), 
(” linear_regression”, linear_regression)]) 
return pipeline

一个Pipeline 可以包含多个处理节点，在 scikit-learn 里，除了最后一个节点外，其他的节点都必须实现’fit()';f日’ transform()’方法，最后一个节点只需要实现 fit() 方法即可。当训练样本数据送进 Pipeline 里进行处理时，它会逐个调用节点的fit()和 transform()方法，然后调用最后一个节点的fit()方法来拟合数据。管道的运算示意图如图示。

2.数据归一化

当线性回归模型有多个输入特征时，特别是使用多项式添加特征时，需要对数据进行归一化处理。 比如，特征x1的范围在[1,4]之间，特征x2的范围在[1, 2000]之间，这种情况下，可以让x1除以4来作为新特征 X1 ，同时让 x2 除以2000来作为新特征 X2 ,该过程称为特征缩放( feature scaling)。可以使用特征缩放来对训练样本进行归一化处理，处理后的特征值范围在 [0,1]之间。

(1)定义一元线性回归方程

其中，θ_1是直线的斜率，θ_0是直线的截距。θ_1和θ_0称为待求的模型参数。为了求模型参数，我们需要定义损失函数，使得函数的预测值和真实值之间的误差越小越好。

(2)设计损失函数

一般通过均方误差MSE定义损失函数，公式为：

在实际的计算过程中，函数的参数θ_0和θ_1是未知的，则损失函数是参数θ_0和θ_1的二元函数，即：

，其中自变量x_i和函数值y_i都是已知的。

(3)优化方法(梯度下降算法)

当模型参数θ_0和θ_1的值时，成本函数J(θ_0,θ_1)最小？我们采用梯度下降法，算法如下：

初始化参数θ_0和θ_1

其中a是学习率，控制梯度下降的速度。如果a太大，则下降速度步伐太大；如果a太小，则下降速度步伐太小。a的取值一般为0.001,0.003,0.01等。

2.多元线性回归算法

（1） 定义多元线性回归方程

（2） 设计损失函数

假设数据集有n个样本，则损失函数J如下。

损失函数是参数

的多元函数。

（3）优化方法(梯度下降算法)

其中a是学习率，控制梯度下降的速度。 a的取值一般为0.001,0.003,0.01等。

假设损失函数J是以

为自变量的二元二次函数，则该函数可以画出来，如下：

三、逻辑回归算法

逻辑回归算法的名字里虽然带有“回归” 字，但实际上逻辑回归算法是用来解决分类问题的算法。首先从二元分类入手，介绍逻辑回归算法的预测函数、成本函数和梯度下降算法公式；然后再介绍了怎样由二元分类延伸到多元分类的问题：接着介绍了正则化，即通过数学的手段来解决模型过拟合问题；针对正则化，还介绍了L1范数和L2范数的含义及区别；最后用一个乳腺癌检测的实例及其模型性能优化来结束内容。
1.逻辑回归算法的原理；
2.用梯度下降算法求解逻辑回归算法的模型参数；
3.正则化及正则化的作用；
4.LI 范数和 L2 范数的含义及其作为模型正则项的区别；
5.用逻辑回归算法解决乳腺癌检测问题

逻辑回归算法的输出 y=0或1 是个离散值，这是与线性回归算法的最大区别。

1.预测函数

需要找出一个预测函数模型，使其值输出在[0,1]之间。然后选择一个基准值，如0.5，如果算出来的预测值大于 0.5，就认为其预测值为1，反之则其预测值为0。

选择

2.判定边界

以下是判断边界的两个例子：

3.Logistic 分布函数

Logistic 分布是一种连续型的概率分布，其分布函数和密度函数分别为：

其中，

表示位置参数，

为形状参数。我们可以看下其图像特征：

Logistic 分布是由其位置和尺度参数定义的连续分布。Logistic 分布的形状与正态分布的形状相似，但是 Logistic 分布的尾部更长，所以我们可以使用 Logistic 分布来建模比正态分布具有更长尾部和更高波峰的数据分布。在深度学习中常用到的 Sigmoid 函数就是 Logistic 的分布函数在

的特殊形式。

代码实现：

import numpy as np
def sigmoid(x):
   return 1 / (1 + np.exp(-x))

import matplotlib.pyplot as plt
x = np.arange(-60, 60, 0.1)
y = sigmoid(x)

plt.plot(x,y) 
plt.xlabel('x')              # 设置x轴标签
plt.ylabel('Sigmoid(x)')     # 设置y轴标签
plt.grid()                   # 生成网格线
plt.show()

根据上面绘制出的 S 形函数图像，我们知道

4.Logistic 分类模型

给定数据集

我们需要构造二分类模型。如图。

5.边界函数

由图可知，边界线上方样本类别为y=1 ，边界线下方的样本类别为y=0。

四、决策树

决策树是最经典的机器学习模型之一。 它的预测结果容易理解，易于向业务部门解释，预测速度快，可以处理类别型数据和连续型数据。在机器 习的数据挖掘类求职面试中，决策树是面试官最喜欢的面试题之一。 读者应掌握以下内容：

1.信息熵及信息增益的概念，以及决策树的分裂的原则；
2.决策树的创建及剪枝算法
3.scikit-learn中决策树算法的相关参数
4.使用决策树预测泰坦尼克号幸存者实例
5.scikit-learn模型参数选择的工具及使用方法
6.聚合算法及随机森林算法的原理。

算法原理

决策树是一个类似于流程图的树结构，分支节点表示对一个特征进行测试，根据测试结果进行分类，树叶节点代表一个类别。即，决策树：从根节点开始一步步走到叶子节点（决策）。

如图所示，我们用决策树来决定下班后的安排（图1）。

对家庭人口进行分类。（图2）

那么问题来了，在创建决策树的过程中，要先对哪个特征进行分裂？比如针对图1中的例子，先判断精力指数进行分裂还是先判断情绪指数进行分裂？ 或者针对图2中的例子，我们为什么不先判断性别再判断年龄呢？

（1）信息增益

1948年，香农在他著名的《通信的数学原理》中提出了信息熵(Entropy)的概念。香农认为，一条信息的信息量和它的不确定性有直接关系。一个问题不确定性越大，要搞清楚这个问题，需要了解的信息就越多，其信息嫡就越大。

信息嫡的计算公式为：

其中，P(x)表示事件X出现的概率。

（2）决策树的创建

当我们要构建一个决策树时，应该优先选择哪个特征来划分数据集呢？答案是：遍历所有的特征，分别计算，使用这个特征划分数据集前后信息熵的变化值，然后选择信息熵变化幅度最大的那个特征，来优先作为数据集划分依据。

如图示，由于使用质量划分数据集比使用体积划分数据集得到了更高的信息增益，所以我们优先选择质量这个特征来划分数据集。信息增益的物理意义:

从这个函数关系可以看出来，当概率P(x)越接近0或越接近1时，信息熵的值越小，其不确定性越小，即数据越“纯”。典型地，当概率值为1时，此时数据是最“纯净”的， 因为只有一种类别的数据，已经消除了不确定性，其信息熵为0。我们在特征选择时，选择信息增益最大的特征，在物理上，即让数据尽量往更纯净的方向上变换。因此，我们得出，信息增益是用来衡量数据变得更有序、更纯净的程度的指标。

决策树的构建过程，就是从训练数据集中归纳出一组分类规则，使它与训练数据矛盾较小的同时具有较强的泛化能力。并且用信息增益来量化地选择数据集的划分特征。

决策树创建基本步骤

(1) 计算数据集划分前的信息熵。
(2) 遍历所有未作为划分条件的特征，分别计算根据每个特征划分数据集后的信息熵。
(3) 选择信息增益最大的特征，并使用这个特征作为数据划分节点来划分数据。
(4) 递归地处理被划分后的所有子数据集，从未被选择的特征里继续选择最优数据划分特征来划分子数据集。
一般来讲，有两个终止递归过程的条件：
（1）所有的特征都用完了，即没有新的特征可以用来进一步划分数据集。
（2）划分后的信息增益足够小了，这个时候就可以停止递归划分了。针对这个停止条件，需要事先选择信息增益的门限值来作为结束递归的条件。
使用信息增益作为特征选择指标的决策树构建算法，称为ID3算法。

离散化

如果一个特征是连续值怎么办呢？我们以开头的图1为例，假设我们有个精力测试仪器，测出来的是一个0〜100的数字，这是个连续值，这个时候怎么用决策树来建模呢？
答案是：离散化。我们需要对数据进行离散化处理。
例如：
精力指数 <= 40 ：低；
精力指数 >40 且 <= 70 ：中；
精力指数 >70 ：高；
这个往往和具体的业务相关。

正则项

最大化信息增益来选择特征，在决策树的构建过程中，容易造成优先选择类别最多的特征来进行分类。
举一个极端的例子，我们把某个产品的唯一标识符ID作为特征之一加入到数据集中，那么构建决策树时，就会优先选择产品ID来作为划分特征，因为这样划分出来的数据，每个叶子节点只有一个样本，划分后的子数据集最“纯净”，其信息增益最大。
这不是我们希望看到的结果。解决办法是，计算划分后的子数据集的信息熵时，加上一个与类别个数成正比的正则项，来作为最后的信息熵。这样，当算法选择的某个类别较多的特征，使信息嫡较小时，由于受到类别个数的正则项惩罚，导致最终的信息熵也比较大。这样通过合适的参数，可以使算法训练得到某种程度的平衡。

基尼不纯度

我们知道，信息熵是衡量信息不确定性的指标，实际上也是衡量信息“纯度”的指标。

除此之外，基尼不纯度(Gini impurity)也是衡量信息不纯度的指标，其计算公式如下：

其中，P(x)是样本属于x这个类别的概率。如果所有的样本都属于一个类别，此时,P(x)=1,则Gini(D)=0，即数据不纯度最低，纯度最高。我们以概率P(x)作为横坐标，以这个类别的基尼不纯度作为纵坐标，在坐标轴上画出其函数关系，如图所示。

从图中可以看出，其形状和信息熵的形状几乎一样。CART算法使用基尼不纯度来作为特征选择标准，CART也是一种决策树构建算法。

（3）剪枝算法

使用决策树模型拟合数据时，容易造成过拟合。解决过拟合的方法是对决策树进行剪枝处理。
决策树的剪枝有两种思路：前剪枝(Pre-Pruning)和后剪枝(Post-Pruning)。

1.前剪枝

前剪枝是在构造决策树的同时进行剪枝。在决策树的构建过程中，如果无法进一步降低信息熵的情况下，就会停止创建分支。为了避免过拟合，可以设定一个阈值，信息熵减小的数量小于这个阈值，即使还可以继续降低熵，也停止继续创建分支。这种方法称为前剪枝。还有一些简单的前剪枝方法，如限制叶子节点的样本个数，当样本个数小于一定的阈值时，即不再继续创建分支。

2.后剪枝

后剪枝是指决策树构造完成后进行剪枝。剪枝的过程是对拥有同样父节点的一组节点进行检査，判断如果将其合并，信息熵的增加量是否小于某一阈值。如果小于阈值，则这一组节点可以合并一个节点。
后剪枝是目前较普遍的做法。后剪枝的过程是删除一些子树， 然后用子树的根节点代替，来作为新的叶子节点。这个新叶子节点所标识的类别通过大多数原则来确定，即把这个叶子节点里样本最多的类别，作为这个叶子节点的类别。
后剪枝算法有很多种，其中常用的一种称为降低错误率剪枝法(Reduced-Error Pruning)。其思路是，自底向上，从已经构建好的完全决策树中找出一个子树，然后用子树的根节点代替这棵子树，作为新的叶子节点。叶子节点所标识的类别通过大多数原则来确定。这样就构建出一个新的简化版的决策树。然后使用交叉验证数据集来测试简化版本的决策树，看看其错误率是不是降低了。如果错误率降低了，则可以使用这个简化版的决策树代替完全决策树，否则还是采用原来的决策树。通过遍历所有的子树，直到针对交叉验证数据集，无法进一步降低错误率为止。

随机森林

1.集成学习方法

将多个机器学习模型进行结合，从而使得效果更好。具体的有三种方法——Bagging、Boosting、Stacking。

Bagging方法是从训练集中抽样得到每个基模型所需要的子训练集，然后对所有基模型预测的结果进行综合，产生最终的预测结果，如下图所示。

2.随机森林

Bagging方法采用的是自助采样法 （Bootstrap sampling ),

即对于m个样本的原始训练集，每次先随机采集一个样本放入采样集，接着把该样本放回，也就是说下次采样时该样本仍有可能被采集到，这样采集m次，最终可以得到m 个样本的采样集。

由于是随机采样，因此每次的采样集和原始的训练集不同，和其他采样集也不同，这样就可以得到多个不同的弱学习器。

随机森林是对 Bagging方法的改进，其改进之处有两点:

（1） 基本学习器限定为决策树;

（2） 除了在 Bagging 的样本上加上扰动，在属性上也加上扰动，相当于在决策树学习的过程中引入了随机属性选择。

对基决策树的每个结点，先从该结点的属性集合中随机选择一个包含k个属性的子集,然后从这个子集中选择一个最优属性用于划分。

五、支持向量机

支持向量机简称SVM，是 Support Vector Machine 的缩写。SVM 是一种分类算法，在工业界和学术界都有广泛的应用。特别是针对数据集较小的情况下，往往其分类效果比神经网络好。涵盖的内容如下：
1.支持向量机的原理及松弛系数的作用；
2.支持向量机的核函数及常见核函数的对比；
3.scikit-learn中的支持向量机算法：
4.使用支持向量机来实现乳腺癌检测实例

1.算法原理

SVM 最大特点是能构造出最大间距的决策边界，从而提高分类算法的鲁棒性。

大间距分类算法

假设要对一个数据集进行分类 ，可以构造一个分隔线把圆形的点和方形的点分开。这个分隔线称为分隔超平面（Separating hyperplane ）。

从图中可以明显看出，实线的分隔线比虚线的分隔线更好，因为使用实线的分隔线进行分类时，离分隔线最近的点到分隔线上的距离更大，即 margin2 > marginl 这段

距离的两倍，称为 间距 （margin ）。那些离分隔超平面最近的点，称为支持向量（ support vector ）。为了达到最好的分类效果， SVM 的算法原理就是要找到 个分隔超平面，它能把数据集正确地分类，并且间距最大。

松弛系数

针对线性不可分的数据集，因为无法找到最大间距的分隔超平面，如下图所示。引入松弛系数。

从这里的描述可知，引入松弛系数类似于逻辑回归算法里的成本函数引入正则项，目的都是为了纠正过拟合问题，让支持向量机对噪声数据有更强的适应性 如图8-3右图所示，当出现 些违反大间距规则的噪声样本时，仍然希望我们的分隔超平面是原来的样子，这就是松弛系数的作用。

2.核函数

核函数是特征转换函数。

最简单的核函数

我们的任务是找出合适的w,b,使得由它们决定的分隔超平面、问距最大，且能正确地对数据集进行分类。间距最大是我们的优化目标，正确地对数据集进行分类是约束条件。

拉格朗日乘子法是解决约束条件下，求函数极值的理想方法。其方法是引入非负系数a来作为约束条件的权重：

六、朴素贝叶斯算法

朴素贝叶斯（ Naive Bayers ）是一种基于概率统计的分类方法。它在条件独立假设的基础上，使用贝叶斯定理构建算法，在文本处理领域有广泛的应用。从条件概率谈起，介绍了贝叶斯定理，帮助读者理解算法原理，接着介绍了概率分布及连续值的处理，最后通过一个文档分类的例子介绍了如何使用朴素贝叶斯算法。涵盖的内容如下：
1.条件概率及贝叶斯定理；
2.朴素贝叶斯算法原理；
3.多项式概率分布及高斯分布：
4.使用朴素贝叶斯处理文档分类实例

算法原理

要讲清楚算法原理，需要先清楚贝叶斯定理，它是一个条件概率公式。

朴素贝叶斯分类法

举例

假设有以下关于驾龄、均车速和性别的统计数据：

七、PCA 算法

PCA是Principal Component Analysis 的缩写，中文称为主成分分析法。它是一种维数约减（ Dimensionality Reduction ）算法，即把高维度数据在损失最小的情况下转换为低维度数据的算法。显然， PCA 可以用来对数据进行压缩，可以在可控的失真范围内提高运算速度。本章涵盖的内容如下：
1.PCA 算法的原理及运算步骤；
2.使用 Numpy 实现简化版的 PCA 算法，并与 scikit-learn 的结果进行比较：
3.PCA 的物理含义；
4.PCA 的数据还原率及应用；
5.通过一个人脸识别程序观察PCA 的重要作用实例

算法原理

当需要从n维数据降为k维数据时，需要找出k个向量

，把n维的数据投射到这k个向量决定的线性空间里，最终使投射误差最小化的过程。

如图所示，当这些二维数据在同一条直线上时，进行 PCA 运算后，误差为0。

假设有一个数据集，用mXn维的矩阵A表示。矩阵中每一行表示一个样本，表示一个特征，总共有m个样本， 每个样本有n个特征。我们的目标是减少特征个数，保留最重要的k个特征。

数据归一化和缩放

数据归一化和缩放是一种数学技巧，旨在提高 PCA 运算时的效率。数据归一化的目标是使特征的均值为0。数据归一化公式为：

当不同的特征值不在同一个数量级上的时候，还需要对数据进行缩放。数据归一化再缩放的公式为：

举例

假设我们的数据集总共有5个记录，每个记录有2个特征，这样构成的矩阵A为：

我们的目标是把二维数据降为一维数据。为了更好地理解 PCA 的计算过程，分别使Numpy 和sklearn对同一个数据进行 PCA 降维处理。

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

• 使用 Numpy 模拟 PCA 计算过程
  使用 Numpy 来模拟 PCA 降维的过程。首先需要对数据进行预处理：

A = np.array([[3, 2000], 
              [2, 3000], 
              [4, 5000], 
              [5, 8000], 
              [1, 2000]], dtype='float')

# 数据归一化
mean = np.mean(A, axis=0)
norm = A - mean
# 数据缩放
scope = np.max(norm, axis=0) - np.min(norm, axis=0)
norm = norm / scope
norm

由于两个特征的均值不在同一个数量级 ，我们同时对数据进行了缩放。

八、k-均值算法

k-均值算法是一种典型的无监督机器学习算法，用来解决聚类问题（ Clustering） 。这也是介绍的唯一一个无监督的学习算法 。但这并不意味着无监督机器学习不重要。相反，由于数据标记需要耗费巨大的资源，无监督或者半监督的学习算法近来逐渐受到学者
青睐，原因是不需要对数据进行标记，可以大大减少工作量。涵盖的内容如下:
1.k-均值算法的成本函数
2.k-均值算法的原理及计算步骤
3.通过一个简单的实例，介绍scikit-learn 均值算法
4.使用k-均值算法进行文本分类
5.聚类问题的性能评估方法

算法原理

k-均值算法，只给出一组无标记的数据集

，目标是找出这组数据的模式特征，如哪些数据是同种类型的，哪些数据是另外一种类型。典型的无监督式学习包括市场细分，即通过分析用户数据，把一个产品市场进行细分，找出细分人群。另 个是社交网络分析，分析社交网络中参与人员不同特点，根据特点区分出不同群体。这些都是无监督式学习里的聚类问题。

k-均值算法包含以下两个步骤。

（1）给聚类中心分配点。计算所有的训练样例，把每个训练样例分配到距离其最近的聚类中心所在的类别里

（2）移动聚类中心。新的聚类中心移动到这个聚类所有的点的平均值处

1.k-均值算法成本函数

根据成本函数的定义，成本即模型预测值与实际值的误差，据此不难得出k-均值算法的成本函数：

k-均值算法的成本函数的物理意义就是， 训练样例到其所属的聚类中心点的距离的平均值。

2.随机初始化聚类中心点

假设k是聚类的个数，m是训练样本的个数，那么必定有 k<m 。在随机初始化肘随机从m个训练数据集里选择k个样本作为聚类中心点。这是正式推荐的随机初始化聚类中心的做法。

在实际解决问题时，最终的聚类结果会和随机初始化的聚类中心点有关。即不同的随机初始化的聚类中心点可能得到不同的最终聚类结果。因为成本函数可能会收敛在一个局部最优解，而不是全局最优解上。有一个解决方法就是多做几次随机初始化的动作，然后

练出不同的聚类中心点及聚类节点分配方案，然后用这些值算出成本函数，从中选择成本最小的那个函数。

3.选择聚类的个数

怎样选择合适的聚类 ？实际上聚类个数和业务有紧密关联，例如我们要对运动鞋的尺码大小进行聚类分析， 那么是分成5个尺寸等级好还是分 10 尺寸等级好呢？这是个业务问题而非技术问题。5个尺寸等级可以给生产和销售带来便利，但客户体验可能不好；10 个尺寸等级客户体验好了，可能会给生产和库存造成不便。
从技术角度来讲，也有一些方法可以用来做一些判断的。我们可以把聚类个数作为横坐标，成本函数作为纵坐标，把成本和聚类个数的数据画出来。大体的趋势是随着k值越来越大，成本会越来越低。我们找出一个拐点，即在这个拐点之前成本下降比较快，在这拐点之后，成本下降比较慢，那么很可能这个拐点所在的k值就是要寻求 最优解。
当然，这个技术方法并不总是有效的，因为很可能会得到一个没有拐点的曲线，这样，就必须和 务逻辑结合以便选择合适的聚类个数。