tf.name_scope

site/en/api_docs/api_docs/python/tf/name_scope.md

tf.name_scope 函数是为了解决命名冲突问题。

1. Class name_scope

1.1 Aliases

• Class tf.keras.backend.name_scope
• Class tf.name_scope

aliases：n. 别名 (alias 的复数)
scope [skəʊp]：n. 范围，余地，视野，眼界，导弹射程 vt. 审视

A context manager for use when defining a Python op.
定义 Python 操作时使用的上下文管理器。

This context manager validates that the given values are from the same graph, makes that graph the default graph, and pushes a name scope in that graph (see tf.Graph.name_scope for more details on that).
此上下文管理器验证给定值来自同一 graph，使该 graph 成为默认 graph，并在该 graph 中推送名称范围 (有关详细信息，请参阅 tf.Graph.name_scope)。

1.2 Methods

1.2.1 init

__init__(
    name,
    default_name=None,
    values=None
)

Initialize the context manager.
初始化上下文管理器。

• name: The name argument that is passed to the op function. - 传递给 op 函数的 name 参数。
• default_name: The default name to use if the name argument is None. -如果 name 参数为 'None`，则使用默认名称。
• values: The list of Tensor arguments that are passed to the op function. -传递给 op 函数的 Tensor 参数列表。

1.2.2 enter

__enter__()

Start the scope block.
启动范围块。

Returns
The scope name.

Raises
ValueError: if neither name nor default_name is provided but values are. 如果既没有提供 name 也没有 default_name，但是 values 存在。

1.2.3 exit

__exit__(
    type_arg,
    value_arg,
    traceback_arg
)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

with tf.name_scope(None, "default_name", None):
    op = tf.constant(0)
print(op.name)

with tf.name_scope("yongqiang", "default_name", None):
    op = tf.constant(0)
print(op.name)

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
default_name/Const:0
yongqiang/Const:0
strong@foreverstrong:~/git_workspace/MonoGRNet$

values 参数的规定了应该把在 with tf.name_scope 区域里生成的 tensor 放到哪个计算图 (graph) 里。在 with tf.name_scope(**, **, values) 这个区域内声明的 tensor，都被放到了 values 所在的 graph 里。它为我们省去了显式地声明某些 tensor 需要被放在哪个图中的麻烦。values 里的所有 tensor 都应该在同一个图里，否则会报错。

在编写比较复杂的程序时，不同的 tensor 可能需要被放在不同的 graph 里。在需要对多个 tensor 进行并行计算时，我们把它们放进不同的 graph 里，然后分别丢给不同的 session 去 run。

下面代码对比了在 with tf.name_scope 使用 values 和不使用 values 的区别。不用 values 时，在 with tf.name_scope 中声明的 tensor 都被放进了当前的“默认图”中。使用 values 时，在 with tf.name_scope 中声明的 tensor 被放进了 tensor A 所在的图中，即 graph_tensor 这个图中。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

graph_tensor = tf.Graph()
with graph_tensor.as_default():
    FS = tf.constant(1)

graph_1 = tf.Graph()
graph_1.as_default()
with tf.name_scope(None, "namescope_1"):
    op1 = tf.constant(2)

graph_2 = tf.Graph()
graph_2.as_default()
with tf.name_scope(None, "namescope_2", [FS]):
    op2 = tf.constant(3)

print(op1.graph == graph_tensor)
print(op2.graph == graph_tensor)
print(op1.graph)
print(op2.graph)
print(graph_tensor)

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
False
True
<tensorflow.python.framework.ops.Graph object at 0x7f3170247f50>
<tensorflow.python.framework.ops.Graph object at 0x7f31e2d53690>
<tensorflow.python.framework.ops.Graph object at 0x7f31e2d53690>
strong@foreverstrong:~/git_workspace/MonoGRNet$

2. tf.name_scope

命名空间就是给变量包一层名字，方便变量管理。函数是 tf.name_scope。就像操作系统文件夹命名一样，不同的顶层文件夹下，可以有同名文件夹。不同的命名空间下，可以有名字相同的变量。

source code

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

with tf.name_scope("yong"):
    weights1 = tf.Variable([1.0, 2.0], name='weights')
    bias1 = tf.Variable([0.3], name='bias')

with tf.name_scope("qiang"):
    weights2 = tf.Variable([4.0, 2.0], name='weights')
    bias2 = tf.Variable([0.5], name='bias')

init = tf.global_variables_initializer()
sess = tf.Session()

writer = tf.summary.FileWriter("./strong_graph", sess.graph)

sess.run(init)
print(weights1.name)
print(weights2.name)

console

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
2019-07-02 16:34:23.707195: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
2019-07-02 16:34:23.793798: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:892] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2019-07-02 16:34:23.794076: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Found device 0 with properties: 
name: GeForce GTX 1080 major: 6 minor: 1 memoryClockRate(GHz): 1.7335
pciBusID: 0000:01:00.0
totalMemory: 7.92GiB freeMemory: 7.51GiB
2019-07-02 16:34:23.794089: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: GeForce GTX 1080, pci bus id: 0000:01:00.0, compute capability: 6.1)
yong/weights:0
qiang/weights:0
strong@foreverstrong:~/git_workspace/MonoGRNet$

sess.graph - events.out.tfevents.1562056463.foreverstrong

strong@foreverstrong:~/git_workspace/MonoGRNet/strong_graph$ ls -l
total 8
-rw-rw-r-- 1 strong strong 5591 Jul  2 16:34 events.out.tfevents.1562056463.foreverstrong
strong@foreverstrong:~/git_workspace/MonoGRNet/strong_graph$ 

tensorboard --logdir="./strong_graph/"

strong@foreverstrong:~/git_workspace/MonoGRNet$ tensorboard --logdir="./strong_graph/"
TensorBoard 0.4.0 at http://foreverstrong:6006 (Press CTRL+C to quit)

浏览器中输入上述网址：http://foreverstrong:6006

auxiliary [ɔːɡˈzɪljərɪ]：adj. 辅助的，副的，附加的，(发动机、设备等) 备用的 n. 助动词，辅助者，辅助物，附属机构，(北美) 志愿队，(海军的)辅助舰队

双击 qiang 矩形框

双击 yong 矩形框

总体框架

Press CTRL + C to quit

strong@foreverstrong:~/git_workspace/MonoGRNet$ tensorboard --logdir="./strong_graph/"
TensorBoard 0.4.0 at http://foreverstrong:6006 (Press CTRL+C to quit)
^Cstrong@foreverstrong:~/git_workspace/MonoGRNet$ 
strong@foreverstrong:~/git_workspace/MonoGRNet$

3. tf.name_scope

tf.name_scope() 当传入字符串时，用以给变量名添加前缀，类似于目录。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

with tf.name_scope('k1'):
    with tf.name_scope('k2'):
        weights1 = tf.Variable([1, 2, 3], name='weights')
        bias1 = tf.Variable([0.1], name='biases')

print(weights1.name)
print(bias1.name)

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
k1/k2/weights:0
k1/k2/biases:0
strong@foreverstrong:~/git_workspace/MonoGRNet$

当传入已存在的 name_scope 对象时，则其范围内变量的前缀只与当前传入的对象有关，与更上层的 name_scope 无关。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

with tf.name_scope('k1') as k1_scope:
    with tf.name_scope('k2'):
        weights0 = tf.Variable([1, 2, 3], name='weights')
        bias0 = tf.Variable([0.1], name='biases')
        with tf.name_scope(k1_scope):
            weights1 = tf.Variable([1, 2, 3], name='weights')
            bias1 = tf.Variable([0.1], name='biases')

print(weights0.name)
print(bias0.name)

print(weights1.name)
print(bias1.name)

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
k1/k2/weights:0
k1/k2/biases:0
k1/weights:0
k1/biases:0
strong@foreverstrong:~/git_workspace/MonoGRNet$

注意观察与上面两个例子的区别。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf

with tf.name_scope('k1'):
    with tf.name_scope('k2'):
        weights1 = tf.Variable([1, 2, 3], name='weights')
        bias1 = tf.Variable([0.1], name='biases')

print(weights1.name)
print(bias1.name)

with tf.name_scope('k1') as k1_scope:
    with tf.name_scope('k2'):
        weights0 = tf.Variable([1, 2, 3], name='weights')
        bias0 = tf.Variable([0.1], name='biases')
        with tf.name_scope(k1_scope):
            weights1 = tf.Variable([1, 2, 3], name='weights')
            bias1 = tf.Variable([0.1], name='biases')

print(weights0.name)
print(bias0.name)

print(weights1.name)
print(bias1.name)

strong@foreverstrong:~/git_workspace/MonoGRNet$ python yongqiang.py 
k1/k2/weights:0
k1/k2/biases:0
k1_1/k2/weights:0
k1_1/k2/biases:0
k1_1/weights:0
k1_1/biases:0
strong@foreverstrong:~/git_workspace/MonoGRNet$

源码地址：https://mxnet.incubator.apache.org/api/python/docs/_modules/mxnet/gluon/block.html#Block.name_scope
其他参考：
参数和Block命名：https://mxnet.incubator.apache.org/api/python/docs/tutorials/packages/gluon/blocks/naming.html

写在前面

name_scope函数是在Block中定义的，而又因为HybridBlock是Block的子类，所以
Block和HybridBlock都有这个函数。而gluon.nn，或者gluon.contrib下定义的高层次的组件继承了HybridBlock，一言概之，gluon中的模型，都具有name_scope功能。

调用 with xxx.name_scope时候，实际调用的是Block的name_scope函数，而name_scope返回的是self._scope，Block在构造的时候，会创建self._scope属性，而self._scope=_BlockScope(self)，所以with语句最终调用的是_BlockScope。

_BlockScope类的定义

import threading
class _BlockScope(object):
    """Scope for collecting child `Block` s."""
    _current = threading.local()  #  确保_current中的同名变量在多线程之间互不干扰

    def __init__(self, block):
        self._block = block  # block是gluon.Block或者gluon.HybridBlock
        self._counter = {}
        self._old_scope = None
        self._name_scope = None

    @staticmethod
    def create(prefix, params, hint):  
    # Block调用时，hint是self._alias()，而self._alias()返回的是类名，
    # self.__class__.__name__.lower()
        """Creates prefix and params for new `Block`."""
        current = getattr(_BlockScope._current, "value", None)
        if current is None:
            if prefix is None:
                if not hasattr(_name.NameManager._current, "value"):
                    _name.NameManager._current.value = _name.NameManager()
                prefix = _name.NameManager._current.value.get(None, hint) + '_'
            if params is None:
                params = ParameterDict(prefix)
            else:
                params = ParameterDict(params.prefix, params)
            return prefix, params

        if prefix is None:
            count = current._counter.get(hint, 0)
            prefix = '%s%d_'%(hint, count)
            current._counter[hint] = count + 1
        if params is None:
            parent = current._block.params
            params = ParameterDict(parent.prefix+prefix, parent._shared)
        else:
            params = ParameterDict(params.prefix, params)
        return current._block.prefix+prefix, params

    def __enter__(self):
        if self._block._empty_prefix:
            return self
        self._old_scope = getattr(_BlockScope._current, "value", None)
        _BlockScope._current.value = self
        self._name_scope = _name.Prefix(self._block.prefix)
        self._name_scope.__enter__()
        return self

    def __exit__(self, ptype, value, trace):
        if self._block._empty_prefix:
            return
        self._name_scope.__exit__(ptype, value, trace)
        self._name_scope = None
        _BlockScope._current.value = self._old_scope

Block相关函数

在这里插入代码片

前言：整理name_scope与variable_scope是因为自己在学习的过程中碰到的一些疑惑，后来看书和网上的一些解释。故这里做一些学习记录。

1、大体的认识

tf.name_scope()和tf.variable_scope()是两个作用域，一般与两个创建/调用变量的函数tf.variable() 和tf.get_variable()搭配使用。它们搭配在一起的两个常见用途：

1. 变量共享
2. tensorboard画流程图时为了可视化封装变量

这两种用途有特定的搭配方式，掌握好就可以用了。

• name_scope：为了更好地管理变量的命名空间而提出的。比如在 tensorboard 中，因为引入了 name_scope， 我们的 Graph 看起来才井然有序。
• variable_scope：大部分情况下，跟 tf.get_variable() 配合使用，实现变量共享的功能。

2、name_scope与variable_scope的区别

先直接给出结论，然后再进行说明，是其他博主整理的结论，这只是借鉴一下，原文是这个。

1. name_scope 对 get_variable新建变量的name属性无影响；对variable新建变量的name属性增加了“范围”标识。
2. variable_scope对get_variable新建变量的name属性和variable新建变量的name属性都增加了“范围”标识。
3. get_variable新建变量如果遇见重复的name则会因为重复而报错。
4. variable新建的变量如果遇见重复的name则会自动修改前缀，以避免重复出现。

2.1 tf.name_scope

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

2.1.1 name_scope()对variable的影响

'''
Signature: tf.name_scope(*args, **kwds)
Docstring:
Returns a context manager for use when defining a Python op.
'''
# 也就是说，它的主要目的是为了更加方便地管理参数命名。
# 与 tf.Variable() 结合使用。简化了命名
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

conv1/weights:0
conv2/weights:0

从上面的例子可以看出name_scope()对variable的变量名自动添上命名空间的名称，形式为/

2.1.2 tf.name_scope对tf.get_variable()的影响

with tf.name_scope("a_name_scope") as myscope:
    initializer = tf.constant_initializer(value=1)
    var1 = tf.get_variable(name='var1', shape=[1], dtype=tf.float32, initializer=initializer)

print(var1.name)        

var1:0

可见并没有在变量名前添加命名空间的名称。

2.2 tf.variable_scope

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

2.2.1 variable_scope()对tf.get_variable() 的影响

with tf.variable_scope('v_scope') as scope1:
    Weights1 = tf.get_variable('Weights', shape=[2,3])
    bias1 = tf.get_variable('bias', shape=[3])

# 下面来共享上面已经定义好的变量
# note: 在下面的 scope 中的变量必须已经定义过了，才能设置 reuse=True，否则会报错
with tf.variable_scope('v_scope', reuse=True) as scope2:
    Weights2 = tf.get_variable('Weights')

print Weights1.name
print Weights2.name

v_scope/Weights:0
v_scope/Weights:0

对variable的影响这里就不展示了，这里只提醒一下，当需要共用变量的时候，设置的reuse=True必须是要已经创建过的变量，否则则会报错。

   也许目前还不知道这会有什么用，但给个例子就会发现这样的好处。这里借鉴一下这篇博客的内容。（也可以参考下这篇文章，讲的还算清楚，对变量的共享，因为在卷积神经网络中，卷积层的参数就是共享的呢）

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

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

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

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

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

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)

    总之，当神经网络结构更加复杂、参数更多时，使用这种变量的管理方式将大大提高程序的可读性。

参考资料：

https://blog.csdn.net/jerr__y/article/details/60877873

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

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