重置 Keras 层中的权重
Reset weights in Keras layer
我想重置（随机化）我的 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() 值，它们似乎发生了变化。但是当我重新开始训练时，成本值远低于第一个 运行 的初始成本值。这几乎就像我已经成功重置了一些权重，但不是全部。
尝试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 而不是零开始的原因）。
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，您可以看到第一层是输入层，其他层是卷积层。
在编译模型之后但在训练之前立即保存初始权重：
model.save_weights('model.h5')
然后在训练后，"reset" 模型通过重新加载初始权重：
model.load_weights('model.h5')
这为您提供了一个同类模型来比较不同的数据集，并且应该比重新编译整个模型更快。
如果您想真正重新随机化权重，而不仅仅是恢复初始权重，您可以执行以下操作。根据您使用的是 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)
通过检查初始化器重置所有层：
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。
K.get_session().close()
K.set_session(tf.Session())
K.get_session().run(tf.global_variables_initializer())
"random" 在 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()]
注意 "if wdim > 1 else w"。您不想重新初始化偏差（它们保持为 0 或 1）。
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)
我找到了 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)
如果多次执行此代码，您会注意到克隆模型每次都会收到新的权重。
我想重置（随机化）我的 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() 值，它们似乎发生了变化。但是当我重新开始训练时，成本值远低于第一个 运行 的初始成本值。这几乎就像我已经成功重置了一些权重，但不是全部。
尝试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 而不是零开始的原因）。
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，您可以看到第一层是输入层，其他层是卷积层。
在编译模型之后但在训练之前立即保存初始权重：
model.save_weights('model.h5')
然后在训练后，"reset" 模型通过重新加载初始权重：
model.load_weights('model.h5')
这为您提供了一个同类模型来比较不同的数据集，并且应该比重新编译整个模型更快。
如果您想真正重新随机化权重，而不仅仅是恢复初始权重，您可以执行以下操作。根据您使用的是 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)
通过检查初始化器重置所有层：
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。
K.get_session().close()
K.set_session(tf.Session())
K.get_session().run(tf.global_variables_initializer())
"random" 在 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()]
注意 "if wdim > 1 else w"。您不想重新初始化偏差（它们保持为 0 或 1）。
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)
我找到了 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)
如果多次执行此代码，您会注意到克隆模型每次都会收到新的权重。