pytorch深度学习（一）

深度学习基本步骤

深度学习的基本步骤通常分为：

1. 数据预处理（或者有处理好的数据集可以直接拿来用），将数据处理成需要的格式（有的数据需要进行标注）
2. 模型构造 可以使用torch.nn中的块或者层构造网络，也可以通过继承nn.Module构造想要的块来使用
3. 模型训练 设置好超参数和优化算法开始模型训练
4. 模型预测及效果验证 通过验证数据集验证模型的准确度

数据预处理

图像数据处理

1. 生成dataset
2. 生成dataloader

import torchvision
from torchvision import transforms
trans = transforms.ToTensor()  # 通过ToTensor将PIL处理过的图像数据转换成像素值在0-1之间的浮点数
                               # 前往注意别漏了ToTensor后面的()，漏掉后不容易查找报错的地方
train_set = torchvision.datasets.FashionMNIST(root="../data", train=True, transform=trans, download=True)
test_set = torchvision.datasets.FashionMNIST(root="../data", train=False, transform=trans, download=True)
'''
通过torchvision内置的datasets获取FashionMNIST数据集，datasets中还有其他常见图像数据集
root 数据集放置路径
train 是否是训练数据集
transforms 图像变换
download 若没有数据集是否下载
'''
# 设置dataloader，用于训练时批量读取数据
BATCH_SIZE = 10
train_loader = data.DataLoader(dataset=train_set, batch_size=BATCH_SIZE, shuffle=True)
test_loader = data.DataLoader(dataset=test_set, batch_size=BATCH_SIZE)
# batch_size 批量大小
# shuffle 是否乱序

模型构造

构造需要的网络模型，这里的模型是残差神经网络

class Residual(nn.Module):  # @save    残差块类
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)


b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))


def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(Residual(input_channels, num_channels,
                                use_1x1conv=True, strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

net = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1, 1)),
                    nn.Flatten(), nn.Linear(512, 10))

DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # 让torch判断是否使用GPU
model = net.to(DEVICE)
# 使用.to方法将残差网络模型移动到设备上（如果torch.cuda.is_available()返回true则会移动到GPU上，否则使用CPU）

模型训练

预测结果及效果验证

深度学习基础概念

MLP（多层感知机）

MLP是将相邻层的神经元全连接而形成的架构

pytorch模型构造

Module

# 使用Module类构造想要的网络层或者块
# 以MLP为例
import torch
from torch import nn
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.hidden = nn.Linear(224, 256)     # nn.Linear自带初始连接权重，无须初始化，只需要设定网络所含神经元数目
        self.out = nn.Linear(256, 10)     # 这里输入数据个数为224，中间隐藏层神经元有256个，输出数据10个
    def forward(self, x):
        return self.out(self.hidden(x))
net = MLP()     # 神经网络实质是一个函数
x = torch.rand(1, 224)
print(net(x))   # 当把初始数据放入网络后，会返回网络计算的结果

管理神经网络的参数

new_net = nn.Sequential(MLP(), nn.Linear(10, 5))
print(new_net(x))
print(new_net[1].state_dict())
# 下面是输出的nn.Linear(10, 5)的参数字典，分为weight和bias，也可以分别查看
'''
OrderedDict([('weight', tensor([[ 0.2950,  0.0497, -0.2664,  0.1174,  0.1241, -0.1012, -0.1466, -0.0249,
         -0.2094,  0.2842],
        [ 0.0406, -0.2793,  0.1879,  0.2448, -0.2328, -0.0453,  0.2498, -0.1665,
          0.0823,  0.0587],
        [-0.2771, -0.3100,  0.1716, -0.0585,  0.1225,  0.2302,  0.0986,  0.1805,
         -0.2287, -0.2573],
        [-0.0166, -0.1432,  0.1078,  0.1682,  0.2516, -0.0623, -0.0927,  0.2254,
          0.3110,  0.0184],
        [-0.0128,  0.1603,  0.2926, -0.1018,  0.1107, -0.0582, -0.2600,  0.1541,
          0.1816, -0.0349]])), ('bias', tensor([0.1897, 0.0811, 0.2096, 0.0112, 0.1741]))])
'''