《深度学习与图像识别：原理与实践》—3.4　模型参数调优

3.4　模型参数调优

机器学习方法（深度学习是机器学习中的一种）往往涉及很多参数甚至超参数，因此实践过程中需要对这些参数进行适当地选择和调整。本节将以KNN为例介绍模型参数调整的一些方法。这里的方法不局限于图像识别，属于机器学习通用的方法。本节的知识既可以完善读者的机器学习知识体系，也可以帮助读者在未来的实践中更快、更好地找到适合自己模型和业务问题的参数。当然如果你比较急切地想了解图像识别、快速地动手实践以看到自己写出的图像识别代码，那么你可以先跳过这一节，实战时再回来翻看也不迟。

对于KNN算法来说，k就是需要调整的超参数。对于一般初学者来说，你可能会尝试不同的值，看哪个值表现最好就选哪个。有一种更专业的穷举调参方法称为GridSearch，即在所有候选的参数中，通过循环遍历，尝试每一种的可能性，表现最好的参数就是最终的结果。

那么选用哪些数据集进行调参呢，我们来具体分析一下。

方法一，选择整个数据集进行测试。这种方法有一个非常明显的问题，那就是设定k=1总是最好的，因为每个测试样本的位置总是与整个训练集中的自己最接近，如图3-10所示。

图3-10　整个数据集

方法二，将整个数据集拆分成训练集和测试集，然后在测试集中选择合适的超参数。这里也会存在一个问题，那就是不清楚这样训练出来的算法模型对于接下来的新的测试数据的表现会如何，如图3-11所示。

图3-11　整个数据集拆分成训练集和测试集

方法三，将整个数据集拆分成训练集、验证集和测试集，然后在验证集中选择合适的超参数，最后在测试集上进行测试。这个方法相对来说比之前两种方法好很多，也是在实践中经常使用的方法，如图3-12所示。

图3-12　训练集、验证集和测试集

方法四，使用交叉验证，将数据分成若干份，将其中的各份作为验证集之后给出平均准确率，最后将评估得到的合适的超参数在测试集中进行测试。这个方法更加严谨，但实践中常在较小的数据集上使用，在深度学习中很少使用，如图3-13所示。

图3-13　交叉验证的数据拆分方法

我们现在针对方法四来做测试。

第一步，使用之前所写的KNN分类器，代码如下：

class Knn:

    def __init__(self):

        pass

    def fit(self,X_train,y_train):

        self.Xtr = X_train

        self.ytr = y_train

    def predict(self,k, dis, X_test):

        assert dis == 'E' or dis == 'M', 'dis must E or M'

        num_test = X_test.shape[0]  #测试样本的数量

        labellist = []

        #使用欧拉公式作为距离度量

        if (dis == 'E'):

            for i in range(num_test):

                distances = np.sqrt(np.sum(((self.Xtr - np.tile(X_test[i], (self.Xtr.shape[0], 1))) ** 2), axis=1))

                nearest_k = np.argsort(distances)

                topK = nearest_k[:k]

                classCount = {}

                for i in topK:

                    classCount[self.ytr[i]] = classCount.get(self.ytr[i], 0) + 1

                sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)

                labellist.append(sortedClassCount[0][0])

            return np.array(labellist)

        #使用曼哈顿公式作为距离度量

        if (dis == 'M'):

            for i in range(num_test):

                #按照列的方向相加，其实就是行相加

                distances = np.sum(np.abs(self.Xtr - np.tile(X_test[i], (self.Xtr.shape[0], 1))), axis=1)

                nearest_k = np.argsort(distances)

                topK = nearest_k[:k]

                classCount = {}

                for i in topK:

                    classCount[self.ytr[i]] = classCount.get(self.ytr[i], 0) + 1

                sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)

                labellist.append(sortedClassCount[0][0])

            return np.array(labellist)

第二步，准备测试数据与验证数据，值得注意的是，如果使用方法四，则在选择超参数阶段不需要使用到X_test和y_test的输出，代码如下：

X_train = train_loader.dataset.train_data

X_train = X_train.reshape(X_train.shape[0],-1)

mean_image = getXmean(X_train)

X_train = centralized(X_train,mean_image)

y_train = train_loader.dataset.train_labels

y_train = np.array(y_train)

X_test = test_loader.dataset.test_data

X_test = X_test.reshape(X_test.shape[0],-1)

X_test = centralized(X_test,mean_image)

y_test = test_loader.dataset.test_labels

y_test = np.array(y_test)

print(X_train.shape)

print(y_train.shape)

print(X_test.shape)

print(y_test.shape)

第三步，将训练数据分成5个部分，每个部分轮流作为验证集，代码如下：

num_folds = 5

k_choices = [1, 3, 5, 8, 10, 12, 15, 20]  #k的值一般选择1~20以内

num_training=X_train.shape[0]

X_train_folds = []

y_train_folds = []

indices = np.array_split(np.arange(num_training), indices_or_sections=num_folds)                                       #把下标分成5个部分

for i in indices:

    X_train_folds.append(X_train[i])

y_train_folds.append(y_train[i])

k_to_accuracies = {}

for k in k_choices:

    #进行交叉验证

    acc = []

    for i in range(num_folds):

        x = X_train_folds[0:i] + X_train_folds[i+1:]  #训练集不包括验证集

        x = np.concatenate(x, axis=0)                  #使用concatenate将4个

                                                         训练集拼在一起

        y = y_train_folds[0:i] + y_train_folds[i+1:]

        y = np.concatenate(y)                             #对label进行同样的操作

        test_x = X_train_folds[i]                     #单独拿出验证集

        test_y = y_train_folds[i]

        classifier = Knn()                              #定义model

        classifier.fit(x, y)                        #读入训练集

        #dist = classifier.compute_distances_no_loops(test_x)

                                                        #计算距离矩阵

        y_pred = classifier.predict(k,'M',test_x)     #预测结果

        accuracy = np.mean(y_pred == test_y)           #计算准确率

        acc.append(accuracy)

k_to_accuracies[k] = acc                          #计算交叉验证的平均准确率

#输出准确度

for k in sorted(k_to_accuracies):

    for accuracy in k_to_accuracies[k]:

        print('k = %d, accuracy = %f' % (k, accuracy))

使用下面的代码图形化展示k的选取与准确度趋势：

# plot the raw observations

import matplotlib.pyplot as plt

for k in k_choices:

    accuracies = k_to_accuracies[k]

    plt.scatter([k] * len(accuracies), accuracies)

# plot the trend line with error bars that correspond to standard deviation

accuracies_mean = np.array([np.mean(v) for k,v in sorted(k_to_accuracies.items())])

accuracies_std = np.array([np.std(v) for k,v in sorted(k_to_accuracies.items())])

plt.errorbar(k_choices, accuracies_mean, yerr=accuracies_std)

plt.title('Cross-validation on k')

plt.xlabel('k')

plt.ylabel('Cross-validation accuracy')

plt.show()

这样我们就能比较直观地了解哪个k比较合适，了解测试集的准确度，当然我们也可以更改下代码（选取欧拉公式来重新测试，看哪个距离度量比较好）。

特别需要注意的是，不能使用测试集来进行调优。当你在设计机器学习算法的时候，应该将测试集看作非常珍贵的资源，不到最后一步，绝不使用它。如果你使用测试集来调优，即使算法看起来效果不错，但真正的危险在于：在算法实际部署后，算法对测试集过拟合，也就是说在实际应用的时候，算法模型对于新的数据预测的准确率将会大大下降。从另一个角度来说，如果使用测试集来调优，那么实际上就是将测试集当作训练集，由测试集训练出来的算法再运行同样的测试集，性能看起来自然会很好，但其实是有一点自欺欺人了，实际部署起来，效果就会差很多。所以，到最终测试的时候再使用测试集，可以很好地近似度量你所设计的分类器的泛化性能。