PyTorch学习笔记1——数据操作

本学习笔记基于 Dive-into-DL-Pytorch

Tensor是pytorch中所应用的一种数据结构，torch.Tensor是存储和变换数据的主要工具。

1.1.1 创建Tensor

创建Tensor

import torch #导入Pytorch

x= torch.empty(5,3) #创建一个5*3的随机Tensor
print(x)

输出：
tensor([[1.0102e-38, 1.0561e-38, 1.0286e-38], [1.0653e-38, 1.0469e-38, 9.5510e-39], [9.9184e-39, 9.0000e-39, 1.0561e-38], [1.0653e-38, 4.1327e-39, 8.9082e-39], [9.8265e-39, 9.4592e-39, 1.0561e-38]])

除此之外，还可以创建全0的Tensor,或者根据数据直接创建

x = torch.tensor([5.5,3]) #直接根据数据创建Tensor
print(x)
print('\n')
y = torch.zeros(5,3) #创建5*3的全 0 Tensor矩阵
print(y) 

输出：

tensor([5.5000, 3.0000])


tensor([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])

另外，可以定义新的数据类型

x = x.new_ones(5, 3, dtype=torch.float64) 
print(x)

x = torch.randn_like(x, dtype=torch.float) # 制定新的数据类型
print(x)

输出：

tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]], dtype=torch.float64)
tensor([[ 0.2305,  0.8490,  0.1854],
        [-2.3753,  1.1425,  0.5664],
        [ 0.2865,  0.8166, -0.9365],
        [ 0.3915,  1.4464, -0.3610],
        [ 0.4563, -1.2072, -2.0004]])
     

我们还可以用shape或者size来获取Tensor的形状

print(x.size)
print(x.shape)

output:

<built-in method size of Tensor object at 0x0000027C8B2CE300>
torch.Size([5, 3])

其他创建Tensor的函数可以查找官方API

1.1.2 运算操作

算术操作：

'''加法操作'''

'''加法操作一'''
y = torch.rand(5,3)
print( x+ y)

'''加法操作二'''
print(torch.add(x, y))

'''还可以指定输出'''
result = torch.empty(5,3)
torch.add(x, y, out=result)
print(y)

'''加法操作三'''
y.add(x)
print(y)
 

以上输出结果都为

tensor([[ 1.0845,  0.6145, -0.1810],
        [-0.7382,  0.4743,  0.9503],
        [ 1.3987,  1.5480,  1.7038],
        [ 1.5131, -1.1012,  1.1869],
        [ 0.7644,  0.7438, -0.7890]])

改变形状
用view()来改变形状

y = x.view(15)
z = x.view(-1,5)
print(x.size(), y.size(), z.size())
print('\n')
print(x)
print('\n')
print(y)
print('\n')
print(z)

输出：

torch.Size([5, 3]) torch.Size([15]) torch.Size([3, 5])


tensor([[ 0.7818, -0.0712, -0.4319],
        [-1.2213,  0.3708,  0.1667],
        [ 0.4310,  1.0007,  1.2327],
        [ 0.7463, -1.6301,  0.4599],
        [ 0.3015,  0.1714, -0.9360]])


tensor([ 0.7818, -0.0712, -0.4319, -1.2213,  0.3708,  0.1667,  0.4310,  1.0007,
         1.2327,  0.7463, -1.6301,  0.4599,  0.3015,  0.1714, -0.9360])


tensor([[ 0.7818, -0.0712, -0.4319, -1.2213,  0.3708],
        [ 0.1667,  0.4310,  1.0007,  1.2327,  0.7463],
        [-1.6301,  0.4599,  0.3015,  0.1714, -0.9360]])

(注意，view只是改变了对这个变量的观察角度)，如果想要返回一个真正的副本，要使用reshape()来改变形状

1.2.1 Tensor和Numpy相互转换

利用numpy()和from_numpy()来完成操作

'''Tensor转Numpy'''

a = torch.ones(5)
b = a.numpy()
print(a,b)
a += 1
print(a,b)
b+=1
print(a, b)

output:

tensor([1., 1., 1., 1., 1.]) [1. 1. 1. 1. 1.]
tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]
tensor([3., 3., 3., 3., 3.]) [3. 3. 3. 3. 3.]

可以看出，Tensor和Numpy的数组共享一个内存，一个改变，另一个也会改变

'''Numpy数组转Tensor'''
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
print(a,b)

output:

[1. 1. 1. 1. 1.] tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

还可以直接用torch.tensor()来转换Numpy为Tensor,此方法的Tensor和原来数据不共享内存，也是最常用的方法

c = torch.tensor(a)
a+=1
print(a,c)

output:

[2. 2. 2. 2. 2.] tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

1.3.1 自动求梯度

对函数求梯度，我们可以用Pytoch提供的autograd包，根据输入和前向传播自动构建计算图

对于Tensor来说，如果将其属性.require_grad设置为True,它将可以追踪在其上的所有操作；完成计算后，可以调用backward()来完成所有梯度计算，Tensor的梯度属性将积累到.grad属性中

如果不想别追踪，可以调用.detach()把其从追踪记录里分离出来，还可以用with torch.no_grad()把不想追踪的操作代码块包裹起来

Function是另外一个重要的类， Tensor和Function结合就可以构建一个记录整个计算过程的有向无环图，每个Tensor都有一个grad_fn属性，即创建该Tensor的Function，意思就是，如果这个Tensor是通过某些运算得到的，则grad_fn返回一个与这些运算相关的对象，否则是None

举例来说明：

x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)

output:

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
None

对x做一个运算

y = x + 2
print(y)
print(y.grad_fn)

output:

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)
<AddBackward0 object at 0x0000027C8B8DC6A0>

可以看出y是通过一个加法创建的，所以它有一个grad_fn;而x是直接创建的，没有gard_fn属性，像x这种直接创建的Tensor我们称之为叶子节点，对应节点的grad_fn是None

我们可以利用.requires_grad_()来改变require_grad属性：

a = torch.randn(2, 2) # 默认情况下requires_grad = False
a = ((a*3)/(a+1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a*a).sum()
print(b.grad_fn)

output:

False
True
<SumBackward0 object at 0x0000027C8BAA85B0>

1.3.2 梯度

具体数学原理这里不再列出，可以直接看书来理解
此处只给出实际例子及问题来解释

需要解释的两点：
（一）在y.backward()时，如果y是标量，则不需要为backward传入任何参数；否则，需要传入一个与y同形的Tensor，其意义在于为了避免张量（向量）对张量求导，而转换为标量对张量求导；

举个例子，假设y由x计算得来，w和y是同形张量，则y.backward(w)的含义是：先计算 L = torch.sum(y * w) , 则l是个标量，然后求L对x的导数

（二）grad在反向传播过程中是累加的，这意味着每一次运行backward,梯度都会累加之前的梯度，所以一般在backward之前需要.grad.data.zero()把梯度清零

x = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)
y = 2 * x
z = y.view(2,2)
print(z)

'''y现在不是一个标量，所以在调用backward时需要传入一个和y同形的权重向量进行加权求和得到一个标量'''
v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float)
z.backward(v)
print(x.grad)

output:

tensor([[2., 4.],
        [6., 8.]], grad_fn=<ViewBackward>)
tensor([2.0000, 0.2000, 0.0200, 0.0020])

中断梯度传播的例子

x = torch.tensor(1.0, requires_grad=True)
y1 = x ** 2
with torch.no_grad():
    y2 = x**3
y3 = y2 + y1

print(x.requires_grad)
print(y1, y1.requires_grad)
print(y2, y2.requires_grad)
print(y3, y3.requires_grad)

output:

True
tensor(1., grad_fn=<PowBackward0>) True
tensor(1.) False
tensor(2., grad_fn=<AddBackward0>) True

注意，由于y2是被torch.no_grad():包裹的，所以与y2有关的梯度是不会回传的，故如果y3对x求导， 只有与y1相关的梯度会被回传，即x^2对x的梯度

此外，如果想修改Tensor的值，而又不希望被autograd记录（不影响反向传播），那么可以对tensor.data进行操作

x = torch.ones(1, requires_grad=True)

print(x.data)  # 依旧是一个Tensor
print(x.data.requires_grad) # 但是已经独立于计算图之外

y = 2 * x
x.data *= 100 #只改变了值，但是不会记录在计算图，不会影响梯度传播

y.backward()
print(x) # 更改data的值也会影响Tensor的值
print(x.grad) # 但是不记录在梯度内

output:

python
tensor([1.])
False
tensor([100.], requires_grad=True)
tensor([2.])

如果没有对tensor.data进行操作，而是直接对x进行操作：

x = torch.ones(1,requires_grad = True)

y = 2 * x
x = x * 100
print(x)
print(x.grad)

output:

tensor([100.], grad_fn=<MulBackward0>)

可见，计算图中也包括了x = x*100 的操作

1.4 总结

本次学习笔记主要熟悉Tensor数据类型的创建，基本运算，以及梯度还有自动求导的实现方式