卷积神经网络不收敛

Question

我一直在看一些关于深度学习/卷积神经网络的视频，比如这里和这里，我试图用C语言实现我自己的。在我第一次尝试时，我试图保持输入数据相当简单，所以我的想法是区分十字和圆，我有一个大约25个的小数据集（64*64个图像），它们如下所示：

网络本身有五层：

Convolution (5 filters, size 3, stride 1, with a ReLU)
MaxPool (size 2) 
Convolution (1 filter, size 3, stride 1, with a ReLU)
MaxPool (size 2)
Linear Regression classifier

我的问题是我的网络没有收敛到任何东西上。权重似乎都没有改变。如果我运行它，预测基本保持不变，除了偶尔出现的异常值，它会在下一次迭代返回之前跳起来。

卷积层训练看起来像这样，删除了一些循环以使其更干净

// Yeah, I know I should change the shared_ptr<float>
void ConvolutionalNetwork::Train(std::shared_ptr<float> input,std::shared_ptr<float> outputGradients, float label)
{
    float biasGradient = 0.0f;

    // Calculate the deltas with respect to the input.
    for (int layer = 0; layer < m_Filters.size(); ++layer)
    {
        // Pseudo-code, each loop on it's own line in actual code
        For z < depth, x <width - filterSize, y < height -filterSize
        {               
            int newImageIndex = layer*m_OutputWidth*m_OutputHeight+y*m_OutputWidth + x;

            For the bounds of the filter (U,V)
            {
                // Find the index in the input image
                int imageIndex = x + (y+v)*m_OutputWidth + z*m_OutputHeight*m_OutputWidth;
                int kernelIndex = u +v*m_FilterSize + z*m_FilterSize*m_FilterSize;
                m_pGradients.get()[imageIndex] += outputGradients.get()[newImageIndex]*input.get()[imageIndex];
                m_GradientSum[layer].get()[kernelIndex] += m_pGradients.get()[imageIndex] * m_Filters[layer].get()[kernelIndex];
                        
                biasGradient += m_GradientSum[layer].get()[kernelIndex];
            }       
        }
    }

    // Update the weights
    for (int layer = 0; layer < m_Filters.size(); ++layer)
    {
        For z < depth, U & V < filtersize
        {
            // Find the index in the input image
            int kernelIndex = u +v*m_FilterSize + z*m_FilterSize*m_FilterSize;
            m_Filters[layer].get()[kernelIndex] -= learningRate*m_GradientSum[layer].get()[kernelIndex];
        }
        m_pBiases.get()[layer] -= learningRate*biasGradient;
    }
}

因此，我创建了一个缓冲区（m\u pGradients），它是输入缓冲区的维度，用于将梯度反馈回前一层，但使用梯度和来调整权重。

“最大池”（max pooling）按原样计算渐变（它保存最大索引并将所有其他渐变置零）

void MaxPooling::Train(std::shared_ptr<float> input,std::shared_ptr<float> outputGradients, float label)
{
    for (int outputVolumeIndex = 0; outputVolumeIndex <m_OutputVolumeSize; ++outputVolumeIndex)
    {
        int inputIndex = m_Indices.get()[outputVolumeIndex];
        m_pGradients.get()[inputIndex] = outputGradients.get()[outputVolumeIndex];
    }
}

最后的回归层计算其梯度如下：

void LinearClassifier::Train(std::shared_ptr<float> data,std::shared_ptr<float> output, float y)
{
    float * x  = data.get();

    float biasError = 0.0f;
    float h = Hypothesis(output) - y;

    for (int i =1; i < m_NumberOfWeights; ++i)
    {
        float error = h*x[i];
        m_pGradients.get()[i] = error;
        biasError += error;
    }

    float cost = h;
    m_Error = cost*cost;

    for (int theta = 1; theta < m_NumberOfWeights; ++theta)
    {
        m_pWeights.get()[theta] = m_pWeights.get()[theta] - learningRate*m_pGradients.get()[theta];
    }

    m_pWeights.get()[0] -= learningRate*biasError;
}

在对这两个示例进行100次迭代训练后，对每个示例的预测与另一个相同，并且从一开始就保持不变。

1. 像这样的卷积网络应该能够区分这两类吗
2. 这是正确的方法吗
3. 我应该考虑卷积层反向传播中的ReLU（max）吗

Answer 1

1. 像这样的卷积网络应该能够区分这两类吗

对事实上，即使是线性分类器本身也应该能够非常容易地进行区分（如果图像或多或少居中）。

最可能的原因是梯度公式中的错误。始终遵循2条简单规则：

>

从基本模型开始。不要从2-conv网络开始。无需任何卷积即可启动代码。现在能用了吗？当您有一个工作线性层时，添加单个卷积。现在能用了吗？等等

始终以数字形式检查渐变。这是很容易做到的，并将节省您数小时的调试！从分析中回忆起

[grad f(x) ]_i ~  (f(x+eps*e_i) - f(x-eps*e_i)) / 2*eps

其中[]_i是指第i个坐标，e_i是指第i个标准向量（第i个坐标上有一个零向量）

我应该考虑卷积层反向传播中的ReLU（max）吗？

是的，ReLU会改变您的梯度，因为这是您需要区分的非线性。再次回到要点1。从简单的模型开始，分别添加每个元素以找出导致梯度/模型崩溃的元素。