前言
本文章是一篇源于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有点相似哦。
好啦！今天的内容就到这里为止啦！是不是很简单呢？哈哈。看完记得早睡哦～早唞！好梦！
