目录
前向传播：简单来说就是input 经过一个forward，然后有一个output
学了神经网络的基本搭建已经有一段时间了，一直在想写一篇关于这方面的文章，恰好最近举办了一场AI的宣讲会，我又把那些少的可怜的知识捋了一遍，在此分享给大家。
Dataset：能够提供一种方式去获取数据及其label，并且可以把获取的数据进行编号
Dataloader:把数据打包
TensorBoard：
在这里我就绘制一个y=x的函数
from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('logs')
for i in range(100):
writer.add_scalar('y=x', i, i) # 注意这里的add_scalar后面没有s
# add_scalar中的tag表示标题，scalar_value表示y轴，global_step表示x轴
writer.close()
然后在Terminal中输入tensorboard --logdir=logs,这里默认打开的是6006的端口，一般我们会自己指定端口
tensorboard --logdir=logs --port=6007
torchvision的一般用法：
归一化的介绍：
Normalize中的参数设置：mean表示均值， std表示标准差
# Compose
trans_resize_2 = transforms.Resize(512)
trans_compose = transforms.Compose([trans_resize_2, trans_totensor])
# 执行顺序：先执行一个resize的变换，再进行totensor的变换
# 后面这个参数的 输入 跟前面那个参数的 输出 要进行匹配的dataloader的用法
import torchvision
from torch.utils.data import DataLoader
# 准备的测试数据集
test_data = torchvision.datasets.CIFAR10('./dataset02', train=False, transform=torchvision.transforms.ToTensor())
# batch_size 每次取出多少的图片
test_loader = DataLoader(dataset=test_data, batch_size=4, shuffle=True, num_workers=0, drop_last=False)
# 测试数据集中第一张图片以及target
img, target = test_data[0]
print(img.shape)
print(target)
print('-------------------------')
for data in test_loader:
imgs, targets = data
print(imgs.shape)
print(targets)
前向传播：简单来说就是input 经过一个forward，然后有一个output
from torch import nn
import torch
class ZWY(nn.Module): # 每一次都要重写这两个方法
def __init__(self):
super(ZWY, self).__init__() # 调用父类中的方法，也可以写成 super().__init__
def forward(self, input):
output = input + 1
return output
zwy = ZWY()
x = torch.tensor(1.0)
output = zwy(x) # 这就是一个简单的前向传播
print(output)
卷积操作
当stride=1时，卷积核一个单位一个单位地移动
输入图像（5x5）和卷积核（3x3）对应位置的数字相乘然后相加之和等于输出
这里以二维卷积举例
这里，torch.nn相当于torch.nn.functional的一个封装，其实只需要了解torch.nn的用法就行了
下面的这个是torch.nn.functional
import torch.nn.functional as F
output = F.conv2d(input, kernel, stride=1) # stride可以是一个int也可以是一个元组，表示每次匹配后横向和纵向的移动距离
torch.nn(要求掌握)
填充的padding默认是0
kernel_size,只需要定义它的大小就行了，因为在训练当中，会不断调整kernel里的值
这张图片的重点在于in_channels和out_channels
当in_channels和out_channels都设置为1的时候如下图
当输入图像的in_channels设置为1，out_channels设置为2，那么就会生成两个不同的卷积核，分别对输入图像进行卷积，得到两个不同的输出图像，然后最终把这两个输出图像叠加起来进行输出
池化层
个最常用的是nn.MaxPool2d
使用的时候可以设置kernel_size，还有floor(向下取整)和ceiling（向上取整），但是要注意的是，这里的stride默认的大小是kernel_size
非线性激活
kernel_size
relu,当input大于等于0的时候，取本身，当小于0的时候就取0
sigmoid
这里的N指batch_size
class ZWY(nn.Module):
def __init__(self):
super(ZWY, self).__init__()
self.relu1 = ReLU() # inplace ：是否替换原来的值 如果input=-1,当True，那么input = 0, 当False，那么input=-1不变，output=0
# 一般设置为False
self.sigmoid1 = Sigmoid()
def forward(self, input):
# output = self.relu1(input)
# return output
output = self.sigmoid1(input)
return output
input
output
非线性变换的主要目的：
引入一些非线性特征，因为非线性引入得多，才能训练出符合各种曲线的模型
线性层
官方文档
import torch
import torchvision.datasets
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader
dataset = torchvision.datasets.CIFAR10('../data', train=False, transform=torchvision.transforms.ToTensor(),
download=True)
dataloader = DataLoader(dataset, 64)
class ZWY(nn.Module):
def __init__(self):
super(ZWY, self).__init__()
self.linear1 = Linear(196608, 10)
def forward(self, input):
output = self.linear1(input)
return output
zwy = ZWY()
for data in dataloader:
imgs, targets = data
print(imgs.shape)
output = torch.reshape(imgs, (1, 1, 1, -1)) # torch.reshape()的参数:在imgs后面的小括号里面分别是batchsize, channel, high, wide
# 上面这一行也可以用下面这一行代替
# output = torch.flatten(imgs) # 平坦成一行
print(output.shape)
output = zwy(output) # 前向传播，重点
print(output.shape)
输出结果
输入层in_features = 196608，经过线性层把它转换成out_features = 10
如果不想自己搭建模型，也可以使用别人已经搭建好了的模型，在Torchvision（图像方面）版本可以选择0.9.0，然后再选择torchvision.model，就可以了
Sequential的作用：把步骤结合起来运行，简化代码
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
class ZWY(nn.Module):
def __init__(self):
super(ZWY, self).__init__()
# self.conv1 = Conv2d(3, 32, 5, padding=2) # padding是根据官方文档里面的ConV2d的公式计算得到的（因为要保证输入和输出的尺寸都是32）
# self.maxpool1 = MaxPool2d(2)
# self.conv2 = Conv2d(32, 32, 5, padding=2)
# self.maxpool2 = MaxPool2d(2)
# self.conv3 = Conv2d(32, 64, 5, padding=2)
# self.maxpool3 = MaxPool2d(2)
# self.flatten = Flatten()
# self.linear1 = Linear(1024, 64)
# self.linear2 = Linear(64, 10)
# 下面的这个sequential,是把这些步骤结合起来运行，简化代码，用完之后在forward中调用这个方法就行了
self.model1 = Sequential(
Conv2d(3, 32, 5, padding=2),
MaxPool2d(2),
Conv2d(32, 32, 5, padding=2),
MaxPool2d(2),
Conv2d(32, 64, 5, padding=2),
MaxPool2d(2),
Flatten(),
Linear(1024, 64),
Linear(64, 10)
)
def forward(self, x):
# x = self.conv1(x)
# x = self.maxpool1(x)
# x = self.conv2(x)
# x = self.maxpool2(x)
# x = self.conv3(x)
# x = self.maxpool3(x)
# x = self.flatten(x)
# x = self.linear1(x)
# x = self.linear2(x)
# # 调用的方法如下
x = self.model1(x)
return x
损失函数
作用
1、计算实际输出与目标之间的差距
运用文档提供的数学公式进行计算。
2、为我们更新输出提供一定的依据（反向传播）
卷积核当中的参数就是我们需要调优的，我们需要根据反向传播算出每一个参数对应的梯度，然后使用优化器根据这些梯度对参数进行一个优化，达到让loss值降低的目的。
梯度下降法
下面我用L1loss来举例
MSELOSS
平方差，用法和L1loss一样只是公式是不一样的，而且用法也挺简单的，这里就不多说
交叉熵
对于c个类别的分类问题有用
上面的这个线性图是四个输出，这里我们把它看作是3个输出，分别对应3个不同的类别（person, dog, cat）
其中x指那个列表，里面的数字分别表示预测person,dog,cat的概率，因为此处要预测出的是dog，而且要使得loss变小，就要让output中的最大数字对应的索引是target中的数字，这样，-x[class]的绝对值变得很大，然后后面的log这一块，要使它变小，所以就是对于person,dog,cat这些的预测概率都不应该很大，像什么0.8，0.9这种，应该是要预测出的那个很大像0.9，但是其他的很小，像0.2这种
C，代表分类的类别
N：batch_size
x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_crose = nn.CrossEntropyLoss()
result_cross = loss_crose(x, y)
print(result_cross)如果要进行反向传播的话，就直接对损失函数使用 .backward()
例如 result_cross.backward()
优化器
先构造优化器
调用优化器的step方法：利用梯度对卷积核当中的参数进行更新
记住：每一次更新完后都要对梯度进行一个清零操作，即上图中蓝色的部分
学习速率设置得不能太大，这样模型训练起来就很不稳定，设置太小训练又会很慢
如何利用现有的网络，去改变它的结构
这里以vgg16来举例，它的输出是1000类，现在我们要把它变成10类
import torchvision
from torch import nn
# train_data = torchvision.datasets.ImageNet('data_image_net', split='train', download=True,
# transform=torchvision.transforms.ToTensor())
# 上面的这个数据集太大了，有大概100多个G，所以这边就不建议下载了
vgg16_false = torchvision.models.vgg16(pretrained=False) # 网络架构中的参数都是默认的
vgg16_true = torchvision.models.vgg16(pretrained=True) # 网络架构中的参数是在数据集上训练好了的
print(vgg16_true) # vgg16的网络架构
train_data = torchvision.datasets.CIFAR10('../data', train=True, transform=torchvision.transforms.ToTensor(),
download=True)
# vgg16_true.add_module('add_linear', nn.Linear(1000, 10))
# print(vgg16_true)
# 如果想要加到classifier里面，就进行下面的操作就可以了
vgg16_true.classifier.add_module('add_linear1', nn.Linear(1000, 10))
print(vgg16_true)
# 修改网络
print(vgg16_false)
vgg16_false.classifier[6] = nn.Linear(4096, 10)
print(vgg16_false)
模型保存方式
import torchvision
import torch
from torch import nn
vgg16 = torchvision.models.vgg16(pretrained=False)
# 保存方式1 这种方式不仅可以保存网络模型的结构，而且还可以保存参数
torch.save(vgg16, 'vgg16_method1.pth') # 第二个参数是保存的路径
# 保存方式2（官方推荐） 不再保存网络模型的结构了，但是会保存网络模型的参数（保存成字典）
torch.save(vgg16.state_dict(), 'vgg16_method2.pth')
# 陷阱的演示
class ZWY(nn.Module):
def __init__(self):
super(ZWY, self).__init__()
self.conv1 = nn.Conv2d(3, 64, 3)
def forward(self, x):
x = self.conv1(x)
return x
zwy = ZWY()
torch.save(zwy, 'zwy_method.pth')
陷阱是，当我们在加载这个模型的时候，前面必须要把那个网络结构（即class ZWY）写过来，或者导入过来才可以，否则会报错.
加载模型的代码是
model = torch.load('zwy_method.pth')完整的模型训练代码
model模块
# 搭建神经网络
import torch
from torch import nn
class ZWY(nn.Module):
def __init__(self):
super(ZWY, self).__init__()
self.model = nn.Sequential(
nn.Conv2d(3, 32, 5, 1, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 32, 5, 1, padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5, 1, padding=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
if __name__ == '__main__':
zwy = ZWY()
input = torch.ones((64, 3, 32, 32))
output = zwy(input)
print(output.shape) # 输出的torch.Size([64, 10])中，表示返回64行数据，每一行数据上有10个数据，这10个数据表示每一张图片在10个类别当中的一个预测概率
大体流程（使用CPU训练）
# 想看类别就在 test_data 那里打断点，然后debug，看class_to_idx就行
import torch
import torchvision
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from model import *
import time
# 准备数据集
from torch.utils.data import DataLoader
# CIFAR10有10种类别
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)
# 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
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)
# 创建网络模型
zwy = ZWY()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
# 优化器
learning_rate = 0.01
# 也可以写成：learning_rate = 1e-2, 1e-2 = 1 x (10)^(-2) = 0.01
optimizer = torch.optim.SGD(zwy.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter('logs_train')
start_time = time.time()
for i in range(epoch):
print('----------第{}轮训练开始----------'.format(i + 1))
# 训练步骤开始
zwy.train()
for data in train_dataloader:
imgs, targets = data
outputs = zwy(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step += 1
if total_train_step % 100 == 0:
end_time = time.time()
print(end_time - start_time)
print('训练次数：{}， Loss：{}'.format(total_train_step, loss))
# print('训练次数：{}， Loss：{}'.format(total_train_step, loss.item()))
# 也可以像上面这样子写
# 举个例子
# a = torch.tensor(5)
# print(a) # 输出tensor(5)
# print(a.item()) # 输出 5
writer.add_scalar('train_loss', loss.item(), total_train_step) # 添加标量
# 测试步骤开始
# 在测试的过程中就不需要对模型进行调优了
zwy.eval()
total_accuracy = 0
total_test_loss = 0
with torch.no_grad(): # 保证不会对他进行一个调优
for data in test_dataloader:
imgs, targets = data
outputs = zwy(imgs)
loss = loss_fn(outputs, targets)
total_test_loss += loss.item()
accuracy = (outputs.argmax(1) == targets).sum() # argmax(1):横向（从左到右）取最大数对应的索引
total_accuracy += accuracy # argmax(0):纵向（从上到下）取最大数对应的索引
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 += 1
torch.save(zwy, 'zwy{}.pth'.format(i))
print('模型已保存')
writer.close()
使用GPU训练1
将网络模型、数据（输入，标注）、损失函数调用.cuda(),然后返回就行了
# 如何训练gpu
# 将网络模型、数据（输入，标注）、损失函数调用.cuda(),然后返回就行了
import torch
import torchvision
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from model import *
import time
# 准备数据集
from torch.utils.data import DataLoader
# CIFAR10有10种类别
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)
# 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
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)
# 创建网络模型
zwy = ZWY()
if torch.cuda.is_available():
zwy = zwy.cuda()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
loss_fn = loss_fn.cuda()
# 优化器
learning_rate = 0.01
# 也可以写成：learning_rate = 1e-2, 1e-2 = 1 x (10)^(-2) = 0.01
optimizer = torch.optim.SGD(zwy.parameters(), lr=learning_rate)
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter('logs_train')
start_time = time.time()
for i in range(epoch):
print('----------第{}轮训练开始----------'.format(i + 1))
# 训练步骤开始
zwy.train()
for data in train_dataloader:
imgs, targets = data
if torch.cuda.is_available():
imgs = imgs.cuda()
targets = targets.cuda()
outputs = zwy(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_train_step += 1
if total_train_step % 100 == 0:
end_time = time.time()
print(end_time - start_time)
print('训练次数：{}， Loss：{}'.format(total_train_step, loss))
# print('训练次数：{}， Loss：{}'.format(total_train_step, loss.item()))
# 也可以像上面这样子写
# 举个例子
# a = torch.tensor(5)
# print(a) # 输出tensor(5)
# print(a.item()) # 输出 5
writer.add_scalar('train_loss', loss.item(), total_train_step) # 添加标量
# 测试步骤开始
# 在测试的过程中就不需要对模型进行调优了
zwy.eval()
total_accuracy = 0
total_test_loss = 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 = zwy(imgs)
loss = loss_fn(outputs, targets)
total_test_loss += loss.item()
accuracy = (outputs.argmax(1) == targets).sum() # argmax(1):横向（从左到右）取最大数对应的索引
total_accuracy += accuracy # argmax(0):纵向（从上到下）取最大数对应的索引
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 += 1
torch.save(zwy, 'zwy{}.pth'.format(i))
print('模型已保存')
writer.close()
使用GPU训练2
# 只有数据、图片、标注需要赋值 像这样imgs = imgs.to(device)
# 损失函数、网络模型就这样就好,不需要赋值 ： tudui.to(device)
# 方式2是比较常用的方式
# 使用方法
# .to(device)
# device = torch.device('cpu') # 括号里面也可以写cuda,表示使用gpu
完结
注：本文由b站上up主们的一些视频截图以及自己平时的积累组成。
3830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
