命名空间是一种以分层方式组织变量和运算符名称的方法（例如“ scopeA / scopeB / scopeC / op1”）

• tf.name_scope在默认图中为运算符创建名称空间。

• tf.variable_scope在默认图中为变量和运算符创建名称空间。

• tf.op_scope相同tf.name_scope ，但对于曲线图，其中指定创建变量。

• tf.variable_op_scope相同tf.variable_scope ，但对于曲线图，其中指定创建变量。

指向上述资源的链接有助于消除此文档问题的歧义。

此示例说明，所有类型的作用域都为变量和运算符定义了名称空间，但存在以下差异：

1. 由tf.variable_op_scope或tf.variable_scope定义的范围与tf.get_variable兼容（它忽略其他两个范围）
2. tf.op_scope和tf.variable_op_scope只需从指定变量列表中选择一个图形即可为其创建范围。除了它们的行为相应地等于tf.name_scope和tf.variable_scope
3. tf.variable_scope和variable_op_scope添加指定的或默认的初始化程序。

对于API r0.11， 不建议使用 op_scope和variable_op_scope 。 name_scope和variable_scope可以嵌套：

with tf.name_scope('ns'):
    with tf.variable_scope('vs'): #scope creation
        v1 = tf.get_variable("v1",[1.0])   #v1.name = 'vs/v1:0'
        v2 = tf.Variable([2.0],name = 'v2')  #v2.name= 'ns/vs/v2:0'
        v3 = v1 + v2       #v3.name = 'ns/vs/add:0'

让我们从变量共享的简短介绍开始。它是TensorFlow中的一种机制，它允许共享在代码的不同部分中访问的变量，而无需传递对变量的引用。

可以将tf.get_variable方法与变量名一起使用，以使用该名称创建新变量或检索以前创建的变量。这与使用tf.Variable构造函数不同，该构造函数在tf.Variable它时都会创建一个新变量（如果已经存在具有该名称的变量，则可能在变量名称后添加一个后缀）。

出于变量共享机制的目的，引入了一种单独的范围类型（变量范围）。

结果，我们最终得到了两种不同类型的范围：

• 名称范围 ，使用tf.name_scope创建
• 变量范围 ，使用tf.variable_scope创建

这两个作用域对所有操作以及使用tf.Variable创建的变量都具有相同的作用，即，该作用域将作为前缀添加到操作或变量名称中。

但是，名称范围将被tf.get_variable忽略。在下面的示例中我们可以看到：

with tf.name_scope("my_scope"):
    v1 = tf.get_variable("var1", [1], dtype=tf.float32)
    v2 = tf.Variable(1, name="var2", dtype=tf.float32)
    a = tf.add(v1, v2)

print(v1.name)  # var1:0
print(v2.name)  # my_scope/var2:0
print(a.name)   # my_scope/Add:0

将使用tf.get_variable访问的变量tf.get_variable在范围中的唯一方法是使用变量范围，如以下示例所示：

with tf.variable_scope("my_scope"):
    v1 = tf.get_variable("var1", [1], dtype=tf.float32)
    v2 = tf.Variable(1, name="var2", dtype=tf.float32)
    a = tf.add(v1, v2)

print(v1.name)  # my_scope/var1:0
print(v2.name)  # my_scope/var2:0
print(a.name)   # my_scope/Add:0

这使我们可以轻松地在程序的不同部分之间共享变量，即使在不同的名称范围内也是如此：

with tf.name_scope("foo"):
    with tf.variable_scope("var_scope"):
        v = tf.get_variable("var", [1])
with tf.name_scope("bar"):
    with tf.variable_scope("var_scope", reuse=True):
        v1 = tf.get_variable("var", [1])
assert v1 == v
print(v.name)   # var_scope/var:0
print(v1.name)  # var_scope/var:0

更新

从r0.11版本开始， op_scope和variable_op_scope均已弃用 ，并由name_scope和variable_scope代替。

Tensorflow 2.0兼容答案 ： Andrzej Pronobis和Salvador Dali的解释非常详细，涉及与Scope相关的功能。

上面讨论的范围函数中，截至目前（2020年2月17日）有效的是variable_scope和name_scope 。

为社区的利益，我们在上面讨论了为这些功能指定2.0兼容的调用。

1.x中的功能 ：

tf.variable_scope

tf.name_scope

2.x中的相应功能 ：

tf.compat.v1.variable_scope

tf.name_scope （如果从1.x to 2.x迁移1.x to 2.x tf.compat.v2.name_scope ）

有关从1.x迁移到2.x的更多信息，请参阅此迁移指南 。

让我们简单点：只需使用tf.variable_scope 。 引用TF开发人员 ：

当前，除了内部代码和库，我们建议每个人都使用variable_scope而不使用name_scope 。

除了variable_scope的功能基本上扩展了name_scope的功能name_scope ，还请考虑一下它们如何不能很好地配合使用：

with tf.name_scope('foo'):
  with tf.variable_scope('bar'):
    x = tf.get_variable('x', shape=())
    x2 = tf.square(x**2, name='x2')
print(x.name)
# bar/x:0
print(x2.name)
# foo/bar/x2:0

通过仅坚持variable_scope ，可以避免由于这种不兼容而引起的一些麻烦。

现在已弃用variable_op_scope和op_scope ，并且完全不应使用。

关于其他两个，在尝试通过创建一个简单的示例来可视化所有内容之前，我还难以理解variable_scope和name_scope （它们看上去几乎相同）之间的区别：

import tensorflow as tf


def scoping(fn, scope1, scope2, vals):
    with fn(scope1):
        a = tf.Variable(vals[0], name='a')
        b = tf.get_variable('b', initializer=vals[1])
        c = tf.constant(vals[2], name='c')

        with fn(scope2):
            d = tf.add(a * b, c, name='res')

        print '\n  '.join([scope1, a.name, b.name, c.name, d.name]), '\n'
    return d

d1 = scoping(tf.variable_scope, 'scope_vars', 'res', [1, 2, 3])
d2 = scoping(tf.name_scope,     'scope_name', 'res', [1, 2, 3])

with tf.Session() as sess:
    writer = tf.summary.FileWriter('logs', sess.graph)
    sess.run(tf.global_variables_initializer())
    print sess.run([d1, d2])
    writer.close()

在这里，我创建了一个函数，该函数创建一些变量和常量，并在范围内对它们进行分组（取决于我提供的类型）。在此函数中，我还将打印所有变量的名称。之后，我执行该图以获取结果值的值，并保存事件文件以在TensorBoard中对其进行调查。如果运行此命令，则会得到以下信息：

scope_vars
  scope_vars/a:0
  scope_vars/b:0
  scope_vars/c:0
  scope_vars/res/res:0 

scope_name
  scope_name/a:0
  b:0
  scope_name/c:0
  scope_name/res/res:0 

如果打开TensorBoard，您会看到类似的图案（因为您看到b在scope_name矩形的外部）：

这给你答案 ：

现在您看到tf.variable_scope()在所有变量（无论如何创建它们），ops和常量的名称之前添加了一个前缀。另一方面， tf.name_scope()忽略使用tf.get_variable()创建的变量，因为它假定您知道要使用哪个变量以及在哪个范围内。

关于共享变量的良好文档告诉您

tf.variable_scope() ：管理传递给tf.get_variable()名称的名称空间。

同一文档提供了更多详细信息，“可变作用域”如何工作以及何时有用。

在Tensorflow文档的此页面的最后一部分中： tf.variable_scope()的ops名称

[...]当我们with tf.variable_scope("name") ，这将隐式打开一个tf.name_scope("name") 。例如：

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

除了变量作用域之外，还可以打开名称作用域，然后它们将仅影响操作的名称，而不影响变量的名称。

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"

当使用捕获的对象而不是字符串打开变量范围时，我们不会更改ops的当前名称范围。

您可以将它们分为两组： variable_op_scope和op_scope以一组变量作为输入，并旨在创建操作。区别在于它们如何影响使用tf.get_variable创建变量：

def mysum(a,b,name=None):
    with tf.op_scope([a,b],name,"mysum") as scope:
        v = tf.get_variable("v", 1)
        v2 = tf.Variable([0], name="v2")
        assert v.name == "v:0", v.name
        assert v2.name == "mysum/v2:0", v2.name
        return tf.add(a,b)

def mysum2(a,b,name=None):
    with tf.variable_op_scope([a,b],name,"mysum2") as scope:
        v = tf.get_variable("v", 1)
        v2 = tf.Variable([0], name="v2")
        assert v.name == "mysum2/v:0", v.name
        assert v2.name == "mysum2/v2:0", v2.name
        return tf.add(a,b)

with tf.Graph().as_default():
    op = mysum(tf.Variable(1), tf.Variable(2))
    op2 = mysum2(tf.Variable(1), tf.Variable(2))
    assert op.name == 'mysum/Add:0', op.name
    assert op2.name == 'mysum2/Add:0', op2.name

注意两个示例中的变量v的名称。

与tf.name_scope和tf.variable_scope相同：

with tf.Graph().as_default():
    with tf.name_scope("name_scope") as scope:
        v = tf.get_variable("v", [1])
        op = tf.add(v, v)
        v2 = tf.Variable([0], name="v2")
        assert v.name == "v:0", v.name
        assert op.name == "name_scope/Add:0", op.name
        assert v2.name == "name_scope/v2:0", v2.name

with tf.Graph().as_default():
    with tf.variable_scope("name_scope") as scope:
        v = tf.get_variable("v", [1])
        op = tf.add(v, v)
        v2 = tf.Variable([0], name="v2")
        assert v.name == "name_scope/v:0", v.name
        assert op.name == "name_scope/Add:0", op.name
        assert v2.name == "name_scope/v2:0", v2.name

您可以在本教程中阅读有关变量作用域的更多信息。 之前在堆栈溢出问题上也曾提出过类似的问题。