由于Adam Optimizer保留了一对移动平均值，例如梯度的均值/方差，所以我不知道它应该如何正确处理权重衰减。我已经看到了两种实现方法。
仅基于客观损失从梯度中更新均值/方差，在每个微型批次中明确地衰减权重。 （以下代码取自https://github.com/dmlc/mxnet/blob/v0.7.0/python/mxnet/optimizer.py）
weight[:] -= lr*mean/(sqrt(variance) + self.epsilon)
wd = self._get_wd(index)
if wd > 0.:
weight[:] -= (lr * wd) * weight
根据目标损失+正则损失更新梯度的均值/方差，并像往常一样更新权重。 （以下代码取自https://github.com/dmlc/mxnet/blob/master/src/operator/optimizer_op-inl.h#L210）
grad = scalar<DType>(param.rescale_grad) * grad +
scalar<DType>(param.wd) * weight;
// stuff
Assign(out, req[0],
weight -
scalar<DType>(param.lr) * mean /
(F<square_root>(var) + scalar<DType>(param.epsilon)));
这两种方法有时在训练结果上显示出显着差异。我实际上认为第一个更有意义（并且发现它有时会提供更好的结果）。 Caffe和旧版本的mxnet遵循第一种方法，而割炬，tensorflow和新版本的mxnet遵循第二种方法。
非常感谢您的帮助！
[Edit：另请参见this PR，它刚刚被合并为TF。
[当使用纯SGD（无动量）作为优化器时，重量衰减与在损失中添加L2正则项相同。 [使用任何其他优化器时，情况并非如此。
重量衰减（这里不知道如何TeX，请原谅我的伪标记）：
w[t+1] = w[t] - learning_rate * dw - weight_decay * w
L2正则化：
loss = actual_loss + lambda * 1/2 sum(||w||_2 for w in network_params)
计算L2正则化中多余项的梯度得到lambda * w，然后将其插入到SGD更新方程中
dloss_dw = dactual_loss_dw + lambda * w
w[t+1] = w[t] - learning_rate * dw
与重量衰减相同，但将lambda与learning_rate混合。任何其他优化器，甚至是带有动量的SGD，都可以为重量衰减提供与L2正规化不同的更新规则！有关更多详细信息，请参见论文Fixing weight decay in Adam。 （编辑：AFAIK，this 1987 Hinton paper引入了“权重衰减”，字面意思是“每次更新权重时，权重的大小也会减少0.4％”，第10页）
话虽如此，但TensorFlow似乎尚不支持“适当的”重量衰减。讨论它时有一些问题，特别是因为上面的论文。
一种实现它的可能方法是编写一个在每个优化器步骤之后手动执行衰减步骤的操作。我目前正在做的另一种方式是使用另一个SGD优化器来减轻重量，然后将其“附加”到您的train_op。不过，这两个都是粗略的解决方法。我当前的代码：
# In the network definition:
with arg_scope([layers.conv2d, layers.dense],
weights_regularizer=layers.l2_regularizer(weight_decay)):
# define the network.
loss = # compute the actual loss of your problem.
train_op = optimizer.minimize(loss, global_step=global_step)
if args.weight_decay not in (None, 0):
with tf.control_dependencies([train_op]):
sgd = tf.train.GradientDescentOptimizer(learning_rate=1.0)
train_op = sgd.minimize(tf.add_n(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)))
这在某种程度上利用了TensorFlow提供的簿记功能。请注意，arg_scope负责为REGULARIZATION_LOSSES图形键的每一层附加一个L2正则化项，然后我将其汇总并使用SGD进行优化，如上所示，它与实际的权重衰减相对应。
希望有帮助，并且如果有人对此有更好的代码段，或者TensorFlow可以更好地实现它（即在优化程序中，请共享。
我遇到了同样的问题。我认为我从here获得的代码将为您工作。它通过继承tf.train.Optimizer实现权重衰减亚当优化器。这是我找到的最干净的解决方案：
class AdamWeightDecayOptimizer(tf.train.Optimizer):
"""A basic Adam optimizer that includes "correct" L2 weight decay."""
def __init__(self,
learning_rate,
weight_decay_rate=0.0,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-6,
exclude_from_weight_decay=None,
name="AdamWeightDecayOptimizer"):
"""Constructs a AdamWeightDecayOptimizer."""
super(AdamWeightDecayOptimizer, self).__init__(False, name)
self.learning_rate = learning_rate
self.weight_decay_rate = weight_decay_rate
self.beta_1 = beta_1
self.beta_2 = beta_2
self.epsilon = epsilon
self.exclude_from_weight_decay = exclude_from_weight_decay
def apply_gradients(self, grads_and_vars, global_step=None, name=None):
"""See base class."""
assignments = []
for (grad, param) in grads_and_vars:
if grad is None or param is None:
continue
param_name = self._get_variable_name(param.name)
m = tf.get_variable(
name=param_name + "/adam_m",
shape=param.shape.as_list(),
dtype=tf.float32,
trainable=False,
initializer=tf.zeros_initializer())
v = tf.get_variable(
name=param_name + "/adam_v",
shape=param.shape.as_list(),
dtype=tf.float32,
trainable=False,
initializer=tf.zeros_initializer())
# Standard Adam update.
next_m = (
tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))
next_v = (
tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,
tf.square(grad)))
update = next_m / (tf.sqrt(next_v) + self.epsilon)
# Just adding the square of the weights to the loss function is *not*
# the correct way of using L2 regularization/weight decay with Adam,
# since that will interact with the m and v parameters in strange ways.
#
# Instead we want ot decay the weights in a manner that doesn't interact
# with the m/v parameters. This is equivalent to adding the square
# of the weights to the loss with plain (non-momentum) SGD.
if self._do_use_weight_decay(param_name):
update += self.weight_decay_rate * param
update_with_lr = self.learning_rate * update
next_param = param - update_with_lr
assignments.extend(
[param.assign(next_param),
m.assign(next_m),
v.assign(next_v)])
return tf.group(*assignments, name=name)
def _do_use_weight_decay(self, param_name):
"""Whether to use L2 weight decay for `param_name`."""
if not self.weight_decay_rate:
return False
if self.exclude_from_weight_decay:
for r in self.exclude_from_weight_decay:
if re.search(r, param_name) is not None:
return False
return True
def _get_variable_name(self, param_name):
"""Get the variable name from the tensor name."""
m = re.match("^(.*):\\d+$", param_name)
if m is not None:
param_name = m.group(1)
return param_name
并且您可以通过以下方式使用它（我进行了一些更改以使其在更一般的上下文中有用），该函数将返回可在Session中使用的train_op：
def create_optimizer(loss, init_lr, num_train_steps, num_warmup_steps):
"""Creates an optimizer training op."""
global_step = tf.train.get_or_create_global_step()
learning_rate = tf.constant(value=init_lr, shape=[], dtype=tf.float32)
# Implements linear decay of the learning rate.
learning_rate = tf.train.polynomial_decay(
learning_rate,
global_step,
num_train_steps,
end_learning_rate=0.0,
power=1.0,
cycle=False)
# Implements linear warmup. I.e., if global_step < num_warmup_steps, the
# learning rate will be `global_step/num_warmup_steps * init_lr`.
if num_warmup_steps:
global_steps_int = tf.cast(global_step, tf.int32)
warmup_steps_int = tf.constant(num_warmup_steps, dtype=tf.int32)
global_steps_float = tf.cast(global_steps_int, tf.float32)
warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)
warmup_percent_done = global_steps_float / warmup_steps_float
warmup_learning_rate = init_lr * warmup_percent_done
is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)
learning_rate = (
(1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)
# It is recommended that you use this optimizer for fine tuning, since this
# is how the model was trained (note that the Adam m/v variables are NOT
# loaded from init_checkpoint.)
optimizer = AdamWeightDecayOptimizer(
learning_rate=learning_rate,
weight_decay_rate=0.01,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-6)
tvars = tf.trainable_variables()
grads = tf.gradients(loss, tvars)
# You can do clip gradients if you need in this step(in general it is not neccessary)
# (grads, _) = tf.clip_by_global_norm(grads, clip_norm=1.0)
train_op = optimizer.apply_gradients(
zip(grads, tvars), global_step=global_step)
# Normally the global step update is done inside of `apply_gradients`.
# However, `AdamWeightDecayOptimizer` doesn't do this. But if you use
# a different optimizer, you should probably take this line out.
new_global_step = global_step + 1
train_op = tf.group(train_op, [global_step.assign(new_global_step)])
return train_op