python - 为什么我的单过滤器卷积神经网络无法学习简单的高斯核？

Question

令我惊讶的是，我实现的深度学习算法不起作用，我决定创建一个非常简单的示例，以更好地理解 CNN 的功能。这是我为一个非常简单的任务构建一个小型 CNN 的尝试，它提供了意想不到的结果。

我实现了一个只有一层和一个过滤器的简单 CNN。我创建了一个包含 5000 个样本的数据集，输入 x 是 256x256 模拟图像，输出 y 是相应的模糊图像(y = signal.convolvded2d(x,gaussian_kernel,boundary='fill',mode='same')) .因此，我希望我的 CNN 学习将原始图像转换为模糊版本的卷积滤波器。换句话说，我希望我的 CNN 恢复我用来创建模糊图像的高斯滤波器。注意:由于我想“模仿”数学框架中描述的卷积过程，因此我使用了与我的图像大小相同的高斯滤波器:256x256。

在我看来，这是一项很容易的任务，尽管如此，CNN 无法提供我所期望的结果。请在下面找到我的训练功能的代码和结果。

# Parameters
size_image = 256
normalization = 1 
sigma = 7

n_train = 4900
ind_samples_training =np.linspace(1, n_train, n_train).astype(int)
nb_epochs = 5
minibatch_size = 5
learning_rate = np.logspace(-3,-5,nb_epochs)

tf.reset_default_graph()
tf.set_random_seed(1)                             
seed = 3                                       

n_train = len(ind_samples_training)   

costs = []                                        

# Create Placeholders of the correct shape
X = tf.placeholder(tf.float64, shape=(None, size_image, size_image, 1), name = 'X')
Y_blur_true = tf.placeholder(tf.float64, shape=(None, size_image, size_image, 1), name = 'Y_true')
learning_rate_placeholder = tf.placeholder(tf.float32, shape=[])

# parameters to learn --should be an approximation of the gaussian filter 
filter_to_learn = tf.get_variable('filter_to_learn',\
                                    shape = [size_image,size_image,1,1],\
                                    dtype = tf.float64,\
                                    initializer = tf.contrib.layers.xavier_initializer(seed = 0),\
                                    trainable = True)

# Forward propagation: Build the forward propagation in the tensorflow graph
Y_blur_hat = tf.nn.conv2d(X, filter_to_learn, strides = [1,1,1,1], padding = 'SAME')

# Cost function: Add cost function to tensorflow graph
cost = tf.losses.mean_squared_error(Y_blur_true,Y_blur_hat,weights=1.0)

# Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.
opt_adam = tf.train.AdamOptimizer(learning_rate=learning_rate_placeholder)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    optimizer = opt_adam.minimize(cost)

# Initialize all the variables globally
init = tf.global_variables_initializer()

lr = learning_rate[0]
# Start the session to compute the tensorflow graph
with tf.Session() as sess:

    # Run the initialization
    sess.run(init)

    # Do the training loop
    for epoch in range(nb_epochs):

        minibatch_cost = 0.
        seed = seed + 1

        permutation = list(np.random.permutation(n_train))
        shuffled_ind_samples = np.array(ind_samples_training)[permutation]

        # Learning rate update
        if learning_rate.shape[0]>1:
            lr = learning_rate[epoch]

        nb_minibatches = int(np.ceil(n_train/minibatch_size))

        for num_minibatch in range(nb_minibatches):

            # Minibatch indices
            ind_minibatch = shuffled_ind_samples[num_minibatch*minibatch_size:(num_minibatch+1)*minibatch_size]

            # Loading of the original image (X) and the blurred image (Y)
            minibatch_X, minibatch_Y  = load_dataset_blur(ind_minibatch,size_image, normalization, sigma)

            _ , temp_cost, filter_learnt = sess.run([optimizer,cost,filter_to_learn],\
                feed_dict = {X:minibatch_X, Y_blur_true:minibatch_Y, learning_rate_placeholder: lr})

我已经对 4900 个样本的 5 个时期进行了训练，批量大小等于 5。高斯核的方差为 7^2=49。我尝试用tensorflow提供的xavier initiliazer方法和我们真正想学习的高斯核的真实值来初始化要学习的过滤器。在这两种情况下，学习的滤波器结果与真正的高斯滤波器差别太大，正如在 https://github.com/megalinier/Helsinki-project 提供的两张图像上可以看到的那样。 .

Answer 1

通过检查照片，网络似乎学习正常，因为预测的图像与真实标签相距不远 - 为了获得更好的结果，您可以调整一些超参数，但事实并非如此。

我认为您缺少的事实是，不同的内核可以得到非常相似的结果，因为它是卷积。想一想，您正在将一些矩阵与另一个矩阵相乘，然后将所有结果相加以创建一个新像素。现在如果真正的标签和是 10，它可能是 2.5 + 2.5 + 2.5 + 2.5 和 -10 + 10 + 10 + 0 的结果。我想说的是，你的网络可能学习得很好，但你会在 conv 内核中获得与过滤器不同的值。