你需要做两件事：
1.按以下方式添加正则化器：

model.get_layer('Dense_1').kernel_regularizer = l2(0.01)

1.重新编译模型：

model.compile(...)

对于tensorflow 2.X，你只需要这样做：

l2 = tf.keras.regularizers.l2(1e-4)
for layer in model.layers:
    # if hasattr(layer, 'kernel'):
    # or
    # If you want to apply just on Conv
    if isinstance(layer, tf.keras.layers.Conv2D):
        model.add_loss(lambda layer=layer: l2(layer.kernel))

希望能有所帮助

Marcin的解决方案对我不起作用。如apatsekin所述，如果在添加Marcin建议的正则化器后打印layer.losses，您将得到一个空列表。
我发现了一个我根本不喜欢的变通方法，但我在这里发帖，以便更有能力的人可以找到一种更简单的方法来做到这一点。
我相信它适用于大多数keras.application网络。我从Github中的keras-application中复制了特定架构的.py文件（例如，InceptionResNetV2）到我机器中的本地文件regularizedNetwork.py。我不得不编辑它来修复一些相对导入，例如：

#old version
from . import imagenet_utils
from .imagenet_utils import decode_predictions
from .imagenet_utils import _obtain_input_shape

backend = None
layers = None
models = None
keras_utils = None

致：

#new version
from keras import backend
from keras import layers
from keras import models
from keras import utils as keras_utils

from keras.applications import imagenet_utils
from keras.applications.imagenet_utils import decode_predictions
from keras.applications.imagenet_utils import _obtain_input_shape

一旦解决了相对路径和导入问题，我就在每个所需的层中添加正则化器，就像定义一个新的未经训练的网络一样。通常，在定义架构之后，来自keras.application的模型加载预训练的权重。
现在，在main代码/notebook中，只需导入新的regularizedNetwork.py并调用main方法来示例化网络。

#main code
from regularizedNetwork import InceptionResNetV2

正则化器应该都设置好了，你可以正常地对正则化模型进行微调。
我相信有一个不那么花哨的方法来做到这一点，所以，请，如果有人发现它，写一个新的答案和/或评论在这个答案。
为了记录在案，我还尝试从keras.application示例化模型，用regModel = model.get_config()获得其架构，按照Marcin的建议添加正则化器，然后用regModel.set_weights(model.get_weights())加载权重，但它仍然不起作用。
编辑：拼写错误。

试试这个：

# a utility function to add weight decay after the model is defined.
def add_weight_decay(model, weight_decay):
    if (weight_decay is None) or (weight_decay == 0.0):
        return

    # recursion inside the model
    def add_decay_loss(m, factor):
        if isinstance(m, tf.keras.Model):
            for layer in m.layers:
                add_decay_loss(layer, factor)
        else:
            for param in m.trainable_weights:
                with tf.keras.backend.name_scope('weight_regularizer'):
                    regularizer = lambda: tf.keras.regularizers.l2(factor)(param)
                    m.add_loss(regularizer)

    # weight decay and l2 regularization differs by a factor of 2
    add_decay_loss(model, weight_decay/2.0)
    return

这是一个有点hacky，但它应该工作。这适用于Tensorflow 2.0中的预训练模型。请注意，所有层都应该是model.layers，即将跳过嵌套的加权层。从这里选择解决方案https://sthalles.github.io/keras-regularizer/

import os
import tempfile

def add_regularization(model, regularizer=tf.keras.regularizers.l2(0.0001)):

    if not isinstance(regularizer, tf.keras.regularizers.Regularizer):
      print("Regularizer must be a subclass of tf.keras.regularizers.Regularizer")
      return model

    for layer in model.layers:
        for attr in ['kernel_regularizer']:
            if hasattr(layer, attr):
              setattr(layer, attr, regularizer)

    # When we change the layers attributes, the change only happens in the model config file
    model_json = model.to_json()

    # Save the weights before reloading the model.
    tmp_weights_path = os.path.join(tempfile.gettempdir(), 'tmp_weights.h5')
    model.save_weights(tmp_weights_path)

    # load the model from the config
    model = tf.keras.models.model_from_json(model_json)

    # Reload the model weights
    model.load_weights(tmp_weights_path, by_name=True)
    return model

Horovod示例中的解决方法。这个想法是序列化模型，添加L2，然后将其恢复回来。

model_config = model.get_config()
for layer, layer_config in zip(model.layers, model_config['layers']):
    if hasattr(layer, 'kernel_regularizer'):
        regularizer = keras.regularizers.l2(args.wd)
        layer_config['config']['kernel_regularizer'] = \
            {'class_name': regularizer.__class__.__name__,
             'config': regularizer.get_config()}
    if type(layer) == keras.layers.BatchNormalization:
        layer_config['config']['momentum'] = 0.9
        layer_config['config']['epsilon'] = 1e-5

model = keras.models.Model.from_config(model_config)

迭代InceptionV3的所有层

def apply_regularization(
    model: tf.keras.Model,
    l1_regularization: Optional[float],
    l2_regularization: Optional[float],
) -> tf.keras.Model:
    for layer in model.layers:
        if hasattr(layer, "kernel_regularizer"):
            if l1_regularization:
                layer.kernel_regularizer = tf.keras.regularizers.l1(l1_regularization)
            if l2_regularization:
                layer.kernel_regularizer = tf.keras.regularizers.l2(l2_regularization)
    return model