IT小白

这个屌丝很懒，什么也没留下！

热门标签

Pytorch学习笔记

作者：IT小白 | 2024-04-03 16:20:52

踩

pytorch学习笔记

1、Pytorch基本语法

1.1、什么是Pytorch

Pytorch是一个基于Numpy的科学计算包
- 作为Numpy的替代者，向用户提供使用GPU强大功能的能力
- 作为一款深度学习的平台，向用户提供最大的灵活性和速度

pytorch安装

pip install torch torchvision torchaudio
1

1.2、Pytorch基本元素操作

1.2.1、Tensors张量

张量的概念类似于Numpy中的ndarray数据结构，最大区别在于Tensor可以利用GPU的加速功能

1.2.1、导入torch

inport torch

1.2.2、创建矩阵

无初始化数据

x = torch.empty(5, 3)
# 结果
tensor([[-4.6138e+20,  5.8574e-43,  0.0000e+00],
        [ 0.0000e+00, -4.6138e+20,  5.8574e-43],
        [-4.6138e+20,  5.8574e-43, -4.6138e+20],
        [ 5.8574e-43, -4.6138e+20,  5.8574e-43],
        [-4.6138e+20,  5.8574e-43, -4.6138e+20]])
1
2
3
4
5
6
7

有初始化数据

x1 = torch.rand(5, 3)
# 结果
tensor([[0.7834, 0.1161, 0.6895],
        [0.6038, 0.3004, 0.2812],
        [0.1132, 0.9600, 0.8586],
        [0.6652, 0.4563, 0.5422],
        [0.7631, 0.2071, 0.1515]])
1
2
3
4
5
6
7

对比有无初始化矩阵：
- 当声明无初始化的矩阵时，它本身不包含任何确切的值，当创建一个未初始化的矩阵时，分配给矩阵的内存中有什么数值就赋值什么，本质上是毫无意义的数据

全零矩阵/全一矩阵

# 全零 类型long
x2 = torch.zeros(5, 3, dtype=torch.long)
# 全1 
x = torch.ones(5, 3, dtype=torch.double)
1
2
3
4

通过数据创建
```
x = torch.tensor([2.5, 3.5])
1
```

通过已有张量创建

# 数据随机，形状与x相同
y = torch.randn_like(x, dtype=torch.float32)
# 查看形状
y.size()
1
2
3
4

1.2.3、基本运算

加法操作

x+y
torch.add(x,y)
torch.add(x,y,out=result)
y.add_(x)

1
2
3
4
5

切片
```
print(x[:, 1])
1
```

改变张量形状

# 元素总量不可改变，-1自动匹配数量
x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)
print(x.size(), y.size(), z.size())
1
2
3
4
5

item取出

# tensor 只有一个元素时，item()取出元素
x = torch.randn(1)
print(x)
print(x.item())
1
2
3
4

Tensor与ndarray转换

# tensor.numpy(): tensor转换成ndarray
a = torch.ones(5)
print(a.numpy())

# from_numpy(): ndarray转换成tensor
a = np.ones(5)
b = torch.from_numpy(a)
print(b)
1
2
3
4
5
6
7
8

所有在CPU上的Tensors，除了CharTensor，都可以转换成numpy array

Cuda Tensor

Tensors可以用.to()方法移动到任意设备上

device = torch.device("cuda")
x.to(device)
x.to("cpu")
1
2
3

1.3、Pytorch中的autograd

1.3.1、autograd介绍

在整个Pytorch框架中，所有的神经网络本质上都是一个autopackage（自动求导工具包）
- autograd package提供了一个对Tensors上所有的操作进行自动微分的功能

1.3.2、关于torch.Tensor类

torch.Tensor是整个package中的核心类，如果将属性.requires_grad设置为True，它将追踪在这个类上定义的所有操作，当代码要进行反向传播时，直接调用.backward()就可以自动计算所有的梯度，在这个Tensor上的所有梯度将被累加进属性.grad()中
如果想终止一个Tensor在计算图中的追踪回溯
- 执行.detach()就可以将该Tensor从计算图中撤下
- with torch.no_grad()代码块

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

y = x + 2
print(y)

print(x.grad_fn)
print(y.grad_fn)
1
2
3
4
5
6
7
8

1.3.3、关于torch.Function类

Function类是和Tensor同等重要的核心类，它和Tensor共同构建了一个完整的类，每个Tensor拥有一个.grad_fn属性，代表引用了哪个具体的Function创建了该Tensor
如果某个张量Tensor是用户自定义的，则其对应的grad_fn is None

1.3.4、关于梯度Gradients

在Pytorch中，反向传播是依靠.backward()实现的

x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
out = z.mean()
print(out)

out.backward()
print(x.grad)
1
2
3
4
5
6
7
8

2、Pytorch初步应用

2.1、使用Pytorch构建一个神经网络

2.1.1、torch.nn

关于torch.nn
- 使用Pytorch来构建神经网络，主要的工具都在torch包中
- nn依赖autograd来定义模型，并对其自动求导

2.1.2、构建神经网络的典型流程

定义一个拥有可学习参数的神经网络
遍历训练数据集
处理输入数据使其流经神经网络
计算损失值
将网络参数的梯度进行反向传播
以一定的规则更新网络的权重

2.1.3、定义Pytorch实现的神经网络

# 导入包
import torch
import torch.nn as nn
import torch.nn.functional as F


# 定义神经网络类
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 定义卷积层1 ,输入维度1，输出维度6，卷积核大小 3*3
        self.conv1 = nn.Conv2d(1, 6, 3)
        # 卷积层2，输入维度6，输出维度16，卷积核大小 3*3
        self.conv2 = nn.Conv2d(6, 16, 3)
        # 全连接层
        self.fc1 = nn.Linear(16 * 6 * 6, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # 卷积、激活、池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2 * 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), (2 * 2))
        # 调整张量形状
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]
        num_features = 1
        for s in size:
            num_features *= s
        return num_features


net = Net()
print(net)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

net.parameters()获取网络参数

params = list(net.parameters())
print(len(params))
print(params[0].size())
1
2
3

注意torch.nn构建的神经网络只支持mini-batches的输入，不支持单一样本输入
- nn.Conv2d需要一个4DTensor，如果单一样本输入，需要通过input.unsqueeze(0),扩张成4D

假设图像尺寸32*32

input1 = torch.randn(1, 1, 32, 32)
out = net(input1)
print(out)
print(out.size())
1
2
3
4

2.1.4、损失函数

损失函数的输入是一个输入的pair(output，target)，然后计算出一个数值来评估output和target之间的差距大小
在torch.nn中有若干不同的损失函数可供使用，比如nn.MSELoss就是通过计算均方误差来评估输入和目标值之间的差距

应用nn.MSELoss计算损失

target = torch.randn(1, 10)
criterion = nn.MSELoss()
loss = criterion(out, target)
print(loss)
1
2
3
4

print(loss.grad_fn)
print(loss.grad_fn.next_functions[0][0])
print(loss.grad_fn.next_functions[0][0].next_functions[0][0])
1
2
3

2.1.5、反向传播

在Pytorch中执行反向传播非常简便，全部的操作就是loss.backward()

在执行反向传播之前，要将梯度清零，否则梯度会在不同的批次数据之间被累加

# 梯度清零
net.zero_grad()
print(net.conv1.bias.grad)
# 反向传播，自动求导
loss.backward()
print(net.conv1.bias.grad)
1
2
3
4
5
6

2.1.6、更新网络参数

最简单的算法SGD（随机梯度下降）
- SGD公式 weight = weight - learning_rate * gradient

Pytorch优化器

import torch.optim as optim

# 构建优化器
optimizer = optim.SGD(net.parameters(), lr=0.01)
# 优化器梯度清零
optimizer.zero_grad()
# 执行网络计算
input1 = torch.randn(1, 1, 32, 32)
output = net(input1)
# 计算损失
target = torch.randn(1, 10)
criterion = nn.MSELoss()
loss = criterion(output, target)
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2、使用Pytorch构建一个分类器

2.2.1、分类器任务和数据介绍

构造一个将不同图像进行分类的神经网络分类器，对输入的图片进行判别并完成分类
数据集采用CIFAR10

2.2.2、训练分类器步骤

使用torchvision下载CIFAR10数据集

import torch
import torchvision
import torchvision.transforms as tf
import torch.nn as nn
import torch.nn.functional as F


def down_datasets():
    transform = tf.Compose([tf.ToTensor(), tf.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=4, shuffle=True, num_workers=2)

    test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
    test_loader = torch.utils.data.DataLoader(test_set, batch_size=4, shuffle=False, num_workers=2)

    classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

定义卷积神经网络

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 定义两个卷积层
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 定义池化层
        self.pool = nn.MaxPool2d(2, 2)
        # 定义全连接层
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        # 变换x的形状
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

定义损失函数

采用交叉熵损失函数和随机梯度下降优化器

net = Net()
    # 定义损失函数，选用交叉熵损失函数
    criterion = nn.CrossEntropyLoss()
    # 定义优化器
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
1
2
3
4
5

在训练集上训练模型

训练

def train(net, train_loader, criterion, optimizer):
    """
    训练模型
    :return:
    """
    print("开始训练")
    for epoch in range(2):
        running_loss = 0.0
        # 按批次迭代训练模型
        for i, data in enumerate(train_loader, 0):
            # 从data中取出含有输入图像的张量inputs，标签张量labels
            inputs, labels = data
            # 梯度清零
            optimizer.zero_grad()
            # 输入网络，得到输出张量
            outputs = net(inputs)
            labels = F.one_hot(labels, num_classes=10).float()
            # 计算损失值
            loss = criterion(outputs, labels)

            # 反向传播，梯度更新
            loss.backward()
            optimizer.step()

            # 打印训练信息
            # print(loss.item())
            running_loss += loss.item()
            if (i + 1) % 200 == 0:
                print('[%d, %5d] loss %.3f' % (epoch + 1, i + 1, running_loss / 200))
                running_loss = 0.0
    print("训练结束")


def save_model(net):
    """
    保存模型
    :param net:
    :return:
    """
    PATH = './cifar_net.pth'
    torch.save(net.state_dict(), PATH)


def run():
    net = Net()
    # 定义损失函数，选用交叉熵损失函数
    criterion = nn.CrossEntropyLoss()
    # 定义优化器
    optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
    # 开始训练
    train(net, train_loader, criterion, optimizer)
    # 保存模型
    save_model(net)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

保存模型

torch.save(net.state_dict(),"./cifar_net.pth")
1

在测试集上测试模型

def test_model():
    """
    测试模型
    :return:
    """
    dataiter = iter(test_loader)
    images, labels = dataiter.next()
    print(''.join('%5s ' % classes[labels[j]] for j in range(4)))

    # 实例化模型对象
    net = Net()
    # 加载模型状态字典
    net.load_state_dict(torch.load("./cifar_net.pth"))
    # 预测
    outputs = net(images)
    # 选取概率最大的类别
    _, predicted = torch.max(outputs, 1)
    # 打印预测标签
    print(''.join('%5s ' % classes[predicted[j]] for j in range(4)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在全部测试集上的准确率

def batch_test_model():
    """
    在整个测试集上测试模型准确率
    :return:
    """
    correct = 0
    total = 0
    # 实例化模型对象
    net = Net()
    # 加载模型状态字典
    net.load_state_dict(torch.load("./cifar_net.pth"))

    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 预测
            outputs = net(images)
            # 选取概率最大的类别
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print("准确率：%d %%" % (100 * correct / total))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在10个类别哪些表现更好

def batch_class_test_model():
    """
    在整个测试集上测试模型每个类别的准确率
    :return:
    """
    # 实例化模型对象
    net = Net()
    # 加载模型状态字典
    net.load_state_dict(torch.load("./cifar_net.pth"))

    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))

    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 预测
            outputs = net(images)
            # 选取概率最大的类别
            _, predicted = torch.max(outputs.data, 1)
            c = (predicted == labels).squeeze()
            for i in range(4):
                label = labels[i]
                class_correct[label] += c[i].item()
                class_total[label] += 1
    for i in range(10):
        print("%5s准确率：%d %%" % (classes[i], 100 * class_correct[i] / class_total[i]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2.2.3、GPU上训练

device = torch.device("cuda:0" if torch.cuda.is_availabe() else "cpu")

# 模型转移到GPU
net.to(device)
# 数据转移
inputs, labels = data[0].to(device), data[1].to(device)
1
2
3
4
5
6

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】