python中list函数中variables变量_如何在Python中使用变量,浅谈,Pytorch,的,Variable,方法...

Variable的基本概念

autograd.Variable 是包的核心类。它包装了张量，并且支持几乎所有的操作。一旦你完成了你的计算， 就可以调用

.backward() 方法

来

自动计算所有的梯度

。你还可以通过

.data 属性

来

访问原始的张量

，而关于

该 variable(变量)的梯度

会被累计到

.grad

上去。

通俗来讲：

Variable实质上也就是可以变化的变量，在Pytorch中的Variable就是一个存放会变化值的地理位置，里面的值会不停发生变化，就像一个装鸡蛋的篮子，里边的鸡蛋数会不断发生变化，而Pytorch中的Tensor就好比是里面的鸡蛋。

也就是说，

Pytorch都是由Tensor(Tensor 是一个多维矩阵)计算的，而Tensor里面的参数都是Variable的形式。

如果用Variable计算的话，那返回的也是一个同类型的Variable。这正好就符合了反向传播，参数更新的属性。

备注：Tensor不能反向传播，Variable可以反向传播。

Variable的自动求导

Variable还有一个针对自动求导实现来说非常重要的类 - Function。

Variable 和 Function 是相互联系的， 并且它们构建了一个非循环的图，编码了一个完整的计算历史信息。 每一个 variable(变量)都有一个

.grad_fn 属性

, 它引用了一个已经创建了 Variable 的 Function。

调用

.backward()

方法——实现Variable 的自动求导

计算变量variable的导数，可以在 Variable 上调用

.backward() 方法

。

如果变量variable是

标量的形式

(例如, 它包含一个元素数据)， 则再调用

.backward() 方法

时，不必指定任何参数；

但是，

如果变量variable是

非标量的形式

例如, 它包含更多的元素数据)，则再调用

.backward() 方法

时，必须去指定一个

grad_output 参数

，该参数是一个匹配

shape(形状)

的张量。

PyTorch中Variable的使用方法

Variable一般的初始化方法，默认是不求梯度的。

import torch

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

x_tensor = torch.randn(2,3) # 创建2*3的张量矩阵

#将tensor转换成Variable

x = Variable(x_tensor)

print(x.requires_grad)

>>>

False

x = Variable(x_tensor,requires_grad=True) #Varibale 默认时不要求梯度的，如果要求梯度，需要说明

print(x)

>>>

tensor([[0.1163, 0.7213, 0.5636],

[1.1431, 0.8590, 0.7056]], requires_grad=True)

典型范例：

import torch

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

tensor = torch.FloatTensor([[1,2], [3,4]]) # 创建2*2的张量矩阵

print(tensor)

>>>

tensor([[1., 2.],

[3., 4.]])

variable = Variable(tensor, requires_grad=True) # 张量转为变量——自变量x

print(variable)

>>>

tensor([[1., 2.],

[3., 4.]], requires_grad=True)

# 定义变量y关于自变量x的函数关系

## Tensor情形

t_out = torch.mean(tensor*tensor) # 求解x^2项的均值，函数表达式：y = 1/n*sum(x1^2+...+xn^2)

print(t_out)

>>>

tensor(7.5000)

## Variable情形

v_out = torch.mean(variable*variable)

print(v_out)

>>>

tensor(7.5000, grad_fn=)

# 求解梯度

# 模拟 v_out 的误差反向传递

v_out.backward() # t_out.backward()报错，由于Tensor不能反向传播，Variable可以反向传播

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

>>>

tensor([[0.5000, 1.0000],

[1.5000, 2.0000]])

#### 梯度的计算原理：

# v_out = 1/4 * sum(variable*variable) 这是计算图中的 v_out 计算步骤

# 针对于 v_out 的梯度就是, d(v_out)/d(variable) = 1/4*2*variable = variable/2

备注：

利用Variable计算时, 它在幕后一步步默默地搭建着一个庞大的系统，叫做

计算图(computational graph)

。

计算图的作用

：是将所有的计算步骤 (节点) 都连接起来，最后进行误差反向传递的时候，一次性将所有 Variable 里面的修改幅度 (梯度) 都计算出来, 而 Tensor 就没有这个能力。

获取Variable里面的数据

直接

print(variable)

只会输出

Variable

形式的数据，在很多时候是用不了的(比如想要用 plt 画图), 所以我们要转换一下，将它转变成

Tensor

形式。

Variable转变为其他形式的方法：

variable

.data

——将Variable 形式转变为Tensor 形式

variable

.data.numpy()

——将Variable 形式转变为Numpy 形式

备注：variable为存放Variable 形式的变量名

典型范例：

import torch

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

tensor = torch.FloatTensor([[1,2], [3,4]]) # 创建2*2的张量矩阵

variable = Variable(tensor, requires_grad=True) # 张量转为变量——自变量x

print(variable) # Variable 形式

>>>

tensor([[1., 2.],

[3., 4.]], requires_grad=True)

print(variable.data) # tensor 形式

>>>

tensor([[1., 2.],

[3., 4.]])

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

>>>

[[1. 2.]

[3. 4.]]

完整教学实例

(1) 变量variable是

标量的形式

(例如, 它包含一个元素数据)，调用

.backward() 方法

求梯度。

import torch

from torch.autograd import Variable

# 创建 variable(变量)

x = Variable(torch.ones(2,2), requires_grad=True)

print(x)

>>>

tensor([[1., 1.],

[1., 1.]], requires_grad=True)

# variable(变量)的操作

y = x+2

print(y)

>>>

tensor([[3., 3.],

[3., 3.]], grad_fn=)

print(y.grad_fn) # y 由操作创建,所以它有 grad_fn 属性

>>>

# y 的更多操作

z = y * y * 4

out = z.mean()

print("z:{}\nout:{}\n".format(z, out))

>>>

z:tensor([[36., 36.],

[36., 36.]], grad_fn=)

out:36.0

# 求梯度

out.backward()

print(x.grad) # d(out)/dx 的梯度

>>>

tensor([[10.5000, 10.5000],

[10.5000, 10.5000]])

(2) 变量variable是

非标量的形式

(例如, 它包含更多的元素数据)，调用

.backward() 方法

求梯度，必须去指定一个

grad_output 参数

，该参数是一个匹配

shape(形状)

的张量。

import torch

from torch.autograd import Variable

# 创建 variable(变量)

x = Variable(torch.rand(3), requires_grad=True)

print(x)

>>>

tensor([0.4635, 0.4550, 0.5725], requires_grad=True)

# variable(变量)的操作

y = x*2

print(y)

>>>

tensor([0.9271, 0.9100, 1.1449], grad_fn=)

while y.data.norm() < 1000:

y = y*2

print(y)

>>>

tensor([ 949.3414, 931.8120, 1172.4226], grad_fn=)

# 求梯度

gradients = torch.FloatTensor([0.1, 1.0, 0.0001]) # 设置参数gradient

y.backward( gradient=gradients )

print(x.grad)

>>>

tensor([2.0480e+02, 2.0480e+03, 2.0480e-01])