常见的分类算法
感知机
感知机是神经网络以及支持向量机的基础。通过w*x + b = 0这样一条直线将二维空间划分为两个区域，落在这两个区域中的点被归为正类和负类。
感知机的学习策略是通过极小化下面的损失函数来选取最终的直线：
该损失函数表达的含义是误分类点到分离平面的总距离和。也就是说，误分类点越少越好，误分类点离分离平面的总距离和越小越好。
实现感知机分类模型：
先导入一个示例数据集，然后画出该数据集的图像。
In [1]: from matplotlib import pyplot as plt
In [2]: import pandas as pd
In [3]: data = pd.read_csv("two_class_data.csv", header=0)
In [4]: x = data['x']
In [5]: y = data['y']
In [6]: c = data['class']
In [7]: plt.scatter(x, y, c=c)
Out[7]:
In [8]: plt.show()
可以看到这个数据集是一个拥有明显二分类特征的数据集。
然后使用Scikit-learn提供的感知机方法来对上面的数据集进行分类效果测试。
In [1]: from matplotlib import pyplot as plt
In [2]: import pandas as pd
In [3]: from sklearn.model_selection import train_test_split
In [4]: from sklearn.linear_model import Perceptron
In [5]: # 导入数据
In [6]: data = pd.read_csv("two_class_data.csv", header=0)
In [7]: # 定义特征变量和目标变量
In [8]: feature = data[['x', 'y']].values
In [9]: target = data['class'].values
In [10]: # 对数据集进行切分，70%为训练集，30%为测试集。
In [13]: x_train, x_test, y_train, y_test = train_test_split(feature, target, test_size=0.3, random_state=50)
In [14]: # 构建模型
In [15]: model = Perceptron()
In [16]: # 训练模型
In [18]: model.fit(x_train, y_train)
C:\Users\yc\Anaconda3\lib\site-packages\sklearn\linear_model\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.
"and default tol will be 1e-3." % type(self), FutureWarning)
Out[18]:
Perceptron(alpha=0.0001, class_weight=None, eta0=1.0, fit_intercept=True,
max_iter=None, n_iter=None, n_jobs=1, penalty=None, random_state=0,
shuffle=True, tol=None, verbose=0, warm_start=False)
In [19]: # 预测
In [20]: results = model.predict(x_test)
In [21]: # 以默认样式绘制训练数据
In [22]: plt.scatter(x_train[:, 0], x_train[:, 1], alpha=0.3)
Out[22]:
In [23]: # 以方块样式绘制测试数据
In [24]: plt.scatter(x_test[:, 0], x_test[:, 1], marker=',', c=y_test)
Out[24]:
In [25]: # 将预测结果用标签样式标注在测试数据左上方
In [26]: for i, txt in enumerate(results):
...: plt.annotate(txt, (x_test[:, 0][i], x_test[:, 1][i]))
...:
In [27]: plt.show()
测试集中有两个数据被错误分类。绿色的方框被标记为了C2。
还可以导出分类评估的数据：
In [29]: print(model.score(x_test, y_test))
0.990196078431
这里如此高的分类正确率，很大程度上是因为示例数据很好。感知机作为一种十分基础的方法，在实际数据分类和预测中并不常用。因为，实战过程中的数据肯定没有示例数据呈现出的线性可分性。
这并不意味着感知机不重要。理解感知机，可以更好地理解后面的支持向量机算法和神经网络算法。
支持向量机（SVM）
支持向量机是一种非常常用的，适用性非常广的分类方法。与感知机不同的是，支持向量机不仅可以用于线性分类，还可以用于非线性分类。支持向量机引入了最大间隔的思想来划定分割平面。
通过支持向量机来重新对刚刚使用过的感知机的数据进行分类：
只需要更改两行代码，分别是导入支持向量机SVC和使用SVC构建模型。
In [30]: from matplotlib import pyplot as plt
In [31]: import pandas as pd
In [32]: from sklearn.model_selection import train_test_split
In [33]: from sklearn.svm import SVC
In [34]: data = pd.read_csv("two_class_data.csv", header=0)
In [35]: # 定义特征变量和目标变量
In [36]: feature = data[['x', 'y']].values
In [37]: target = data['class'].values
In [38]: # 对数据集进行切分，70%为训练集，30%为测试集。
In [39]: x_train, x_test, y_train, y_test = train_test_split(feature, target, test_s
...: ize=0.3, random_state=50)
In [40]: # 构建模型
In [41]: model = SVC()
In [42]: # 训练模型
In [43]: model.fit(x_train, y_train)
Out[43]:
SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)
In [44]: # 预测
In [45]: results = model.predict(x_test)
In [46]: # 以默认样式绘制训练数据
In [47]: plt.scatter(x_test[:, 0], x_test[:, 1], marker=',', c=y_test)
Out[47]:
In [48]: # 将预测结果用标签样式标注在测试数据左上方
In [49]: for i, txt in enumerate(results):
...: plt.annotate(txt, (x_test[:, 0][i], x_test[:, 1][i]))
...:
In [50]: plt.show()
测试结果如下图：
正确率已经达到100%。
除了线性分类，支持向量机还通过引入核函数来解决非线性分类的问题。
在将特征映射到高维空间的过程中，常常会用到多种核函数，包括：线性核函数，多项式核函数，高斯经向基核函数等。其中最常用的就是高斯径向基核函数，也简称为RBF核。
通过支持向量机完成一个非线性分类的任务。
zoo.csv叫动物园数据集，总共有18列，第一列为动物名称，最后一列为动物分类。
数据集中间的16列为动物特征，比如：是否有毛发，是否下蛋。除了腿的数量为数值型，其余特征列均为布尔型数据。数据集中的动物共有7类，通过最后一列的数字表示。
用支持向量机完成这个非线性分类任务。导入csv文件。定义其中16列为特征，最后一列为目标值。
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.decomposition import PCA
data = pd.read_csv("zoo.csv", header=0)
feature = data.iloc[:, 1:17].values
target = data['type'].values
x_train, x_test, y_train, y_test = train_test_split(feature, target, test_size=0.3, random_state=50)
model = SVC()
model.fit(x_train, y_train)
result = model.predict(x_test)
print(model.score(x_test, y_test))
测试集的正确分类率为0.867
0.866666666667
16个特征参与运算，但得出的正确率并不高。主要原因为数据集太小了，才100行。
由于存在16个特征，所以无法进行可视化，有一种叫作PCA`降维的方法，它的作用是缩减特征的数量，从而更方便可视化呈现。
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.decomposition import PCA
data = pd.read_csv("zoo.csv", header=0)
feature = data.iloc[:, 1:17].values
target = data['type'].values
pca = PCA(n_components=2)
feature_pca = pca.fit_transform(feature)
x_train, x_test, y_train, y_test = train_test_split(feature_pca, target, test_size=0.3, random_state=50)
model = SVC()
model.fit(x_train, y_train)
results = model.predict(x_test)
print(model.score(x_test, y_test))
plt.scatter(x_train[:, 0], x_train[:, 1], alpha=0.3)
plt.scatter(x_test[:, 0], x_test[:, 1], marker=',', c=y_test)
for i, txt in enumerate(results):
plt.annotate(txt, (x_test[:, 0][i], x_test[:, 1][i]))
plt.show()
当特征降为2维时，就可以通过平面图画出来了。
0.833333333333
这里得出的准确度变成了0.833，比之前的0.867还要低。原因是特征数量减少了，影响了准确度。
K - 近邻法（KNN）
k 近邻时一种十分常用的分类方法。KNN中的三个关键要素：
1.K值的大小。K值一般通过测试数据交叉验证来选择。
2.距离的度量。新数据与最近邻数据之间的距离计算方式，有欧式距离或者曼哈顿距离等。
3.分类决策规则。KNN的决策规则为多数表决，即新数据属于圆圈中占比最大的一类。
使用一个由3种类别构成的数据集测试，并将KNN的决策边界绘制出来。
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
data = pd.read_csv('c:/Users/yc/Desktop/data05/three_class_data.csv', header=0)
feature = data[['x', 'y']].values
target = data['class'].values
x_train, x_test, y_train, y_test = train_test_split(feature, target, test_size=0.3, random_state=50)
model = KNeighborsClassifier()
model.fit(x_train, y_train)
results = model.predict(x_test)
print(model.score(x_test, y_test))
# 绘制决策边界等高线图
cm0 = plt.cm.Oranges
cm1 = plt.cm.Greens
cm2 = plt.cm.Reds
cm_color = ListedColormap(['red', 'yellow'])
x_min, x_max = data['x'].min() - .5, data['x'].max() + .5
y_min, y_max = data['y'].min() - .5, data['y'].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, .1),
np.arange(y_min, y_max, .1))
Z0 = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 0]
Z1 = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z2 = model.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 2]
Z0 = Z0.reshape(xx.shape)
Z1 = Z1.reshape(xx.shape)
Z2 = Z2.reshape(xx.shape)
plt.contourf(xx, yy, Z0, cmap=cm0, alpha=.9)
plt.contourf(xx, yy, Z1, cmap=cm0, alpha=.5)
plt.contourf(xx, yy, Z2, cmap=cm0, alpha=.4)
# 绘制训练集和测试集
plt.scatter(x_train[:, 0], x_train[:, 1], c=y_train, cmap=cm_color)
plt.scatter(x_test[:, 0], x_test[:, 1], c=y_test, cmap=cm_color, edgecolors='black')
plt.show()
由于示例数据集界线清晰，所以分类的正确率为100%。KNN的决策边界：
图中，颜色越深的地方代表属于某一类别的可能性越高。
决策树和随机森林
除了支持向量机和KNN之外，决策树和随机森林也是非常不错的分类方法。
在决策分析中，可以用决策树形象地展示决策过程，而决策数中，就是类似于if-then规则的集合。
在用决策进行分类时，从跟节点出发，对实例的特征进行测试，然后将其分别分给不同的子节点。然后对子节点重复上面的步骤，最终所有的实例被分给叶节点中。
执行决策树算法，一般分为三步：
1. 特征选项。
特性选择及选择判断规则。一般情况下，依据3种指标来选择特征，分别是信息增益，信息增益比，以及基尼指数。
其中依据增益来选择特征，是一种来源于信息论和概率统计中的方法。通过判断某一特征对决策树前后影响的信息差值，从而选出最关键的特征。这种依据信息增益来选择特征的算法，也被称作ID3算法。
信息增益在划分训练数据特征时，容易偏向取值较多的特征。于是改进了 ID3 算法，通过信息增益比值来选择，发展出了 C4.5 算法。除此之外，还有一种叫 CART 的生成算法，它利用了基尼指数最小化的原则。
2. 数的生成。
选择完特征之后，通过这些特征来生成一颗完整的决策树。生成的原则是，所有训练数据都能分配到相应的叶节点。
3. 数的剪枝。
一颗完整的决策树，使得训练数据得到有效的划分。但是完整的决策树往往对于测试数据的效果并不好。因为出现了过度拟合的问题。过度拟合，指模型对训练数据的效果很好，但是对测试数据的效果差，泛化能力较弱。
解决决策树过度拟合的方法是对决策树进行剪枝。剪枝，也就是去掉一些叶节点。剪枝并不是随意乱剪，它的依据是，剪枝前和剪枝后的决策树整体损失函数最小。
对于决策树的演示，用到了著名的鸢尾花 iris 数据集。
iris是机器学习领域一个非常经典的分类数据集，它总共包含150行数据。每一行数据由4 个特征值及一个目标值组成。其中 4` 个特征值分别为：萼片长度、萼片宽度、花瓣长度、花瓣宽度。而目标值及为三种不同类别的鸢尾花，分别为：Iris Setosa，Iris Versicolour，Iris Virginica。
iris 数据集无需导入 csv 文件，作为常用的基准数据集之一，sklearn 提供了相应的导入方法。输出数据看一看。
from sklearn import datasets
# 载入数据集
iris = datasets.load_iris()
print(iris.data, iris.target)
部分输出：
[[ 5.1 3.5 1.4 0.2]
[ 4.9 3. 1.4 0.2]
[ 4.7 3.2 1.3 0.2]
[ 4.6 3.1 1.5 0.2]
[ 5. 3.6 1.4 0.2]
[ 5.4 3.9 1.7 0.4]
[ 4.6 3.4 1.4 0.3]
[ 5. 3.4 1.5 0.2]
········
[ 6.2 3.4 5.4 2.3]
[ 5.9 3. 5.1 1.8]] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2]
构建 iris 分类决策树。
from sklearn.datasets import load_iris
from sklearn import tree
import graphviz
# 导入数据
iris = load_iris()
# 建立模型
model = tree.DecisionTreeClassifier()
# 模拟训练
clf = model.fit(iris.data, iris.target)
完成模型训练，就建立起一颗决策树了。通过 graphviz 模块，将决策树绘制出来。
from sklearn.datasets import load_iris
from sklearn import tree
# 导入数据
iris = load_iris()
# 建立模型
model = tree.DecisionTreeClassifier()
# 模拟训练
clf = model.fit(iris.data, iris.target)
dot_data = tree.export_graphviz(clf, out_file=None,
feature_names=iris.feature_names,
class_names=iris.target_names,
filled=True,rounded=True,
special_characters=True)
graph = graphviz.Source(dot_data)
graph
随机森林与决策树不同的地方在于，它不只是一棵树，而是建立一堆树。与决策树不同，随机森林每次只从全部数据集中随机抽取一部分数据用于生成树。随机森林在生成树的时候不会剪枝。
随机森林优点很多，它可以处理大量的数据；可以在特征不均衡时，依然维持较高的准确度；随机森林学习速度快，一般情况下，比单纯应用决策树要好。
使用随机森林和决策树算法针对上面的 iris 数据集进行分类，比较准确度。
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
# 导入数据
iris = load_iris()
x_train = iris.data[:120]
x_test = iris.data[120:]
y_train = iris.target[:120]
y_test = iris.target[120:]
# 建立模型
model_tree = DecisionTreeClassifier(random_state=10)
model_random = RandomForestClassifier(random_state=10)
# 训练模型并验证
model_tree.fit(x_train, y_train)
s1 = model_tree.score(x_test, y_test)
model_random.fit(x_train, y_train)
s2 = model_random.score(x_test, y_test)
print('DecisionTree:', s1)
print('RandomForest:', s2)
结果显示，随机森林的正确分类率比决策数高 10 个百分点。
DecisionTree: 0.7333333333333333
RandomForest: 0.8333333333333334