使用近邻算法评估模型精确性

• 1  概念
  • 1.1  近邻算法
• 2  使用scikit-learn
  • 2.1  引入各种包
  • 2.2  获取数据集
  • 2.3  数据集拆分
  • 2.4  调用fit()对训练集进行训练
  • 2.5  调用predict()对测试集评估效果
  • 2.6  交叉检验
  • 2.7  调参
• 3  数据预处理
  • 3.1  预处理范畴
  • 3.2  预处理示例
  • 3.3  标准预处理
• 4  流水线

概念

• 估计器（Estimator）：用于分类、聚类和回归分析
• 转换器（Transformer）：用于数据预处理和数据转换
• 流水线（Pipeline）：组合数据挖掘流程，便于再次使用

近邻算法

• 是标准数据挖掘算法中最为直观的一种
• 它计算数据集中每两个个体之间的距离，然后将当前个体划归到最邻近的类别当中
• 距离度量
  • 距离是数据挖掘的核心概念之一
  • 计算距离的方法
    • 欧氏距离：两个特征向量长度平方和的平方根
      • 欧氏距离确实很直观，但是如果某些特征比其他特征取值大很多，精确度就会比较差
    • 曼哈顿距离：两个特征在标准坐标系中绝对轴距之和（没有使用平方距离）
      • 异常值也会影响分类结果，但是其所受的影响要比欧氏距离小得多
    • 余弦距离：特征向量夹角的余弦值
      • 更适合解决异常值和数据稀疏问题
• 采用哪种距离度量方法对最终结果有很大影响
• 本文使用欧氏距离

使用scikit-learn

引入各种包

• 为实现分类算法， scikit-learn 把相关功能封装成所谓的估计器
• 估计器用于分类任务，它主要包括以下两个函数。
  • fit()
    • 训练算法，设置内部参数。该函数接收训练集及其类别两个参数
  • predict()
    • 参数为测试集。预测测试集类别，并返回一个包含测试集各条数据类别的数组
• 大多数 scikit-learn 估计器接收和输出的数据格式均为 numpy 数组或类似格式
• scikit-learn 提供了大量估计器，其中有支持向量机（SVM）、随机森林、神经网络等，本文使用 scikit-learn 中的近邻算法

# 拆分数据集为训练集和测试集
from sklearn.model_selection import train_test_split
# 导入 K近邻分类器库，该算法默认选择5个近邻作为分类依据
# 可大体上保证切分后得到的子数据集中类别分布相同，以避免某些子数据集出现类别分布失衡的情况
from sklearn.neighbors import KNeighborsClassifier
# 导入 交叉检验方法库， 默认使用 Stratified K Fold 方法切分数据集
from sklearn.model_selection import cross_val_score
# 可用 MinMaxScaler 类进行基于特征的规范化
from sklearn.preprocessing import MinMaxScaler
# 用于创建流水线
from sklearn.pipeline import Pipeline

%matplotlib inline
from matplotlib import pyplot as plt 

import os
import numpy as np
import csv
data_folder = os.path.expanduser("~")

# 组合文件路径，不过本文使用相对路径，所以注释掉
# data_filename = os.path.join(data_folder, "03_DataMiner/rawdata","ionosphere.data")
data_filename = 'rawdata/ionosphere.data'

获取数据集

• 创建Numpy数组 X 和 y 存放数据集

X = np.zeros((351, 34), dtype='float')
y = np.zeros((351,), dtype='bool')

X

array([[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.]])

y[:5]

array([False, False, False, False, False])

with open(data_filename, 'r') as input_file:
    reader = csv.reader(input_file)
    # 遍历文件中的每一行数据
    for i, row in enumerate(reader):
        # 获取每一个个体的前34个值，将其强制转化为浮点型
        data = [float(datum) for datum in row[:-1]]
        X[i] = data
        # 获取每个个体最后一个表示类别的值，把字母转化为数字，如果类别为“g”，值为1，否则值为0
        y[i] = row[-1] == 'g'

X

array([[ 1.     ,  0.     ,  0.99539, ..., -0.54487,  0.18641, -0.453  ],
       [ 1.     ,  0.     ,  1.     , ..., -0.06288, -0.13738, -0.02447],
       [ 1.     ,  0.     ,  1.     , ..., -0.2418 ,  0.56045, -0.38238],
       ...,
       [ 1.     ,  0.     ,  0.94701, ...,  0.00442,  0.92697, -0.00577],
       [ 1.     ,  0.     ,  0.90608, ..., -0.03757,  0.87403, -0.16243],
       [ 1.     ,  0.     ,  0.8471 , ..., -0.06678,  0.85764, -0.06151]])

y[:5]

array([ True, False,  True, False,  True])

数据集拆分

X_train, X_test, y_train, y_test = train_test_split(
      X
    , y
    , random_state=14
)
print("There are {} training samples".format(y_train.shape))
print("There are {} testing samples".format(y_test.shape))

There are (263,) training samples
There are (88,) testing samples

X_train

array([[ 0.     ,  0.     ,  1.     , ...,  0.     ,  0.     ,  0.     ],
       [ 1.     ,  0.     ,  1.     , ..., -0.26284,  0.64207, -0.39487],
       [ 0.     ,  0.     ,  0.     , ...,  0.     ,  0.     ,  0.     ],
       ...,
       [ 1.     ,  0.     ,  1.     , ...,  0.18897,  0.56167,  0.1518 ],
       [ 1.     ,  0.     ,  0.76046, ...,  0.01484,  0.63887,  0.01525],
       [ 1.     ,  0.     ,  0.99449, ..., -0.25741,  0.76586, -0.27794]])

y_train[:5]

array([False,  True, False, False, False])

X_test

array([[ 1.     ,  0.     ,  1.     , ...,  0.32492,  1.     ,  0.46712],
       [ 1.     ,  0.     ,  1.     , ..., -0.06288, -0.13738, -0.02447],
       [ 1.     ,  0.     ,  0.99025, ..., -0.80278,  0.49195, -0.83245],
       ...,
       [ 1.     ,  0.     ,  0.83367, ..., -0.51206,  0.64662, -0.30075],
       [ 0.     ,  0.     ,  1.     , ..., -1.     , -1.     ,  1.     ],
       [ 1.     ,  0.     ,  1.     , ...,  0.72688,  0.0699 ,  0.71444]])

y_test[:5]

array([ True, False,  True,  True,  True])

调用fit()对训练集进行训练

# 为 K近邻分类器 初始化一个实例
# 其中参数 n_neighbors 表示：选取多少个近邻作为预测依据
estimator = KNeighborsClassifier()

# 用训练数据进行训练
estimator.fit(X_train, y_train)

KNeighborsClassifier()

调用predict()对测试集评估效果

# 用测试集测试算法，评估它在测试集上的表现
y_predicted = estimator.predict(X_test)
print(y_predicted)
accuracy = np.mean(y_test == y_predicted) * 100
print("The accuracy is {0:.1f}%".format(accuracy))

[ True  True  True  True  True False  True False  True  True  True  True
  True  True False False  True False False  True  True  True  True False
  True  True  True  True  True  True  True  True  True False False  True
  True  True  True  True  True False  True False  True  True  True  True
 False  True  True  True  True  True False  True  True  True  True  True
 False  True  True  True  True  True  True  True False False False  True
  True False  True  True  True False False  True False  True  True False
  True  True False  True]
The accuracy is 86.4%

交叉检验

• 解决一次性测试所带来的问题(偶然性)
• 每次切分时，都要保证这次得到的训练集和测试集与上次不一样，还要确保每条数据都只能用来测试一次
• 算法描述
  • (1) 将整个大数据集分为几个部分
  • (2) 对于每一部分执行以下操作
    • 将其中一部分作为当前测试集
    • 用剩余部分训练算法
    • 在当前测试集上测试算法
  • (3) 记录每次得分及平均得分
  • (4) 在上述过程中，每条数据只能在测试集中出现一次，以减少（但不能完全规避）运气成分

# 传入完整的数据集和类别值
scores = cross_val_score(
      estimator
    , X
    , y
    , scoring='accuracy'
)
# 取均值
average_accuracy = np.mean(scores) * 100
print("The average accuracy is {0:.1f}%".format(average_accuracy))

The average accuracy is 82.6%

调参

• 增强算法的泛化能力
• 选取好的参数值跟数据集的特征息息相关
• 近邻算法有多个参数（ n_neighbors ），最重要的是选取多少个近邻作为预测依据
  • n_neighbors 过小，分类结果容易受干扰，随机性很强
  • n_neighbors 过大，实际近邻的影响将削弱
• 实践
  • 测试一系列 n_neighbors 的值，比如从1到50，可以重复进行多次实验，观察不同的参数值所带来的结果之间的差异

avg_scores = []
all_scores = []

parameter_values = list(range(1, 51)) # Include 50

for n_neighbors in parameter_values:
    estimator = KNeighborsClassifier(n_neighbors = n_neighbors)
    scores = cross_val_score(
          estimator
        , X
        , y
        , scoring='accuracy'
    )
    avg_scores.append(np.mean(scores))
    all_scores.append(scores)
print('avg_scores is: ', avg_scores[:5], '\n')
print('all_scores is: ', all_scores[:5])

avg_scores is:  [0.8432997987927566, 0.8718712273641852, 0.8318712273641851, 0.8432997987927567, 0.8261971830985916] 

all_scores is:  [array([0.84507042, 0.78571429, 0.82857143, 0.91428571, 0.84285714]), array([0.84507042, 0.81428571, 0.84285714, 0.94285714, 0.91428571]), array([0.84507042, 0.74285714, 0.78571429, 0.92857143, 0.85714286]), array([0.84507042, 0.77142857, 0.8       , 0.92857143, 0.87142857]), array([0.83098592, 0.77142857, 0.8       , 0.88571429, 0.84285714])]

#  n_neighbors 的不同取值和分类正确率之间的关系
# 参数为近邻数和平均正确率
plt.plot(
      parameter_values
    , avg_scores
    , '-o'
)

[<matplotlib.lines.Line2D at 0x7fca3dea27f0>]

• 整体趋势是随着近邻数的增加，正确率不断下降

数据预处理

• 异常值会影响近邻算法，不同算法对值域大小的敏感度不同

预处理范畴

• （1）选择最具区分度的特征
• （2）创建新特征
• scikit-learn 的预处理工具
  • 转换器 Transformer
    • 接受原始数据集，返回转换后的数据集
    • 还可用来抽取特征

预处理示例

X_broken = np.array(X)
X_broken

array([[ 1.     ,  0.     ,  0.99539, ..., -0.54487,  0.18641, -0.453  ],
       [ 1.     ,  0.     ,  1.     , ..., -0.06288, -0.13738, -0.02447],
       [ 1.     ,  0.     ,  1.     , ..., -0.2418 ,  0.56045, -0.38238],
       ...,
       [ 1.     ,  0.     ,  0.94701, ...,  0.00442,  0.92697, -0.00577],
       [ 1.     ,  0.     ,  0.90608, ..., -0.03757,  0.87403, -0.16243],
       [ 1.     ,  0.     ,  0.8471 , ..., -0.06678,  0.85764, -0.06151]])

# 每隔一行，就把第二个特征的值除以10
# “::”是用于定义逆序,但是新版python已不使用
X_broken[:,::2] /= 10
X_broken

array([[ 0.1     ,  0.      ,  0.099539, ..., -0.54487 ,  0.018641,
        -0.453   ],
       [ 0.1     ,  0.      ,  0.1     , ..., -0.06288 , -0.013738,
        -0.02447 ],
       [ 0.1     ,  0.      ,  0.1     , ..., -0.2418  ,  0.056045,
        -0.38238 ],
       ...,
       [ 0.1     ,  0.      ,  0.094701, ...,  0.00442 ,  0.092697,
        -0.00577 ],
       [ 0.1     ,  0.      ,  0.090608, ..., -0.03757 ,  0.087403,
        -0.16243 ],
       [ 0.1     ,  0.      ,  0.08471 , ..., -0.06678 ,  0.085764,
        -0.06151 ]])

标准预处理

• 使用 MinMaxScaler 类进行基于特征的规范化，把特征值转变到0到1之间

estimator = KNeighborsClassifier()

original_scores = cross_val_score(
      estimator
    , X
    , y
    , scoring='accuracy'
)

print("The original average accuracy for is{0:.1f}%".format(np.mean(original_scores) * 100))

broken_scores = cross_val_score(
      estimator
    , X_broken
    , y
    , scoring='accuracy'
)
print("The 'broken' average accuracy for is {0:.1f}%".format(np.mean(broken_scores) * 100))

The original average accuracy for is82.6%
The 'broken' average accuracy for is 73.8%

• 表示
  • 在原始数据集上的正确率为82.6%
  • 经过 X_broken[:,::2] /= 10 处理后的数据集，正确率跌至73.8% -但是
  • 把特征值转变到0到1之间就能解决这个问题

estimator = KNeighborsClassifier()

# MinMaxScaler 直接调用 fit_transform() 函数，即可完成训练和转换
# X_transformed 与 X 行列数相等，为同型矩阵
# X_transformed 每列值的值域为0到1
X_transformed = MinMaxScaler().fit_transform(X_broken)

transformed_scores = cross_val_score(
      estimator
    , X_transformed
    , y
    , scoring='accuracy'
)
print("The average accuracy for is {0:.1f}%".format(np.mean(transformed_scores) * 100))

The average accuracy for is 82.9%

• 正确率再次升到82.9%

• 其他规范化方法
  • 为使每条数据各特征值的和为1，使用 sklearn.preprocessing.Normalizer
  • 为使各特征的均值为0，方差为1，使用 sklearn.preprocessing.StandardScaler ，常用作规范化的基准
  • 为将数值型特征的二值化，使用 sklearn.preprocessing.Binarizer ，大于阈值的为1，反之为0

流水线

• 需要流水线的原因
  • 操作的复杂程度逐步提高
  • 我们可能需要
    • 切分数据集
    • 对特征进行二值化处理
    • 以特征或数据集中的个体为基础规范化数据
    • 其他可能需要的各种操作
• 要跟踪记录所有这些操作不容易，如果中间出点问题，先前实验的结果将很难再现
  • 常见问题
    • 落下步骤
    • 数据转换错误
    • 进行了不必要的转换操作
    • 其他
  • 另一个问题就是代码的先后顺序
• 步骤
  • (1) 用 MinMaxScaler 将特征取值范围规范到0~1
    • 第一步叫作规范特征取值（scale）
  • (2) 指定 KNeighborsClassifier 分类器
    • 第二步叫作预测（predict）
  • 每一步都用元组（‘名称’，步骤）来表示。现在来创建流水线
• 流水线把这些步骤保存到数据挖掘的工作流中
• 可以在 cross_val_score 等接收估计器的函数中使用流水线

# 流水线的核心是 元素为元组的列表
# 每一步都用元组（‘名称’，步骤）来表示
scaling_pipeline = Pipeline(
    [
          ('scale', MinMaxScaler())
        , ('predict', KNeighborsClassifier())
    ]
)

scores = cross_val_score(
      scaling_pipeline
    , X_broken
    , y
    , scoring='accuracy'
)
print("The pipeline scored an average accuracy for is {0:.1f}%".format(np.mean(transformed_scores) * 100))

The pipeline scored an average accuracy for is 82.9%

• 运行结果跟之前一样（82.9%），表明本次用到的步骤跟之前相同