深度学习：Pytorch最全面的入门教程
关于深度学习的入门理论知识可阅读博主的另一篇博客深度学习：卷积神经网络CNN.
关于Python基础与速成可阅读博主的另一篇博客Python基础与速成.
本文主要介绍了Python和Pytorch的相关入门基础知识，更多详细的关于python的基础教程可见Python 基础语法 | 菜鸟教程，重点了解python的基础语法、常用数据类型、条件和循环语句、函数、模块和面向对象的编程即可。更多关于Pytorch的详细知识可参考Pytorch官网文档.
python学习中的两大工具函数
dir()：打开查看工具箱及分支
dir(torch)
dir(torch.cuda)
help()：查看帮助
help(torch.cuda.is_available) # 注意在此要省去()
数据集与相关处理
- Dataset
主要用于编辑、获取数据集及其label。
from torch.utils.data import Dataset
# 详细文档可查看help
help(Dataset)
- TensorBoard
直观地观察输入与输出结果或不同阶段的结果，其中包括了数据、图片和计算图等多个类型，方便用于可视化分析。
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("../logs")
writer.add_image()
writer.add_graph()
writer.add_scalar()
writer.close()
# 在终端输入
tensorboard --logdir=logs
# 此时会输出一个网址，打开网址，即可查看显示结果
- torchvision
包含了在图像视觉领域，目前较为流行的数据集、模型结构和常用的图片转换工具。
torchvision.datasets包含了一些图像视觉领域流行的数据集，它是torch.utils.data.Dataset的子类，例如：
- List item
- MNIST
- COCO（用于图像标注和目标检测）(Captioning and Detection)
- LSUN Classification
- ImageFolder
- Imagenet-12
- CIFAR10 and CIFAR100
- STL10
torchvision.models包含了一些图像视觉领域典型的模型，例如：
- AlexNet
- VGG
- ResNet
- SqueezeNet
- DenseNet
torchvision.transforms包含了图片处理的一些操作，例如，数据类型的转换、裁剪、标准化等等。详细可看官方文档，重点了解输入、输出类型以及作用。
图片的三种主要的类型：tensor、numpy、PIL。
torchvision.utils包含了一些常用的工具。
- DataLoader
DataLoader可以基于某个可迭代的dataset，每次从dataset中基于某种采样原则取出一个batch的数据。
torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None,
batch_sampler=None, num_workers=0, collate_fn=None,pin_memory=False,
drop_last=False, timeout=0, worker_init_fn=None)
主要用于batch的相关操作。常见的参数：
dataset：数据集名称
batch_size：batch大小。
shuffle：每Epoch划分Batch时是否随机（每一个epoch是否为乱序），一般设为True。
num_workers：是否多进程读取数据（默认为０)；num_workers的经验设置值是自己电脑/服务器的CPU核心数，如果CPU很强、RAM也很充足，就可以设置得更大些，windows下设为非零可能会报错。
drop_last： 当样本数不能被batchsize整除时，最后一批数据是否舍弃（default: False)。
深度学习 | 三个概念：Epoch, Batch, Iteration
网络搭建
网络基类 torch.nn.Module
所有网络的基类，你的模型也应该继承这个类。
例如：
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__() # 调用基类的初始化函数
self.conv1 = nn.Conv2d(1, 20, 5) # submodule: Conv2d
self.relu1 = nn.Relu()
self.conv2 = nn.Conv2d(20, 20, 5)
self.relu2 = nn.Relu()
def forward(self, x):
x = self.conv1(x)
x = self.relu1(x)
x = self.conv2(x)
x = self.relu2(x)
return x
可以使用sequential容器，使得上述代码变得更加精简：
import torch.nn as nn
class Model(nn.Module):
def __init__(self):
super(Model, self).__init__() # 调用基类的初始化函数
self.model = nn.Sequential(
nn.Conv2d(1, 20, 5),
nn.ReLU(),
nn.Conv2d(20, 20, 5),
nn.ReLU())
def forward(self, x):
x = self.model(x)
return x
卷积层
卷积在数字图像处理中最常见的应用是锐化和边缘提取，而用于深度学习中可以方便地进行特征提取。这里以2d卷积函数torch.nn.functional.conv2d为例介绍其有关参数与使用。
torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)
参数：
input – 输入张量的形状 (minibatch x in_channels x iT x iH x iW)
weight – 过滤器的形状 (in_channels x out_channels x kH x kW)
bias – 可选偏置的形状 (out_channels)
stride – 卷积核的步长，可以是单个数字或一个元组 (sh x sw)。默认: 1
padding – 输入上隐含零填充。
nn.Conv2d卷积层相当于对2d卷积函数做了一次封装。
class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
参数：
in_channels(int) – 输入信号的通道
out_channels(int) – 卷积产生的通道
kerner_size(int or tuple) - 卷积核的尺寸
stride(int or tuple, optional) - 卷积步长
padding (int or tuple, optional)- 输入的每一条边补充0的层数
dilation(int or tuple, `optional``) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数，通常使用默认值1
bias(bool, optional) - 如果bias=True，添加偏置，默认值为True
卷积前后尺寸变化：
N为batch_size
C
i
n
C_{in}
Cin为in_channels，
C
o
u
t
C_{out}
Cout为out_channels；
H
i
n
H_{in}
Hin为输入图片的高，
H
o
u
t
H_{out}
Hout为输出图片的高；
W
i
n
W_{in}
Win为输入图片的宽，
W
o
u
t
W_{out}
Wout为输出图片的宽；
池化层
一般有最大池化和平均池化，下面以2d最大池化层为例介绍其使用：
class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
参数：
kernel_size(int or tuple) - max pooling的窗口大小
stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 池化核元素之间的间距
return_indices - 如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助（一般不使用）
ceil_mode - 当ceil_mode = true时，将保存不足为kernel_size大小的数据保存，自动补足NAN至kernel_size大小；当ceil_mode = False时，剩余数据不足kernel_size大小时，直接舍弃。
池化前后尺寸变化：
激活层
激活层相对简单，一般使用非线性函数ReLu
class torch.nn.ReLU(inplace=False)
参数： inplace-是否对计算结果进行覆盖，若为True，覆盖input，若为False，保留input的值，计算结果保留在output。
线性层及其其他层
线性层一般作为全链接层。
class torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
参数：
in_features - 每个输入样本的大小
out_features - 每个输出样本的大小
bias - 若设置为False，这层不会学习偏置。默认值：True
在此仅列举一些其他层的简单介绍，详细可参考官网教程
- 正则化层：包含了LayerNorm、BatchNorm等层，主要防止过拟合，提高模型泛化能力；
- dropout层：在训练期间，使用来自伯努利分布的样本以概率 p 将输入张量的一些元素随机归零，也是为了防止过拟合，提高模型泛化能力；值得注意的是，dropout层在训练状态和测试状态是不一样的。在训练时 dropout 层是有效的，但是数据尺度会缩放，为了保持数据尺度不变，所有的权重需要除以 1-p。而在测试时 dropout 层是关闭的。因此在测试时需要先调用model.eval()设置各个网络层的的training属性为 False，在训练时需要先调用model.train()设置各个网络层的的training属性为 True。
- 循环层：包含了RNN、LSTM等模型；
- Transformer层：包含了transformer模型、编码器和解码器等。
损失函数与反向传播
常用的交叉熵损失函数与反向传播：
# Example of target with class indices
loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.empty(3, dtype=torch.long).random_(5)
output = loss(input, target)
output.backward()
# Example of target with class probabilities
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5).softmax(dim=1)
output = loss(input, target)
output.backward()
优化器
SGD：随机梯度下降算法
Adam：自适应学习率梯度下降算法
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
optimizer = optim.Adam([var1, var2], lr=0.0001)
迭代一次epoch
for input, target in dataset:
optimizer.zero_grad() # 梯度清零
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
现有网络模型的使用与修改
基于预训练好的ResNet模型，在其最后添加一个线性层，并打印其网络结构
import torchvision
from torch import nn
Resnet_model = torchvision.models.resnet50(pretrained=True)
Resnet_model.add_module('linear',nn.Linear(1000,10))
print(Resnet_model)
网络模型的保存与提取
网络模型的保存
import torch
import torchvision
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1，保存模型结构+模型参数
torch.save(vgg16, "vgg16_method1.pth")
# 保存方式2，保存模型参数
torch.save(vgg16.state_dict(), "vgg16_method2.pth")
网络模型的提取
import torch
import torchvision
# 提取方式1，对应保存方式1
model = torch.load("vgg16_method1.pth")
# 提取方式2，对应保存方式2
vgg16 = torchvision.models.vgg16(pretrained=False)
vgg16.load_state_dict(torch.load("vgg16_methed2.pth"))
模型训练
train_cpu.py文件：使用CPU进行训练
import torchvision
from torch.utils.tensorboard import SummaryWriter
# 准备数据集
from torch import nn
from torch.utils.data import DataLoader
train_data = torchvision.datasets.CIFAR10(root="../data", train=True, transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(root="../data", train=False, transform=torchvision.transforms.ToTensor(),
download=True)
# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10, 训练数据集的长度为：10
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 利用 DataLoader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
# 创建网络模型
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
tudui = Tudui()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
# 优化器
# learning_rate = 0.01
# 1e-2=1 x (10)^(-2) = 1 /100 = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("../logs_train")
for i in range(epoch):
print("-------第 {} 轮训练开始-------".format(i+1))
# 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}, Loss: {}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤开始
tudui.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print("整体测试集上的Loss: {}".format(total_test_loss))
print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step = total_test_step + 1
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存")
writer.close()
使用GPU进行训练：与CPU代码不同的地方主要是在模型、数据（输入img和标注target）和损失函数处做一些修改。
train_gpu1.py文件：使用GPU进行训练的方式1
import torch
import torchvision
from torch.utils.tensorboard import SummaryWriter
# from model import *
# 准备数据集
from torch import nn
from torch.utils.data import DataLoader
train_data = torchvision.datasets.CIFAR10(root="../data", train=True, transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(root="../data", train=False, transform=torchvision.transforms.ToTensor(),
download=True)
# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10, 训练数据集的长度为：10
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 利用 DataLoader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
# 创建网络模型
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
tudui = Tudui()
if torch.cuda.is_available():
tudui = tudui.cuda()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
loss_fn = loss_fn.cuda()
# 优化器
# learning_rate = 0.01
# 1e-2=1 x (10)^(-2) = 1 /100 = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("../logs_train")
for i in range(epoch):
print("-------第 {} 轮训练开始-------".format(i+1))
# 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}, Loss: {}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤开始
tudui.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print("整体测试集上的Loss: {}".format(total_test_loss))
print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step = total_test_step + 1
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存")
writer.close()
train_gpu2.py文件：使用GPU进行训练的方式2
import torch
import torchvision
from torch.utils.tensorboard import SummaryWriter
# from model import *
# 准备数据集
from torch import nn
from torch.utils.data import DataLoader
# 定义训练的设备（CPU、GPU、指定GPU）
# device = torch.device("cpu")
# device = torch.device("cuda:0")
# device = torch.device("cuda:1")
device = torch.device("cuda")
train_data = torchvision.datasets.CIFAR10(root="../data", train=True, transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(root="../data", train=False, transform=torchvision.transforms.ToTensor(),
download=True)
# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
# 如果train_data_size=10, 训练数据集的长度为：10
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 利用 DataLoader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
# 创建网络模型
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
tudui = Tudui()
tudui = tudui.to(device) # 省去赋值也可以 tudui.to(device)
# 损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device) # 省去赋值也可以 loss_fn.to(device)
# 优化器
# learning_rate = 0.01
# 1e-2=1 x (10)^(-2) = 1 /100 = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("../logs_train")
for i in range(epoch):
print("-------第 {} 轮训练开始-------".format(i+1))
# 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
imgs = imgs.to(device) # 不可省去赋值
targets = targets.to(device) # 不可省去赋值
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step = total_train_step + 1
if total_train_step % 100 == 0:
print("训练次数：{}, Loss: {}".format(total_train_step, loss.item()))
writer.add_scalar("train_loss", loss.item(), total_train_step)
# 测试步骤开始
tudui.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_dataloader:
imgs, targets = data
imgs = imgs.to(device)
targets = targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()
total_accuracy = total_accuracy + accuracy
print("整体测试集上的Loss: {}".format(total_test_loss))
print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
writer.add_scalar("test_loss", total_test_loss, total_test_step)
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step = total_test_step + 1
torch.save(tudui, "tudui_{}.pth".format(i))
print("模型已保存")
writer.close()
模型测试
test.py文件：对模型进行测试
import torch
import torchvision
from PIL import Image
from torch import nn
image_path = "../imgs/airplane.png"
image = Image.open(image_path)
print(image)
image = image.convert('RGB')
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),
torchvision.transforms.ToTensor()])
image = transform(image)
print(image.shape)
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, 2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, 2),
nn.MaxPool2d(2),
nn.Flatten(),
nn.Linear(64*4*4, 64),
nn.Linear(64, 10)
)
def forward(self, x):
x = self.model(x)
return x
model = torch.load("tudui_29_gpu.pth", map_location=torch.device('cpu'))
print(model)
image = torch.reshape(image, (1, 3, 32, 32))
model.eval()
with torch.no_grad():
output = model(image)
print(output)
print(output.argmax(1))
计算平台
如果自己的电脑GPU较差，且没有服务器可用，可以使用网上的一些计算平台资源：
- Google Colab：前提是可以访问Google
- Openbayes
- AutoDL
340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
