卷积神经网络学习记录（1）--------利用pytorch构建卷积神经网络
目录
1.卷积神经网络
卷积神经网络主要结构为：卷积层，隐含层，输出层，其中隐含层可以分为三个部分，分别是卷积层（对输入数据进行特征提取）、池化层（特征选择和信息过滤）、全连接层（等价于传统前馈神经网络中的隐含层）。
1.1隐含层介绍
1.1.1卷积层
先来看pytorch中构建卷积层的重要函数
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
其中：
- in_channels：输入通道数（深度）
- out_channels：输出通道数（深度）
- kernel_size：滤波器（卷积核）大小，宽和高相等的卷积核可以用一个数字表示，例如：kernel_size=2；否则用不同数字表示，例如 kernel_size=(4，9）
- stride：表示滤波器滑动的步长
- padding：是否进行零填充，padding=0 表示四周不进行零填充，padding=1 表示四周进行1个像素点的零填充
- bias：默认为 True，表示使用偏置
- groups：groups=1 表示所有输入输出是相关联的；groups=n 表示输入输出通道数（深度）被分割为 n 份，并分别对应，且需要被 groups 整除（这里不太明白）
- dilation：卷积对输入的空间间隔，默认为 True
1.1.2池化层
池化最直观的作用便是降维，最常见的池化方式有最大值池化和平均值池化
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)
其中：
- kernel_size、stride、padding、dilation与卷积层定义一致
- return_indices：表示是否返回最大值的下标，默认为 False
- ceil_mode：默认为 False，即不使用方格代替层结构
- count_include_pad：默认为 True，表示包含零填充
1.1.3全连接层
torch.nn.Linear(in_features, out_features, bias=True)其中：
- in_features：上层网络神经元的个数
- out_features：该网络层神经元的个数
- bias：网络层是否有偏置，默认为True，且维度为[out_features]
1.2其他结构
1.2.1BN层
批标准化层可以加快收敛速度
torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)
其中：
- num_features：输入通道数（深度）
- eps：为数值稳定性而添加到分母的值， 默认值为 1e-5
- momentum：用于 running_mean 和 running_var 计算的值；对于累积移动平均值（即简单平均值），可以设置为“无”。 默认值为 0.1
- affine：当设置为 True 时，该模块具有可学习的仿射参数。 默认为 True
- track_running_stats：当设置为 True 时，该模块跟踪运行的均值和方差，当设置为 False 时，该模块不跟踪这样的统计数据，并且总是在训练和评估模式。 默认为 True
1.2.2激活函数
import torch.nn.functional as F
F.relu()
F.sigmoid()
F.tanh()
F.softplus()
1.2.3防止过拟合
torch.nn.Dropout(p=0.5, inplace=False)
其中：
- p：将元素置0的概率。默认值：0.5
- in-place：若设置为True，会在原地执行操作。默认值：False
1.3 练习
1.3.1参考文章
- 卷积：【深度学习基础】什么是卷积？为什么要用卷积？
- 池化： [CNN] 卷积、反卷积、池化、反池化
- 构建卷积神经网络实例：PyTorch手写数字识别(MNIST数据集)
- MNIST数据集介绍：MNIST数据集介绍
- 其中可能出现的HTTP Error 503: Service Unavailable问题：pytorch MNIST数据集无法正常加载的解决办法
- pytorch显示图片的问题：np.transpose(npimg, (1, 2, 0))
- transform.ToTensor(), transform.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))作用
- torch.nn.CrossEntropyLoss的相关
1.3.2全部代码
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import torchvision
from torch.autograd import Variable
from torch.utils.data import DataLoader
import cv2
#***************************获取训练集和测试集*********************************
"""
# 下载训练集
train_dataset = datasets.MNIST(root='./num/',
train=True,
transform=transforms.ToTensor(),
download=True)
# 下载测试集
test_dataset = datasets.MNIST(root='./num/',
train=False,
transform=transforms.ToTensor(),
download=True)
"""
#下载训练集
train_dataset = datasets.MNIST(root='./num/',
train=True ,
download=True,
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(
(0.1307,), (0.3081,))
]))
#下载数据集
test_dataset = datasets.MNIST(root='./num/',
train=False,
download=True,
transform=torchvision.transforms.Compose([
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(
(0.1307,), (0.3081,))
]))
#***************************数据装载和预览***********************************
# dataset 参数用于指定我们载入的数据集名称
# batch_size参数设置了每个包中的图片数据个数
# 在装载的过程会将数据随机打乱顺序并进打包
batch_size = 64
#建立一个数据迭代器
# 装载训练集
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True) # shuffle=True随机打乱数据进行打包
# 装载测试集
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=True)
# 实现单张图片可视化
images, labels = next(iter(train_loader)) #使用iter和next来获取一个批次的图片数据和其对应的图片标签， iter为迭代器，next遍历
img = torchvision.utils.make_grid(images) #make_grid 类方法将一个批次的图片构造成网格模式
#格式转换 img的格式（channels,imagesize,imagesize）
#plt.imshow的输入格式（imagesize,imagesize，channels）
#先把torch.FloatTensor 转换为numpy
img = img.numpy().transpose(1, 2, 0) #transpose为交换数据维度
std = [0.5, 0.5, 0.5] #std:各通道的标准差
mean = [0.5, 0.5, 0.5] #mean:各通道的均值
img = img * std + mean #灰度拉伸
print(labels)
cv2.imshow('win', img)
key_pressed = cv2.waitKey(0)
#**************************搭建卷积神经网络***************************
# 卷积层使用 torch.nn.Conv2d
# 激活层使用 torch.nn.ReLU
# 池化层使用 torch.nn.MaxPool2d
# 全连接层使用 torch.nn.Linear
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__()
self.conv1 = nn.Sequential(nn.Conv2d(1, 6, 3, 1, 2), nn.ReLU(),
nn.MaxPool2d(2, 2))
self.conv2 = nn.Sequential(nn.Conv2d(6, 16, 5), nn.ReLU(),
nn.MaxPool2d(2, 2))
self.fc1 = nn.Sequential(nn.Linear(16 * 5 * 5, 120),
nn.BatchNorm1d(120), nn.ReLU())
self.fc2 = nn.Sequential(
nn.Linear(120, 84),
nn.BatchNorm1d(84),
nn.ReLU(),
nn.Linear(84, 10))
# 最后的结果一定要变为 10，因为数字的选项是 0 ~ 9
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = x.view(x.size()[0], -1)
x = self.fc1(x)
x = self.fc2(x)
return x
#****************************训练模型***************************************
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
LR = 0.001 #学习率
net = LeNet().to(device)
# 损失函数使用交叉熵，关于损失函数：loss 类型为torch.Tensor是一个可求导的tensor; loss.item类型为float是python类型的常数值．
criterion = nn.CrossEntropyLoss()
# 优化函数使用 Adam 自适应优化算法
optimizer = optim.Adam(
net.parameters(),
lr=LR,
)
epoch = 1
if __name__ == '__main__':
for epoch in range(epoch):
sum_loss = 0.0
for i, data in enumerate(train_loader):
inputs, labels = data
inputs, labels = Variable(inputs).to(device), Variable(labels).to(device)
optimizer.zero_grad() #将梯度归零
outputs = net(inputs) #将数据传入网络进行前向运算
loss = criterion(outputs, labels) #得到损失函数
loss.backward() #反向传播
optimizer.step() #通过梯度做一步参数更新
# print(loss)
sum_loss += loss.item()
if i % 100 == 99:
print('[%d,%d] loss:%.03f' %
(epoch + 1, i + 1, sum_loss / 100))
sum_loss = 0.0
#****************************测试模型**************************************
net.eval() #将模型变换为测试模式
correct = 0
total = 0
for data_test in test_loader:
images, labels = data_test #获取训练样本
#images, labels = Variable(images).cuda(), Variable(labels).cuda()
images, labels = Variable(images).to(device), Variable(labels).to(device) #设为计算节点
output_test = net(images) #将图像放入模型进行计算
_, predicted = torch.max(output_test, 1) #返回一个tensor中的最大值
total += labels.size(0)
correct += (predicted == labels).sum() #预测正确的个数
print("correct1: ", correct)
print("Test acc: {0}".format(correct.item() /
len(test_dataset)))
2182
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
