前言

本文章是一篇源于Tensorflow里面Programmer's Guide的Sharing Variables教程。这也算是自己在学习tensorflow里面的一些感悟吧，所以就记录下来与大家分享并作为回忆录。在tensorflow官网的地址：Sharing Variables。这个变量范围和共享变量一开始看起来好像没啥用，可是一旦你在实际项目进行deep learning编码的时候，你会发现这是一个对代码重构和编码优化很有帮助的东西。过几天我会写一篇使用CNN模型进行人脸识别的实战文章，里面很能体现今天讲的内容。

---

问题

先看一个例子（也是官网上的例子）

def my_image_filter(input_images):
    conv1_weights = tf.Variable(tf.random_normal([5, 5, 32, 32]),
        name="conv1_weights")
    conv1_biases = tf.Variable(tf.zeros([32]), name="conv1_biases")
    conv1 = tf.nn.conv2d(input_images, conv1_weights,
        strides=[1, 1, 1, 1], padding='SAME')
    relu1 = tf.nn.relu(conv1 + conv1_biases)

    conv2_weights = tf.Variable(tf.random_normal([5, 5, 32, 32]),
        name="conv2_weights")
    conv2_biases = tf.Variable(tf.zeros([32]), name="conv2_biases")
    conv2 = tf.nn.conv2d(relu1, conv2_weights,
        strides=[1, 1, 1, 1], padding='SAME')
    return tf.nn.relu(conv2 + conv2_biases)

在官网上说想利用这个方法对两张图片进行相同的卷积操作。但是Variable()会重新创建变量，这样变量就不能复用了。这是个很蛋疼的事情。

# 第一次执行方法创建4个变量
result1 = my_image_filter(image1)
# 第二次执行再创建4个变量
result2 = my_image_filter(image2)

但我觉得还有个问题，就是代码的重复问题。尽管这个问题不是解决的重点，但作为写惯项目的人来说，这个真的受不了。Tensorflow给出一个很优雅的解决方案。

---

引入Variable Scope（变量范围）

首先这里要介绍两个方法：

• tf.get_variable(<name>, <shape>, <initializer>) ：创建一个名为<name>的变量
• tf.variable_scope(<scope_name>)：创建namespaces

其中创建了variable_scope(<scope_name>)后，get_variable(<name>)的变量名就会变为scope_name/name啦！这就可以用来管理我们的变量啦！因为我们有时候在不同的情况想创建相同名称的变量，假如用get_variable()创建两个相同名字的变量是会报错的，但你用Variable()的话就会把之前相同名称的变量给覆盖了。所以我们就用了variable_scope()这个方法了。话不多说，直接贴代码展示一下。

# -*- coding: utf-8 -*-

import tensorflow as tf
import numpy as np

input_images = tf.placeholder(tf.float32, shape=(1, 32, 32, 1))

# 定义了一层卷积神经网络
def conv_relu(input, kernel_shape, bias_shape):
    # 创建名为weights的变量
    weights = tf.get_variable("weights", kernel_shape, initializer=tf.random_normal_initializer())
    # 创建名为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)

def my_image_filter(input_images):
    with tf.variable_scope("conv1"):
        # 在名为conv1的variable scope下调用一层神经网络，对应的参数名为
        # "conv1/weights", "conv1/biases"
        relu1 = conv_relu(input_images, [3, 3, 1, 1], [1])
    with tf.variable_scope("conv2"):
        # 在名为conv2的variable scope下调用一层神经网络，对应的参数名为
        # "conv2/weights", "conv2/biases"
        return conv_relu(relu1, [3, 3, 1, 1], [1])

with tf.variable_scope("image_filter") as scope:
    result1 = my_image_filter(input_images)
    # 重用变量
    scope.reuse_variables()
    result2 = my_image_filter(input_images)

init = tf.global_variables_initializer();

with tf.Session() as sess:
    sess.run(init)
    image = np.random.rand(1, 32, 32, 1)
    result1 = sess.run(result1, feed_dict={input_images: image})
    result2 = sess.run(result2, feed_dict={input_images: image})

    print(result2.all() == result1.all())

---

理解get_variable_scope()

其实根据上面的代码，我们可以想到一些关于这个内容。假如tf.get_variable_scope().reuse == False的话，在这个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
# True

理解variable_scope

1. scope可以一层一层的叠下去，如

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

2. 同一个scope里面调用同名变量名则：

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

3. scope的reuse可继承，子层的可重用性不影响父层的可重用性：

with tf.variable_scope("root"):
    # 一开始root scope是不可重用的
    assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo"):
        # 接下来root的子scope foo也是不可重用的
        assert tf.get_variable_scope().reuse == False
    with tf.variable_scope("foo", reuse=True):
        # 这里我们设置foo可重用
        assert tf.get_variable_scope().reuse == True
        with tf.variable_scope("bar"):
            # 这样他的的子scope就继承了父scope的可复用性
            assert tf.get_variable_scope().reuse == True
    # 退回到root scope，发现并没有影响到
    assert tf.get_variable_scope().reuse == False

4. 获取variable scope

我们调用variable_scope创建新的scope后，可能经过一段时间又会再度使用这个scope。那就会用到像下面的代码那样啦

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

而且可以在任何时候都可以跳回原来的scope，并且独立于当前所在的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"  # 没有任何改变

本人认为这个用法很容易把自己思维混淆，建议编程的时候还是注意点或者少用。

5. 变量作用域中的初始化器

在我们调用tf.get_variable()真的十分蛋疼，因为都需要定义initializer，因为有时候我们都使用一样的初始器。那variable_scope就帮到你了。我们可以在variable_scope方法里面传入参数initializer作为当前scope下每个变量的默认初始器

with tf.variable_scope("foo", initializer=tf.constant_initializer(0.4)):
    v = tf.get_variable("v", [1])
    assert v.eval() == 0.4  # 默认初始器起作用了
    w = tf.get_variable("w", [1], initializer=tf.constant_initializer(0.3)):
    assert w.eval() == 0.3  # 这个变量我定义了其他初始器
    with tf.variable_scope("bar"):
        v = tf.get_variable("v", [1])
        assert v.eval() == 0.4  # 原来子scope也会继承父scope的初始器，这个和reuse有点相似哦。

---

好啦！今天的内容就到这里为止啦！是不是很简单呢？哈哈。看完记得早睡哦～早唞！好梦！