Tensorflow：如何设置对数尺度的学习率和一些 Tensorflow 问题

Question

我是一名深度学习和 Tensorflow 初学者，我正在尝试使用 Tensorflow 在 paper 中实现该算法。本文使用 Matconvnet+Matlab 来实现，我很好奇 Tensorflow 是否有等效的功能来实现相同的东西。论文说：

使用 Xavier 方法 [14] 初始化网络参数。我们使用了 l2 惩罚下的四个小波子带的回归损失，并通过使用随机梯度下降 (SGD) 对所提出的网络进行了训练。正则化参数 (λ) 为 0.0001，动量为 0.9。学习率设置为 10-1 到 10-4，在每个 epoch 以对数规模减小。

本文使用小波变换（WT）和残差学习方法（其中残差图像= WT(HR) - WT(HR')，其中HR'用于训练）。 Xavier 方法建议使用

初始化变量正态分布

stddev=sqrt(2/(filter_size*filter_size*num_filters)

第一季度。我应该如何初始化变量？下面的代码是否正确？

weights = tf.Variable(tf.random_normal[img_size, img_size, 1, num_filters], stddev=stddev)

---

本文没有详细解释如何构造损失函数。我找不到等效的 Tensorflow 函数来设置对数刻度的学习率（仅限 exponential_decay）。我理解MomentumOptimizer 相当于带有动量的随机梯度下降。

Q2：是否可以设置对数尺度的学习率？

Q3：如何创建上述损失函数？

我按照website 编写了下面的代码。假设model()函数返回本文提到的网络，lamda=0.0001，

inputs = tf.placeholder(tf.float32, shape=[None, patch_size, patch_size, num_channels])
labels = tf.placeholder(tf.float32, [None, patch_size, patch_size, num_channels])

# get the model output and weights for each conv
pred, weights = model()

# define loss function
loss = tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=pred)

for weight in weights:
    regularizers += tf.nn.l2_loss(weight)

loss = tf.reduce_mean(loss + 0.0001 * regularizers)

learning_rate = tf.train.exponential_decay(???) # Not sure if we can have custom learning rate for log scale
optimizer = tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss, global_step)

注意：由于我是深度学习/Tensorflow 初学者，我在这里和那里复制粘贴代码，所以如果可以的话，请随时纠正它；）

Answer 1

Q1。我应该如何初始化变量？下面的代码是否正确？

没错（尽管缺少左括号）。如果要重用变量，您还可以查看tf.get_variable。

Q2：是否可以设置对数尺度的学习率？

指数衰减会降低每一步的学习率。我认为您想要的是tf.train.piecewise_constant，并在每个时期设置边界。

编辑：查看另一个答案，使用 staircase=True 参数！

Q3：如何创建上述损失函数？

您的损失函数看起来是正确的。

Answer 2

Q1。我应该如何初始化变量？下面的代码是否正确？

使用 tf.get_variable 或切换到 slim（它会自动为您进行初始化）。 example

Q2：是否可以设置对数尺度的学习率？

你可以，但你需要吗？这不是您需要在此网络中解决的第一件事。请检查#3

但是，仅供参考，请使用以下符号。

learning_rate_node = tf.train.exponential_decay(learning_rate=0.001, decay_steps=10000, decay_rate=0.98, staircase=True)

优化器 = tf.train.AdamOptimizer(learning_rate=learning_rate_node).minimize(loss)

Q3：如何创建上述损失函数？

一开始，你还没有写“pred”到“image”转换到这个消息（根据论文，你需要应用减法和IDWT来获得最终图像）。

这里有一个问题，logits 必须根据你的标签数据来计算。即如果您将标记数据用作“Y：标签”，则需要编写

pred = 模型（）

pred = tf.matmul(pred, weights) + 偏差

logits = tf.nn.softmax(pred)

损失 = tf.reduce_mean(tf.abs(logits - 标签))

这将为您提供 Y 的输出：要使用的标签

如果您的数据集的标记图像是去噪的，在这种情况下，您需要遵循这个：

pred = 模型（）

pred = tf.matmul(image, weights) + 偏差

logits = tf.nn.softmax(pred)

image = apply_IDWT("X : input", logits) # 这将应用 IDWT(x_label - y_label)

loss = tf.reduce_mean(tf.abs(图像 - 标签))

Logits 是网络的输出。您将使用这个作为结果来计算其余部分。您可以在此处添加一个 conv2d 层而不是 matmul，而无需批量归一化和激活函数，并将输出特征计数设置为 4。示例：

pred = 模型（）

pred = slim.conv2d(pred, 4, [3, 3], activation_fn=None, padding='SAME', scope='output')

logits = tf.nn.softmax(pred)

image = apply_IDWT("X : input", logits) # 这将应用 IDWT(x_label - y_label)

损失 = tf.reduce_mean(tf.abs(logits - 标签))

此损失函数将为您提供基本的训练能力。但是，这是 L1 距离，它可能会遇到一些问题 (check)。考虑以下情况

假设您有以下数组作为输出 [10, 10, 10, 0, 0] 并且您尝试实现 [10, 10, 10, 10, 10]。在这种情况下，您的损失为 20 (10 + 10)。但是，您有 3/5 的成功。此外，它可能表明有些过拟合。

对于相同的情况，请考虑以下输出 [6, 6, 6, 6, 6]。它仍然损失了 20 (4 + 4 + 4 + 4 + 4)。但是，无论何时应用阈值 5，您都可以获得 5/5 的成功。因此，这就是我们想要的情况。

如果您使用 L2 损失，对于第一种情况，您将有 10^2 + 10^2 = 200 作为损失输出。对于第二种情况，您将得到 4^2 * 5 = 80。 因此，优化器将尝试尽可能快地逃离 #1 以实现全局成功，而不是某些输出的完美成功和其他输出的完全失败。您可以为此应用这样的损失函数。

tf.reduce_mean(tf.nn.l2_loss(logits - image))

或者，您可以检查交叉熵损失函数。 （它确实在内部应用了softmax，不要应用两次softmax）

tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, image))

Answer 3

其他答案非常详细且很有帮助。这是一个代码示例，它使用占位符以对数尺度衰减学习率。 HTH。

import tensorflow as tf

import numpy as np


# data simulation
N = 10000
D = 10
x = np.random.rand(N, D)
w = np.random.rand(D,1)
y = np.dot(x, w)

print y.shape

#modeling
batch_size = 100
tni = tf.truncated_normal_initializer()
X = tf.placeholder(tf.float32, [batch_size, D])
Y = tf.placeholder(tf.float32, [batch_size,1])
W = tf.get_variable("w", shape=[D,1], initializer=tni)
B = tf.zeros([1])

lr = tf.placeholder(tf.float32)

pred = tf.add(tf.matmul(X,W), B)
print pred.shape
mse = tf.reduce_sum(tf.losses.mean_squared_error(Y, pred))
opt = tf.train.MomentumOptimizer(lr, 0.9)

train_op = opt.minimize(mse)

learning_rate = 0.0001

do_train = True
acc_err = 0.0
sess = tf.Session()
sess.run(tf.global_variables_initializer())
while do_train:
  for i in range (100000):
     if i > 0 and i % N == 0:
       # epoch done, decrease learning rate by 2
       learning_rate /= 2
       print "Epoch completed. LR =", learning_rate

     idx = i/batch_size + i%batch_size
     f = {X:x[idx:idx+batch_size,:], Y:y[idx:idx+batch_size,:], lr: learning_rate}
     _, err = sess.run([train_op, mse], feed_dict = f)
     acc_err += err
     if i%5000 == 0:
       print "Average error = {}".format(acc_err/5000)
       acc_err = 0.0