精华内容
下载资源
问答
  • variable_scope对get_variable新建变量的name属性variable新建变量的name属性都增加了“范围”标识。 get_variable新建变量如果遇见重复的name则会因为重复而报错。 variable新建的变量如果遇见...
    1.  name_scope 对 get_variable新建变量的name属性无影响;对variable新建变量的name属性增加了“范围”标识。
    2. variable_scope对get_variable新建变量的name属性和variable新建变量的name属性都增加了“范围”标识。
    3. get_variable新建变量如果遇见重复的name则会因为重复而报错。
    4. variable新建的变量如果遇见重复的name则会自动修改前缀,以避免重复出现。
    展开全文
  • 另一个区别在于,一个在('...请查看源代码 :def _get_default_variable_store():store = ops.get_collection(_VARSTORE_KEY)if store:return store[0]store = _VariableStore()ops.add_to_collection(_VARST...

    另一个区别在于,一个在('variable_store',)集合中,而另一个不在。

    请查看源代码 :

    def _get_default_variable_store():

    store = ops.get_collection(_VARSTORE_KEY)

    if store:

    return store[0]

    store = _VariableStore()

    ops.add_to_collection(_VARSTORE_KEY, store)

    return store

    让我说明一下:

    import tensorflow as tf

    from tensorflow.python.framework import ops

    embedding_1 = tf.Variable(tf.constant(1.0, shape=[30522, 1024]), name="word_embeddings_1", dtype=tf.float32)

    embedding_2 = tf.get_variable("word_embeddings_2", shape=[30522, 1024])

    graph = tf.get_default_graph()

    collections = graph.collections

    for c in collections:

    stores = ops.get_collection(c)

    print('collection %s: ' % str(c))

    for k, store in enumerate(stores):

    try:

    print('\t%d: %s' % (k, str(store._vars)))

    except:

    print('\t%d: %s' % (k, str(store)))

    print('')

    输出:

    collection ('__variable_store',): 0: {'word_embeddings_2':

    dtype=float32_ref>}

    展开全文
  • Tensorflow的Variable和get_variable

    千次阅读 2018-07-11 21:00:47
    tf创建变量主要有两种方式:tf.Variable()(V大写)、tf.get_variable()。 1、tf.Variable() (1)每次调用得到的都是不同的变量,即使使用了相同的变量名,在底层实现的时候还是会为变量创建不同的别名var1 = tf....

        tf创建变量主要有两种方式:tf.Variable()(V大写)、tf.get_variable()。

        1、tf.Variable()

        (1)每次调用得到的都是不同的变量,即使使用了相同的变量名,在底层实现的时候还是会为变量创建不同的别名

    var1 = tf.Variable(name='var', initial_value=[2], dtype=tf.float32)
    var2 = tf.Variable(name='var', initial_value=[2], dtype=tf.float32)
    sess.run(tf.global_variables_initializer())
    print var1.name, sess.run(var1)
    print var2.name, sess.run(var2)
    
    # 输出为:
    # var:0 [ 2.]
    # var_1:0 [ 2.]

        (2)会受tf.name_scope环境的影响,即会在前面加上name_scope的空间前缀

    with tf.name_scope('var_a_scope'):
         var1 = tf.Variable(name='var', initial_value=[2], dtype=tf.float32)
         var2 = tf.Variable(name='var', initial_value=[2], dtype=tf.float32)
     
    with tf.Session() as sess:
         sess.run(tf.global_variables_initializer())
         print var1.name, sess.run(var1)
         print var2.name, sess.run(var2)
    
    #输出为:
    #var_a_scope/var:0 [ 2.]
    #var_a_scope/var_1:0 [ 2.]

        (3)Variable()创建时直接指定初始化的方式

        可以直接给定值和dtype,如上面的initial_value=[1],也可以传入一个随机数生成函数,或是其他的tensor,其中tf中的随机数生成函数主要有:

     

        固定值生成函数:


        还可以把其他变量的初始值作为初始值

    var2=tf.Variable(var1.initialized_value())

        2、tf.get_variable()

        (1)只会创建一个同名变量,如果想共享变量,需指定reuse=True,否则多次创建会报错

    import tensorflow as tf
    
    def func(x):
        weight = tf.get_variable(tf.random_normal([1]),name="weight")
        bias = tf.get_variable(tf.zeros([1]), name="bias")
        return tf.add(tf.multiply(weight, x), bias)
    
    with tf.Session() as sess:
        init = tf.global_variables_initializer()
        sess.run(init)
        result1 = func(1)
        result2 = func(2)
        print(sess.run(result1))
        print(sess.run(result2))
    
    #报错:ValueError: Variable weight already exists, disallowed.

         使用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')
    print v.name
    print v1.name
    assert v == v1

           可以动态的修改某个scope的共享属性:

    def my_image_filter(input_images):
        conv1_weights = tf.get_variable(name="conv1_weights", shape=[5, 5, 3, 3], dtype=tf.float32, \
                                        initializer=tf.truncated_normal_initializer())
        conv1_biases = tf.get_variable(name='conv1_biases', shape=[3], dtype=tf.float32, \
                                        initializer=tf.zeros_initializer())
        conv1 = tf.nn.conv2d(input_images, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
        return  tf.nn.relu(conv1 + conv1_biases)
    
    image1 = np.random.random(3*5*5).reshape(1, 5, 5, 3).astype(np.float32)
    image2 = np.random.random(3*5*5).reshape(1, 5, 5, 3).astype(np.float32)
    with tf.variable_scope("image_filters") as scope:
        result1 = my_image_filter(image1)
        scope.reuse_variables() #or 
        # tf.get_variable_scope().reuse_variables()
        result2 = my_image_filter(image2)
        (2)不受with tf.name_scop的影响(注:是name_scop,不是variable_scop,tf.Variable和tf.get_variable都会受variable_scop影响)
    with tf.name_scope('var_a_scope'):
         var1 = tf.get_variable('var1', [1])
    print var1.name
    #输出:
    var1:0
    

        (3)创建时,通过传入initializer来指定初始化方式,可选方式与上节(3)中的类似,不过后面加_initialize后缀,且不用输入shape参数

    conv1_weights = tf.get_variable(name="conv1_weights", shape=[5, 5, 3, 3], dtype=tf.float32, \
                                                                    initializer=tf.truncated_normal_initializer())
    conv1_biases = tf.get_variable(name='conv1_biases', shape=[3], dtype=tf.float32, initializer=tf.zeros_initializer())

        (4)with tf.variable_scope('scope_name")会进行“累加”,每调用一次就会给里面的所有变量添加一次前缀,叠加顺序是外层先调用的在前,后调用的在后

    def my_image_filter(input_images):
        with tf.variable_scope('scope_a'):
            conv1_weights = tf.get_variable(name="conv1_weights", shape=[5, 5, 3, 3], dtype=tf.float32, \
                                            initializer=tf.truncated_normal_initializer())
            conv1_biases = tf.get_variable(name='conv1_biases', shape=[3], dtype=tf.float32, \
                                            initializer=tf.zeros_initializer())
            conv1 = tf.nn.conv2d(input_images, conv1_weights, strides=[1, 1, 1, 1], padding='SAME')
            print conv1_weights.name
            return  tf.nn.relu(conv1 + conv1_biases)
    
    image1 = np.random.random(3*5*5).reshape(1, 5, 5, 3).astype(np.float32)
    image2 = np.random.random(3*5*5).reshape(1, 5, 5, 3).astype(np.float32)
    with tf.variable_scope("image_filters") as scope:
        result1 = my_image_filter(image1)
        print result1.name
    
    #输出:
    image_filters/scope_a/conv1_weights:0
    image_filters/scope_a/Relu:0

        举个栗子:    

        首先定义一个conv_relu节点:

    def conv_relu(input, kernel_shape, bias_shape):
        weights = tf.get_variable("weights", kernel_shape,
            initializer=tf.random_normal_initializer())
        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)

        然后,定义一个由上面的节点组成的简单网络:(注意:此时每个节点赋予一个‘scope’,用以区分)

    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, [3, 3, 32, 32], [32])
        with tf.variable_scope("conv2"):
            # Variables created here will be named "conv2/weights", "conv2/biases".
            return conv_relu(relu1, [3, 3, 32, 32], [32])

        再然后,把上面的网络用以计算:

    def compute_op():
         img1 = tf.Variable(tf.random_normal([1, 5, 5, 32]))
         img2 = tf.Variable(tf.random_normal([1, 5, 5, 32]))
         with tf.variable_scope('filter') as scope:
              result1 = my_image_filter(img1)
              scope.reuse_variables()
              result2 = my_image_filter(img2)
        这里第二次调用前就必须设置reuse_variables(),否则就会报错 “Variable conv1/weights already exists”

        

    展开全文
  • 在tensorflow中,可以使用tf.Variable来创建一个变量,也可以使用tf.get_variable来创建一个变量,但是在一个模型需要使用其他模型的变量时,tf.get_variable就派上大用场了。 先分别介绍两个函数的用法: 1 ...

    在tensorflow中,可以使用tf.Variable来创建一个变量,也可以使用tf.get_variable来创建一个变量,但是在一个模型需要使用其他模型的变量时,tf.get_variable就派上大用场了。

    先分别介绍两个函数的用法:

     1 import tensorflow as tf
     2 var1 = tf.Variable(1.0,name='firstvar')
     3 print('var1:',var1.name)
     4 var1 = tf.Variable(2.0,name='firstvar')
     5 print('var1:',var1.name)
     6 var2 = tf.Variable(3.0)
     7 print('var2:',var2.name)
     8 var2 = tf.Variable(4.0)
     9 print('var2:',var2.name)
    10 get_var1 = tf.get_variable(name='firstvar',shape=[1],dtype=tf.float32,initializer=tf.constant_initializer(0.3))
    11 print('get_var1:',get_var1.name)
    12 get_var1 = tf.get_variable(name='firstvar1',shape=[1],dtype=tf.float32,initializer=tf.constant_initializer(0.4))
    13 print('get_var1:',get_var1.name)
    14 
    15 with tf.Session() as sess:
    16     sess.run(tf.global_variables_initializer())
    17     print('var1=',var1.eval())
    18     print('var2=',var2.eval())
    19     print('get_var1=',get_var1.eval())

    结果如下:

    我们来分析一下代码,tf.Varibale是以定义的变量名称为唯一标识的,如var1,var2,所以可以重复地创建name='firstvar'的变量,但是tensorflow会给它们按顺序取后缀,如firstvar_1:0,firstval_2:0,...,如果没有制定名字,系统会自动加上一个名字Variable:0。而且由于tf.Varibale是以定义的变量名称为唯一标识的,所以当第二次命名同一个变量名时,第一个变量就会被覆盖,所以var1由1.0变成2.0。

    对于tf.get_variable,它是以指定的name属性为唯一标识,而不是定义的变量名称,所以不能同时定义两个变量name是相同的,例如下面这种就会报错:

    1 get_var1 = tf.get_variable(name='a',shape=[1],dtype=tf.float32,initializer=tf.constant_initializer(0.3))
    2 print('get_var1:',get_var1.name)
    3 get_var2 = tf.get_variable(name='a',shape=[1],dtype=tf.float32,initializer=tf.constant_initializer(0.4))
    4 print('get_var1:',get_var1.name)

    这样就会报错了。如果我们想声明两次相同name的变量,这时variable_scope就派上用场了,可以使用variable_scope将它们分开:

    1 import tensorflow as tf
    2 with tf.variable_scope('test1'):
    3     get_var1 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    4 with tf.variable_scope('test2'):
    5     get_var2 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    6 print('get_var1:',get_var1.name)
    7 print('get_var2:',get_var2.name)

    这样就不会报错了,variable_scope相当于声明了作用域,这样在不同的作用域存在相同的变量就不会冲突了,结果如下:

    当然,scope还支持嵌套:

    1 import tensorflow as tf
    2 with tf.variable_scope('test1',):
    3     get_var1 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    4     with tf.variable_scope('test2',):
    5         get_var2 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    6 print('get_var1:',get_var1.name)
    7 print('get_var2:',get_var2.name)

    输出结果为:

    怎么样?可以对照上面的结果体会一下不同。那么如何通过get_variable来实现变量共享呢?这就要用到variable_scope里的一个属性:reuse,顾名思义嘛,当把reuse设置成True时就可以了,它表示使用已经定义过的变量,这是get_variable就不会再创建新的变量,而是去找与name相同的变量:

    import tensorflow as tf
    with tf.variable_scope('test1',):
        get_var1 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
        with tf.variable_scope('test2',):
            get_var2 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    print('get_var1:',get_var1.name)
    print('get_var2:',get_var2.name)
    with tf.variable_scope('test1',reuse=True):
        get_var3 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
        with tf.variable_scope('test2',):
            get_var4 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    print('get_var3:',get_var3.name)
    print('get_var4:',get_var4.name)

    输出结果如下:

    当然前面说过,reuse=True是使用前面已经创建过的变量,如果仅仅只有从第八行到最后的代码,也会报错的,如果还是想这么做,就需要把reuse属性设置成tf.AUTO_REUSE

    1 import tensorflow as tf
    2 with tf.variable_scope('test1',reuse=tf.AUTO_REUSE):
    3     get_var3 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    4     with tf.variable_scope('test2',):
    5         get_var4 = tf.get_variable(name='firstvar',shape=[2],dtype=tf.float32)
    6 print('get_var3:',get_var3.name)
    7 print('get_var4:',get_var4.name)

    此时就不会报错,tf.AUTO_REUSE可以实现第一次调用variable_scope时,传入的reuse值为False,再次调用时,传入reuse的值就会自动变为True。

    转载于:https://www.cnblogs.com/wf-ml/p/9721027.html

    展开全文
  • tensorflow中有两个关于variable的op,tf.Variable()与tf.get_variable()下面介绍这两个的区别 使用tf.Variable时,如果检测到命名冲突,系统会自己处理。使用tf.get_variable()时,系统不会处理冲突,而会报错 ...
  • 1、tf.Variable() tf.get_variable() (1)tf.Variable()会自动检测命名冲突并自行处理。 with tf.Session( ) as sess: with tf.variable_scope("scope2"): w2 = tf.Variable(0.0, name="w2") w3 = tf....
  • variable共享 tf的Variable是什么就不说了,我们只说下Variable的复用,如下例所示,我们要为图像建立两层卷积网络: def conv_relu(input, kernel_shape, bias_shape): # Create variable named "weights". ...
  • 在tensorflow中,可以使用tf.Variable来创建一个变量,也可以使用tf.get_variable来创建一个变量,但是在一个模型需要使用其他模型的变量时,tf.get_variable就派上大用场了。 先分别介绍两个函数的用法: import ...
  • 文章目录Variable与get_variablename_scope与variable_scope Variable与get_variable 直接上代码: #!/usr/bin/env python # -*- coding: utf-8 -*- """ @Time : 2018/11/13 9:18 @Author : Li ...
  • tensorflow 存储训练数据...* tf.get_variable(name, shape, initializer) >如果要创建变量的名字存在,则返回已经创建的变量,否则使用参数shapeinitializer来创建新的函数 * tf.variable_scope() ...
  • 使用get_variable和safe_embedding_lookup_sparse进行...safe_embedding_lookup_sparse能够实现“Lookup embedding results, accounting for invalid IDs and empty features”,配合get_variable进行初始化embeddi...
  • 这篇博文的主线是 探究如何使用tensorflow 的 tf.get_variable tf.variable_scope 这两个函数 来实现 权值共享 , 这点别忘。 所谓的权值共享其实就是卷积核参数的共享, 首先在这里你要搞清楚是哪些卷积核的...
  • variable_scope and get_variabletensorflow计算图get_variable()函数(一)当我定义节点tensor的时候是用tf...关于tensorflow计算图、以及variable_scope() get_variable()函数的一些想法: tensorflow计算图 ...
  • 目录 1、tf.get_variable() 2、tf.variable_scope() 3、tf.variable_scope()...tf.get_variable()用来创建变量时,tf.Variable()函数的功能基本等价。 v = tf.get_variable("v", shape=[1], initializer=tf....
  • tf.get_variable(name>, shape>, initializer>) tf.variable_scope(scope_name>)。11 先来看第一个函数: tf.get_variable。 tf.get_variable tf.Variable不同的一点是,前者拥有一个变量检查机制,会检测...
  • tf.get_variable() 该函数使用时会去先查找是否已经有过该变量,如果有的话就直接使用,否则创建新的变量。 有一个变量检查机制,会检测已经存在的变量是否设置为共享变量。 tf.name_scope() 使用该函数来为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,407
精华内容 562
关键字:

variable和get_variable