PyTorch-Variable变量

硬件：NVIDIA-GTX1080

软件：Windows7、python3.6.5、pytorch-gpu-0.4.1

一、基础知识

variable = torch.autograd.Variable(tensor, requires_grad = False)，requires_grad表示参不参与误差反向传播

二、代码展示

import torch
from torch.autograd import Variable # torch 中 Variable 模块

# 先生鸡蛋
tensor = torch.FloatTensor([[1,2],[3,4]])
# requires_grad是参不参与误差反向传播, 要不要计算梯度
variable = Variable(tensor, requires_grad=True)

t_out = torch.mean(tensor*tensor)       # x^2
v_out = torch.mean(variable*variable)   # x^2

v_out.backward()    # 模拟 v_out 的误差反向传递

# v_out = 1/4 * sum(variable*variable) 这是计算图中的 v_out 计算公式
# 针对于 v_out 的梯度就是通过 v_out 对 variable 求偏导
# d(v_out)/d(variable) = 1/4*2*variable = variable/2

print(variable.grad)    # 初始 Variable 的梯度

print(variable)     #  Variable 形式
print(variable.data)    # tensor 形式
print(variable.data.numpy())    # numpy 形式

三、参考：

https://morvanzhou.github.io/

 

任何问题请加唯一QQ2258205918（名称samylee）！

或唯一VX：samylee_csdn

首先，在Java中我们常用 constant 来定义一个常量，用 Variable 来定义变量。

Constant 常量

1.常量的概念：不变化的量，及不被人修改的量
2.常量的分析：

（1）字面值常量（掌握）

（2）自定义常量（了解）
3.注意事项：区分字符串常量和字符常量

字符串常量： “HelloWorld”

字符常量：   ’a‘


补充两个快捷方式：

– main方法的快捷键：psvm

– 输出语句的快捷键： sout

常量：
        ***概述：***
            在程序的运行过程中，其值不会发生改变的量。
        ***字面值常量分类：***
            1.字符串常量，值要用“” 括起来， “abc”
            2.字符常量，值要用’‘括起来，    ’a‘，’0‘
            3.整数常量， 10，20
            4.小数常量，1，2
            5.布尔常量，值只有两个，true和false
            6.空常量，null  目前只做了解。

public class ConstantDemo {
    /*
        Constant   常量
        1.常量的概念：不变化的量，及不被人修改的量
        2.常量的分析：
            （1）字面值常量（掌握）
            （2）自定义常量（了解）

        3.注意事项：区分字符串常量和字符常量
            字符串常量： "HelloWorld"
            字符常量：   ’a‘
        补充两个快捷方式：
            main方法的快捷键：psvm
            输出语句的快捷键： sout
        常量：
            概述：
                在程序的运行过程中，其值不会发生改变的量。
            字面值常量分类：
                1.字符串常量，值要用“” 括起来， “abc”
                2.字符常量，值要用’‘括起来，    ’a‘，’0‘
                3.整数常量， 10，20
                4.小数常量，1，2
                5.布尔常量，值只有两个，true和false
                6.空常量，null  目前只做了解。
    * */
    public static void main(String[] args) {
        //1.字符串常量
        System.out.println("abc");
        System.out.println("123");

        //字符常量
        System.out.println('a');
        System.out.println('0');

        //整数常量
        System.out.println(10);
        System.out.println(-10);

        //小数常量
        System.out.println(1.2);
        System.out.println(-12.3);

        //布尔常量
        System.out.println(true);
        System.out.println(false);

    }

}

Variable 变量


变量的定义和使用


    1.变量的概念：
    
        在程序执行的过程中，其值可以在某个范围内发生改变的量
        
        变量的本质，是内存中的一小块区域
        
    2.变量定义的格式：数据类型 变量 = 初始化值；
    
            变量名：每个变量都有一个名字，方便存取
            
            初始化值：使用变量前，需要给变量赋值
            
    3.数据类型的概念：变量变化的范围就是数据类型
    
    4.变量的使用：直接通过变量名来使用变量。

public class VariableDemo {
    //Variable 变量
    /*
    变量的定义和使用
        1.变量的概念：
            在程序执行的过程中，其值可以在某个范围内发生改变的量
            变量的本质，是内存中的一小块区域
        2.变量定义的格式：数据类型 变量 = 初始化值；
                变量名：每个变量都有一个名字，方便存取
                初始化值：使用变量前，需要给变量赋值
        3.数据类型的概念：变量变化的范围就是数据类型
        4.变量的使用：直接通过变量名来使用变量。
    */
    public static void main(String[] args) {
        //定义变量，记录学生个数
        //变量的定义格式：数据类型 变量名 = 初始化值
        int number = 12;
        //使用变量
        System.out.println(number);
    }
}

2.variable变量

tf.Variable()：
（1）参数说明

tf.Variable是一个Variable类。通过变量维持图graph的状态，以便在sess.run()中执行；可以用Variable类创建一个实例在图中增加变量；

Args参数说明:

initial_value：Tensor或可转换为Tensor的Python对象，它是Variable的初始值。除非validate_shape设置为False，否则初始值必须具有指定的形状。也可以是一个可调用的，没有参数，在调用时返回初始值。在这种情况下，必须指定dtype。 （请注意，init_ops.py中的初始化函数必须首先绑定到形状才能在此处使用。）

trainable：如果为True，则会默认将变量添加到图形集合GraphKeys.TRAINABLE_VARIABLES中。此集合用于优化器Optimizer类优化的的默认变量列表【可为optimizer指定其他的变量集合】，可就是要训练的变量列表。

collections：一个图graph集合列表的关键字。新变量将添加到这个集合中。默认为[GraphKeys.GLOBAL_VARIABLES]。也可自己指定其他的集合列表；

validate_shape：如果为False，则允许使用未知形状的值初始化变量。如果为True，则默认为initial_value的形状必须已知。

caching_device：可选设备字符串，描述应该缓存变量以供读取的位置。默认为Variable的设备。如果不是None，则在另一台设备上缓存。典型用法是在使用变量驻留的Ops的设备上进行缓存，以通过Switch和其他条件语句进行重复数据删除。

name：变量的可选名称。默认为“Variable”并自动获取。

variable_def：VariableDef协议缓冲区。如果不是None，则使用其内容重新创建Variable对象，引用图中必须已存在的变量节点。图表未更改。 variable_def和其他参数是互斥的。

dtype：如果设置，则initial_value将转换为给定类型。如果为None，则保留数据类型（如果initial_value是Tensor），或者convert_to_tensor将决定。

expected_shape：TensorShape。如果设置，则initial_value应具有此形状。

import_scope：可选字符串。要添加到变量的名称范围。仅在从协议缓冲区初始化时使用。

（2）使用tf.Variable定义变量常用的两种方式

常用的参数包括初始化值和名称name(是该变量的唯一索引)：

1、用固定的值初始化变量

w = tf.Variable(<initial-value>,name=<optional-name>)

2、用tf的初始化器初始化变量

w = tf.Variable(tf.truncated_normal([3,4],mean=0,stddev=.5),name='weight')

用tf的初始化器initializer op初始化变量必须指定变量shape,用name指定名称

注意：这里只是定义了变量的初始化方式，并没有进行变量初始化。要在sess中执行初始化操作。

import tensorflow as tf

state = tf.Variable(0, name='counter')
state2 = tf.Variable(tf.truncated_normal([3, 4], meam=0, stddev=.5), name='weight')
# print(state.name)
one = tf.constant(1)

new_value = tf.add(state,one)
update = tf.assign(state, new_value)  # 使state的值 = new_valeu

init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    for _ in range(3):
        sess.run(update)
        print(sess.run(state))

（3）执行变量初始化的三种方式

在使用变量之前必须要进行初始化，初始化的方式有三种：

1.在会话中run

tf.global_variable_initializer().run

2.从文件中恢复，restore from checkpoint

saver = tf.train.Saver()

with tf.Session() as sess:

    ckpt = tf.train.get_checkpoint_state(checkpoint_path)

    if ckpt and ckpt.model_checkpoint_path:

        saver.restore(sess,ckpt.model_checkpoint_path)

    else:

        print('No checkpoint file found')

变量初始化方式1、2也就是在模型训练和测试中常用的两种方式，在模型训练时，需要随机给模型赋初值，使用tf.global_variable_initializer().run()去初始化变量，在模型测试（或者进行fine-tune）时，使用初始化方式2从保存的ckpt中初始化变量。

3、也可自己通过tf.assign()给变量附初值，

实际上用initializer初始化方法给变量赋初值就是调用tf.assign()将变量的值赋给变量，可以自己调用tf.assign()给变量赋初值；

a = tf.Variable(1.0)
a = tf.assign(a,5.0)
b = tf.Variable(2.0)
b = tf.assign(b,6.0)
c = a+b
with tf.Session() as sess:
#相当于调用tf.assign()给变量赋初值
    sess.run([a,b])
    print(c.eval())

tf.get_Variable()
获取一个已经存在的变量或者创建一个新的变量

get_variable(
    name,
    shape=None,
    dtype=None,
    initializer=None,
    regularizer=None,
    trainable=True,
    collections=None,
    caching_device=None,
    partitioner=None,
    validate_shape=True,
    use_resource=None,
    custom_getter=None,
    constraint=None
)

Args参数说明:

name：新变量或现有变量的名称。

shape：新变量或现有变量的形状。

dtype：新变量或现有变量的类型（默认为DT_FLOAT）。

ininializer：如果创建了则用它来初始化变量。

regularizer：A（Tensor - > Tensor或None）函数;将它应用于新创建的变量的结果将添加到集合tf.GraphKeys.REGULARIZATION_LOSSES中，并可用于正则化。

trainable：如果为True，还将变量添加到图形集合GraphKeys.TRAINABLE_VARIABLES（参见tf.Variable）。

collections：要将变量添加到的图表集合列表。默认为[GraphKeys.GLOBAL_VARIABLES]（参见tf.Variable）。

caching_device：可选的设备字符串或函数，描述变量应被缓存以供读取的位置。默认为Variable的设备。如果不是None，则在另一台设备上缓存。典型用法是在使用变量驻留的Ops的设备上进行缓存，以通过Switch和其他条件语句进行重复数据删除。

partitioner：可选callable，接受完全定义的TensorShape和要创建的Variable的dtype，并返回每个轴的分区列表（当前只能对一个轴进行分区）。

validate_shape：如果为False，则允许使用未知形状的值初始化变量。如果为True，则默认为initial_value的形状必须已知。

use_resource：如果为False，则创建常规变量。如果为true，则使用定义良好的语义创建实验性ResourceVariable。默认为False（稍后将更改为True）。在Eager模式下，此参数始终强制为True。

custom_getter：Callable，它将第一个参数作为true getter，并允许覆盖内部get_variable方法。 custom_getter的签名应与此方法的签名相匹配，但最适合未来的版本将允许更改：def custom_getter（getter，* args，** kwargs）。也允许直接访问所有get_variable参数：def custom_getter（getter，name，* args，** kwargs）。一个简单的身份自定义getter只需创建具有修改名称的变量是：python def custom_getter（getter，name，* args，** kwargs）：return getter（name +'_suffix'，* args，** kwargs）

注意：如果initializer初始化方法是None(默认值),则会使用variable_scope()中定义的initializer,如果也为None,则默认使用glorot_uniform_initializer,也可以使用其他的tensor来初始化，value,和shape与此tensor相同

正则化方法默认是None,如果不指定，只会使用variable_scope()中的正则化方式，如果也为None，则不使用正则化；

附： tf.truncated_narmal()和tf.truncated_naomal__initializer()的区别

tf.truncated_narmal(shape=[],mean=0,stddev=0.5)使用时必须制定shape,返回值是在截断的正态分布随机生成的指定shape的tensor

tf.truncated_normal_initializer(mean=0.stddev=0.5)调用返回一个initializer 类的一个实例（就是一个初始化器），不可指定shape,

注意的点：

(1)

tf.Variable()与tf.get_variable()区别

1.使用tf.Variable时，如果检测到命名冲突，系统会自己处理。使用tf.get_variable()时，系统不会处理冲突，而会报错

import tensorflow as tf

state = tf.Variable(0, name='counter')
state2 = tf.Variable(2,name='counter')
print(state.name)
print(state2.name)

输出：
counter:0
counter_1:0



import tensorflow as tf

state = tf.get_variable(name='counter',initializer=1)
state2 = tf.get_variable(name='counter',initializer=2)
print(state.name)
print(state2.name)

输出：
ValueError: Variable counter already exists, disallowed. Did you mean to set reuse=True or reuse=tf.AUTO_REUSE in VarScope? Originally defined 

2.基于这两个函数的特性，当我们需要共享变量的时候，需要使用tf.get_variable()。在其他情况下，这两个的用法是一样的

import tensorflow as tf

with tf.variable_scope("scope1"):
    w1 = tf.get_variable("w1", shape=[])
    w2 = tf.Variable(0.0, name="w2")
with tf.variable_scope("scope1", reuse=True):
    w1_p = tf.get_variable("w1", shape=[])
    w2_p = tf.Variable(1.0, name="w2")

print(w1 is w1_p, w2 is w2_p)
#输出
#True  False

random Tensor

可用于赋值给tf.Variable()的第一个参数

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

tf.random_uniform(shape, minval=0, maxval=None, dtype=tf.float32, seed=None, name=None)

tf.random_shuffle(value, seed=None, name=None)

tf.random_crop(value, size, seed=None, name=None)

tf.multinomial(logits, num_samples, seed=None, name=None)

tf.random_gamma(shape, alpha, beta=None, dtype=tf.float32, seed=None, name=None)

tf.set_random_seed(seed)

constant value tensor

tf.zeros(shape, dtype=tf.float32, name=None)

tf.zeros_like(tensor, dtype=None, name=None)

tf.ones(shape, dtype=tf.float32, name=None)

tf.ones_like(tensor, dtype=None, name=None)

tf.fill(dims, value, name=None)

tf.constant(value, dtype=None, shape=None, name='Const')

initializer

·

tf.constant_initializer(value=0, dtype=tf.float32)
tf.random_normal_initializer(mean=0.0, stddev=1.0, seed=None, dtype=tf.float32)
tf.truncated_normal_initializer(mean=0.0, stddev=1.0, seed=None, dtype=tf.float32)
tf.random_uniform_initializer(minval=0, maxval=None, seed=None, dtype=tf.float32)
tf.uniform_unit_scaling_initializer(factor=1.0, seed=None, dtype=tf.float32)
tf.zeros_initializer(shape, dtype=tf.float32, partition_info=None)
tf.ones_initializer(dtype=tf.float32, partition_info=None)
tf.orthogonal_initializer(gain=1.0, dtype=tf.float32, seed=None)

tf.placeholder()

import tensorflow as tf

input1 = tf.placeholder(tf.float32)  # 可以指定shape
input2 = tf.placeholder(tf.float32)
output = tf.multiply(input1, input2)
with tf.Session() as sess:
    print(sess.run(output, feed_dict={input1:[7.],input2:[2.]}))

 

参考资料

https://blog.csdn.net/u012436149/article/details/53696970?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

Pytorch中Variable变量
1.它是一个可以变化的变量，符合反向传播和参数更新的属性，而tensor不能反向传播
pytorch中的tensor就像鸡蛋，Variable就像装鸡蛋的篮子
import torch
from torch.autograd import Variable # torch 中 Variable 模块
tensor = torch.FloatTensor([[1,2],[3,4]])
# 把鸡蛋放到篮子里, requires_grad是参不参与误差反向传播, 要不要计算梯度，Variable默认不需要被求导的
variable = Variable(tensor, requires_grad=True)
 
print(tensor)
"""
 1 2
 3 4
[torch.FloatTensor of size 2x2]
"""
 
print(variable)
"""
Variable containing:
 1 2
 3 4
[torch.FloatTensor of size 2x2]
"""

2.Variable计算时，会逐步生成计算图，这个图将所有的计算节点都连接起来，最后进行loss反向传播时，一次性将所有Variable里的梯度计算出来，然而tensor没有这个能力
loss.backward() # 模拟 v_out 的误差反向传递
 
print(variable.grad) # 初始 Variable 的梯度
'''
 0.5000 1.0000
 1.5000 2.0000
'''

3.我们在输出时常将Variable形式的数据进行转换，转换成tensor形式或者numpy形式，因为有时候直接输出Variable形式用不了
print(variable.data) # 将variable形式转为tensor 形式
"""
 1 2
 3 4
[torch.FloatTensor of size 2x2]
"""
print(variable.data.numpy())#numpy形式
"""
[[ 1. 2.]
 [ 3. 4.]]
"""