Je porte mon réseau Caffe sur TensorFlow, mais il ne semble pas avoir d'initialisation xavier. J'utilise truncated_normal
mais cela semble rendre la formation beaucoup plus difficile.
Depuis la version 0.8, il existe un initialiseur Xavier, voir ici pour la documentation .
Vous pouvez utiliser quelque chose comme ceci:
W = tf.get_variable("W", shape=[784, 256],
initializer=tf.contrib.layers.xavier_initializer())
Juste pour ajouter un autre exemple sur la façon de définir un tf.Variable
initialisé en utilisant la méthode de Xavier et Yoshua :
graph = tf.Graph()
with graph.as_default():
...
initializer = tf.contrib.layers.xavier_initializer()
w1 = tf.Variable(initializer(w1_shape))
b1 = tf.Variable(initializer(b1_shape))
...
Cela m'a empêché d'avoir des valeurs nan
sur ma fonction de perte en raison d'instabilités numériques lors de l'utilisation de plusieurs couches avec des RELU.
@ Aleph7, l'initialisation Xavier/Glorot dépend du nombre de connexions entrantes (fan_in), du nombre de connexions sortantes (fan_out) et du type de fonction d'activation (sigmoïde ou tanh) du neurone. Voir ceci: http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf
Alors maintenant, à votre question. Voici comment je le ferais dans TensorFlow:
(fan_in, fan_out) = ...
low = -4*np.sqrt(6.0/(fan_in + fan_out)) # use 4 for sigmoid, 1 for tanh activation
high = 4*np.sqrt(6.0/(fan_in + fan_out))
return tf.Variable(tf.random_uniform(shape, minval=low, maxval=high, dtype=tf.float32))
Notez que nous devrions échantillonner à partir d'une distribution uniforme, et non de la distribution normale comme suggéré dans l'autre réponse.
A propos, j’ai écrit un post hier pour quelque chose de différent en utilisant TensorFlow qui utilise également l’initialisation de Xavier. Si cela vous intéresse, il existe également un bloc-notes python avec un exemple de bout en bout: https://github.com/delip/blog-stuff/blob/master/tensorflow_ufp. ipynb
TF-contrib a xavier_initializer
. Voici un exemple d'utilisation:
_import tensorflow as tf
a = tf.get_variable("a", shape=[4, 4], initializer=tf.contrib.layers.xavier_initializer())
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
print sess.run(a)
_
En plus de cela, tensorflow a d’autres initialiseurs:
Un bel emballage autour de tensorflow
appelé prettytensor
donne une implémentation dans le code source (copié directement à partir de ici ):
def xavier_init(n_inputs, n_outputs, uniform=True):
"""Set the parameter initialization using the method described.
This method is designed to keep the scale of the gradients roughly the same
in all layers.
Xavier Glorot and Yoshua Bengio (2010):
Understanding the difficulty of training deep feedforward neural
networks. International conference on artificial intelligence and
statistics.
Args:
n_inputs: The number of input nodes into each output.
n_outputs: The number of output nodes for each input.
uniform: If true use a uniform distribution, otherwise use a normal.
Returns:
An initializer.
"""
if uniform:
# 6 was used in the paper.
init_range = math.sqrt(6.0 / (n_inputs + n_outputs))
return tf.random_uniform_initializer(-init_range, init_range)
else:
# 3 gives us approximately the same limits as above since this repicks
# values greater than 2 standard deviations from the mean.
stddev = math.sqrt(3.0 / (n_inputs + n_outputs))
return tf.truncated_normal_initializer(stddev=stddev)
Dans , Tensorflow 2.0 et plus encore, tf.contrib.*
et tf.get_variable()
sont obsolètes. Pour effectuer l'initialisation de Xavier, vous devez maintenant passer à:
init = tf.initializers.GlorotUniform()
var = tf.Variable(init(shape=shape))
# or a oneliner with a little confusing brackets
var = tf.Variable(tf.initializers.GlorotUniform()(shape=shape))
L'uniforme de Glorot et l'uniforme de Xavier sont deux noms différents du même type d'initialisation. Si vous souhaitez en savoir plus sur l’utilisation des initialisations dans TF2.0 avec ou sans Keras, reportez-vous à documentation .
Juste au cas où vous voudriez utiliser une ligne comme vous le faites avec:
W = tf.Variable(tf.truncated_normal((n_prev, n), stddev=0.1))
Tu peux faire:
W = tf.Variable(tf.contrib.layers.xavier_initializer()((n_prev, n)))
Via le paramètre kernel_initializer
à tf.layers.conv2d, tf.layers.conv2d_transpose, tf.layers.Dense
etc
par exemple.
layer = tf.layers.conv2d(
input, 128, 5, strides=2,padding='SAME',
kernel_initializer=tf.contrib.layers.xavier_initializer())
https://www.tensorflow.org/api_docs/python/tf/layers/conv2d
https://www.tensorflow.org/api_docs/python/tf/layers/conv2d_transpose
J'ai regardé et je n'ai rien trouvé construit. Cependant, selon ceci:
http://andyljones.tumblr.com/post/110998971763/an-explanation-of-xavier-initialization
L’initialisation de Xavier ne fait qu’échantillonner une distribution (généralement gaussienne) où la variance est fonction du nombre de neurones. tf.random_normal
peut le faire pour vous, il vous suffit de calculer stddev (c'est-à-dire le nombre de neurones représentés par la matrice de poids que vous essayez d'initialiser).