Réinitialisation de poids dans Keras couche

Je voudrais réinitialiser (aléatoire), le poids de toutes les couches dans mon Keras (deep learning) modèle. La raison en est que je veux être en mesure de former le modèle plusieurs fois avec des données différentes scissions, sans avoir à faire la (lente) modèle de la recompilation à chaque fois.

Inspiré par cette discussion, je vais essayer le code suivant:

# 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())

Cependant, seulement en partie les travaux.

En partie, parce que j'ai inspecté un calque.get_weights() les valeurs, et elles semblent changer. Mais lorsque je redémarre la formation, le coût des valeurs sont beaucoup plus faibles que le coût initial des valeurs lors de la première exécution. C'est presque comme si je l'ai réussi réinitialisation de certains poids, mais pas tous d'entre eux.

Des conseils sur les endroits où je vais mal serait vivement appréciée. Thx..

OriginalL'auteur Tor | 2016-11-08

16

Enregistrer les poids initiaux à droite après la compilation du modèle, mais avant la formation:
```
model.save_weights('model.h5')
```
et puis, après la formation, "reset", le modèle en rechargeant les poids initiaux:
```
model.load_weights('model.h5')
```
Cela vous donne une des pommes avec des pommes modèle de comparer les différents ensembles de données et devrait être plus rapide que la recompilation de l'ensemble du modèle.

J'ai fini par faire quelque chose de similaire. La sauvegarde sur disque et le chargement prend beaucoup de temps, alors j'ai juste garder le poids dans une variable: poids = modèle.get_weights (), je reçois le poids initiaux comme ça avant l'exécution de la première formation. Ensuite, avant chaque subsequentt de formation, j'ai recharger les poids initiaux et exécuter jkleint de lecture aléatoire de la méthode, comme indiqué dans le lien que j'ai posté. Semble bien fonctionner..
Pour le code complet extrait de @Tor suggestion: weights = model.get_weights(), model.compile(args), model.fit(args), model.set_weights(weights)

OriginalL'auteur ezchx

Si vous voulez vraiment ré-aléatoire, le poids, et non pas seulement de restaurer les poids initiaux, vous pouvez effectuer les opérations suivantes. Le code est légèrement différente selon que vous êtes en utilisant TensorFlow ou Théano.

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)

Agréable et simple solution!
Cannot evaluate tensor using `eval()`: No default session is registered.
Voir mon edit

OriginalL'auteur BallpointBen

Réinitialiser tous les calques en vérifiant les initialiseurs:

def reset_weights(model):
    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)

C'est la meilleure approche à mon avis.
Est-il obsolète? Maintenant kernel_initializer n'a pas d'attribut run. Dans mon cas, kernel_initializer est un VarianceScaling objet

OriginalL'auteur Mendi Barel

Essayer set_weights.

par exemple:

#!/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))

construire un modèle à dire, les deux convolutifs couches

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)

ensuite définir votre poids (je suis à l'aide d'un simple w, mais vous pouvez utiliser np.aléatoire.uniforme ou quelque chose comme ça si vous voulez)

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

Prendre un coup d'oeil à ce que sont les couches à l'intérieur d'un modèle

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

Définir chaque poids pour chaque convolutifs couche (vous verrez que la première couche est en fait l'entrée et vous ne voulez pas changer cela, c'est pourquoi la gamme commence à partir de 1 pas zéro).

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

Générer une entrée pour votre test et de prédire la sortie de votre modèle

input_mat = np.asarray([ 
[[
[1.,2.,3.,10.],
[4.,5.,6.,11.],
[7.,8.,9.,12.]
]]
])
print("Output:")
print(model_network.predict(input_mat))

Vous pouvez le changer à nouveau si vous le souhaitez et vérifiez à nouveau pour la sortie:

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))

Exemple de sortie:

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.]]]]

De votre coup d'oeil .couches vous pouvez voir que la première couche d'entrée et les autres votre convolutifs couches.

OriginalL'auteur maz

2
```
K.get_session().close()
K.set_session(tf.Session())
K.get_session().run(tf.global_variables_initializer())
```
Pas tout à fait comme portable, mais fonctionne bien pour tensorflow backend!

OriginalL'auteur Ashot Matevosyan

Vous devez vous connecter pour publier un commentaire.