tf之变量与作用域

Posted 2021-02-13 yanshw

生成变量

tensorflow生成变量有两种方式，Variable 和 get_variable

Variable(initial_value=None, trainable=True,
         collections=None, validate_shape=True,
         caching_device=None,name=None,
         expected_shape=None, import_scope=None,
         constraint=None)

get_variable(name, shape=None, dtype=None,
             initializer=None, regularizer=None,
             trainable=True, collections=None,
             caching_device=None, partitioner=None,
             validate_shape=True, use_resouce=None,
             constraint=None)

两者有何区别呢?

### Variable
w_1 = tf.Variable(3, name="w_1")
w_2 = tf.Variable(1, name="w_1")
print(w_1.name)     # w_1:0
print(w_2.name)     # w_1_1:0   系统检测到命名冲突，会自动处理，把w_1变成w_1_1,保证了变量的唯一性

### get_variable
w_1 = tf.get_variable(name="g_1", initializer=1)
# w_2 = tf.get_variable(name="w_1",initializer=2)     # 这句报错，系统检测到命名冲突，会直接报错
# 错误信息
# ValueError: Variable w_1 already exists, disallowed. Did you mean to set reuse=True in VarScope?

Variable 系统检测到命名冲突会自动处理，保证了变量的唯一性，也就是不可复用，

get_variable 检测到命名冲突会直接报错。这使得 get_variable 可以创建共享变量。

其他情况两者一般通用。

 

实际上 get_variable 是获取指定属性（name）的已存在变量，如果指定属性的变量不存在，就新建一个。

但需要特定的语法。

 

变量作用域

先看个例子

def myfunc():
    w = tf.Variable(tf.random_uniform([2,2]), name=‘data‘)
    return w

### 直接调用2次，结果不同
w1 = myfunc()
w2 = myfunc()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w1))
    print(sess.run(w2))     # 结果不相同

上面用Variable创建变量，可以直接调用两次，但是结果不相同，这是显而易见的，符合常规。　　（ps：如果用 get_variable 创建，无法直接调用两次。）

 

但是假如我们需要它相同呢？实际上在训练模型时都需要迭代过程中参数保存一致。

此时就需要共享变量。

tf 用 get_variable 和 variable_scope 来解决共享变量问题。并提供了两种方法。

方法1

with tf.variable_scope(‘test‘) as scope:
    w1 = tf.get_variable(‘data‘, [2,2])
    # scope.reuse_variables()　　or
    tf.get_variable_scope().reuse_variables()
    w2 = tf.get_variable(‘data‘)

print(w1 is w2)     # True

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w1))
    print(sess.run(w2))     # 结果相同

可以看到两个变量是一样的。

with tf.variable_scope(‘test2‘) as scope2:
    w11 = tf.Variable(tf.random_uniform([2,2]), name=‘data2‘)       # 这样无法被共享
    # scope.reuse_variables()
    tf.get_variable_scope().reuse_variables()
    w21 = tf.get_variable(‘data2‘)      # 报错

用Variable是不行的。

 

方法2

with tf.variable_scope(‘test3‘) as tt:
    w12 = tf.get_variable(‘data3‘, [2,2])

with tf.variable_scope(tt, reuse=True):
    w22 = tf.get_variable(‘data3‘)

print(w12 is w22)       # True

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w12))
    print(sess.run(w22))        # 结果相同

这也可以共享变量。

variable_scope 是用来创建变量左右域的，后面会详细介绍。

 

共享变量的方法总结

1. 需要使用 同时使用 get_variable 和 variable_scope

2. 在同一个 variable_scope 内，不需要指定reuse=True，但需要用scope.reuse_variables() 或者 tf.get_variable_scope().reuse_variables()

3. 在不同的 variable_scope 内， 第一个不需要指定reuse=True，但后面需要指定。

 

get_variable 机制

get_variable 会判断指定属性的变量是否存在，如果存在，并且该变量空间的reuse=True，那么就共享之前的变量，否则新建一个，

但是如果没有指定reuse=True，会提示命名冲突，

也就是说 get_variable 必须和 variable_scope 配套使用。

实例

with tf.variable_scope(‘scope1‘):
    w1 = tf.Variable(1, name=‘w1‘)
    w2 = tf.get_variable(name=‘w2‘, initializer=2.)

with tf.variable_scope(‘scope1‘, reuse=True):
    w1_p = tf.Variable(1, name=‘w1‘)
    w2_p = tf.get_variable(name=‘w2‘, initializer=2.)  # initializer=3. 亦可

print(‘w1‘, w1)         # w1   <tf.Variable ‘scope1/w1:0‘ shape=() dtype=int32_ref>
print(‘w1_p‘, w1_p)     # w1_p <tf.Variable ‘scope1_1/w1:0‘ shape=() dtype=int32_ref>

print(‘w2‘, w2)         # w2   <tf.Variable ‘scope1/w2:0‘ shape=() dtype=float32_ref>
print(‘w2_p‘, w2_p)     # w2_p <tf.Variable ‘scope1/w2:0‘ shape=() dtype=float32_ref>

print(w1 is w1_p, w2 is w2_p)   # False True

可以看到 Variable 无法共享，get_variable 共享。

 

变量作用域进阶

多重作用域

作用域中的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
        # with tf.variable_scope("bar2"):
        #     # Now sub-scope inherits the reuse flag.
        #     assert tf.get_variable_scope().reuse == False       # AssertionError
    # Exited the reusing scope, back to a non-reusing one.
    assert tf.get_variable_scope().reuse == False

可以看到在 bar2 作用域内，reuse==False 报错了，因为这个父域是True。

 

作用域的调用

作用域名字可以作为参数

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(‘scope1‘):
    w1 = tf.Variable(1, name=‘w1‘)
    w2 = tf.get_variable(name=‘w2‘, initializer=2.)

with tf.variable_scope(‘scope1‘, reuse=True):　　# 另一种方式
    w1_p = tf.Variable(1, name=‘w1‘)
    w2_p = tf.get_variable(name=‘w2‘, initializer=2.) 

用as 或者直接用名字都可作为参数。 但是有区别，后面会总结。

 

作用域跳转

不管作用域如何嵌套，当使用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:
　　　　　　　　print(tf.get_variable_scope().name) # foo
　　　　　　　　assert foo_scope2.name == "foo" # Not changed
　　　　　　with tf.variable_scope(‘foo‘) as foo_scope3:
　　　　　　　　print(tf.get_variable_scope().name) # bar/baz/foo
　　　　　　　　assert foo_scope3.name == "foo" # AssertionError

这里可以看到，直接用名字没有跳转，而用as跳转成功。 

 

多重作用域下的变量

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

# encoding:utf-8
__author__ = ‘HP‘
import tensorflow as tf

with tf.variable_scope(‘s1‘):
    x1 = tf.get_variable(‘data1‘, [3, 4])
    print(x1)                   # <tf.Variable ‘s1/data1:0‘ shape=(3, 4) dtype=float32_ref>
    tf.get_variable_scope().reuse_variables()

    with tf.variable_scope(‘s11‘):
        # x2 = tf.get_variable(‘data1‘)           # ValueError: Variable s1/s11/data1 does not exist
        # print(x2)
        pass

        with tf.variable_scope(‘s1‘):
            # x3 = tf.get_variable(‘data1‘)       # ValueError: Variable s1/s11/s1/data1 does not exist
            # print(x3)
            pass

    with tf.variable_scope(‘s1‘, reuse=True):
        x4 = tf.get_variable(‘data1‘)       # ValueError: Variable s1/s1/data1 does not exist
        print(x4)
        pass

with tf.variable_scope(‘s1‘, reuse=True):
    x5 = tf.get_variable(‘data1‘)
    print(x5)                       # <tf.Variable ‘s1/data1:0‘ shape=(3, 4) dtype=float32_ref>

　with tf.variable_scope(‘s2‘):
　　 with tf.variable_scope(‘s1‘, reuse=True):
　print(tf.get_variable_scope().name) # s2/s1
　　 # x6 = tf.get_variable(‘data1‘) # Variable s2/s1/data1 does not exist
　　 # print(x6)

可以看到 变量 就像文件一样，这个文件夹内的a文件和另外文件夹内的a文件不是一个文件。

 

综上得出如下结论：

1. 如果直接用名字，只能在同级作用域下跳转，如上例。 

2. 如果用as， 可以在任何地方跳转到该作用域

　　// 可以这么理解：如果直接用名字，是相对路径，相当于是在当前目录下创建了一个该名字的文件夹，

　　// 而as是绝对路径，不管在哪调用，都能指定该路径。

 

命名空间

命名空间，也是一种作用域

name_scope 仅对普通operation 有用，对 get_variable 无效，

variable_scope 不仅对普通operation 有效，也对 get_variable 有效

先上代码

with tf.name_scope(‘name_test‘):
    n1 = tf.constant(1, name=‘cs1‘)
    n2 = tf.Variable(tf.zeros([1]), name=‘v1‘)
    ww1 = tf.multiply(n2, [1])

    nv1 = tf.get_variable(name=‘nv1‘, initializer=1.0)

with tf.variable_scope(‘v_test‘):
    v_n1 = tf.constant(2, name=‘cs2‘)
    v_n2 = tf.Variable(tf.zeros([1]), name=‘v2‘)
    ww2 = tf.multiply(v_n2, [1])

    v1 = tf.get_variable(name=‘vv1‘, initializer=2.0)

### name_scope
print(‘n1‘, n1.name)        # n1 name_test/cs1:0
print(‘n2‘, n2.name)        # n2 name_test/v1:0
print(‘nv1‘, nv1.name)      # nv1 nv1:0                 # 注意和前两个不同，name_scope 对 get_variable 无效

print(‘ww1‘, ww1.name)      # ww name_test/Mul:0        # 注意也加上了name_scope

### variable_scope
print(‘v_n1‘, v_n1.name)    # v_n1 v_test/cs2:0
print(‘v_n2‘, v_n2.name)    # v_n2 v_test/v2:0
print(‘v1‘, v1.name)        # v1   v_test/vv1:0         # 注意和前两个相同，name_scope 对 get_variable 有效

print(‘ww2‘, ww2.name) # ww2 v_test/Mul:0 # 注意也加上了variable_scope

变量的名称是指针名，变量的name是地址。

 

共享变量用法进阶

在重复使用（即 非第一次使用）时，设置 reuse=True 来 再次调用 该共享变量作用域（variable_scope）。但是这种方法太繁琐了。

 简单方法

def myfunc():
    with tf.variable_scope(‘test‘, reuse=tf.AUTO_REUSE):
        w = tf.get_variable(‘data‘, [2, 2])
    return w

for i in range(3):
    print(myfunc())

# <tf.Variable ‘test/data:0‘ shape=(2, 2) dtype=float32_ref>
# <tf.Variable ‘test/data:0‘ shape=(2, 2) dtype=float32_ref>
# <tf.Variable ‘test/data:0‘ shape=(2, 2) dtype=float32_ref>

 

 相关API

with tf.variable_scope(‘V1‘) as variable_scope:
    a1 = tf.get_variable(name=‘a1‘, shape=[1], initializer=tf.constant_initializer(1))
    a2 = tf.Variable(tf.random_normal(shape=[2,3], mean=0, stddev=1), name=‘a2‘)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(variable_scope)                            # <tensorflow.python.ops.variable_scope.VariableScope object at 0x000000000D5F67F0>
    print(variable_scope.name)                       # V1
    print(tf.get_variable_scope())                   # <tensorflow.python.ops.variable_scope.VariableScope object at 0x000000000D5F67B8>
    print(tf.get_variable_scope().original_name_scope)      # 空
    print(tf.get_variable_scope().reuse)             # False
    print(tf.get_variable_scope().name)              # 空
    print(a1.name)      # V1/a1:0
    print(a2.name)      # V1/a2:0

获取当前环境的作用域  tf.get_variable_scope()

 

 

参考资料

https://www.cnblogs.com/MY0213/p/9208503.html

https://blog.csdn.net/lucky7213/article/details/78967306

https://blog.csdn.net/u012436149/article/details/53081454

https://blog.csdn.net/u010867294/article/details/78695487

https://blog.csdn.net/jeryjeryjery/article/details/79242684

http://www.cnblogs.com/Charles-Wan/p/6200446.html