共享变量

如果要在图形的各个组件之间共享一个变量，一个简单的选项是首先创建它，然后将其作为参数传递给需要它的函数。 例如，假设要使用所有 ReLU 的共享阈值变量来控制 ReLU 阈值（当前硬编码为 0）。 您可以先创建该变量，然后将其传递给relu()函数：

  1. reset_graph()
  3. def relu(X, threshold):
  4.     with tf.name_scope("relu"):
  5.         w_shape = (int(X.get_shape()[1]), 1)                        #  not shown in the book
  6.         w = tf.Variable(tf.random_normal(w_shape), name="weights")  #  not shown
  7.         b = tf.Variable(0.0, name="bias")                           #  not shown
  8.         z = tf.add(tf.matmul(X, w), b, name="z")                    #  not shown
  9.         return tf.maximum(z, threshold, name="max")
  11. threshold = tf.Variable(0.0, name="threshold")
  12. X = tf.placeholder(tf.float32, shape=(None, n_features), name="X")
  13. relus = [relu(X, threshold) for i in range(5)]
  14. output = tf.add_n(relus, name="output")

这很好:现在您可以使用阈值变量来控制所有 ReLU 的阈值。但是，如果有许多共享参数，比如这一项，那么必须一直将它们作为参数传递，这将是非常痛苦的。许多人创建了一个包含模型中所有变量的 Python 字典，并将其传递给每个函数。另一些则为每个模块创建一个类（例如：一个使用类变量来处理共享参数的 ReLU 类）。另一种选择是在第一次调用时将共享变量设置为relu()函数的属性，如下所示:

  1. def relu(X):
  2.     with tf.name_scope("relu"):
  3.         if not hasattr(relu, "threshold"):
  4.             relu.threshold = tf.Variable(0.0, name="threshold")
  5.         w_shape = int(X.get_shape()[1]), 1                          #  not shown in the book
  6.         w = tf.Variable(tf.random_normal(w_shape), name="weights")  #  not shown
  7.         b = tf.Variable(0.0, name="bias")                           #  not shown
  8.         z = tf.add(tf.matmul(X, w), b, name="z")                    #  not shown
  9.         return tf.maximum(z, relu.threshold, name="max")

TensorFlow 提供了另一个选项，这将提供比以前的解决方案稍微更清洁和更模块化的代码。首先要明白一点，这个解决方案很刁钻难懂，但是由于它在 TensorFlow 中使用了很多，所以值得我们去深入细节。 这个想法是使用get_variable()函数来创建共享变量，如果它还不存在，或者如果已经存在，则复用它。 所需的行为（创建或复用）由当前variable_scope()的属性控制。 例如，以下代码将创建一个名为relu/threshold的变量（作为标量，因为shape = ()，并使用 0.0 作为初始值）：

  1. with tf.variable_scope("relu"):
  2.     threshold = tf.get_variable("threshold", shape=(),
  3.                                 initializer=tf.constant_initializer(0.0))

请注意，如果变量已经通过较早的get_variable()调用创建，则此代码将引发异常。 这种行为可以防止错误地复用变量。如果要复用变量，则需要通过将变量scope的复用属性设置为True来明确说明（在这种情况下，您不必指定形状或初始值）：

  1. with tf.variable_scope("relu", reuse=True):
  2.     threshold = tf.get_variable("threshold")

该代码将获取现有的relu/threshold变量，如果不存在会引发异常（如果没有使用get_variable()创建）。 或者，您可以通过调用scope的reuse_variables()方法将复用属性设置为true：

  1. with tf.variable_scope("relu") as scope:
  2.     scope.reuse_variables()
  3.     threshold = tf.get_variable("threshold")

一旦重新使用设置为True，它将不能在块内设置为False。 而且，如果在其中定义其他变量作用域，它们将自动继承reuse = True。 最后，只有通过get_variable()创建的变量才可以这样复用.

现在，您拥有所有需要的部分，使relu()函数访问阈值变量，而不必将其作为参数传递：

  1. def relu(X):
  2.     with tf.variable_scope("relu", reuse=True):
  3.         threshold = tf.get_variable("threshold")
  4.         w_shape = int(X.get_shape()[1]), 1                          #  not shown
  5.         w = tf.Variable(tf.random_normal(w_shape), name="weights")  #  not shown
  6.         b = tf.Variable(0.0, name="bias")                           #  not shown
  7.         z = tf.add(tf.matmul(X, w), b, name="z")                    #  not shown
  8.         return tf.maximum(z, threshold, name="max")
  10. X = tf.placeholder(tf.float32, shape=(None, n_features), name="X")
  11. with tf.variable_scope("relu"):
  12.     threshold = tf.get_variable("threshold", shape=(),
  13.                                 initializer=tf.constant_initializer(0.0))
  14. relus = [relu(X) for relu_index in range(5)]
  15. output = tf.add_n(relus, name="output")

该代码首先定义relu()函数，然后创建relu/threshold变量（作为标量，稍后将被初始化为 0.0），并通过调用relu()函数构建五个ReLU。relu()函数复用relu/threshold变量，并创建其他 ReLU 节点。

使用get_variable()创建的变量始终以其variable_scope的名称作为前缀命名（例如，relu/threshold），但对于所有其他节点（包括使用tf.Variable()创建的变量），变量作用域的行为就像一个新名称的作用域。 特别是，如果已经创建了具有相同名称的名称作用域，则添加后缀以使该名称是唯一的。 例如，在前面的代码中创建的所有节点（阈值变量除外）的名称前缀为relu_1/到relu_5/，如图 9-8 所示。

共享变量 - 图1

不幸的是，必须在relu()函数之外定义阈值变量，其中 ReLU 代码的其余部分都驻留在其中。 要解决此问题，以下代码在第一次调用时在relu()函数中创建阈值变量，然后在后续调用中重新使用。 现在，relu()函数不必担心名称作用域或变量共享：它只是调用get_variable()，它将创建或复用阈值变量（它不需要知道是哪种情况）。 其余的代码调用relu()五次，确保在第一次调用时设置reuse = False，而对于其他调用来说，reuse = True。

  1. def relu(X):
  2.     threshold = tf.get_variable("threshold", shape=(),
  3.                                 initializer=tf.constant_initializer(0.0))
  4.     w_shape = (int(X.get_shape()[1]), 1)                        #  not shown in the book
  5.     w = tf.Variable(tf.random_normal(w_shape), name="weights")  #  not shown
  6.     b = tf.Variable(0.0, name="bias")                           #  not shown
  7.     z = tf.add(tf.matmul(X, w), b, name="z")                    #  not shown
  8.     return tf.maximum(z, threshold, name="max")
  10. X = tf.placeholder(tf.float32, shape=(None, n_features), name="X")
  11. relus = []
  12. for relu_index in range(5):
  13.     with tf.variable_scope("relu", reuse=(relu_index >= 1)) as scope:
  14.         relus.append(relu(X))
  15. output = tf.add_n(relus, name="output")

生成的图形与之前略有不同，因为共享变量存在于第一个 ReLU 中（见图 9-9）。

共享变量 - 图2

TensorFlow 的这个介绍到此结束。 我们将在以下章节中讨论更多高级课题，特别是与深层神经网络，卷积神经网络和递归神经网络相关的许多操作，以及如何使用多线程，队列，多个 GPU 以及如何将 TensorFlow 扩展到多台服务器。