python getvariable - Différence entre Variable et get_variable dans TensorFlow




different graphs (4)

Je peux trouver deux différences principales entre l'un et l'autre:

  1. La première est que tf.Variable créera toujours une nouvelle variable, que tf.get_variable obtienne du graphique une variable existante avec ces paramètres, et si elle n'existe pas, elle en crée une nouvelle.

  2. tf.Variable nécessite qu'une valeur initiale soit spécifiée.

Il est important de préciser que la fonction tf.get_variable préfixe le nom avec la portée de la variable courante pour effectuer des vérifications de réutilisation. Par exemple:

with tf.variable_scope("one"):
    a = tf.get_variable("v", [1]) #a.name == "one/v:0"
with tf.variable_scope("one"):
    b = tf.get_variable("v", [1]) #ValueError: Variable one/v already exists
with tf.variable_scope("one", reuse = True):
    c = tf.get_variable("v", [1]) #c.name == "one/v:0"

with tf.variable_scope("two"):
    d = tf.get_variable("v", [1]) #d.name == "two/v:0"
    e = tf.Variable(1, name = "v", expected_shape = [1]) #e.name == "two/v_1:0"

assert(a is c)  #Assertion is true, they refer to the same object.
assert(a is d)  #AssertionError: they are different objects
assert(d is e)  #AssertionError: they are different objects

La dernière erreur d'assertion est intéressante: Deux variables ayant le même nom sous la même portée sont supposées être la même variable. Mais si vous testez les noms des variables d et e vous vous rendrez compte que Tensorflow a changé le nom de la variable e :

d.name   #d.name == "two/v:0"
e.name   #e.name == "two/v_1:0"

Pour autant que je sache, Variable est l'opération par défaut pour faire une variable, et get_variable est principalement utilisé pour le partage de poids.

D'une part, certaines personnes suggèrent d'utiliser get_variable au lieu de l'opération Variable primitive chaque fois que vous avez besoin d'une variable. D'un autre côté, je ne vois que l'utilisation de get_variable dans les documents officiels et les démos de TensorFlow.

Ainsi, je veux savoir quelques règles empiriques sur la façon d'utiliser correctement ces deux mécanismes. Y a-t-il des principes "standards"?


Je recommande de toujours utiliser tf.get_variable(...) - il sera plus facile de refactoriser votre code si vous avez besoin de partager des variables à tout moment, par exemple dans un multi-gpu (voir le multi-gpu) Exemple CIFAR). Il n'y a aucun inconvénient à cela.

Pure tf.Variable est de niveau inférieur; à un certain moment, tf.get_variable() n'existait pas, donc du code utilise toujours la méthode de bas niveau.


tf.Variable est une classe et il existe plusieurs façons de créer tf.Variable, y compris tf.Variable .__ init__ et tf.get_variable.

tf.Variable .__ init__: Crée une nouvelle variable avec initial_value .

W = tf.Variable(<initial-value>, name=<optional-name>)

tf.get_variable: Récupère une variable existante avec ces paramètres ou en crée une nouvelle. Vous pouvez également utiliser l'initialiseur.

W = tf.get_variable(name, shape=None, dtype=tf.float32, initializer=None,
       regularizer=None, trainable=True, collections=None)

Il est très utile d'utiliser des initialiseurs tels que xavier_initializer:

W = tf.get_variable("W", shape=[784, 256],
       initializer=tf.contrib.layers.xavier_initializer())

Plus d'informations sur https://www.tensorflow.org/versions/r0.8/api_docs/python/state_ops.html#Variable .


La méthode append () ajoute un seul élément à la fin de la liste.

x = [1, 2, 3]
x.append([4, 5])
x.append('abc')
print(x)
# gives you
[1, 2, 3, [4, 5], 'abc']

La méthode extend () prend un argument, une liste, et ajoute chacun des éléments de l'argument à la liste d'origine. (Les listes sont implémentées en tant que classes. «Créer» une liste, c'est vraiment instancier une classe. En tant que telle, une liste a des méthodes qui fonctionnent dessus.)

x = [1, 2, 3]
x.extend([4, 5])
x.extend('abc')
print(x)
# gives you
[1, 2, 3, 4, 5, 'a', 'b', 'c']

De plonger en Python .





python tensorflow