Python 在TensorFlow中，是否有任何方法可以初始化未初始化的变量？

在TensorFlow中初始化变量的标准方法是

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

在运行了一段时间的学习之后，我创建了一组新的变量，但一旦初始化它们，它就会重置所有现有的变量。目前我解决这个问题的方法是保存我需要的所有变量，然后在tf.initalize\u all\u variables调用之后重新应用它们。这是可行的，但有点难看和笨重。我在文件里找不到这样的东西

---

有人知道初始化未初始化变量的好方法吗

没有优雅的*方法来枚举图形中未初始化的变量。但是，如果您有权访问新的变量对象，让我们将它们称为

v_6

、

v_7

、和

v_8

，您可以使用以下选项选择性地初始化它们：

---

*可以使用试错过程来识别未初始化的变量，如下所示：

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

---

…但是，我不会宽恕这种行为：-）。

更新：TensorFlow 0.9有一种新方法，可以“修复”所有这些，但前提是您使用的是将

重用设置为
True
。它可以与sess.run（tf.initialize_变量（list（tf.get_变量（name））作为sess.run（tf.report_uninitialized_变量（tf.all_变量（）））中的name一起使用）

或者更智能地通过指定预期初始化的变量：

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

这仍然不如实际知道哪些变量是初始化的，哪些变量没有初始化，并正确处理这些变量，但是在像

optim

类（见下文）这样的错误引导的情况下，可能很难避免

还要注意，tf.initialize_变量不能计算tf.report_uninitialized_变量，因此它们都必须在会话上下文中运行才能工作

---

有一种不雅致但简洁的方法可以做到这一点。在引入新变量之前，运行

temp=set（tf.all\u variables（））

，然后运行

sess.run（tf.initialize\u variables（set（tf.all\u variables（））-temp））

。这些变量一起只会初始化分配临时值后创建的任何变量

我一直在玩迁移学习，所以我也想要一个快速的方法，但这是我能找到的最好的方法。尤其是在使用AdamOptimizer之类的工具时，它不能让您轻松（或任何，我不确定）访问它使用的变量。因此，以下内容实际上出现在我的代码中。（我显式初始化新层的变量，并在转移学习之前运行一次以显示初始错误。只是为了检查是否正常。）

它解决了我所有的问题

编辑：说明解决问题的正确方法。理论上，您应该使用和：

---

然而，这给了我

AttributeError:“NoneType”对象没有属性“initializer”

。当我发现我做错了什么时，我会进行编辑，这样你就不会犯我的错误。

对于@Poik提到的情况，当变量由优化器创建，因此无法直接访问时，一个更干净的解决方案是使用

tf.train.Optimizer.get\u slot

---

一些优化器子类，如

MomentumOptimizer

和

AdagradOptimizer

分配和管理与要训练的变量相关的其他变量。这些被称为插槽。您可以使用

tf.train.Optimizer.get_slot_names（）

获取优化器拥有的所有插槽名称，然后使用

tf.train.Optimizer.get_slot

获取分配给这些插槽的变量。

我为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]

---

我认为最简单的方法是首先创建所有的训练操作符，然后初始化变量

例如，我使用Adam Optimizer通过以下方式解决了分层预训练问题：

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

TF，但您可以轻松编写一个：

import tensorflow as tf

def initialize_uninitialized(sess):
    global_vars          = tf.global_variables()
    is_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_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))

在这里，我提取所有数据，迭代所有数据，并检查它们是否正确。在这之后，我得到了一个未初始化变量的列表。我还打印了为了调试而要初始化的变量

---

您可以轻松验证它是否按预期工作：

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

这将在初始化之前打印所有单元化变量，最后一次sess.run将确保说服您所有变量都已初始化

---

---

也可以使用编写类似的函数。它的简图是。

顺便说一句，如果您只想初始化一个未使用

tf.global\u variables\u initializer（）

初始化的张量（例如

tf.Variable

），那么您可以在

sess.run（）

中使用

您的张量.initializer>，如下例所示：

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

我已经重现了
AttributeError:'NoneType'对象没有属性“initializer”
问题。请注意，尽管有插槽，优化器可能会创建其他变量
AdamOptimizer
为我还创建了变量
[，]
，这些变量与可训练变量不对应，因此不能将它们作为插槽。Tensorflow 0.9具有可能有用的函数tf.report\u uninitialized\u variables（）。tf.initialize\u variables已被弃用。使用等效的方法此答案实际上还不可用，因为
tf.train.Optimizer.get_slot
会为插槽返回
None
，直到优化器创建所需的变量，这将在第一次运行
minimize
时发生。要解决这个问题，需要调用未记录的函数
tf.train.Optimizer.\u zeros\u slot（）
或其他函数，如果您想要有记录的支持，并且能够使用TensorFlow的未来更新，则不应该这样做。请注意，尽管有这些槽，优化器也可以创建其他变量
AdamOptimizer
for me还创建了与可训练的var不对应的var
[，]
，因此您不会将它们作为插槽获取。
tf.train.Optimizer.mi
import tensorflow as tf

def initialize_uninitialized(sess):
    global_vars          = tf.global_variables()
    is_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_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))

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

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