Dans TensorFlow est-il possible d'initialiser non initialisée variables?

Le niveau moyen de l'initialisation des variables dans TensorFlow est

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

Après l'exécution de certains d'apprentissage pour un moment, j'ai créer un nouvel ensemble de variables, mais une fois que je les initialiser, il réinitialise toutes mes variables existantes. En ce moment, ma façon de contourner cela est d'enregistrer toutes les variables dont j'ai besoin et puis réappliquer après la tf.initalize_all_variables appel. Cela fonctionne, mais c'est un peu laid et maladroit. Je ne peux pas trouver quelque chose comme cela dans les docs...

Personne ne sait de toute bonne façon d'initialiser les variables non initialisées?

  • Le tf.train.Optimizer.minimize(loss) fonction est définie dans la documentation optim.apply_gradients(optim.compute_gradients(loss)). Ce serait faire de votre exemple la même que la mienne, sauf que vous jetez toutes les Nones. Pouvez-vous courir le train_step après cela? Lorsque je l'ai exécuté, tous les logements ont été None de sorte que l'optimiseur est resté initialisé et le réseau de neurones n'a pas pu exécuter.
  • Voici un exemple de simple qui fait exactement ce que vous voulez.
InformationsquelleAutor Daniel Slater | 2016-02-02
  1. 35

    Il n'est pas élégant* pour énumérer les variables non initialisées dans un graphe. Toutefois, si vous avez accès à la nouvelle variable objets—appelons-la v_6, v_7, et v_8—vous pouvez choisir de les initialiser à l'aide de tf.initialize_variables():

    init_new_vars_op = tf.initialize_variables([v_6, v_7, v_8])
sess.run(init_new_vars_op)

    * Un processus d'essai et d'erreur pourrait être utilisé pour identifier les variables non initialisées, comme suit:

    uninitialized_vars = []
for var in tf.all_variables():
    try:
        sess.run(var)
    except tf.errors.FailedPreconditionError:
        uninitialized_vars.append(var)

init_new_vars_op = tf.initialize_variables(uninitialized_vars)
# ...

    ...cependant, je ne voudrais pas tolérer un tel comportement :-).

    InformationsquelleAutor mrry
  2. 31

    Mise à JOUR: TensorFlow 0.9 a une nouvelle méthode qui "corrige" tout ce mais seulement si vous utilisez un VariableScope avec reuse ensemble de True. tf.report_uninitialized_variables qui peut être utilisé dans une ligne avec sess.run( tf.initialize_variables( list( tf.get_variable(name) for name in sess.run( tf.report_uninitialized_variables( tf.all_variables( ) ) ) ) ) )

    ou plus intelligemment grâce à la possibilité de spécifier les variables que vous vous attendez à être initialisé:

    def guarantee_initialized_variables(session, list_of_variables = None):
    if list_of_variables is None:
        list_of_variables = tf.all_variables()
    uninitialized_variables = list(tf.get_variable(name) for name in
                                   session.run(tf.report_uninitialized_variables(list_of_variables)))
    session.run(tf.initialize_variables(uninitialized_variables))
    return unintialized_variables

    C'est encore moins idéal que de savoir qui sont les variables et ne sont pas initialisées et en prenant soin de que bien, mais dans le cas de "détournement" comme le optim classes (voir ci-dessous), il peut être difficile de les éviter.

    Noter également, tf.initialize_variables ne peut pas évaluer tf.report_uninitialized_variables, de sorte que les deux d'entre eux ont à être exécuté dans le contexte de la session de travail.

    Il y a un peu élégante, mais concis façon de le faire. Avant de présenter votre nouveau variables exécuter temp = set(tf.all_variables()) et ensuite exécuter sess.run(tf.initialize_variables(set(tf.all_variables()) - temp)). Ensemble, ils ne initialiser toutes les variables créées après le temp la valeur est affectée.

    J'ai joué avec le transfert de l'apprentissage, donc je voulais un moyen rapide de le faire aussi, mais c'est le mieux que j'ai pu trouver. En particulier lors de l'utilisation de choses comme AdamOptimizer, qui ne vous donne pas facile (ou tout, je ne suis pas sûr) l'accès à des variables qu'il utilise. Donc ce qui suit s'affiche en fait dans mon code. (J'initialise la nouvelle couche explicitement les variables, et de l'exécuter une fois pour afficher l'erreur initiale avant le transfert de l'apprentissage. Juste pour un test de cohérence.)

    temp = set(tf.all_variables())
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#I honestly don't know how else to initialize ADAM in TensorFlow.
sess.run(tf.initialize_variables(set(tf.all_variables()) - temp))

    Et il résout tous mes problèmes.

    EDIT: @Lifu_Huang réponse les états la bonne façon de régler mon problème. En théorie, vous devriez utiliser tf.le train.L'optimiseur.get_slot_names et tf.le train.L'optimiseur.get_slot:

    optim = tf.train.AdadeltaOptimizer(1e-4)
loss = cross_entropy(y,yhat)
train_step = optim.minimize(loss)
sess.run(tf.initialize_variables([optim.get_slot(loss, name)
                                  for name in optim.get_slot_names()])

    Toutefois, cela me donne AttributeError: 'NoneType' object has no attribute 'initializer'. Je vais faire des modifications, lorsque je comprendre ce que j'ai fait de mal, de sorte que vous ne faites pas mon erreur.

    • J'en ai reproduit le AttributeError: 'NoneType' object has no attribute 'initializer' question.
    • Notez que malgré les fentes, il ne peut y avoir d'autres vars créé par l'optimiseur. AdamOptimizer pour moi aussi crée l'vars [<tf.Variable 'optimize/beta1_power:0' shape=() dtype=float32_ref>, <tf.Variable 'optimize/beta2_power:0' shape=() dtype=float32_ref>] qui ne correspondent pas à un éducables var, donc vous n'obtenez pas comme des machines à sous.
    InformationsquelleAutor Poik
  3. 26

    TF n'a pas une fonction qui fait exactement ce que vous voulez, mais vous pouvez facilement écrire:

    import tensorflow as tf

def initialize_uninitialized(sess):
    global_vars          = tf.global_variables()
    is_not_initialized   = sess.run([tf.is_variable_initialized(var) for var in global_vars])
    not_initialized_vars = [v for (v, f) in zip(global_vars, is_not_initialized) if not f]

    print [str(i.name) for i in not_initialized_vars] # only for testing
    if len(not_initialized_vars):
        sess.run(tf.variables_initializer(not_initialized_vars))

    Ici, j'ai extrait tous les les variables globales, itérer tous, et de vérifier si elles sont déjà initialisé. Après cela, j'obtiens une liste de variables non initialisées qui je initialiser. J'ai aussi l'impression des variables que je vais initialiser à des fins de débogage.

    Vous pouvez facilement vérifier qu'il fonctionne comme prévu:

    a = tf.Variable(3, name='my_var_a')
b = tf.Variable(4, name='my_var_b')

sess = tf.Session()
initialize_uninitialized(sess)
initialize_uninitialized(sess)

c = tf.Variable(5, name='my_var_a') # the same name, will be resolved to different name
d = tf.Variable(6, name='my_var_d')
initialize_uninitialized(sess)

print '\n\n', sess.run([a, b, c, d])

    Cela permettra d'imprimer tous les non initialisé les variables avant l'initialisation et la dernière sess.run sera assurez-vous vous convaincre que toutes les variables sont initialisées.

    Vous pouvez également utiliser tf.report_uninitialized_variables() écrire une fonction similaire. Un croquis est ici.

    • Grande Réponse. Vous avez obtenu mon vote. En utilisant tf.report_uninitialized_variables() être une meilleure approche?
    • à mon avis, les deux approches sont similaires, et je ne peux pas dire que l'un d'eux, c'est mieux.
    • Alors le premier lien est rompu.
    InformationsquelleAutor Salvador Dali
  4. 4

    Pour le cas @Poik mentionné, lorsque les variables sont créées par les optimiseurs de sorte qu'elles ne soient pas accessibles directement, une meilleure solution est d'utiliser tf.train.Optimizer.get_slot.

    Certains optimiseur de sous-classes, comme MomentumOptimizer et AdagradOptimizer d'allouer et de gérer d'autres variables associées aux variables de train. Celles-ci sont appelées machines à sous. Vous pouvez utiliser tf.train.Optimizer.get_slot_names() pour obtenir toutes les machines à sous les noms d'un optimiseur de a et ensuite utiliser tf.train.Optimizer.get_slot récupérer la variable allouée pour ces logements.

    • Cette réponse n'est pas réellement utilisable pourtant, depuis tf.train.Optimizer.get_slot retourne None pour les fentes jusqu'à ce que l'optimiseur crée les variables nécessaires, ce qui va se passer quand minimize est exécuté pour la première fois. Obtenir autour de cette nécessite d'appeler les sans-papiers de la fonction tf.train.Optimizer._zeros_slot() ou d'autres que vous ne devriez jamais faire si vous voulez la documentation de soutien et d'être en mesure d'utiliser les futures mises à jour de TensorFlow.
    • Notez que malgré les fentes, il ne peut y avoir d'autres vars créé par l'optimiseur. AdamOptimizer pour moi aussi crée l'vars [<tf.Variable 'optimize/beta1_power:0' shape=() dtype=float32_ref>, <tf.Variable 'optimize/beta2_power:0' shape=() dtype=float32_ref>] qui ne correspondent pas à un éducables var, donc vous n'obtenez pas comme des machines à sous.
    InformationsquelleAutor Lifu Huang
  5. 4

    J'ai trouvé une méthode pour TensorFlow r0.11:

    def get_uninitialized_variables(variables=None):
    """Get uninitialized variables as a list.

    Parameters
    ----------
    variables : collections.Iterable[tf.Variable]
        Return only uninitialized variables within this collection.
        If not specified, will return all uninitialized variables.

    Returns
    -------
    list[tf.Variable]
    """
    sess = tf.get_default_session()
    if variables is None:
        variables = tf.all_variables()
    else:
        variables = list(variables)
    init_flag = sess.run(
        tf.pack([tf.is_variable_initialized(v) for v in variables]))
    return [v for v, f in zip(variables, init_flag) if not f]
    InformationsquelleAutor 平芜泫
  6. 1

    Btw, si vous souhaitez initialiser un seul tenseur (par exemple tf.Variable) qui n'a pas été initialisé à l'aide de tf.global_variables_initializer(), alors vous pouvez utiliser your_tensor.initializer dans le sess.run() comme dans l'exemple suivant:

    In [196]: weights = tf.Variable(tf.zeros(shape=(3, 4)), name='weights')

In [197]: with tf.Session() as sess:
     ...:     sess.run(weights.initializer)
     ...:     print(weights.eval())
     ...:     

# the result
[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]
    InformationsquelleAutor kmario23
  7. 0

    Je pense que le plus simple est de créer tous les opérateurs de formation première et initialiser des variables par la suite.

    Par exemple, j'ai résolu le problème de la couche-sage préformation avec Adam Optimiseur de la manière suivante:

     # create an optimizer
 pretrain_optimizer =  tf.train.AdamOptimizer(learning_rate=learning_rate)

 # Make an array of the trainers for all the layers
 trainers=[pretrain_optimizer.minimize(loss_reconstruction(ae.run_less_layers(ae._input_, i+1), ae.run_less_layers(ae._input_, i+1, is_target=True)), global_step=tf.contrib.framework.get_or_create_global_step(), name='Layer_wise_optimizer_'+str(i)) for i in xrange(len(ae_shape) - 2)]

 # Initialize all the variables
 sess.run(tf.global_variables_initializer())
    InformationsquelleAutor Taras Kucherenko