CIFAR-10不能达到60％以上的精度，带有Tensorflow后端的Keras [关闭]

在CIFAR-10数据集上经过15个纪元后的训练似乎使验证损失不再减少，大约为1.4（验证准确度为60％）。我重新整理了训练集，将其除以255，然后导入为float32。我已经尝试了许多体系结构，在Conv2D层中有或没有辍学，似乎没有任何效果。相同的体系结构在MNIST的测试集上实现了99.7％的准确性。请查看以下架构：

（注意：我曾尝试增加Adam优化器的辍学率和提高/降低学习率，以防止过度拟合，所有这些操作都是为了防止过度拟合，但是现在训练和测试集的准确性都低至60％左右）。

with tf.device('/gpu:0'):
    tf.placeholder(tf.float32, shape=(None, 20, 64))
    #placeholder initialized (pick /cpu:0 or /gpu:0)
    seed = 6
    np.random.seed(seed)
    modelnn = Sequential()
    neurons = x_train_reduced.shape[1:]

    modelnn.add(Convolution2D(32, 3, 3, input_shape=neurons, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(32, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    #modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    #modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    #modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Flatten())
    #modelnn.add(Dropout(0.5))
    modelnn.add(Dense(1024, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(512, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(10, activation='softmax'))
    modelnn.compile(loss='categorical_crossentropy', optimizer=optimizer_input, metrics=['accuracy'])
    y_train = to_categorical(y_train)
    modelnn.fit(x_train_reduced, y_train, nb_epoch=nb_epoch_count, shuffle=True, batch_size=bsize,
                           validation_split=0.1)

结果：

    44100/44100 [==============================] - 22s - loss: 2.1453 - acc: 0.2010 - val_loss: 1.9812 - val_acc: 0.2959
    Epoch 2/50
    44100/44100 [==============================] - 24s - loss: 1.9486 - acc: 0.3089 - val_loss: 1.8685 - val_acc: 0.3567
    Epoch 3/50
    44100/44100 [==============================] - 18s - loss: 1.8599 - acc: 0.3575 - val_loss: 1.7822 - val_acc: 0.3982
    Epoch 4/50
    44100/44100 [==============================] - 18s - loss: 1.7925 - acc: 0.3933 - val_loss: 1.7272 - val_acc: 0.4229
    Epoch 5/50
    44100/44100 [==============================] - 18s - loss: 1.7425 - acc: 0.4195 - val_loss: 1.6806 - val_acc: 0.4459
    Epoch 6/50
    44100/44100 [==============================] - 18s - loss: 1.6998 - acc: 0.4440 - val_loss: 1.6436 - val_acc: 0.4682
    Epoch 7/50
    44100/44100 [==============================] - 18s - loss: 1.6636 - acc: 0.4603 - val_loss: 1.6156 - val_acc: 0.4837
    Epoch 8/50
    44100/44100 [==============================] - 18s - loss: 1.6333 - acc: 0.4781 - val_loss: 1.6351 - val_acc: 0.4776
    Epoch 9/50
    44100/44100 [==============================] - 18s - loss: 1.6086 - acc: 0.4898 - val_loss: 1.5732 - val_acc: 0.5063
    Epoch 10/50
    44100/44100 [==============================] - 18s - loss: 1.5776 - acc: 0.5065 - val_loss: 1.5411 - val_acc: 0.5227
    Epoch 11/50
    44100/44100 [==============================] - 18s - loss: 1.5585 - acc: 0.5145 - val_loss: 1.5485 - val_acc: 0.5212
    Epoch 12/50
    44100/44100 [==============================] - 18s - loss: 1.5321 - acc: 0.5288 - val_loss: 1.5354 - val_acc: 0.5316
    Epoch 13/50
    44100/44100 [==============================] - 18s - loss: 1.5082 - acc: 0.5402 - val_loss: 1.5022 - val_acc: 0.5427
    Epoch 14/50
    44100/44100 [==============================] - 18s - loss: 1.4945 - acc: 0.5438 - val_loss: 1.4916 - val_acc: 0.5490
    Epoch 15/50
    44100/44100 [==============================] - 192s - loss: 1.4762 - acc: 0.5535 - val_loss: 1.5159 - val_acc: 0.5394
    Epoch 16/50
    44100/44100 [==============================] - 18s - loss: 1.4577 - acc: 0.5620 - val_loss: 1.5389 - val_acc: 0.5257
    Epoch 17/50
    44100/44100 [==============================] - 18s - loss: 1.4425 - acc: 0.5671 - val_loss: 1.4590 - val_acc: 0.5667
    Epoch 18/50
    44100/44100 [==============================] - 18s - loss: 1.4258 - acc: 0.5766 - val_loss: 1.4552 - val_acc: 0.5763
    Epoch 19/50
    44100/44100 [==============================] - 18s - loss: 1.4113 - acc: 0.5805 - val_loss: 1.4439 - val_acc: 0.5767
    Epoch 20/50
    44100/44100 [==============================] - 18s - loss: 1.3971 - acc: 0.5879 - val_loss: 1.4473 - val_acc: 0.5769
    Epoch 21/50
    44100/44100 [==============================] - 18s - loss: 1.3850 - acc: 0.5919 - val_loss: 1.4251 - val_acc: 0.5871
    Epoch 22/50
    44100/44100 [==============================] - 18s - loss: 1.3668 - acc: 0.6006 - val_loss: 1.4203 - val_acc: 0.5910
    Epoch 23/50
    44100/44100 [==============================] - 18s - loss: 1.3549 - acc: 0.6051 - val_loss: 1.4207 - val_acc: 0.5939
    Epoch 24/50
    44100/44100 [==============================] - 18s - loss: 1.3373 - acc: 0.6111 - val_loss: 1.4516 - val_acc: 0.5784
    Epoch 25/50
    44100/44100 [==============================] - 18s - loss: 1.3285 - acc: 0.6149 - val_loss: 1.4146 - val_acc: 0.5922
    Epoch 26/50
    44100/44100 [==============================] - 18s - loss: 1.3134 - acc: 0.6205 - val_loss: 1.4090 - val_acc: 0.6024
    Epoch 27/50
    44100/44100 [==============================] - 18s - loss: 1.3043 - acc: 0.6239 - val_loss: 1.4307 - val_acc: 0.5959
    Epoch 28/50
    44100/44100 [==============================] - 18s - loss: 1.2862 - acc: 0.6297 - val_loss: 1.4241 - val_acc: 0.5978
    Epoch 29/50
    44100/44100 [==============================] - 18s - loss: 1.2706 - acc: 0.6340 - val_loss: 1.4046 - val_acc: 0.6067
    Epoch 30/50
    44100/44100 [==============================] - 18s - loss: 1.2634 - acc: 0.6405 - val_loss: 1.4120 - val_acc: 0.6037
    Epoch 31/50
    44100/44100 [==============================] - 18s - loss: 1.2473 - acc: 0.6446 - val_loss: 1.4067 - val_acc: 0.6045
    Epoch 32/50
    44100/44100 [==============================] - 18s - loss: 1.2411 - acc: 0.6471 - val_loss: 1.4083 - val_acc: 0.6098
    Epoch 33/50
    44100/44100 [==============================] - 18s - loss: 1.2241 - acc: 0.6498 - val_loss: 1.4091 - val_acc: 0.6076
    Epoch 34/50
    44100/44100 [==============================] - 18s - loss: 1.2121 - acc: 0.6541 - val_loss: 1.4209 - val_acc: 0.6127
    Epoch 35/50
    44100/44100 [==============================] - 18s - loss: 1.1995 - acc: 0.6582 - val_loss: 1.4230 - val_acc: 0.6131
    Epoch 36/50
    44100/44100 [==============================] - 18s - loss: 1.1884 - acc: 0.6622 - val_loss: 1.4024 - val_acc: 0.6124
    Epoch 37/50
    44100/44100 [==============================] - 18s - loss: 1.1778 - acc: 0.6657 - val_loss: 1.4328 - val_acc: 0.6080
    Epoch 38/50
    44100/44100 [==============================] - 18s - loss: 1.1612 - acc: 0.6683 - val_loss: 1.4246 - val_acc: 0.6159
    Epoch 39/50
    44100/44100 [==============================] - 18s - loss: 1.1466 - acc: 0.6735 - val_loss: 1.4282 - val_acc: 0.6122
    Epoch 40/50
    44100/44100 [==============================] - 18s - loss: 1.1325 - acc: 0.6783 - val_loss: 1.4311 - val_acc: 0.6157
    Epoch 41/50
    44100/44100 [==============================] - 18s - loss: 1.1213 - acc: 0.6806 - val_loss: 1.4647 - val_acc: 0.6047
    Epoch 42/50
    44100/44100 [==============================] - 18s - loss: 1.1064 - acc: 0.6842 - val_loss: 1.4631 - val_acc: 0.6047
    Epoch 43/50
    44100/44100 [==============================] - 18s - loss: 1.0967 - acc: 0.6870 - val_loss: 1.4535 - val_acc: 0.6106
    Epoch 44/50
    44100/44100 [==============================] - 18s - loss: 1.0822 - acc: 0.6893 - val_loss: 1.4532 - val_acc: 0.6149
    Epoch 45/50
    44100/44100 [==============================] - 18s - loss: 1.0659 - acc: 0.6941 - val_loss: 1.4691 - val_acc: 0.6108
    Epoch 46/50
    44100/44100 [==============================] - 18s - loss: 1.0610 - acc: 0.6956 - val_loss: 1.4751 - val_acc: 0.6106
    Epoch 47/50
    44100/44100 [==============================] - 18s - loss: 1.0397 - acc: 0.6981 - val_loss: 1.4857 - val_acc: 0.6041
    Epoch 48/50
    44100/44100 [==============================] - 18s - loss: 1.0208 - acc: 0.7039 - val_loss: 1.4901 - val_acc: 0.6106
    Epoch 49/50
    44100/44100 [==============================] - 18s - loss: 1.0187 - acc: 0.7036 - val_loss: 1.4994 - val_acc: 0.6106
    Epoch 50/50
    44100/44100 [==============================] - 18s - loss: 1.0024 - acc: 0.7070 - val_loss: 1.5078 - val_acc: 0.6039
    Time: 1109.7512991428375
    Neural Network now trained from dimensions (49000, 3, 32, 32)

更新：进一步测试，包括使用和不使用MaxNorm的BatchNormalization-

新架构：

    modelnn.add(Convolution2D(32, 3, 3, input_shape=neurons, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(32, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(64, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.2))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(Convolution2D(128, 3, 3, activation='relu', border_mode='same'))
    modelnn.add(BatchNormalization())
    modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Dropout(0.2))
    # modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    # modelnn.add(Convolution2D(256, 3, 3, activation='relu', border_mode='same'))
    # modelnn.add(MaxPooling2D(pool_size=(2, 2)))
    modelnn.add(Flatten())
    modelnn.add(Dense(1024, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(512, activation='relu', W_constraint=maxnorm(3)))
    modelnn.add(BatchNormalization())
    modelnn.add(Dropout(0.5))
    modelnn.add(Dense(10, activation='softmax'))

请注意，MNIST比CIFAR-10问题要简单得多，并且可以从困难的情况下从完全连接的（非卷积）NNet获得98％的问题。具有一个或两个卷积层的非常简单的CNN同样可以达到相同的精度水平。

我不确定您的NNet架构，但是通过以下架构（相对简单且权重较小），我可以使您在CIFAR-10上达到78％的测试准确性。使用原始默认设置和Adam优化器，不需要特殊的初始化或手持处理：

model = Sequential()
model.add(Conv2D(input_shape=trainX[0,:,:,:].shape, filters=96, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Conv2D(filters=96, kernel_size=(3,3), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Conv2D(filters=192, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Conv2D(filters=192, kernel_size=(3,3), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(BatchNormalization())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dense(n_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

该架构非常简单，并且大致基于https://arxiv.org/pdf/1412.6806.pdf。

因此训练该模型：

n_epochs = 25
batch_size = 256
callbacks_list = None
H = model.fit(trainX, trainY, validation_data=(testX, testY), 
              epochs=n_epochs, batch_size=batch_size, callbacks=callbacks_list)
print('Done!!!')

给出以下内容，您可以看到到第25个时期达到了将近77％，并且从那里开始或多或少地变平了（但具有足够的正则化从辍学，以防止它由于过度拟合而降级，至少超过了测试的迭代次数） 。

训练50000个样本，对10000个样本进行验证
时代1/50
50000/50000 [==============================]-19s 390us / step-损失：1.6058-acc：0.4150-val_loss：1.5285-val_acc：0.4669
时代2/50
50000/50000 [======================= =======]-19秒371us / step-损耗：1.2563-acc：0.5477-val_loss：1.1447-val_acc：0.5901
时期3/50
50000/50000 [============= =================]-19s 373us / step-损耗：1.0784-acc：0.6163-val_loss：1.1577-val_acc：0.6002
...
时代25/50
50000/50000 [ =============================]-19s 374us / step-损耗：0.3188-acc：0.8857-val_loss：0.7493-val_acc ：0.7680
...
时代50/50
50000/50000 [==============================]-19s 373us / step-损耗：0.1928-acc：0.9329-val_loss ：0.8718-val_acc：0.7751
完成！！！

这是一个更简单，更小的体系结构，使用相同的训练方案（没有BatchNormalization或池化层），可以很快达到70％：

# CNN architecture with Keras
model = Sequential()
model.add(Conv2D(input_shape=trainX[0,:,:,:].shape, filters=32, 
                 use_bias=True, kernel_size=(3,3)))
model.add(Activation('relu'))
model.add(Dropout(0.1))
model.add(Conv2D(filters=64, use_bias=False, kernel_size=(5,5), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.3))
model.add(Dense(n_classes, activation="softmax"))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=    ['accuracy'])

值得注意的是，在CIFAR-10（目前在90-96％的范围内）上达到最佳发布精度的体系结构通常更加复杂，并且在GPU硬件上进行培训需要花费大量时间。但是我已经能够在几分钟内完成训练的相当简单的体系结构达到70-80％的范围，这是我建议在获得最佳结果之前，通常需要更复杂的体系结构，更长的训练时间，有时需要特殊的手持/培训方案或数据扩充，以及培训时间。

更新：

根据问题中更新的图，所显示的最明显问题是过度拟合。大约在第15个时期后，火车测试数据的差异就证明了这一点，这表明对于该数据集，该体系结构的正则化不足。除非解决了过度拟合问题，否则您不可能通过调整任何其他超参数（规范化策略，学习率等）来获得改善。

在使用NNets时，我建议以下内容：

1. 从模仿或复制已知可产生良好结果的架构开始
2. 验证数据集的性能，尤其要注意网络的过度拟合（由火车测试错误的严重差异证明）
3. 观察到过度拟合时，添加其他正则化（增加辍学率）（您正在寻找“正好”以防止过度拟合-过多会导致拟合不足）
4. 试验结构，训练方法和超参数，以找到改进的途径

关于后者的规定实际上很难获得，因为关于结构，训练或超参数如何相互作用以在任何给定数据集上产生性能的理论基础很少。事实证明，已发布的体系结构所采用的在基准数据集上实现类似高水平性能的方法差异很大。

已经发现批量规范化可以显着改善某些体系结构，但是如果没有它，其他规范可以做得很好（或者对它的存在无动于衷）。在这里提供的唯一真正的指导就是尝试一下，看看是否有帮助。

通常应该避免微调学习率，除非您是对ConvNets有深刻理解的高级从业者，并且具有相应的阅读能力，可以了解培训期间的跨时代增量表现。在某些情况下，定制的学习率和其他专门的培训方案可以帮助网络在局部最小值上浏览并找到更好的整体解决方案，但是除非您有很多时间和专门知识来诊断网络的融合行为，否则这不是一个很好的起点。我们大多数人应该使用亚当之类的优化程序，在大多数情况下，该优化程序的性能要优于新手的手动调整学习率。

通过图像预处理进行的数据增强有时可以显着提高性能（通常，输入数据的变化越多，模型的概括性就越好-数据预处理会增加输入空间的变化，从而可以提高样本外精度，并且可能可以减少正则化要求-假设，使用无限的训练数据，我们根本不需要任何正则化，但是在图像处理空间中，我们不太可能接近该渐近线。但是，这可能会大大增加训练时间并降低收敛速度，并且会引入与输入图像置换技术（旋转，修剪，缩放，降噪等）有关的另一组超参数。由于此路径会增加训练时间，并且需要进行其他实验来调整结果，因此一些一般性建议是在不首先进行扩充的情况下提高网络的最佳准确性，然后查看是否有适度的扩充会带来改善。如果这样做，则可能需要进行进一步的实验。

对于所有调谐实验，您都需要密切注意过拟合和欠拟合行为的变化。不断变化的网络体系结构，训练方案或超参数可能需要对辍学规则化进行其他调整。可以很容易地从训练/测试性能中确定过拟合和欠拟合行为，这可以说是与NNets一起使用时最重要的基础技能，而随着经验的积累，这变得更加直观。

这是指导您所有努力的蜡烛。蜡烛只能模糊地照亮路径，但是如果没有它，您将在黑暗中绊倒。如果您的网络严重过剩或不足，应在尝试网络结构或超参数的随机排列之前解决该问题。

此答案中包含具有简单训练方案的相对简单的体系结构，展示了使用NNET体系结构解决诸如图像分类之类的难题的现实：基于已知有效的方法获得“相当不错”的结果并不难，但可以逐步改进越来越昂贵。通过实验获得最佳发表的结果将超出许多人的能力或时间范围（尽管有足够的时间和精力可以遵循已发表方法的食谱来复制其结果，但是即使如此，也并非如此。意味着微不足道）。从“相当好”的起点获得渐进式改进可能是一个非常耗时的反复试验过程，并且许多实验不会产生任何重大改进。

这并不是要劝阻任何人尝试学习，而只是要表明要掌握NNet技巧包（不断扩展）的工具集需要大量投资，并且可能需要通过反复试验来推动改进在数天或数周的专用GPU培训中进行了数十（或数百）个实验。

将网络训练到非常高的性能水平所需的时间，技能和资源（专用GPU）在一定程度上解释了预训练网络的普及程度。

查看您的样本内和样本外损失以及准确性值，您的模型目前拟合不足，但是它在单调地改进。换句话说，似乎将其运行更多的时间段将导致更高的预测性能/更少的熵损失。

您使用的是高度规范化（退出层）的体系结构，这还不错。但是，培训花费的时间比没有任何正规化的时间长得多也就不足为奇了。由于掉落层，您不太可能（基本上）过拟合。

您可以尝试加快学习速度的事情：

一世。调整学习率：例如，从一个小的学习率开始，在中间将其提高，直到结束时再将其降低。

ii。添加batchnormalization：在上述架构中，您可以在卷积块和密集层中都包含批处理规范。通常，在非线性激活之后但在退出之前添加批处理规范层。我不确定批处理规范在maxnorm中的表现如何。对于您的密集层，我尝试使用/不使用maxnorm的batch-norm + dropuout。我觉得如果您应用批处理规范化，则不需要maxnorm。

iii。增加批处理大小：我不确定您的批处理大小是多少，以及您是否拥有GPU。如果您有GPU，则可能应尝试以32的乘法数来最大化批处理大小。

最后，为了确保您的数据“可学习” /没有损坏（例如，您没有不情愿地应用转换以使其变形），我将放弃架构中的所有正则化操作，进行培训，然后看您可以对培训集进行过拟合。如果您可以成功学习训练数据，那么剩下的就是泛化练习。如果即使不进行正则化也无法过度拟合训练数据，则很可能您的模型需要更多的容量（更深更广泛的体系结构）。

我今天试了一下，始终能够达到近75-80％的测试准确性。

• 使用的参数总数为： 183,242

• 您可以通过添加更多的层来做得更好，但是您并不需要过多。更复杂的网络并不一定总能带来更好的结果。

意见建议

我建议您保持体系结构简单。跟随Occam的Razor，简单更好。

• 扩展数据

• 不要使用随机种子

• 使用适当的优化器；我使用了Keras的Adadelta。

• CNN不需要复杂。把事情简单化

• 更细的网络有时比更细的网络更有效

• 使用正则化（例如，辍学）

下面是我的代码（使用Keras）

# Define the model
model = Sequential()
model.add(Convolution2D(64, (4, 4), padding='same', input_shape=(3, 32, 32)))
model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(64, (2, 2), padding='same'))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Convolution2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=2))
model.add(Dropout(0.15))
model.add(Flatten())
model.add(Dense(64))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Dense(64))
model.add(Activation('tanh'))
model.add(Dropout(0.25))
model.add(Dense(num_classes, activation='softmax'))
# Compile the model