如何在 TensorFlow 中添加正则化？

Posted 2023-02-23

【中文标题】如何在 TensorFlow 中添加正则化？

【英文标题】：How to add regularizations in TensorFlow?

【发布时间】：2016-09-03 14:00:45

【问题描述】：

我在许多使用 TensorFlow 实现的可用神经网络代码中发现，正则化项通常是通过手动向损失值添加一个附加项来实现的。

我的问题是：

有没有比手动进行更优雅或更推荐的正则化方式？

我还发现get_variable 有一个参数regularizer。应该如何使用？根据我的观察，如果我们将正则化器传递给它（例如tf.contrib.layers.l2_regularizer，则表示正则化项的张量将被计算并添加到名为tf.GraphKeys.REGULARIZATOIN_LOSSES 的图形集合中。TensorFlow 是否会自动使用该集合（例如训练时使用优化器）？还是希望我自己使用该集合？

【问题讨论】：

只是为了超级明确，是S = tf.get_variable(name='S', regularizer=tf.contrib.layers.l2_regularizer )的方法吗？

@Pinocchio 你知道了吗？

@Euler_Salter 我不记得了，对不起！不再使用张量流！

【参考方案1】：

正如您在第二点中所说，使用regularizer 参数是推荐的方式。您可以在get_variable 中使用它，或者在您的variable_scope 中设置一次，然后对所有变量进行正则化。

损失被收集在图表中，您需要像这样手动将它们添加到成本函数中。

  reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
  reg_constant = 0.01  # Choose an appropriate one.
  loss = my_normal_loss + reg_constant * sum(reg_losses)

希望有帮助！

【讨论】：

谢谢伙计。我在想 TensorFlow 会比手动处理更智能的方式来处理 reg 项，似乎不是：P

顺便说一句，有两个建议，如果我错了，请纠正我。 (1)，我猜reg_constant 可能不是必需的，因为 TensorFlow 中的正则化器在其构造函数中有一个参数 scale，因此可以以更细粒度的方式控制 reg 项的影响。并且（2）使用tf.add_n 可能比sum 稍微好一点，我猜使用sum 可能会在图中创建许多张量来存储中间结果。

所以只是为了让它超级清楚，在我将正则化器放入变量S = tf.get_variable(name='S', regularizer=tf.contrib.layers.l2_regularizer ) 之后，我是否是您建议的代码？如sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) ?

能否展示如何使权重变量成为可通过 tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) 检索的集合的一部分？

似乎应该使用tf.reduce_sum 而不是sum？

【参考方案2】：

现有答案的一些方面对我来说不是很清楚，所以这里有一个分步指南：

定义一个正则化器。这是可以设置正则化常数的地方，例如：

regularizer = tf.contrib.layers.l2_regularizer(scale=0.1)

通过以下方式创建变量：

    weights = tf.get_variable(
        name="weights",
        regularizer=regularizer,
        ...
    )

同样，可以通过常规的weights = tf.Variable(...) 构造函数创建变量，然后是tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, weights)。

定义一些loss术语并添加正则化术语：

reg_variables = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
reg_term = tf.contrib.layers.apply_regularization(regularizer, reg_variables)
loss += reg_term

注意：看起来tf.contrib.layers.apply_regularization 被实现为AddN，因此或多或少等同于sum(reg_variables)。

【讨论】：

我认为您在步骤和步骤 3 中应用了两次正则化器。如果您在创建变量时已经指定了正则化器，则不需要apply_regularization。

@interjay 请举个例子，所有这些答案都超级不清楚！这是因为总是至少有一个人在下面写评论说上面的答案有问题。

@interjay 我很确定我上次测试时必须同时执行这两项操作。我不确定这是否已经改变。

不，这没有任何意义，因为这样您就不需要将相同的正则化器传递给两个函数。文档（和名称）清楚地表明 REGULARIZATION_LOSSES 是从正则化器返回的总损失，因此您实际上是在调用 regularizer(regularizer(weight))。

我认为这里的混淆源于“等效”部分。他描述了两种不同的方法，您可以选择一种，这不是一种涉及两次应用正则化的方法。

【参考方案3】：

我将提供一个简单的正确答案，因为我没有找到答案。你只需要两个简单的步骤，剩下的就靠 tensorflow 魔法来完成：

在创建变量或层时添加正则化器：

tf.layers.dense(x, kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
# or
tf.get_variable('a', regularizer=tf.contrib.layers.l2_regularizer(0.001))

定义损失时添加正则化项：

loss = ordinary_loss + tf.losses.get_regularization_loss()

【讨论】：

如果我通过正则化器 = tf.contrib.layers.l2_regularizer(0.001) 创建正则化器操作，我可以将它传递给多层启动吗？还是我需要为每一层创建一个单独的正则化器，例如regularizer1=tf.contrib.layers.l2_regularizer(0.001), regularizer2 = ..regularizer3 = .... ..等等？

@Nitin 您可以使用相同的正则化器。它只是一个 python 函数，将损失作为参数应用于权重。

这看起来是最优雅的解决方案，但这真的有效吗？这与说 reg_variables = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) reg_term = tf.contrib.layers.apply_regularization(regularizer, reg_variables) loss += reg_term

有何不同

我只想提一下 tf.contrib.layers.fully_connected 可以替代 tf.layers.dense 并且还可以添加更多功能。请参考：this、this 和 this。

【参考方案4】：

使用 contrib.learn 库的另一个选项如下，基于 Tensorflow 网站上的 Deep MNIST tutorial。首先，假设你已经导入了相关的库（比如import tensorflow.contrib.layers as layers），你可以在单独的方法中定义一个网络：

def easier_network(x, reg):
    """ A network based on tf.contrib.learn, with input `x`. """
    with tf.variable_scope('EasyNet'):
        out = layers.flatten(x)
        out = layers.fully_connected(out, 
                num_outputs=200,
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = tf.nn.tanh)
        out = layers.fully_connected(out, 
                num_outputs=200,
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = tf.nn.tanh)
        out = layers.fully_connected(out, 
                num_outputs=10, # Because there are ten digits!
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = None)
        return out 

然后，在main方法中，可以使用如下代码sn -p：

def main(_):
    mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])

    # Make a network with regularization
    y_conv = easier_network(x, FLAGS.regu)
    weights = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'EasyNet') 
    print("")
    for w in weights:
        shp = w.get_shape().as_list()
        print("-  shape: size:".format(w.name, shp, np.prod(shp)))
    print("")
    reg_ws = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, 'EasyNet')
    for w in reg_ws:
        shp = w.get_shape().as_list()
        print("-  shape: size:".format(w.name, shp, np.prod(shp)))
    print("")

    # Make the loss function `loss_fn` with regularization.
    cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
    loss_fn = cross_entropy + tf.reduce_sum(reg_ws)
    train_step = tf.train.AdamOptimizer(1e-4).minimize(loss_fn)

要使其工作，您需要遵循我之前链接的 MNIST 教程并导入相关库，但这是学习 TensorFlow 的一个很好的练习，并且很容易看到正则化如何影响输出。如果您应用正则化作为参数，您可以看到以下内容：

- EasyNet/fully_connected/weights:0 shape:[784, 200] size:156800
- EasyNet/fully_connected/biases:0 shape:[200] size:200
- EasyNet/fully_connected_1/weights:0 shape:[200, 200] size:40000
- EasyNet/fully_connected_1/biases:0 shape:[200] size:200
- EasyNet/fully_connected_2/weights:0 shape:[200, 10] size:2000
- EasyNet/fully_connected_2/biases:0 shape:[10] size:10

- EasyNet/fully_connected/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0
- EasyNet/fully_connected_1/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0
- EasyNet/fully_connected_2/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0

请注意，正则化部分根据可用项目为您提供三个项目。

使用 0、0.0001、0.01 和 1.0 的正则化，我得到的测试准确度值分别为 0.9468、0.9476、0.9183 和 0.1135，显示了高正则化项的危险。

【讨论】：

很详细的例子。

【参考方案5】：

如果有人还在寻找，我只想在 tf.keras 中添加它，您可以通过将它们作为参数传递到您的层中来添加权重正则化。从 Tensorflow Keras 教程网站批量添加 L2 正则化的示例：

model = keras.models.Sequential([
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu),
    keras.layers.Dense(1, activation=tf.nn.sigmoid)
])

据我所知，这种方法不需要手动添加正则化损失。

参考：https://www.tensorflow.org/tutorials/keras/overfit_and_underfit#add_weight_regularization

【参考方案6】：

我在图中用一个l2_regularizer 测试了tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES) 和tf.losses.get_regularization_loss()，发现它们返回的值相同。通过观察值的数量，我猜reg_constant通过设置tf.contrib.layers.l2_regularizer的参数已经对值有意义了。

【参考方案7】：

如果您有 CNN，您可以执行以下操作：

在你的模型函数中：

conv = tf.layers.conv2d(inputs=input_layer,
                        filters=32,
                        kernel_size=[3, 3],
                        kernel_initializer='xavier',
                        kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-5),
                        padding="same",
                        activation=None) 
...

在你的损失函数中：

onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=num_classes)
loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits)
regularization_losses = tf.losses.get_regularization_losses()
loss = tf.add_n([loss] + regularization_losses)

【参考方案8】：

有些答案让我比较迷茫，这里我给两个方法说清楚。

#1.adding all regs by hand
var1 = tf.get_variable(name='v1',shape=[1],dtype=tf.float32)
var2 = tf.Variable(name='v2',initial_value=1.0,dtype=tf.float32)
regularizer = tf.contrib.layers.l1_regularizer(0.1)
reg_term = tf.contrib.layers.apply_regularization(regularizer,[var1,var2])
#here reg_term is a scalar

#2.auto added and read,but using get_variable
with tf.variable_scope('x',
        regularizer=tf.contrib.layers.l2_regularizer(0.1)):
    var1 = tf.get_variable(name='v1',shape=[1],dtype=tf.float32)
    var2 = tf.get_variable(name='v2',shape=[1],dtype=tf.float32)
reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
#here reg_losses is a list,should be summed 

然后，它可以被添加到总损失中

【参考方案9】：

cross_entropy = tf.losses.softmax_cross_entropy(
  logits=logits, onehot_labels=labels)

l2_loss = weight_decay * tf.add_n(
     [tf.nn.l2_loss(tf.cast(v, tf.float32)) for v in tf.trainable_variables()])

loss = cross_entropy + l2_loss

【讨论】：

感谢您提供此代码 sn-p，它可能会提供一些有限的即时帮助。一个适当的解释将通过展示为什么这是解决问题的好方法来极大地提高其长期价值，并使其对有其他类似问题的未来读者更有用。请编辑您的答案以添加一些解释，包括您所做的假设。

【参考方案10】：

tf.GraphKeys.REGULARIZATION_LOSSES 不会自动添加，但有一个简单的添加方法：

reg_loss = tf.losses.get_regularization_loss()
total_loss = loss + reg_loss

tf.losses.get_regularization_loss() 使用 tf.add_n 对 tf.GraphKeys.REGULARIZATION_LOSSES 元素的条目求和。 tf.GraphKeys.REGULARIZATION_LOSSES 通常是一个标量列表，使用正则化函数计算。它从对tf.get_variable 的调用中获取指定了regularizer 参数的条目。您也可以手动添加到该集合。这在使用tf.Variable 以及指定活动正则化器或其他自定义正则化器时会很有用。例如：

#This will add an activity regularizer on y to the regloss collection
regularizer = tf.contrib.layers.l2_regularizer(0.1)
y = tf.nn.sigmoid(x)
act_reg = regularizer(y)
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, act_reg)

（在这个例子中，对 x 进行正则化可能会更有效，因为对于较大的 x，y 确实会变平。）