床头笔记之tensorflow学习（一）

tensorflowAPI笔记之变量

变量

class tf.Variable

可变辅助函数

tf.all_variables()
tf.trainable_variables()
tf.initialize_all_variables()
tf.initialize_variables(var_list, name='init')
tf.assert_variables_initialized(var_list=None)

保存和恢复变量

class tf.train.Saver
tf.train.latest_checkpoint(checkpoint_dir, latest_filename=None)
tf.train.get_checkpoint_state(checkpoint_dir, latest_filename=None)
tf.train.update_checkpoint_state(save_dir, model_checkpoint_path, all_model_checkpoint_paths=None, latest_filename=None)

共享变量

tf.get_variable(name, shape=None, dtype=tf.float32, initializer=None, trainable=True, collections=None)
tf.get_variable_scope()
tf.variable_scope(name_or_scope, reuse=None, initializer=None)
tf.constant_initializer(value=0.0)
tf.random_normal_initializer(mean=0.0, stddev=1.0, seed=None)
tf.truncated_normal_initializer(mean=0.0, stddev=1.0, seed=None)
tf.random_uniform_initializer(minval=0.0, maxval=1.0, seed=None)
tf.uniform_unit_scaling_initializer(factor=1.0, seed=None)
tf.zeros_initializer(shape, dtype=tf.float32)

稀疏变量更新

tf.scatter_update(ref, indices, updates, use_locking=None, name=None)
tf.scatter_add(ref, indices, updates, use_locking=None, name=None)
tf.scatter_sub(ref, indices, updates, use_locking=None, name=None)
tf.sparse_mask(a, mask_indices, name=None)
class tf.IndexedSlices

讲解

变量

class tf.Variable

• 变量在调用run()时获得图中的状态。您可以通过构造类Variable的实例将变量添加到图形中。 初始值定义变量的类型和形状。

• 构造完成后，变量的类型和形状是固定的。可以使用其中一种assign方法更改该值。 如果您之后想更改变量的形状，则必须
  在validate_shape=False下使用 assign操作。

• 与任何Tensor张量一样，创建的变量Variable()可以用作图中其他操作Ops的输入。此外，为Tensor类重载的所有运算符都被转移到变量，因此您还可以通过对变量进行算术运算来向图中添加节点。

   import tensorflow as tf
   # Create a variable.
   w = tf.Variable(, name=)
   # Use the variable in the graph like any Tensor.
   y = tf.matmul(w, ...another variable or tensor...)
   # The overloaded operators are available too.
   z = tf.sigmoid(w + b)
   # Assign a new value to the variable with `assign()` or a related method.
   w.assign(w + 1.0)
   w.assign_add(1.0)
  

• 启动图形时，必须先初始化变量，然后才能运行使用了变量其值的Ops。您可以通过运行初始化程序op，从保存文件恢复变量，或者只是运行assign为变量赋值的Op来初始化变量。实际上，变量初始化器op只是一个assign Op，它将变量的初始值赋给变量本身。

   # Launch the graph in a session.
   with tf.Session() as sess:
       # Run the variable initializer.
       sess.run(w.initializer)
       # ...you now can run ops that use the value of 'w'...
  

初始化

• 最常见的初始化模式是使用便捷函数
  initialize_all_variables()初始化所有变量，将这个Op添加到图形中。然后在启动图形后运行该Op。
  # Add an Op to initialize all variables.
  init_op = tf.initialize_all_variables()

   # Launch the graph in a session.
   with tf.Session() as sess:
       # Run the Op that initializes all variables.
       sess.run(init_op)
       # ...you can now run any Op that uses variable values...
  

如果需要创建一个初始值取决于另一个变量的变量，请使用另一个变量initialized_value()。这可确保以正确的顺序初始化变量。

所有变量都会自动收集在创建它们的图形中。默认情况下，构造函数将新变量添加到图集合中GraphKeys.VARIABLES。便捷函数 all_variables()返回该集合的内容。

在构建机器学习模型时，通常很容易区分保持可训练模型参数的变量和其他变量，例如global step用于计算训练步骤的变量。为了使这更容易，变量构造函数支持一个trainable=参数。如果 True，新变量也会添加到图表集合中 GraphKeys.TRAINABLE_VARIABLES。便捷函数 trainable_variables()返回此集合的内容。各种Optimizer类使用此集合作为要优化的变量的默认列表。

创建变量构造函数。

tf.Variable.__init__(initial_value, trainable=True, collections=None, validate_shape=True, name=None)

使用值创建新变量initial_value。
新变量将添加到列出的图表集合中collections，默认为[GraphKeys.VARIABLES]。
如果trainable是True变量也被添加到图集合中 GraphKeys.TRAINABLE_VARIABLES。
此构造函数创建variableOp和assignOp以将变量设置为其初始值。
参数ARGS：

• initial_value：A Tensor，或可转换为Tensor的Python对象。变量的初始值。必须具有指定的形状，除非
  validate_shape设置为False。
• trainable：如果True是默认值，还会将变量添加到图表集合中
• GraphKeys.TRAINABLE_VARIABLES。此集合用作类使用的默认变量列表Optimizer。
• collections：图表集合键列表。新变量将添加到这些集合中。默认为[GraphKeys.VARIABLES]。
• validate_shape：If False，允许使用未知形状的值初始化变量。如果True，默认情况下，
• initial_value必须知道形状 。
• name：变量的可选名称。默认为’Variable’自动并且不受限制。

返回：
一个变量。
Raises抛出:
ValueError: 如果初始值没有形状并且 validate_shape是True。

tf.Variable.initialized_value()

返回初始化变量的值。
您应该使用它而不是变量本身来初始化另一个变量，其值取决于此变量的值。

# Initialize 'v' with a random tensor.
v = tf.Variable(tf.truncated_normal([10, 40]))
# Use `initialized_value` to guarantee that `v` has been
# initialized before its value is used to initialize `w`.
# The random values are picked only once.
w = tf.Variable(v.initialized_value() * 2.0)

返回：
一个Tensor，这个变量持有它初始化后的值。

更改变量值

tf.Variable.assign(value, use_locking=False)

为变量分配一个新值。
这本质上是一个捷径 assign(self, value)。
参数ARGS：

• value：A Tensor。此变量的新值。
• use_locking：如果True，在分配期间锁定使用。

返回：
一Tensor，将保持分配后该变量的新值已完成。

tf.Variable.assign_add(delta, use_locking=False)

为此变量添加值。
这本质上是一个捷径assign_add(self, delta)。
参数ARGS：

• delta：A Tensor。要添加到此变量的值。
• use_locking：如果True，在操作过程中使用锁定。

返回：
A Tensor将在添加完成后保存此变量的新值。

tf.Variable.assign_sub(delta, use_locking=False)

从此变量中减去一个值。
这本质上是一个捷径assign_sub(self, delta)。
参数ARGS：

• delta：A Tensor。要从此变量中减去的值。

• use_locking：如果True，在操作过程中使用锁定。
  返回：
  一个Tensor将保存减法后该变量的新值已完成。

   tf.Variable.scatter_sub(sparse_delta, use_locking=False)
  

  IndexedSlices从此变量中减去。
  这本质上是一个捷径scatter_sub(self, sparse_delta.indices, sparse_delta.values)。
  ARGS：
  sparse_delta：IndexedSlices从此变量中减去。
  use_locking：如果True，在操作过程中使用锁定。
  返回：
  一Tensor，将举行散射减法后该变量的新值已完成。

Raises:
ValueError：如果sparse_delta不是IndexedSlices。

	tf.Variable.count_up_to(limit)

增加此变量直到达到limit。
运行该操作时，它会尝试增加变量1。如果递增变量会将其带到上面，limit那么Op会引发异常OutOfRangeError。
如果没有引发错误，则Op在增量之前输出变量的值。
这本质上是一个捷径count_up_to(self, limit)。
ARGS：
limit：递增变量引发错误的值。
返回：
A Tensor将在增量之前保存变量值。如果没有其他Op修改此变量，则生成的值将是不同的。

tf.Variable.eval(session=None)

在会话中，计算并返回此变量的值。
这不是图构造方法，它不会向图中添加操作。
这种便捷方法需要一个会话，其中包含此变量的图形已经启动。如果未传递会话，则使用默认会话。有关启动图形和会话的更多信息，请参阅Session类。

v = tf.Variable([1, 2])
init = tf.initialize_all_variables()	
with tf.Session() as sess:
    sess.run(init)
    # Usage passing the session explicitly.
    print v.eval(sess)
    # Usage with the default session.  The 'with' block
    # above makes 'sess' the default session.
    print v.eval()

ARGS：
session：用于评估此变量的会话。如果不是，则使用默认会话。
返回：
numpy，ndarray带有此变量值的副本。

属性:

tf.Variable.name

此变量的名称。

tf.Variable.dtype

这个变量的DType类型。

tf.Variable.get_shape()

获得这个变量的形状TensorShape。
返回：
一TensorShape。

tf.Variable.device

这个变量的设备。

tf.Variable.initializer

此变量的初始化程序操作。

tf.Variable.graph

在Graph这个变量。

tf.Variable.op

在Operation这个变量。

可变辅助函数

TensorFlow提供了一组函数来帮助管理图中收集的变量集。

tf.all_variables()

返回图中收集的所有变量。
该Variable()构造函数自动添加新的变数图表收集GraphKeys.VARIABLES。此便捷函数返回该集合的内容。
返回：
Variable对象 列表。

tf.trainable_variables()

返回使用的所有变量trainable=True。
传递时trainable=True，Variable()构造函数会自动将新变量添加到图集合中 GraphKeys.TRAINABLE_VARIABLES。此便捷函数返回该集合的内容。
返回：
变量对象列表。

tf.initialize_all_variables()

返回初始化所有变量的Op。
这只是一个捷径 initialize_variables(all_variables())
返回：
一个Op，初始化图中的所有变量。

tf.initialize_variables(var_list, name='init')

返回初始化变量列表的Op。
在会话中启动图形后，可以运行返回的Op来初始化所有变量var_list。该Op var_list并行运行变量的所有初始值设定项。
调用initialize_variables()等同于将初始化列表传递给Group()。
但是var_list如果为空，则该函数仍返回可以运行的Op。Op只是没有效果。
ARGS：
var_list：Variable要初始化的对象列表。
name：返回操作的可选名称。
返回：
运行所有指定变量的初始值设定项的Op。

tf.assert_variables_initialized(var_list=None)

返回一个Op来检查变量是否已初始化。
运行时，FailedPreconditionError 如果尚未初始化任何变量，则返回的Op将引发异常。
注意：此函数是通过尝试获取变量的值来实现的。如果其中一个变量未初始化，则C ++运行时可能会记录一条消息。这是预料之中的。
ARGS：
var_list：Variable要检查的对象列表。默认值为all_variables().
返回：
如果没有变量，则为Op或None。

保存和恢复变量

class tf.train.Saver

保存和恢复变量。
有关 变量，保存和恢复的概述，请参见变量。
将Saver类添加OPS保存和恢复变量和 检查站。它还提供了运行这些操作的便捷方法。
检查点是专有格式的二进制文件，它将变量名称映射到张量值。检查检查点内容的最佳方法是使用a加载它Saver。

存储者可以使用提供的计数器自动为检查点文件名编号。这使您可以在训练模型时在不同的步骤中保留多个检查点。例如，您可以使用训练步骤编号对检查点文件名进行编号。为避免填满磁盘，储存器会自动管理检查点文件。例如，他们只能保留N个最新文件，或每N小时训练一个检查点。

您可以通过将值传递给可选global_step参数来对检查点文件名进行编号 save()：

saver.save(sess, 'my-model', global_step=0) ==> filename: 'my-model-0'
...
saver.save(sess, 'my-model', global_step=1000) ==> filename: 'my-model-1000'

此外，Saver()构造函数的可选参数允许您控制磁盘上检查点文件的扩散：
max_to_keep表示要保留的最近检查点文件的最大数量。创建新文件时，将删除旧文件。如果为None或0，则保留所有检查点文件。默认为5（即保留最近的5个检查点文件。）

keep_checkpoint_every_n_hours：除了保留最新的 max_to_keep检查点文件之外，您可能还希望每N小时的训练保留一个检查点文件。如果您想稍后分析模型在长时间训练期间的进展情况，这将非常有用。例如，传递keep_checkpoint_every_n_hours=2确保每2小时训练保留一个检查点文件。默认值10,000小时可有效禁用该功能。

请注意，您仍然需要调用save()方法来保存模型。将这些参数传递给构造函数不会自动为您保存变量。

定期保存的培训计划如下：

...
# Create a saver.
saver = tf.train.Saver(...variables...)
# Launch the graph and train, saving the model every 1,000 steps.
sess = tf.Session()
for step in xrange(1000000):
    sess.run(..training_op..)
    if step % 1000 == 0:
        # Append the step number to the checkpoint name:
        saver.save(sess, 'my-model', global_step=step)

除了检查点文件之外，保存程序还在磁盘上保留协议缓冲区以及最近的检查点列表。这用于管理编号的检查点文件，通过latest_checkpoint()它可以轻松发现最近检查点的路径。该协议缓冲区存储在检查点文件旁边名为“checkpoint”的文件中。

如果创建多个保护程序，则可以在调用中为协议缓冲区文件指定不同的文件名save()。

tf.train.Saver.__init__(var_list=None, reshape=False, sharded=False, max_to_keep=5, keep_checkpoint_every_n_hours=10000.0, name=None, restore_sequentially=False, saver_def=None, builder=None)

创建一个Saver。
构造函数添加操作以保存和恢复变量。
var_list指定将保存和恢复的变量。它可以作为一个dict或一个列表传递：
一个dict名字变量：键是将被用来在检查点文件保存或恢复变量名。
变量列表：变量将在检查点文件中使用其op名称进行键控。
例如：

v1 = tf.Variable(..., name='v1')
v2 = tf.Variable(..., name='v2')

# Pass the variables as a dict:
saver = tf.train.Saver({'v1': v1, 'v2': v2})

# Or pass them as a list.
saver = tf.train.Saver([v1, v2])
# Passing a list is equivalent to passing a dict with the variable op names
# as keys:
saver = tf.train.Saver({v.op.name: v for v in [v1, v2]})

可选reshape参数（如果为True）允许从保存文件中恢复变量，其中变量具有不同的形状，但元素和类型的数量相同。如果您已重新变换变量并希望从较旧的检查点重新加载它，则此选项非常有用。

可选sharded参数（如果为True）指示保护程序为每个设备分片检查点。
ARGS：
var_list：变量列表或将变量名称映射到变量的字典。如果为None，则默认为所有变量的列表。
reshape：如果为True，则允许从变量具有不同形状的检查点恢复参数。
sharded：如果为True，则为每个设备分配一个检查点。
max_to_keep：要保留的最近检查点的最大数量。默认为10,000小时。
keep_checkpoint_every_n_hours：保持检查站的频率。默认为10,000小时。
name：字符串。添加操作时用作前缀的可选名称。
restore_sequentially：Bool，如果为true，则会导致不同变量的恢复在每个设备中按顺序发生。这可以在恢复非常大的模型时降低内存使用量。
saver_def：可选的SaverDef proto，而不是运行构建器。这仅适用于想要为之前构建的具有Saver的Graph重新创建Saver对象的专业代码。saver_def proto应该是为该Graph创建的Saver的as_saver_def（）调用返回的原型。
builder：如果未提供saver_def，则使用可选的SaverBuilder。默认为BaseSaverBuilder（）。
Raises:
TypeError：如果var_list无效。
ValueError：如果任何键或值var_list不是唯一的。
tf.train.Saver.save(sess, save_path, global_step=None, latest_filename=None)
保存变量。

此方法运行构造函数添加的ops以保存变量。它需要启动图表的会话。要保存的变量也必须已初始化。
该方法返回新创建的检查点文件的路径。此路径可以直接传递给调用restore()。
ARGS：
sess：用于保存变量的会话。
save_path：字符串。检查点文件名的路径。如果是保护程序 sharded，则这是分片检查点文件名的前缀。
global_step：如果提供，则附加全局步骤编号 save_path以创建检查点文件名。可选参数可以是Tensor，Tensor名称或整数。
latest_filename：协议缓冲区文件的可选名称，其中包含最新检查点文件名列表。该文件与检查点文件保存在同一目录中，由保护程序自动管理，以跟踪最近的检查点。默认为’checkpoint’。
返回：
字符串：保存变量的路径。如果保护程序是分片的，则该字符串以：’ - ??? - of -nnnnn’，其中’nnnnn’是创建的分片数。

Raises:
TypeError：如果sess不是会话。

tf.train.Saver.restore(sess, save_path)

恢复以前保存的变量。
此方法运行构造函数添加的ops以恢复变量。它需要启动图表的会话。要恢复的变量不必初始化，因为恢复本身就是一种初始化变量的方法。
该save_path参数通常是先前从save()调用或调用返回的值 latest_checkpoint()。
ARGS：
sess：用于还原参数的会话。
save_path：先前保存参数的路径。

其他实用方法。

tf.train.Saver.last_checkpoints

尚未删除的检查点文件名列表。
您可以将任何返回的值传递给restore()。
返回：
检查点文件名列表，从最旧到最新排序。

tf.train.Saver.set_last_checkpoints(last_checkpoints)

设置尚未删除的检查点文件名列表。
ARGS：
last_checkpoints：检查点文件名列表。
Raises:
AssertionError：如果已设置检查点文件名列表。

tf.train.Saver.as_saver_def()

生成SaverDef此保护程序的表示。
返回：
一个SaverDef原型。

tf.train.latest_checkpoint(checkpoint_dir, latest_filename=None)

查找最新保存的检查点文件的文件名。
ARGS：
checkpoint_dir：保存变量的目录。
latest_filename：协议缓冲区文件的可选名称，其中包含最新检查点文件名列表。请参阅相应的参数Saver.save()。
返回：
最新检查点的完整路径，如果未找到检查点，则为None。

tf.train.get_checkpoint_state(checkpoint_dir, latest_filename=None)

从“checkpoint”文件返回CheckpointState proto。
如果“checkpoint”文件包含有效的CheckpointState原型，则返回它。
ARGS：
checkpoint_dir：检查点的目录。
latest_filename：检查点文件的可选名称。默认为’checkpoint’。
返回：
如果状态可用，则为CheckpointState，否则为None。

tf.train.update_checkpoint_state(save_dir, model_checkpoint_path, all_model_checkpoint_paths=None, latest_filename=None)

更新“检查点”文件的内容。
这将更新包含CheckpointState原型的检查点文件。
ARGS：
save_dir：保存模型的目录。
model_checkpoint_path：检查点文件。
all_model_checkpoint_paths：字符串列表。所有尚未删除的检查点的路径，从最旧到最新排序。如果这是非空列表，则最后一个元素必须等于model_checkpoint_path。这些路径也保存在CheckpointState原型中。
latest_filename：检查点文件的可选名称。默认为’checkpoint’。
Raises:
RuntimeError：如果保存路径冲突。
共享变量
TensorFlow提供了几个类和操作，您可以使用它们根据特定条件创建变量。

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

获取具有这些参数的现有变量或创建一个新变量。
此函数将名称作为当前变量作用域的前缀，并执行重用检查。有关 重用如何工作的详细说明，请参见 变量范围操作方法。这是一个基本的例子：

with tf.variable_scope("foo"):
    v = get_variable("v", [1])  # v.name == "foo/v:0"
    w = get_variable("w", [1])  # w.name == "foo/w:0"
with tf.variable_scope("foo", reuse=True)
    v1 = get_variable("v")  # The same as v above.

如果初始化程序是None（默认值），则使用构造函数中传递的默认初始值设定项。如果那个None也是， UniformUnitScalingInitializer将使用a。
ARGS：
name：新变量或现有变量的名称。
shape：新变量或现有变量的形状。
dtype：新变量或现有变量的类型（默认为DT_FLOAT）。
initializer：如果创建了变量，则为变量的初始化程序。
trainable：如果True还将变量添加到图表集合中 GraphKeys.TRAINABLE_VARIABLES（请参阅variables.Variable）。
collections：要将变量添加到的图形集合键列表。默认为[GraphKeys.VARIABLES]（参见variables.Variable）。
返回：
创建的或现有的变量。
Raises:
ValueError：当创建新变量并且未声明形状时，或者在变量创建期间违反重用时。内部重复使用 variable_scope。

tf.get_variable_scope()

返回当前变量范围。

tf.variable_scope(name_or_scope, reuse=None, initializer=None)

返回变量范围的上下文。
变量范围允许创建新变量并共享已创建的变量，同时提供不会意外创建或共享的检查。有关详细信息，请参阅变量范围操作方法，此处我们仅提供一些基本示例。
如何创建新变量的简单示例：

with tf.variable_scope("foo"):
    with tf.variable_scope("bar"):
        v = tf.get_variable("v", [1])
        assert v.name == "foo/bar/v:0"

共享变量的基本示例：

with tf.variable_scope("foo"):
    v = get_variable("v", [1])
with tf.variable_scope("foo", reuse=True):
    v1 = tf.get_variable("v", [1])
assert v1 == v

通过捕获范围和设置重用来共享变量：

with tf.variable_scope("foo") as scope.
    v = get_variable("v", [1])
    scope.reuse_variables()
    v1 = tf.get_variable("v", [1])
assert v1 == v

为了防止意外共享变量，我们在非重用范围内获取现有变量时引发异常。

with tf.variable_scope("foo") as scope.
    v = get_variable("v", [1])
    v1 = tf.get_variable("v", [1])
    #  Raises ValueError("... v already exists ...").

类似地，我们在尝试获取在重用模式下不存在的变量时引发异常。

with tf.variable_scope("foo", reuse=True):
    v = get_variable("v", [1])
    #  Raises ValueError("... v does not exists ...").

请注意，该reuse标志是继承的：如果我们打开一个重用范围，那么它的所有子范围也会重用。
ARGS：
name_or_scope：string或VariableScope：打开的范围。
reuse：True或None; 如果True，我们进入该范围的重用模式以及所有子范围; 如果None，我们只是继承父范围重用。
initializer：此范围内变量的默认初始值设定项。
产量：
可以捕获和重用的范围。
Raises:
ValueError：尝试在创建范围内重用，或在重用范围内创建，或者重用不是None或时True。
TypeError：当某些参数的类型不合适时。
tf.constant_initializer(value=0.0)
返回使用单个值生成Tensors的初始值设定项。
ARGS：
value：Python标量。初始化变量的所有元素都将设置为此值。
返回：
使用单个值生成张量的初始值设定项。

tf.random_normal_initializer(mean=0.0, stddev=1.0, seed=None)

返回生成具有正态分布的张量的初始值设定项。
ARGS：
mean：python标量或标量张量。要生成的随机值的平均值。
stddev：python标量或标量张量。要生成的随机值的标准偏差。
seed：一个Python整数。用于创建随机种子。看看 set_random_seed 行为。
返回：
生成具有正态分布的张量的初始值设定项。

tf.truncated_normal_initializer(mean=0.0, stddev=1.0, seed=None)

返回生成截断的正态分布的初始值设定项。
这些值类似于来自random_normal_initializer的值，除了丢弃并重新绘制超过平均值两个标准偏差的值。这是神经网络权重和过滤器的推荐初始化程序。
ARGS：
mean：python标量或标量张量。要生成的随机值的平均值。
stddev：python标量或标量张量。要生成的随机值的标准偏差。
seed：一个Python整数。用于创建随机种子。看看 set_random_seed 行为。
返回：
生成具有截断正态分布的张量的初始值设定项。

tf.random_uniform_initializer(minval=0.0, maxval=1.0, seed=None)

返回生成具有均匀分布的张量的初始值设定项。
ARGS：
minval：python标量或标量张量。要生成的随机值范围的下限。
maxval：python标量或标量张量。要生成的随机值范围的上限。
seed：一个Python整数。用于创建随机种子。看看 set_random_seed 行为。
返回：
生成具有均匀分布的张量的初始值设定项。

tf.uniform_unit_scaling_initializer(factor=1.0, seed=None)

返回生成张量而不缩放方差的初始值设定项。
在初始化深度网络时，原则上有利的是保持输入方差的比例恒定，因此它不会通过到达最终层而爆炸或减弱。如果输入x和操作x * W，我们要初始化W均匀随机的，我们需要挑选W从
[-sqrt(3) / sqrt(dim), sqrt(3) / sqrt(dim)]
保持比例完整，在哪里dim = W.shape[0]（输入的大小）。对卷积网络的类似计算给出了类似的结果，其dim等于前3维的乘积。当存在非线性时，我们需要将其乘以常数factor。有关更深层次的动机，实验和常量计算，请参阅https://arxiv.org/pdf/1412.6558v3.pdf。在那里的2.3节中，常数是数值计算的：对于线性层，它是1.0，relu：_{1.43，tanh：}1.15。
ARGS：
factor：漂浮。用于缩放值的乘法因子。
seed：一个Python整数。用于创建随机种子。看看 set_random_seed 行为。
返回：
生成具有单位方差的张量的初始值设定项。

tf.zeros_initializer(shape, dtype=tf.float32)

适用于零（）的适配器以匹配初始化程序规范。
稀疏变量更新
稀疏更新操作会修改密集条目的子集Variable，或者覆盖条目，或者添加/减去增量。这些对于训练嵌入模型和类似的基于查找的网络是有用的，因为在任何给定步骤中只有一小部分嵌入向量发生变化。
由于可以在梯度计算期间（如在梯度中tf.gather）自动生成大张量的稀疏更新， IndexedSlices因此提供了封装一组稀疏索引和值的类。 IndexedSlices在大多数情况下，优化器会自动检测和处理对象。

tf.scatter_update(ref, indices, updates, use_locking=None, name=None)

将稀疏更新应用于变量引用。

此操作计算

# Scalar indices
ref[indices, ...] = updates[...]

# Vector indices (for each i)
ref[indices[i], ...] = updates[i, ...]

# High rank indices (for each i, ..., j)
ref[indices[i, ..., j], ...] = updates[i, ..., j, ...]

ref更新完成后，此操作将输出。这样可以更容易地链接需要使用重置值的操作。
如果indices包含重复条目，则按字典顺序排列的条目将覆盖较早的条目。
需要updates.shape = indices.shape + ref.shape[1:]。
ARGS：
ref：一个可变的Tensor。应该来自一个Variable节点。
indices：A Tensor。必须是以下类型之一：int32，int64。第一个维度的指数张量ref。
updates：A Tensor。必须与…相同ref。要存储的更新值的张量ref。
use_locking：可选bool。默认为True。如果为True，则分配将受锁保护; 否则行为未定义，但可能表现出较少的争用。
name：操作的名称（可选）。
返回：
与…相同ref。返回以方便在更新完成后要使用更新值的操作。

tf.scatter_add(ref, indices, updates, use_locking=None, name=None)

向变量引用添加稀疏更新。
此操作计算

# Scalar indices
ref[indices, ...] += updates[...]

# Vector indices (for each i)
ref[indices[i], ...] += updates[i, ...]

# High rank indices (for each i, ..., j)
ref[indices[i, ..., j], ...] += updates[i, ..., j, ...]

ref更新完成后，此操作将输出。这样可以更容易地链接需要使用重置值的操作。
正确处理重复的条目：如果多个条目indices引用相同的位置，则添加其贡献。
需要updates.shape = indices.shape + ref.shape[1:]。
ARGS：
ref：一个可变的Tensor。必须是下列类型之一：float32，float64，int64，int32，uint8，int16，int8，complex64，qint8，quint8，qint32。应该来自一个Variable节点。
indices：A Tensor。必须是以下类型之一：int32，int64。第一个维度的指数张量ref。
updates：A Tensor。必须与…相同ref。要添加的更新值的张量ref。
use_locking：可选bool。默认为False。如果为True，则添加将受锁保护; 否则行为未定义，但可能表现出较少的争用。
name：操作的名称（可选）。
返回：
与…相同ref。返回以方便在更新完成后要使用更新值的操作。

tf.scatter_sub(ref, indices, updates, use_locking=None, name=None)

将稀疏更新减去变量引用。

# Scalar indices
ref[indices, ...] -= updates[...]

# Vector indices (for each i)
ref[indices[i], ...] -= updates[i, ...]

# High rank indices (for each i, ..., j)
ref[indices[i, ..., j], ...] -= updates[i, ..., j, ...]

ref更新完成后，此操作将输出。这样可以更容易地链接需要使用重置值的操作。
正确处理重复的条目：如果多个条目indices引用相同的位置，则它们的（否定的）贡献会添加。
需要updates.shape = indices.shape + ref.shape[1:]。
ARGS：
ref：一个可变的Tensor。必须是下列类型之一：float32，float64，int64，int32，uint8，int16，int8，complex64，qint8，quint8，qint32。应该来自一个Variable节点。
indices：A Tensor。必须是以下类型之一：int32，int64。第一个维度的指数张量ref。
updates：A Tensor。必须与…相同ref。要减去的更新值的张量ref。
use_locking：可选bool。默认为False。如果为True，则减法将受锁保护; 否则行为未定义，但可能表现出较少的争用。
name：操作的名称（可选）。
返回：
与…相同ref。返回以方便在更新完成后要使用更新值的操作。

tf.sparse_mask(a, mask_indices, name=None)

面具元素IndexedSlices。
给定一个IndexedSlices实例a，返回另一个IndexedSlices包含切片子集的实例a。仅mask_indices返回指定索引处的切片。
当您需要在IndexedSlices对象中提取切片子集时，这非常有用 。
例如：

# `a` contains slices at indices [12, 26, 37, 45] from a large tensor
# with shape [1000, 10]
a.indices => [12, 26, 37, 45]
tf.shape(a.values) => [4, 10]

# `b` will be the subset of `a` slices at its second and third indices, so
# we want to mask of its first and last indices (which are at absolute
# indices 12, 45)
b = tf.sparse_mask(a, [12, 45])

b.indices => [26, 37]
tf.shape(b.values) => [2, 10]
ARGS：
a：一个IndexedSlices实例。
mask_indices：要掩盖的元素的索引。
name：操作的名称（可选）。

返回：
蒙面IndexedSlices实例。

class tf.IndexedSlices

给定索引处的一组张量切片的稀疏表示。
这个类是一对Tensor对象的简单包装器：
values：Tensor任何形状的dtype中的一个[D0, D1, …, Dn]。
indices：Tensor具有形状的1-D整数[D0]。
一个IndexedSlices通常用来表示一个较大的张量的一个子集dense的形状的[LARGE0, D1, … , DN]其中LARGE0 >> D0。值in indices是从较大张量中提取的切片的第一维中的索引。

致密张量dense由一个表示IndexedSlices slices具有

dense[slices.indices[i], :, :, :, ...] = slices.values[i, :, :, :, ...]

的IndexedSlices类是在对于具有稀疏梯度（例如操作梯度的定义主要用于tf.gather）。
将此表示与SparseTensor使用多维索引和标量值的对比进行对比 。

tf.IndexedSlices.__init__(values, indices, dense_shape=None)

创造一个IndexedSlices。

tf.IndexedSlices.values

A Tensor包含切片的值。

tf.IndexedSlices.indices

Tensor包含切片索引的1-D 。

tf.IndexedSlices.dense_shape

1-D Tensor包含相应的致密张量的形状。

tf.IndexedSlices.name

这个名字IndexedSlices。

tf.IndexedSlices.dtype

在DType这个张量元素。

tf.IndexedSlices.device

values要生成的设备的名称，或None。

tf.IndexedSlices.op

的Operation产生values作为输出。