第二次作业：卷积神经网络 part 1
视频学习
-
深度学习的数学基础
-
卷积神经网络
代码练习
MNIST 数据集分类
- 配置
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy
# 一个函数，用来计算模型中有多少参数
def get_n_params(model):
np=0
for p in list(model.parameters()):
np += p.nelement()
return np
# 使用GPU训练，可以在菜单 "代码执行工具" -> "更改运行时类型" 里进行设置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
下载数据集
DataLoader是一个比较重要的类
显示数据集中的部分图像
-
创建网络
一个全连接和一个cnn -
在小型全连接网络上训练结果
-
在卷积神经网络上训练
-
打乱像素顺序再次在两个网络上训练与测试
-
全连接结果
-
CNN结果
打乱像素顺序后，全连接网络的性能基本上没有发生变化，但是卷积神经网络的性能明显下降。
这是因为对于卷积神经网络，会利用像素的局部关系，但是打乱顺序以后，这些像素间的关系将无法得到利用。
CIFAR10 数据集分类
-
数据集下载，把范围在[0,1]的输出变为[-1,1]的张量 Tensors。
input[channel] = (input[channel] - mean[channel]) / std[channel]
由(（0,1）-0.5）/0.5=(-1,1) -
展示 CIFAR10 里面的一些图片（8*8）和第一行的标签
truck truck frog cat plane deer dog car -
定义网络，损失函数和优化器
-
训练结果
-
测试
测试图片
标签：cat ship ship plane frog frog car frog
结果:cat ship ship ship(×) deer(×) frog truck(×) frog
使用生个数据集测试的结果
使用 VGG16 对 CIFAR10 分类
- 定义 dataloader
mport torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
# 使用GPU训练，可以在菜单 "代码执行工具" -> "更改运行时类型" 里进行设置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
- VGG 网络定义
有个报错修改
cfg = [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']
class VGG(nn.Module):
def __init__(self):
super(VGG, self).__init__()
#self.cfg = [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']
self.features = self._make_layers(cfg)
self.classifier = nn.Linear(512, 10)
def forward(self, x):
out = self.features(x)
out = out.view(out.size(0), -1)
out = self.classifier(out)
return out
def _make_layers(self, cfg):
layers = []
in_channels = 3
for x in cfg:
if x == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),
nn.BatchNorm2d(x),
nn.ReLU(inplace=True)]
in_channels = x
layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
return nn.Sequential(*layers)
# 网络放到GPU上
net = VGG().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
- 网络训练
结果
Epoch: 1 Minibatch: 1 loss: 2.531
Epoch: 1 Minibatch: 101 loss: 1.400
Epoch: 1 Minibatch: 201 loss: 1.315
Epoch: 1 Minibatch: 301 loss: 1.169
Epoch: 2 Minibatch: 1 loss: 0.968
Epoch: 2 Minibatch: 101 loss: 0.932
Epoch: 2 Minibatch: 201 loss: 1.006
Epoch: 2 Minibatch: 301 loss: 0.818
Epoch: 3 Minibatch: 1 loss: 0.968
Epoch: 3 Minibatch: 101 loss: 0.761
Epoch: 3 Minibatch: 201 loss: 0.848
Epoch: 3 Minibatch: 301 loss: 0.613
Epoch: 4 Minibatch: 1 loss: 0.716
Epoch: 4 Minibatch: 101 loss: 0.836
Epoch: 4 Minibatch: 201 loss: 0.553
Epoch: 4 Minibatch: 301 loss: 0.553
Epoch: 5 Minibatch: 1 loss: 0.616
Epoch: 5 Minibatch: 101 loss: 0.440
Epoch: 5 Minibatch: 201 loss: 0.438
Epoch: 5 Minibatch: 301 loss: 0.511
Epoch: 6 Minibatch: 1 loss: 0.478
Epoch: 6 Minibatch: 101 loss: 0.770
Epoch: 6 Minibatch: 201 loss: 0.614
Epoch: 6 Minibatch: 301 loss: 0.803
Epoch: 7 Minibatch: 1 loss: 0.485
Epoch: 7 Minibatch: 101 loss: 0.561
Epoch: 7 Minibatch: 201 loss: 0.507
Epoch: 7 Minibatch: 301 loss: 0.436
Epoch: 8 Minibatch: 1 loss: 0.451
Epoch: 8 Minibatch: 101 loss: 0.581
Epoch: 8 Minibatch: 201 loss: 0.552
Epoch: 8 Minibatch: 301 loss: 0.366
Epoch: 9 Minibatch: 1 loss: 0.465
Epoch: 9 Minibatch: 101 loss: 0.414
Epoch: 9 Minibatch: 201 loss: 0.277
Epoch: 9 Minibatch: 301 loss: 0.388
Epoch: 10 Minibatch: 1 loss: 0.388
Epoch: 10 Minibatch: 101 loss: 0.367
Epoch: 10 Minibatch: 201 loss: 0.396
Epoch: 10 Minibatch: 301 loss: 0.569
Finished Training
- 测试验证准确率
使用VGG模型迁移学习进行猫狗大战
- 下载数据集，处理图片为224×224×3，并归一化
# 数据部分属性
['cats', 'dogs']
{'cats': 0, 'dogs': 1}
[('./dogscats/train/cats/cat.0.jpg', 0), ('./dogscats/train/cats/cat.1.jpg', 0), ('./dogscats/train/cats/cat.10.jpg', 0), ('./dogscats/train/cats/cat.100.jpg', 0), ('./dogscats/train/cats/cat.101.jpg', 0)]
dset_sizes: {'train': 1800, 'valid': 2000}
第一个batch的5张图片
-
创建 VGG模型
使用训练好的vgg模型进行预测 -
修改最后一层，冻结前面层的参数
设置 required_grad=False，只反向传递训练最后一层
print(model_vgg)
model_vgg_new = model_vgg;
for param in model_vgg_new.parameters():
param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)
model_vgg_new = model_vgg_new.to(device)
print(model_vgg_new.classifier)
结果：
VGG(
(features): Sequential(
(0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(1): ReLU(inplace=True)
(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(3): ReLU(inplace=True)
(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(6): ReLU(inplace=True)
(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(8): ReLU(inplace=True)
(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(11): ReLU(inplace=True)
(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(13): ReLU(inplace=True)
(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(15): ReLU(inplace=True)
(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(18): ReLU(inplace=True)
(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(20): ReLU(inplace=True)
(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(22): ReLU(inplace=True)
(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(25): ReLU(inplace=True)
(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(27): ReLU(inplace=True)
(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(29): ReLU(inplace=True)
(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
(classifier): Sequential(
(0): Linear(in_features=25088, out_features=4096, bias=True)
(1): ReLU(inplace=True)
(2): Dropout(p=0.5, inplace=False)
(3): Linear(in_features=4096, out_features=4096, bias=True)
(4): ReLU(inplace=True)
(5): Dropout(p=0.5, inplace=False)
(6): Linear(in_features=4096, out_features=1000, bias=True)
)
)
Sequential(
(0): Linear(in_features=25088, out_features=4096, bias=True)
(1): ReLU(inplace=True)
(2): Dropout(p=0.5, inplace=False)
(3): Linear(in_features=4096, out_features=4096, bias=True)
(4): ReLU(inplace=True)
(5): Dropout(p=0.5, inplace=False)
(6): Linear(in_features=4096, out_features=2, bias=True)
(7): LogSoftmax(dim=1)
)
- 训练并测试全连接层
1.创建损失函数和优化器；
2.训练模型；
3.测试模型。
'''
第一步：创建损失函数和优化器
损失函数 NLLLoss() 的 输入 是一个对数概率向量和一个目标标签.
它不会为我们计算对数概率，适合最后一层是log_softmax()的网络.
'''
criterion = nn.NLLLoss()
# 学习率
lr = 0.001
# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)
'''
第二步：训练模型
'''
def train_model(model,dataloader,size,epochs=1,optimizer=None):
model.train()
for epoch in range(epochs):
running_loss = 0.0
running_corrects = 0
count = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
optimizer = optimizer
optimizer.zero_grad()
loss.backward()
optimizer.step()
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
count += len(inputs)
print('Training: No. ', count, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(
epoch_loss, epoch_acc))
# 模型训练
train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1,
optimizer=optimizer_vgg)
def test_model(model,dataloader,size):
model.eval()
predictions = np.zeros(size)
all_classes = np.zeros(size)
all_proba = np.zeros((size,2))
i = 0
running_loss = 0.0
running_corrects = 0
for inputs,classes in dataloader:
inputs = inputs.to(device)
classes = classes.to(device)
outputs = model(inputs)
loss = criterion(outputs,classes)
_,preds = torch.max(outputs.data,1)
# statistics
running_loss += loss.data.item()
running_corrects += torch.sum(preds == classes.data)
predictions[i:i+len(classes)] = preds.to('cpu').numpy()
all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
i += len(classes)
print('Testing: No. ', i, ' process ... total: ', size)
epoch_loss = running_loss / size
epoch_acc = running_corrects.data.item() / size
print('Loss: {:.4f} Acc: {:.4f}'.format(
epoch_loss, epoch_acc))
return predictions, all_proba, all_classes
predictions, all_proba, all_classes = test_model(model_vgg_new,loader_valid,size=dset_sizes['valid'])
- 可视化模型预测结果（主观分析）
主观分析就是把预测的结果和相对应的测试图像输出出来看看，人工判断一下？一般有四（五？）种方式：
1.随机查看一些预测正确的图片
2.随机查看一些预测错误的图片
3.预测正确，同时具有较大的probability的图片
4.预测错误，同时具有较大的probability的图片
5.最不确定的图片，比如说预测概率接近0.5的图片
# 单次可视化显示的图片个数
n_view = 8
correct = np.where(predictions==all_classes)[0]
from numpy.random import random, permutation
idx = permutation(correct)[:n_view]
print('random correct idx: ', idx)
loader_correct = torch.utils.data.DataLoader([dsets['valid'][x] for x in idx],
batch_size = n_view,shuffle=True)
for data in loader_correct:
inputs_cor,labels_cor = data
# Make a grid from batch
out = torchvision.utils.make_grid(inputs_cor)
imshow(out, title=[l.item() for l in labels_cor])
# 类似的思路，可以显示错误分类的图片，这里不再重复代码
