在 Keras 层中重置权重

Posted 2023-02-16

【中文标题】在 Keras 层中重置权重

【英文标题】：Reset weights in Keras layer

【发布时间】：2017-03-22 14:52:40

【问题描述】：

我想重置（随机化）我的 Keras（深度学习）模型中所有层的权重。原因是我希望能够使用不同的数据拆分多次训练模型，而不必每次都进行（缓慢的）模型重新编译。

受this discussion 的启发，我正在尝试以下代码：

# Reset weights
for layer in KModel.layers:
    if hasattr(layer,'init'):
        input_dim = layer.input_shape[1]
        new_weights = layer.init((input_dim, layer.output_dim),name='_W'.format(layer.name))
        layer.trainable_weights[0].set_value(new_weights.get_value())

但是，它只是部分起作用。

部分是因为我检查了一些 layer.get_weights() 值，它们似乎发生了变化。但是当我重新开始训练时，成本值远低于第一次运行时的初始成本值。这几乎就像我已经成功地重置了一些权重，但不是全部。

【参考方案1】：

在编译模型之后但在训练之前保存初始权重：

model.save_weights('model.h5')

然后在训练之后，通过重新加载初始权重来“重置”模型：

model.load_weights('model.h5')

这为您提供了一个苹果对苹果模型来比较不同的数据集，并且应该比重新编译整个模型更快。

【讨论】：

我最终做了类似的事情。保存到磁盘和加载需要很多时间，所以我只是将权重保存在一个变量中： weights = model.get_weights() 在运行第一次训练之前，我得到了这样的初始权重。然后，在每次后续训练之前，我重新加载初始权重并运行 jkleint 的 shuffle 方法，如我发布的链接中所述。似乎工作顺利..

@Tor 建议的完整代码 sn-p：weights = model.get_weights()、model.compile(args)、model.fit(args)、model.set_weights(weights)

基于此，我在初始化模型的时候已经开始做一个lambda函数了。我构建模型，然后执行weights = model.get_weights() 之类的操作； reset_model = lambda model: model.set_weights(weights)，这样我以后就可以打电话给reset_model(model)了。

这有一个明显的问题，所有模型将具有相同的起始权重。我们想要（我认为）是再次随机初始化权重。

【参考方案2】：

通过检查初始化器来重置所有层：

def reset_weights(model):
    import keras.backend as K
    session = K.get_session()
    for layer in model.layers: 
        if hasattr(layer, 'kernel_initializer'): 
            layer.kernel.initializer.run(session=session)
        if hasattr(layer, 'bias_initializer'):
            layer.bias.initializer.run(session=session)     

更新：kernel_initializer 现在是 kernel.initializer。

【讨论】：

这是我认为最好的方法。

过时了吗？现在kernel_initializer 没有属性run。在我的情况下，kernel_initializer 是一个 VarianceScaling 对象

@XiaohongDeng 试试kernel.initializer.run(session=session)。我有同样的问题

AttributeError: module 'tensorflow_core.keras.backend' has no attribute 'get_session' 使用 tensorflow.keras

是的，它在 tf2 中不起作用，请在此处查看 tf2 的末尾：github.com/keras-team/keras/issues/341

【参考方案3】：

如果您想真正重新随机化权重，而不仅仅是恢复初始权重，您可以执行以下操作。根据您使用的是 TensorFlow 还是 Theano，代码会略有不同。

from keras.initializers import glorot_uniform  # Or your initializer of choice
import keras.backend as K

initial_weights = model.get_weights()

backend_name = K.backend()
if backend_name == 'tensorflow': 
    k_eval = lambda placeholder: placeholder.eval(session=K.get_session())
elif backend_name == 'theano': 
    k_eval = lambda placeholder: placeholder.eval()
else: 
    raise ValueError("Unsupported backend")

new_weights = [k_eval(glorot_uniform()(w.shape)) for w in initial_weights]

model.set_weights(new_weights)

【讨论】：

不错的简单解决方案！

Cannot evaluate tensor using `eval()`: No default session is registered.

【参考方案4】：

我找到了clone_model 函数，它创建了一个具有相同架构但新模型权重的克隆网络。

使用示例：

model_cloned = tensorflow.keras.models.clone_model(model_base)

比较权重：

original_weights = model_base.get_weights()
print("Original weights", original_weights)
print("========================================================")
print("========================================================")
print("========================================================")
model_cloned = tensorflow.keras.models.clone_model(model_base)
new_weights = model_cloned.get_weights()
print("New weights", new_weights)

如果您多次执行此代码，您会注意到克隆的模型每次都会收到新的权重。

【讨论】：

RuntimeError: 您必须在训练/测试之前编译您的模型。使用model.compile(optimizer, loss)。

【参考方案5】：

Tensorflow 2 答案：

for ix, layer in enumerate(model.layers):
    if hasattr(model.layers[ix], 'kernel_initializer') and \
            hasattr(model.layers[ix], 'bias_initializer'):
        weight_initializer = model.layers[ix].kernel_initializer
        bias_initializer = model.layers[ix].bias_initializer

        old_weights, old_biases = model.layers[ix].get_weights()

        model.layers[ix].set_weights([
            weight_initializer(shape=old_weights.shape),
            bias_initializer(shape=old_biases.shape)])

原始重量：

model.layers[1].get_weights()[0][0]

array([ 0.4450057 , -0.13564804,  0.35884023,  0.41411972,  0.24866664,
        0.07641453,  0.45726687, -0.04410008,  0.33194816, -0.1965386 ,
       -0.38438258, -0.13263905, -0.23807487,  0.40130925, -0.07339832,
        0.20535922], dtype=float32)

新权重：

model.layers[1].get_weights()[0][0]

array([-0.4607593 , -0.13104361, -0.0372932 , -0.34242013,  0.12066692,
       -0.39146423,  0.3247317 ,  0.2635846 , -0.10496247, -0.40134245,
        0.19276887,  0.2652442 , -0.18802321, -0.18488845,  0.0826562 ,
       -0.23322225], dtype=float32)

【参考方案6】：

K.get_session().close()
K.set_session(tf.Session())
K.get_session().run(tf.global_variables_initializer())

【讨论】：

不那么便携，但适用于 tensorflow 后端！

【参考方案7】：

试试 set_weights。

例如：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function
import numpy as np
np.random.seed(1234)
from keras.layers import Input
from keras.layers.convolutional import Convolution2D
from keras.models import Model

print("Building Model...")
inp = Input(shape=(1,None,None))
x   = Convolution2D(1, 3, 3, border_mode='same', init='normal',bias=False)(inp)
output = Convolution2D(1, 3, 3, border_mode='same', init='normal',bias=False)(x)
model_network = Model(input=inp, output=output)

w = np.asarray([ 
    [[[
    [0,0,0],
    [0,2,0],
    [0,0,0]
    ]]]
    ])

for layer_i in range(len(model_network.layers)):
    print (model_network.layers[layer_i])

for layer_i in range(1,len(model_network.layers)):
    model_network.layers[layer_i].set_weights(w)



input_mat = np.asarray([ 
    [[
    [1.,2.,3.,10.],
    [4.,5.,6.,11.],
    [7.,8.,9.,12.]
    ]]
    ])

print("Input:")
print(input_mat)
print("Output:")
print(model_network.predict(input_mat))

w2 = np.asarray([ 
    [[[
    [0,0,0],
    [0,3,0],
    [0,0,0]
    ]]]
    ])


for layer_i in range(1,len(model_network.layers)):
    model_network.layers[layer_i].set_weights(w2)

print("Output:")
print(model_network.predict(input_mat))

用两个卷积层构建模型

print("Building Model...")
inp = Input(shape=(1,None,None))
x   = Convolution2D(1, 3, 3, border_mode='same', init='normal',bias=False)(inp)
output = Convolution2D(1, 3, 3, border_mode='same', init='normal',bias=False)(x)
model_network = Model(input=inp, output=output)

然后定义你的权重（我使用一个简单的 w，但如果你愿意，你可以使用 np.random.uniform 或类似的东西）

w = np.asarray([ 
    [[[
    [0,0,0],
    [0,2,0],
    [0,0,0]
    ]]]
    ])

看看模型中的层是什么

for layer_i in range(len(model_network.layers)):
    print (model_network.layers[layer_i])

为每个卷积层设置每个权重（您会看到第一层实际上是输入并且您不想更改它，这就是范围从 1 开始而不是 0 的原因）。

for layer_i in range(1,len(model_network.layers)):
    model_network.layers[layer_i].set_weights(w)

为您的测试生成一些输入并预测模型的输出

input_mat = np.asarray([ 
    [[
    [1.,2.,3.,10.],
    [4.,5.,6.,11.],
    [7.,8.,9.,12.]
    ]]
    ])

print("Output:")
print(model_network.predict(input_mat))

如果需要，您可以再次更改它并再次检查输出：

w2 = np.asarray([ 
    [[[
    [0,0,0],
    [0,3,0],
    [0,0,0]
    ]]]
    ])

for layer_i in range(1,len(model_network.layers)):
    model_network.layers[layer_i].set_weights(w2)

print("Output:")
print(model_network.predict(input_mat))

样本输出：

Using Theano backend.
Building Model...
<keras.engine.topology.InputLayer object at 0x7fc0c619fd50>
<keras.layers.convolutional.Convolution2D object at 0x7fc0c6166250>
<keras.layers.convolutional.Convolution2D object at 0x7fc0c6150a10>
Weights after change:
[array([[[[ 0.,  0.,  0.],
         [ 0.,  2.,  0.],
         [ 0.,  0.,  0.]]]], dtype=float32)]
Input:
[[[[  1.   2.   3.  10.]
   [  4.   5.   6.  11.]
   [  7.   8.   9.  12.]]]]
Output:
[[[[  4.   8.  12.  40.]
   [ 16.  20.  24.  44.]
   [ 28.  32.  36.  48.]]]]
Output:
[[[[   9.   18.   27.   90.]
   [  36.   45.   54.   99.]
   [  63.   72.   81.  108.]]]]

通过查看 .layers，您可以看到第一层是输入层，其他层是卷积层。

【参考方案8】：

在 TF 2.0 (tf.keras) 中“随机”重新初始化已编译未训练模型的权重：

weights = [glorot_uniform(seed=random.randint(0, 1000))(w.shape) if w.ndim > 1 else w for w in model.get_weights()]

注意“如果 wdim > 1 else w”。您不想重新初始化偏差（它们保持 0 或 1）。