【TensorFlow】tf.name_scope、tf.variable_scope使用

一、 tf.name_scope(‘scope_name’)

tf.name_scope 主要结合 tf.Variable() 来使用，方便参数命名管理。

import tensorflow as tf
'''
Signature: tf.name_scope(*args, **kwds)
Docstring:
Returns a context manager for use when defining a Python op.
'''
# 也就是说，它的主要目的是为了更加方便地管理参数命名。
# 与 tf.Variable() 结合使用。简化了命名
# 注意，这里的 with 和 python 中其他的 with 是不一样的
# 执行完 with 里边的语句之后，这个 conv1/ 和 conv2/ 空间还是在内存中的。这时候如果再次执行此代码，就会再生成其他命名空间
with tf.name_scope('conv1') as scope:
    weights1 = tf.Variable([1.0, 2.0], name='weights')
    bias1 = tf.Variable([0.3], name='bias')

# 下面是在另外一个命名空间来定义变量的
with tf.name_scope('conv2') as scope:
    weights2 = tf.Variable([4.0, 2.0], name='weights')
    bias2 = tf.Variable([0.33], name='bias')

# 所以，实际上weights1 和 weights2 这两个引用名指向了不同的空间，不会冲突
print(weights1.name)
print(weights2.name)
print(bias1.name)
print(bias2.name)

执行结果：

# 第一次执行
conv1/weights:0
conv2/weights:0
conv1/bias:0
conv2/bias:0

# 第二次执行
conv1_1/weights:0
conv2_1/weights:0
conv1_1/bias:0
conv2_1/bias:0

# 第三次执行
conv1_2/weights:0
conv2_2/weights:0
conv1_2/bias:0
conv2_2/bias:0

未使用tf.name_scope：

import tensorflow as tf

# weights1、bias1、weights2、bias2在同一个命名空间
weights1 = tf.Variable([1.0, 2.0], name='weights')
bias1 = tf.Variable([0.3], name='bias')

weights2 = tf.Variable([4.0, 2.0], name='weights')
bias2 = tf.Variable([0.33], name='bias')

print(weights1.name)
print(weights2.name)
print(bias1.name)
print(bias2.name)

结果：

# 第一次执行
weights:0
weights_1:0
bias:0
bias_1:0

# 第二次执行
weights_2:0
weights_3:0
bias_2:0
bias_3:0

# 第三次执行
weights_4:0
weights_5:0
bias_4:0
bias_5:0

二、tf.variable_scope(‘scope_name’)

tf.variable_scope() 主要结合 tf.get_variable() 来使用，实现 变量共享。

TensorFlow中的变量一般就是模型的参数。当模型复杂的时候共享变量会无比复杂。

官网给了一个case，当创建两层卷积的过滤器时，每输入一次图片就会创建一次过滤器对应的变量，但是我们希望所有图片都共享同一过滤器变量，一共有4个变量：conv1_weights,conv1_biases,conv2_weights, and conv2_biases。

通常的做法是将这些变量设置为全局变量。但是存在的问题是打破封装性，这些变量必须文档化被其他代码文件引用，一旦代码变化，调用方也可能需要变化。

还有一种保证封装性的方式是将模型封装成类。

不过TensorFlow提供了Variable Scope 这种独特的机制来共享变量。这个机制涉及两个主要函数：

tf.get_variable(<name>, <shape>, <initializer>) 创建或返回给定名称的变量
tf.variable_scope(<scope_name>) 管理传给get_variable()的变量名称的作用域

在下面的代码中，通过tf.get_variable()创建了名称分别为weights和biases的两个变量。

def conv_relu(input, kernel_shape, bias_shape):
    # Create variable named "weights".
    weights = tf.get_variable("weights", kernel_shape,
        initializer=tf.random_normal_initializer())
    # Create variable named "biases".
    biases = tf.get_variable("biases", bias_shape,
        initializer=tf.constant_initializer(0.0))
    conv = tf.nn.conv2d(input, weights,
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv + biases)

但是我们需要两个卷积层，这时可以通过tf.variable_scope()指定作用域进行区分，如with tf.variable_scope("conv1")这行代码指定了第一个卷积层作用域为conv1，

在这个作用域下有两个变量weights和biases。

def my_image_filter(input_images):
    with tf.variable_scope("conv1"):
        # Variables created here will be named "conv1/weights", "conv1/biases".
        relu1 = conv_relu(input_images, [5, 5, 32, 32], [32])
    with tf.variable_scope("conv2"):
        # Variables created here will be named "conv2/weights", "conv2/biases".
        return conv_relu(relu1, [5, 5, 32, 32], [32])

最后在image_filters这个作用域重复使用第一张图片输入时创建的变量，调用函数reuse_variables()，代码如下：

with tf.variable_scope("image_filters") as scope:
    result1 = my_image_filter(image1)
    scope.reuse_variables()
    result2 = my_image_filter(image2)

1、tf.get_variable()工作机制

tf.get_variable()工作机制是这样的：

• 当tf.get_variable_scope().reuse == False，调用该函数会创建新的变量

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

 

import tensorflow as tf;  
import numpy as np;  
import matplotlib.pyplot as plt;  
  
with tf.variable_scope("foooo"):
    a1 = tf.get_variable(name='a11', shape=[2,3], initializer=tf.random_normal_initializer(mean=0, stddev=1))
    a2 = tf.get_variable(name='a22', shape=[1], initializer=tf.constant_initializer(1))
    a3 = tf.get_variable(name='a33', shape=[2,3], initializer=tf.ones_initializer())
assert a1.name == "foooo/a11:0"
assert a2.name == "foooo/a22:0"
assert a3.name == "foooo/a33:0"
    
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(a1))
    print(sess.run(a2))
    print(sess.run(a3))

# 输出
[[ 0.24116004 -0.3908934   1.0101722 ]
 [-0.6565249   0.6331108  -0.06850986]]
[1.]
[[1. 1. 1.]
 [1. 1. 1.]]

• 当tf.get_variable_scope().reuse == True，调用该函数会重用已经创建的变量

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

变量都是通过作用域/变量名来标识，后面会看到作用域可以像文件路径一样嵌套。

2、tf.variable_scope理解

tf.variable_scope()用来指定变量的作用域，作为变量名的前缀，支持嵌套，如下：

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

当前环境的作用域可以通过函数tf.get_variable_scope()获取，并且reuse标志可以通过调用reuse_variables()设置为True，这个非常有用，如下

with tf.variable_scope("foo"):
    v = tf.get_variable("v", [1])
    tf.get_variable_scope().reuse_variables()
    v1 = tf.get_variable("v", [1])
assert v1 is v

作用域中的resuse默认是False，调用函数reuse_variables()可设置为True，一旦设置为True，就不能返回到False，并且该作用域的子空间reuse都是True。如果不想重用变量，那么可以退回到上层作用域，相当于exit当前作用域，如

with tf.variable_scope("root"):
    # At start, the scope is not reusing.
    assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo"):
        # Opened a sub-scope, still not reusing.
        assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo", reuse=True):
        # Explicitly opened a reusing scope.
        assert tf.get_variable_scope().reuse == True
        with tf.variable_scope("bar"):
            # Now sub-scope inherits the reuse flag.
            assert tf.get_variable_scope().reuse == True
    # Exited the reusing scope, back to a non-reusing one.
    assert tf.get_variable_scope().reuse == False

一个作用域可以作为另一个新的作用域的参数，如：

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

不管作用域如何嵌套，当使用with tf.variable_scope()打开一个已经存在的作用域时，就会跳转到这个作用域。

with tf.variable_scope("foo") as foo_scope:
    assert foo_scope.name == "foo"
with tf.variable_scope("bar"):
    with tf.variable_scope("baz") as other_scope:
        assert other_scope.name == "bar/baz"
        with tf.variable_scope(foo_scope) as foo_scope2:
            assert foo_scope2.name == "foo"  # Not changed.

variable scope的Initializers可以创递给子空间和tf.get_variable()函数，除非中间有函数改变，否则不变。

with tf.variable_scope("foo", initializer=tf.constant_initializer(0.4)):
    v = tf.get_variable("v", [1])
    assert v.eval() == 0.4  # Default initializer as set above.
    w = tf.get_variable("w", [1], initializer=tf.constant_initializer(0.3)):
    assert w.eval() == 0.3  # Specific initializer overrides the default.
    with tf.variable_scope("bar"):
        v = tf.get_variable("v", [1])
        assert v.eval() == 0.4  # Inherited default initializer.
    with tf.variable_scope("baz", initializer=tf.constant_initializer(0.2)):
        v = tf.get_variable("v", [1])
        assert v.eval() == 0.2  # Changed default initializer.

算子（ops）会受变量作用域（variable scope）影响，相当于隐式地打开了同名的名称作用域（name scope)，如+这个算子的名称为foo/add

with tf.variable_scope("foo"):
    x = 1.0 + tf.get_variable("v", [1])
assert x.op.name == "foo/add"

除了变量作用域（variable scope），还可以显式打开名称作用域（name scope)，名称作用域仅仅影响算子的名称，不影响变量的名称。另外如果tf.variable_scope()传入字符参数，创建变量作用域的同时会隐式创建同名的名称作用域。如下面的例子，变量v的作用域是foo，而算子x的算子变为foo/bar，因为有隐式创建名称作用域foo

with tf.variable_scope("foo"):
    with tf.name_scope("bar"):
        v = tf.get_variable("v", [1])
        x = 1.0 + v
assert v.name == "foo/v:0"
assert x.op.name == "foo/bar/add"

注意： 如果tf.variable_scope()传入的不是字符串而是scope对象，则不会隐式创建同名的名称作用域。

 

参考：

• https://blog.csdn.net/jerr__y/article/details/60877873
• 关于tf.variable_scope函数的使用，看了很多文章都是一知半解，唯有一篇文章让我茅塞顿开，感谢这位大神的倾力分享。https://www.cnblogs.com/MY0213/p/9208503.html