我目前一直在与CNN合作，我很难相信过度拟合。具体来说，即使我的训练数据收敛到最小误差，我的验证数据仍然拒绝在错误方面下降。我正在使用的输入数据是512 x 650 x 1 x 4000（2D数据，4000个样本），我想要区分的数据只有两个类（A类和B类）。我知道我将来需要更多的样本，但就目前而言，我只想在我投入生成更多数据之前看到我的验证错误甚至下降。
我的网络长度大约为60-70层，并包含以下类型的图层：
卷积层[3 x 3]滤镜大小，步幅[1 x 1]，填充[1 1 1 1]
ReLU图层（非线性）
批量标准化（对培训数据融合和实施速度的巨大帮助）
最大合并图层[2 x 2]过滤器尺寸，步幅[2 x 2]，填充[0 0 0 0]
然后我重复这个“块”，直到我的输入数据为1 x 1 x N大小，然后我通过一些完全连接的层运行它，然后运行到softmax。
我的实际MatConvNet代码在下面进行检查，并附上输出图。对于图，蓝色表示我的训练错误，橙色表示我的验证错误。我正在将我最近的代码链接到下面的代码中。
我的问题：
1）如何知道用于数据的过滤器大小？我知道这是一个经验过程，但这背后肯定有某种直觉吗？我已经阅读了有关使用[3x3]小型过滤器并使用大量过滤器的论文（VGG.net等），但即使在设计了70层网络后，仍然没有验证错误。
2）我已经尝试过辍学层，因为它们在减少过度拟合方面很受欢迎...我在ReLU之后将丢失层放在我的网络中，并在上面所示的“块”中汇集层，但是在所有卷积层之间。不幸的是，它对我的验证数据没有影响，错误仍然是相同的。接下来我尝试在完全连接的层之后使用它，因为在我的架构中创建了大多数神经元（或特征映射），但仍然没有运气。我已经阅读了有关辍学的论文。我应该放弃使用它吗？这又是一个“伎俩”吗？
3）如果我尝试一个较小的网络（我已经读过这是一种处理过度拟合的下降方式），我该如何有效地减少数据的大小？只是最大化池？
任何建议都会很精彩。
再次感谢大家阅读这个长期问题。我向你保证，我已经完成了我的研究，并发现从长远来看这里的问题可能对我有所帮助。
MatConvNet代码（用于CNN设计的Matlab工具箱）
opts.train.batchSize = 25;
opts.train.numEpochs = 200 ;
opts.train.continue = true ;
opts.train.gpus = [1] ;
opts.train.learningRate = 1e-3;
opts.train.weightDecay = 0.04;
opts.train.momentum = 0.9;
opts.train.expDir = 'epoch_data';
opts.train.numSubBatches = 1;
bopts.useGpu = numel(opts.train.gpus) > 0 ;
load('imdb4k.mat');
net = dagnn.DagNN() ;
% Block #1
net.addLayer('conv1', dagnn.Conv('size', [3 3 1 64], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'input'}, {'conv1'}, {'conv1f' 'conv1b'});
net.addLayer('relu1', dagnn.ReLU(), {'conv1'}, {'relu1'}, {});
net.addLayer('bn1', dagnn.BatchNorm('numChannels', 64), {'relu1'}, {'bn1'}, {'bn1f', 'bn1b', 'bn1m'});
net.addLayer('pool1', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn1'}, {'pool1'}, {});
% Block #2
net.addLayer('conv2', dagnn.Conv('size', [3 3 64 64], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool1'}, {'conv2'}, {'conv2f' 'conv2b'});
net.addLayer('relu2', dagnn.ReLU(), {'conv2'}, {'relu2'}, {});
net.addLayer('bn2', dagnn.BatchNorm('numChannels', 64), {'relu2'}, {'bn2'}, {'bn2f', 'bn2b', 'bn2m'});
net.addLayer('pool2', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn2'}, {'pool2'}, {});
% Block #3
net.addLayer('conv3', dagnn.Conv('size', [3 3 64 128], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool2'}, {'conv3'}, {'conv3f' 'conv3b'});
net.addLayer('relu3', dagnn.ReLU(), {'conv3'}, {'relu3'}, {});
net.addLayer('bn3', dagnn.BatchNorm('numChannels', 128), {'relu3'}, {'bn3'},
{'bn3f', 'bn3b', 'bn3m'});
net.addLayer('pool3', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn3'}, {'pool3'}, {});
% Block #4
net.addLayer('conv4', dagnn.Conv('size', [3 3 128 128], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool3'}, {'conv4'}, {'conv4f' 'conv4b'});
net.addLayer('relu4', dagnn.ReLU(), {'conv4'}, {'relu4'}, {});
net.addLayer('bn4', dagnn.BatchNorm('numChannels', 128), {'relu4'}, {'bn4'}, {'bn4f', 'bn4b', 'bn4m'});
net.addLayer('pool4', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn4'}, {'pool4'}, {});
% Block #5
net.addLayer('conv5', dagnn.Conv('size', [3 3 128 256], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool4'}, {'conv5'}, {'conv5f' 'conv5b'});
net.addLayer('relu5', dagnn.ReLU(), {'conv5'}, {'relu5'}, {});
net.addLayer('bn5', dagnn.BatchNorm('numChannels', 256), {'relu5'}, {'bn5'}, {'bn5f', 'bn5b', 'bn5m'});
net.addLayer('pool5', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn5'}, {'pool5'}, {});
% Block #6
net.addLayer('conv6', dagnn.Conv('size', [3 3 256 256], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool5'}, {'conv6'}, {'conv6f' 'conv6b'});
net.addLayer('relu6', dagnn.ReLU(), {'conv6'}, {'relu6'}, {});
net.addLayer('bn6', dagnn.BatchNorm('numChannels', 256), {'relu6'}, {'bn6'}, {'bn6f', 'bn6b', 'bn6m'});
net.addLayer('pool6', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn6'}, {'pool6'}, {});
% Block #7
net.addLayer('conv7', dagnn.Conv('size', [3 3 256 512], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool6'}, {'conv7'}, {'conv7f' 'conv7b'});
net.addLayer('relu7', dagnn.ReLU(), {'conv7'}, {'relu7'}, {});
net.addLayer('bn7', dagnn.BatchNorm('numChannels', 512), {'relu7'}, {'bn7'}, {'bn7f', 'bn7b', 'bn7m'});
net.addLayer('pool7', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn7'}, {'pool7'}, {});
% Block #8
net.addLayer('conv8', dagnn.Conv('size', [3 3 512 512], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool7'}, {'conv8'}, {'conv8f' 'conv8b'});
net.addLayer('relu8', dagnn.ReLU(), {'conv8'}, {'relu8'}, {});
net.addLayer('bn8', dagnn.BatchNorm('numChannels', 512), {'relu8'}, {'bn8'}, {'bn8f', 'bn8b', 'bn8m'});
net.addLayer('pool8', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [1 2], 'pad', [0 0 0 0]), {'bn8'}, {'pool8'}, {});
% Block #9
net.addLayer('conv9', dagnn.Conv('size', [3 3 512 512], 'hasBias', true, 'stride', [1, 1], 'pad', [1 1 1 1]), {'pool8'}, {'conv9'}, {'conv9f' 'conv9b'});
net.addLayer('relu9', dagnn.ReLU(), {'conv9'}, {'relu9'}, {});
net.addLayer('bn9', dagnn.BatchNorm('numChannels', 512), {'relu9'}, {'bn9'}, {'bn9f', 'bn9b', 'bn9m'});
net.addLayer('pool9', dagnn.Pooling('method', 'max', 'poolSize', [2, 2], 'stride', [2 2], 'pad', [0 0 0 0]), {'bn9'}, {'pool9'}, {});
% Incorporate MLP
net.addLayer('fc1', dagnn.Conv('size', [1 1 512 1000], 'hasBias', true, 'stride', [1, 1], 'pad', [0 0 0 0]), {'pool9'}, {'fc1'}, {'conv15f' 'conv15b'});
net.addLayer('relu10', dagnn.ReLU(), {'fc1'}, {'relu10'}, {});
net.addLayer('bn10', dagnn.BatchNorm('numChannels', 1000), {'relu10'}, {'bn10'}, {'bn10f', 'bn10b', 'bn10m'});
net.addLayer('classifier', dagnn.Conv('size', [1 1 1000 2], 'hasBias', true, 'stride', [1, 1], 'pad', [0 0 0 0]), {'bn10'}, {'classifier'}, {'conv16f' 'conv16b'});
net.addLayer('prob', dagnn.SoftMax(), {'classifier'}, {'prob'}, {});
% The dagnn.Loss computes the loss incurred by the prediction scores X given the categorical labels
net.addLayer('objective', dagnn.Loss('loss', 'softmaxlog'), {'prob', 'label'}, {'objective'}, {});
net.addLayer('error', dagnn.Loss('loss', 'classerror'), {'prob','label'}, 'error') ;
答案 0 :(得分：0)
首先，对于数据而言，您的网络对我而言似乎过于复杂，您需要两个数量级的样本才能在这样复杂的网络上查看任何类型的结果。如果问题本身就那么复杂。尝试通过更小的网络来查看结果是否有所改善。回答你的问题：
1）滤波器尺寸是经验性的，但通常使用1x1,3x3,5x5滤波器。除非问题非常复杂并且您拥有大量数据，否则70层网络没有意义。此外，为了成功训练你可能需要查看resnet。
2）辍学最常用于完全连接的图层。你可以看一下dropconnect。一般情况下，无需在conv层之间使用它们。
3）通过conv + maxpooling堆栈可以轻松地减小中间映射的大小。在使用MLP之前，您不必将其减小到1x1的大小。例如，当地图在网络中达到8x8的大小时，您可以直接使用它。尝试使用多个FC层。还要减小网络宽度以降低模型复杂度（每层过滤器数量）
总体而言，您拥有的数据非常少，绝对不适用于深度模型。 Finetuning预训练模型可能会给您带来更好的结果。这一切都取决于数据本身和手头的任务。还要记住像VGG这样的网络已经训练了1000个不同的类，其中包含数百万个图像，这是一个非常复杂的问题。