Pytorch学习（1）：张量、torch.autpgrad

Pytorch学习

张量学习

1、张量初始化的方法

1、由原始数据直接生成张量，张量的类型由原始数据的类型决定

data = [[1, 2], [3, 4]]
x_torch = torch.tensor(data)

2、通过numpy数组来生成张量

np_array = np.array(data)
x_torch = torch.from_numpy(np_array)
# 由张量转化为numpy数组
x_numpy = x_torch.numpy()

3、通过已有的张量来生成新的张量

# 保留 x_data 的属性
x_ones = torch.ones_like(x_data)
# 重写 x_data 的数据类型，int -> float
x_rand = torch.rand_like(x_data, dtype=torch.float)

4、通过指定数据维度来生成张量

shape = (2,3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

2、张量属性

1、从张量属性我们可以得到张量的维数、数据类型以及它们所存储的设备(CPU或GPU)

tensor = torch.rand(3,4)

print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

3、张量运算

1、判断当前环境GPU是否可用

# 判断当前环境GPU是否可用, 然后将tensor导入GPU内运行
if torch.cuda.is_available():
  tensor = tensor.to('cuda')

2、张量的索引和切片

tensor = torch.ones(4, 4)
tensor[:,1] = 0            # 将第1列(从0开始)的数据全部赋值为0

3、张量的拼接

# dim决定在哪个维度上进行拼接
tensor = torch.ones(4, 4)
tensor[:,1] = 0            # 将第1列(从0开始)的数据全部赋值为0
t1 = torch.cat([tensor, tensor, tensor], dim=1)

4、张量的乘积和矩阵乘法

# 逐个元素相乘结果
print(f"tensor.mul(tensor): \n {tensor.mul(tensor)} \n")
# 等价写法:
print(f"tensor * tensor: \n {tensor * tensor}")

5、张量与张量的矩阵乘法

# tensor.T表示转置
print(f"tensor.matmul(tensor.T): \n {tensor.matmul(tensor.T)} \n")
# 等价写法:
print(f"tensor @ tensor.T: \n {tensor @ tensor.T}")

6、自动赋值运算

# 使用add_()的时候原始tensor的值被修改，而使用add()时没有被修改
print(tensor, "\n")
tensor.add_(5)
print(tensor)

2、torch.autograd学习

背景

torch.autograd是 PyTorch 的自动差分引擎，可为神经网络训练提供支持。

神经网络（NN）是在某些输入数据上执行的嵌套函数的集合。 这些函数由参数（由权重和偏差组成）定义，这些参数在 PyTorch 中存储在张量中。

训练 NN 分为两个步骤：

正向传播：在正向传播中，NN 对正确的输出进行最佳猜测。 它通过其每个函数运行输入数据以进行猜测。

反向传播：在反向传播中，NN 根据其猜测中的误差调整其参数。 它通过从输出向后遍历，收集有关函数参数（梯度）的误差导数并使用梯度下降来优化参数来实现。

1、实例

import torch, torchvision

# 从torchvision中加载经过预训练的resnet18模型
model = torchvision.models.resnet18(pretrained=True)
# 创建一个随机数据张量来表示具有3通道的单个图像，高度&宽度为64
data = torch.rand(1, 3, 64, 64)
# 其对应的label初始化为一些随机值
labels = torch.rand(1, 1000)

# 通过模型的每一层运行输入数据以进行预测，这是正向传播
prediction = model(data) # forward pass

# 使用模型的预测和相应的标签来计算误差：loss
loss = (prediction - labels).sum()
# 通过网络反向传播此误差
loss.backward() # backward pass

# 加载一个优化器，在本例中为SGD，学习率为0.01，动量为0.9
optim = torch.optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)

# 调用.step()启动梯度下降。 优化器通过.grad中存储的梯度来调整每个参数
optim.step() #gradient descent

2、Autograd的微分

import torch

# requires_grad=True使得backward可以追踪这个参数并且计算它的梯度
a = torch.tensor([2., 3.], requires_grad=True)
b = torch.tensor([6., 4.], requires_grad=True)

# 定义一个目标函数
Q = 3*a**3 - b**2

# 当我们在Q上调用.backward()时，Autograd 将计算这些梯度并将其存储在各个张量的.grad属性中。
# 我们需要在Q.backward()中显式传递gradient参数，因为它是向量。gradient是与Q形状相同的张量，它表示Q相对于本身的梯度。
external_grad = torch.tensor([1., 1.])
Q.backward(gradient=external_grad)

# check if collected gradients are correct
print(9*a**2 == a.grad)
print(-2*b == b.grad)