[自学笔记]使用scikit-learn机器学习分类器

获取数据

以鸢尾花数据集为例

from sklearn import datasets
import numpy as np

iris = datasets.load_iris()  # 获取数据
X = iris.data[:, [2, 3]]   
y = iris.target    

print('Class labels:', np.unique(y))

  其中np.unique方法返回一个排序后的数组，去重、升序
  而此处np.unique(y)将返回的三个独立分类标签存储在iris.target，以整数(0, 1, 2)分别存储Iris-setosa、Iris-versicolor和Iris-virginica标签
输出：

Class labels: [0, 1, 2]

拆分数据

获取数据后，我们需要按一定比例将数据分成训练集和测试集

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=1, stratify=y)

  这里使用train_test_split方法，按测试集0.3的比例分配。
  random_state是随机数种子，可以用来复盘。
  stratify是分类依据，比如y中有两种目标数据A和B，那么返回的训练集和测试集中的A与B的比例会尽量接近。

  我们可以用NumPy中的bincount函数来统计一下数组中每个值的出现次数：

print('Labels count in y:', np.bincount(y))
print('Labels count in y_train:', np.bincount(y_train))
print('Labels count in y_test:', np.bincount(y_test))

Labels count in y: [50 50 50]
Labels count in y_train: [35 35 35]
Labels count in y_test: [15 15 15]

标准化

  和感知器一样，对数据进行标准化$x^{\prime }=\frac{x-\mu }{\sigma }$
  我们用sklearn.preprocessing模块中的StandardScaler类来实现

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()   # 实例化
sc.fit(X_train)		# 使用训练集拟合sc,让sc学习X_train的均值和标准差
print(sc.mean_)		# 获取均值
print(sc.scale_)	# 获取标准差
X_train_std = sc.transform(X_train) 	# 进行标准化
X_test_std = sc.transform(X_test)

OvR方法

  全称一对其余方法
  OvR方法的基本思想是，对于N类分类问题，我们将问题分解为N个二分类问题来解决。
  scikit-learn中的大多数算法默认支持多类分类，允许把三类花的数据同时提交给感知器

from sklearn.linear_model import Perceptron

# 创建一个二分类感知器
ppn = Perceptron(eta0=0.1, random_state=1)
# 拟合数据
ppn.fit(X_train_std, y_train)

# 评估性能
y_pred = ppn.predict(X_test_std)
# 输出预测错误的样本数量
print('Misclassified examples: %d' % (y_test != y_pred).sum())

# 输出感知器的分类准确率
from sklearn.metrics import accuracy_score
print('Accuracy: %.3f' % accuracy_score(y_test, y_pred))
# 或者
print('Misclassified examples: %d' % (y_test != y_pred).sum())

绘制

可视化区分不同花朵样本，用圆圈来突出显示来自测试集的样本

from matplotlib.colors import ListedColormap
import matplotlib.pyplot as plt

# To check recent matplotlib compatibility
import matplotlib
from distutils.version import LooseVersion

def plot_decision_regions(X, y, classifier, test_idx=None, resolution=0.02):

    """
    绘制分类器的决策区域。

    参数:
    X (array-like): 特征矩阵。
    y (array-like): 目标标签。
    classifier (分类器模型): 已训练的分类器，用于绘制决策区域。
    test_idx (array-like, 可选): 测试集的索引，用于在图中高亮显示。
    resolution (float, 可选): 绘制决策区域时网格的分辨率。
    """
	# 定义标记类型和颜色映射，基于类别数量
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])  # 根据类别数量生成颜色映射

    # 创建覆盖整个数据范围的网格
    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
                           np.arange(x2_min, x2_max, resolution))
                           
	# 为网格上的每个点预测类标签
    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    
    # 绘制决策区域
    plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

	# 绘制训练样本，根据类别着色
    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y == cl, 0], 
                    y=X[y == cl, 1],
                    alpha=0.8, 		# 样本点的透明度
                    color=colors[idx],		# 颜色
                    marker=markers[idx], 	# 标记类型
                    label=cl, 		# 图例标签
                    edgecolor='black')		# 边框颜色

    # 如果提供了测试集索引，高亮显示测试样本
    if test_idx:
        # plot all examples
        X_test, y_test = X[test_idx, :], y[test_idx]
        # 检查matplotlib版本，以确保散点图的兼容性
        if LooseVersion(matplotlib.__version__) < LooseVersion('0.3.4'):
            plt.scatter(X_test[:, 0],
                        X_test[:, 1],
                        c='',
                        edgecolor='black',
                        alpha=1.0,
                        linewidth=1,
                        marker='o',
                        s=100, 
                        label='test set')
        else:
            plt.scatter(X_test[:, 0],
                        X_test[:, 1],
                        c='none',		# 透明颜色
                        edgecolor='black',
                        alpha=1.0,
                        linewidth=1,
                        marker='o',
                        s=100, 
                        label='test set')  
# 设置坐标轴标签
X_combined_std = np.vstack((X_train_std, X_test_std))
y_combined = np.hstack((y_train, y_test))
plot_decision_regions(X=X_combined_std, y=y_combined,
                      classifier=ppn, test_idx=range(105, 150))
plt.xlabel('petal length [standardized]')
plt.ylabel('petal width [standardized]')
plt.legend(loc='upper left')

# 调整布局，可选择保存图片
plt.tight_layout()
#plt.savefig('images/03_01.png', dpi=300)
plt.show()

  np.vstack用于垂直堆叠数组，即按行（第一轴）将数组连接在一起。
  具体来说，X_train_std 和 X_test_std 应当是两个形状相似的二维数组（或者矩阵），它们的列数（第二轴的长度）必须相等。X_train_std 通常包含了训练集数据的标准化特征，而 X_test_std 包含了测试集数据的标准化特征。
  通过 np.vstack，X_train_std 和 X_test_std 被组合成了一个新的二维数组，该数组的第一部分是 X_train_std 的所有行，紧接着是 X_test_std 的所有行。结果数组 X_combined_std 将拥有 X_train_std 和 X_test_std 的所有行，列是不变的。

  np.hstack 函数，它与 vstack 类似，但用于水平堆叠数组，即按列（第二轴，对于一维数组来说，就是沿着唯一的轴）连接数组。
  在机器学习的上下文中，y_train 和 y_test 分别代表训练集和测试集的目标（或标签）值。假设 y_train 和 y_test 都是一维数组，其中分别包含了训练集和测试集的标签信息。使用 hstack 后，y_train 和 y_test 将被连接成一个新的一维数组 y_combined，这个数组包含了所有训练和测试样本的标签，顺序保持不变。

效果展示