Pytorch构建ResNet-50V2
Posted 老师我作业忘带了
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Pytorch构建ResNet-50V2相关的知识，希望对你有一定的参考价值。
-
🍨 本文为🔗365天深度学习训练营 中的学习记录博客
-
🍦 参考文章地址： 365天深度学习训练营-第J2周：ResNet-50V2算法实战与解析
-
🍖 作者：K同学啊
一、ResNetV2与ResNet结构对比
改进点
(a)original 表示原始的 ResNet 的残差结构，(b)proposed 表示新的 ResNet 的残差结构。主要差别就是(a)结构先卷积后进行 BN 和激活函数计算，最后执行 addition 后再进行ReLU 计算； (b)结构先进行 BN 和激活函数计算后卷积，把 addition 后的 ReLU 计算放到了残差结构内部。
改进结果
作者使用这两种不同的结构在 CIFAR-10 数据集上做测试，模型用的是 1001层的 ResNet 模型。从图中结果我们可以看出，(b)proposed 的测试集错误率明显更低一些，达到了 4.92%的错误率，(a)original 的测试集错误率是 7.61%
二、模型实现
2.1 残差结构
''' Residual Block '''
class Block2(nn.Module):
def __init__(self, in_channel, filters, kernel_size=3, stride=1, conv_shortcut=False):
super(Block2, self).__init__()
self.preact = nn.Sequential(
nn.BatchNorm2d(in_channel),
nn.ReLU(True)
)
self.shortcut = conv_shortcut
if self.shortcut:
self.short = nn.Conv2d(in_channel, 4*filters, 1, stride=stride, padding=0, bias=False)
elif stride>1:
self.short = nn.MaxPool2d(kernel_size=1, stride=stride, padding=0)
else:
self.short = nn.Identity()
self.conv1 = nn.Sequential(
nn.Conv2d(in_channel, filters, 1, stride=1, bias=False),
nn.BatchNorm2d(filters),
nn.ReLU(True)
)
self.conv2 = nn.Sequential(
nn.Conv2d(filters, filters, kernel_size, stride=stride, padding=1, bias=False),
nn.BatchNorm2d(filters),
nn.ReLU(True)
)
self.conv3 = nn.Conv2d(filters, 4*filters, 1, stride=1, bias=False)
def forward(self, x):
x1 = self.preact(x)
if self.shortcut:
x2 = self.short(x1)
else:
x2 = self.short(x)
x1 = self.conv1(x1)
x1 = self.conv2(x1)
x1 = self.conv3(x1)
x = x1 + x2
return x2.2 模块构建
class Stack2(nn.Module):
def __init__(self, in_channel, filters, blocks, stride=2):
super(Stack2, self).__init__()
self.conv = nn.Sequential()
self.conv.add_module(str(0), Block2(in_channel, filters, conv_shortcut=True))
for i in range(1, blocks-1):
self.conv.add_module(str(i), Block2(4*filters, filters))
self.conv.add_module(str(blocks-1), Block2(4*filters, filters, stride=stride))
def forward(self, x):
x = self.conv(x)
return x2.3 网络构建
''' 构建ResNet50V2 '''
class ResNet50V2(nn.Module):
def __init__(self,
include_top=True, # 是否包含位于网络顶部的全链接层
preact=True, # 是否使用预激活
use_bias=True, # 是否对卷积层使用偏置
input_shape=[224, 224, 3],
classes=1000,
pooling=None): # 用于分类图像的可选类数
super(ResNet50V2, self).__init__()
self.conv1 = nn.Sequential()
self.conv1.add_module('conv', nn.Conv2d(3, 64, 7, stride=2, padding=3, bias=use_bias, padding_mode='zeros'))
if not preact:
self.conv1.add_module('bn', nn.BatchNorm2d(64))
self.conv1.add_module('relu', nn.ReLU())
self.conv1.add_module('max_pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
self.conv2 = Stack2(64, 64, 3)
self.conv3 = Stack2(256, 128, 4)
self.conv4 = Stack2(512, 256, 6)
self.conv5 = Stack2(1024, 512, 3, stride=1)
self.post = nn.Sequential()
if preact:
self.post.add_module('bn', nn.BatchNorm2d(2048))
self.post.add_module('relu', nn.ReLU())
if include_top:
self.post.add_module('avg_pool', nn.AdaptiveAvgPool2d((1, 1)))
self.post.add_module('flatten', nn.Flatten())
self.post.add_module('fc', nn.Linear(2048, classes))
else:
if pooling=='avg':
self.post.add_module('avg_pool', nn.AdaptiveAvgPool2d((1, 1)))
elif pooling=='max':
self.post.add_module('max_pool', nn.AdaptiveMaxPool2d((1, 1)))
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = self.conv3(x)
x = self.conv4(x)
x = self.conv5(x)
x = self.post(x)
return x三、鸟类数据集效果
数据集可视化：
后三个epoch：
Epoch:18, Train_acc:92.9%, Train_loss:0.210, Test_acc:84.1%，Test_loss:0.538 Epoch:19, Train_acc:94.9%, Train_loss:0.160, Test_acc:89.4%，Test_loss:0.484 Epoch:20, Train_acc:92.7%, Train_loss:0.270, Test_acc:82.3%，Test_loss:0.700 Done best_acc： 0.9491150442477876
Loss与Accuracy图：
指定图片预测：
用Pytorch构建一个喵咪识别模型
本文参加新星计划人工智能(Pytorch)赛道：https://bbs.csdn.net/topics/613989052
目录
一、前言
舍友最近养了只猫咪，看起来很好看，但是你绝对想不到它拉的shi巨臭啊，哈哈哈哈，就很离谱。刚好最近在学习Pytorch，心血来潮，就用Pytorch来做个喵咪识别模型并，于是就有了本篇博文。
二、问题阐述及理论流程
2.1问题阐述
现一共有 259 张图片，总体分为两类：
有猫咪类
无猫咪类
2.2猫咪图片识别原理
三、用PyTorch 实现
3.1PyTorch介绍
PyTorch 是一个开源的深度学习框架，它的底层基于 Torch ，但实现与运用全部由 python 来完成。该框架主要用于人工智能领域的科学研究与应用开发。
3.2PyTorch 构建模型的五要素
1.数据：包括数据读取，数据清洗，进行数据划分和数据预处理。
2.模型：包括构建模型模块，组织复杂网络，初始化网络参数，定义网络层。
3.损失函数：包括创建损失函数，设置损失函数超参数，要根据不同任务选择合适的损失函数。
4.优化器：包括根据梯度使用某种优化器更新参数，管理模型参数，调整学习率。
5.迭代训练：组织上述 4 个模块进行反复训练。观察训练效果，绘制 Loss/ Accuracy 曲线或者用 TensorBoard 进行可视化分析。
3.3PyTorch 实现的步骤
3.3.1.数据
在深度学习时会遇到各种不同形式的数据，如文本、图片、音频等，而每种数据又有多种文件类型。因此拿到数据，我们首先应该了解它的内部结构。
h5py 文件是一种 " Dataset " 和 " Group " 二合一的容器：
-
「Dataset」: 类似数组组织的数据的集合，像 numpy 数组一样工作；
-
「Group」: 包含了其它 Dataset 和 其它 Group ，像字典一样工作。
读取下载好的 h5py 文件（以含有 209 张图片的测试集为例）
import h5py
f = h5py.File("/home/tian/dataset/catvnocat/train/train_catvnoncat.h5","r")#"r"代表读取模式
for key in f.keys():
print(key)
#输出
#list_classes
#train_set_x
#train_set_y依次打印出这三个" key "下的内容
print(f["list_classes"])
print(f["train_set_x"])
print(f["train_set_y"])
#输出
#<HDF5 dataset "list_classes": shape (2,), type "|S7">
#<HDF5 dataset "train_set_x": shape (209, 64, 64, 3), type "|u1">
#<HDF5 dataset "train_set_y": shape (209,), type "<i8">可以得到三个 Dataset 的相关信息：
-
list_classes：包含两个元素 ' non-cat ' 和' cat '，代表无猫和有猫这两个大类。 -
train_set_x：一个四维张量，形状为 209 * 64 * 64 * 3。代表一共有 209 张图片，其中每张图片以像素大小为 64 * 64 的三通道矩阵存储信息。 -
train_set_y：一个一维数组，元素全部存储着 209 张图片对应的标签，其中有猫为 1 ，无猫为 0 。
该 h5py 文件的结构如下图所示：
制作数据集
从torch.utils.data中引入Dataset，Dataset是能够表示数据集的抽象类，一般有三个方法：
-
「__init__方法」
用于类的初始化，负责创建类的实例属性并进行赋值，并在实例化类后自动执行。这里我创建的 MyData 类中包含以下属性：
-
Archive：文件的路径及对文件的操作，只读或写入
-
Image：样本中的图片或者包含全部图片信息的像素矩阵
-
Label：样本中的标签
-
Transform：可能要对数据进行的变换或增强
-
-
「__getitem__方法」
所有子类都必须重写该方法，该方法通过索引（index）或键（key）访问样本，返回值为 样本和标签。
-
「__len__方法」
返回数据集的大小。
from torch.utils.data import Dataset
class MyDataset(Dataset):
def __init__(self, archive , image , label , transform = None ):
self.Archive = h5.File(archive, 'r')
self.Images = self.Archive[image]
self.Labels = self.Archive[label]
self.Transform = transform
def __getitem__(self,index):
image = self.Images[index]
label = self.Labels[index]
if self.Transform is not None:
image = self.Transforms(image)
return image ,label
def __len__(self):
return len(self.Labels)
train_dataset = MyDataset('/home/tian/dataset/catvnocat/train/train_catvnoncat.h5','train_set_x','train_set_y',train_transformer)
test_dataset = MyDataset('/home/tian/dataset/catvnocat/test/test_catvnoncat.h5','test_set_x','test_set_y',test_transformer)读取数据集
从torch.utils.data引入DataLoader，它帮助我们从Dataset中加载样本数据。它联合了数据集 Dataset 和采样器 Sampler，使其本身可以像一个迭代器一样工作。前者提供数据来源，后者提供索引。
from torch.utils.data import Dataloader
train_loader = DataLoader(train_dataset, batch_size = batch_size_train, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size = batch_size_test, shuffle=False)shuffle = True指的是将样本打乱，一般只针对训练集。
3.3.2模型
该神经网络采用简单的 2 隐藏层全连接的方式，并在每一层采用 ReLU 函数作为激活函数，最后通过 Softmax 函数输出预测概率，以达到二分类的目的。
class Net(nn.Module):
def __init__(self, in_dim, n_hidden_1,n_hidden_2,out_dim):
super(Net, self).__init__()
self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1), nn.ReLU(True),nn.Dropout(0.25))
self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d(n_hidden_2), nn.ReLU(True),nn.Dropout(0.25))
self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim), nn.Softmax(dim = 1))
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x3.3.3损失函数
交叉熵损失函数是二分类问题常用的损失函数，可以直接在torch.nn里直接调用，其形式为：
criterion = nn.CrossEntropyLoss()3.3.4优化器
在 torch.optim中直接调用随机梯度下降法 SGD：
optimizer = optim.SGD(model.parameters(), lr = learning_rate, weight_decay = 1e-4)3.3.5迭代训练
一切准备工作就绪，进行迭代训练。也可以根据需要绘制 Loss/ Accuracy 曲线观察 train_loss 和 val_loss，并以此为依据来调试超参数。
for epoch in range(num_epoches+1):
model.train()
for data in train_loader:
img, label = data
img = img.view(img.size(0), -1)
img = Variable(img)
label = Variable(label)
out = model(img.to(torch.float32))
loss = criterion(out, label)
_, pred = torch.max(out, 1)
acc = (pred == label).sum().item() / (len(train_dataset))
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
img, label = data
img = img.view(img.size(0), -1)
out = model(img.to(torch.float32))
loss_1 = criterion(out, label)
eval_loss += loss_1.data.item()*label.size(0)
_, pred = torch.max(out, 1)
eval_acc += (pred == label).sum().item() / len(test_dataset)
if epoch%50 == 0:
train_losses.append(loss.data.item())
train_acc.append(acc)
test_losses.append(loss_1.data.item())
test_acc.append(eval_acc)
print('epoch: '.format(epoch))
print('Train Loss: :.4, Train_Acc: :.4'.format(loss.data.item(), acc))
print('Test Loss: :.4f, Test_Acc: :.4f'.format(eval_loss / (len(test_dataset)),eval_acc))
fig = plt.figure()
plt.plot(train_counter, train_losses, color='blue')
plt.plot(test_counter, test_losses, '--',color='red')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('negative log likelihood loss')
fig = plt.figure()
plt.plot(train_counter, train_acc, color='blue')
plt.plot(test_counter, test_acc, '--',color='red')
plt.legend(['Train Acc', 'Test Acc'], loc='lower right')
plt.xlabel('number of training examples seen')
plt.ylabel('Acc')
plt.show()「结果展示」：
可以看到，过拟合的情况没有发生，并且训练集和测试集的准确率都接近 90%，相对于原本的准确率有了较大的提高。
四、我用了哪些方法防止过拟合？
4.1控制网络规模
当神经网络具有过多的神经元时，训练集中包含的有限信息量不足以训练隐藏层中的所有神经元，很可能导致过拟合。因此要控制网络规模，既不能太宽也不能太深。
4.2数据增强
样本量少是造成过拟合的主要原因之一，但我们往往很难从源头上解决这一问题。数据增强通过对现有的样本（以图片为例）进行各种不同的变换（如随机自定义大小裁剪、随机翻转、随机旋转、增加色彩对比度等），然后适当增加训练迭代次数，从而达到样本量扩张的效果。
本文采用了以下手段进行数据增强：
-
对输入图片随机裁剪，将原本像素大小为64的图片裁剪成像素大小为48的图片
-
在水平方向上对一半的图片进行随机翻转
-
在垂直方向上对一半的图片进行随机翻转
-
对图在一定角度内进行旋转
from torchvision import transforms
train_transformer = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomResizedCrop(48),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation((-15, 15)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
test_transformer = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(48),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])测试集大多数情况下不进行数据增强，这里为了适应训练集数据增强后的图片大小对测试集进行了尺寸缩放，同样变为像素大小为的图片。
4.3正则化
-
「Drop_out」
作为常用的预防过拟合的方法之一，它的主要思想是让隐藏层的节点在每次迭代时有一定几率失效，从而避免对某个节点的强依赖，让反向传播的修正值可以更加平衡的分布到各个参数上。也在一定程度上降低了网络复杂度。
-
「weight_decay」
过拟合时模型会拟合很多位置较偏的点，导致拟合函数在某些小区间剧烈变化，权重 w 的绝对值很大。此方法通过控制权重 w 的大小来缓解过拟合的情况。
4.4K 折交叉验证
以模型调优的思路来缓解过拟合。在训练每种模型时，通过k折交叉验证得到k组不同的训练集和测试集，并将每组的误差平均作为衡量模型泛化能力的准则，从而选择出泛化能力最好的（即最不容易发生过拟合）的模型。
kf = KFold(n_splits = 7, shuffle=True)五、用自己的图片验证
训练神经网络最终的目的就是为了应用，因此最后一个环节我们用自己的图片来验证“猫咪识别器”的性能如何。
5.1输入数据
有猫咪类
无猫咪类
5.2代码实现
from PIL import Image
def trans_pic(img_dir,width,height):
image = Image.open(img_dir) #打开图片
resized_image = image.resize((width, height), Image.ANTIALIAS)
data = np.asarray(resized_image)#转换为矩阵
image = Image.fromarray(data) #将之前的矩阵转换为图片
#image.show()#调用本地软件显示图片，win10是叫照片的工具
return data
path_cat = [r"/home/tian/Pictures/cat_1.jpg",
r"/home/tian/Pictures/cat_2.jpg",
r"/home/tian/Pictures/cat_3.jpg",
r"/home/tian/Pictures/cat_4.jpg",
r"/home/tian/Pictures/cat_5.jpg"]
path_nocat = [r"/home/tian/Pictures/nocat_1.jpg",
r"/home/tian/Pictures/nocat_2.jpg",
r"/home/tian/Pictures/nocat_3.jpg",
r"/home/tian/Pictures/nocat_4.jpg",
r"/home/tian/Pictures/nocat_5.jpg"]
for i in range(5):
a = test_transformer(trans_pic(path_cat[i],48,48)).view(1, -1)
b = test_transformer(trans_pic(path_nocat[i],48,48)).view(1, -1)
out_1 = model(a.to(torch.float32))
out_2 = model(b.to(torch.float32))
_, pred_1= torch.max(out_1, 1)
_, pred_2= torch.max(out_2, 1)
if pred_1 == 1:
print("第",i+1,"张猫咪图片识别正确")
if pred_1 == 0:
print("第",i+1,"张猫咪图片识别错误")
if pred_2 == 1:
print("第",i+1,"张非猫咪图片识别错误")
if pred_2 == 0:
print("第",i+1,"张非猫咪图片识别正确")
print("\\n")
5.3结果输出及分析
「结果输出」：
第 1 张猫咪图片识别正确
第 1 张非猫咪图片识别正确
第 2 张猫咪图片识别正确
第 2 张非猫咪图片识别正确
第 3 张猫咪图片识别正确
第 3 张非猫咪图片识别错误
第 4 张猫咪图片识别正确
第 4 张非猫咪图片识别错误
第 5 张猫咪图片识别正确
第 5 张非猫咪图片识别正确「结果分析」：
-
猫咪图片：都能识别正确。
-
非猫咪图片：第三张、第四张图片出现了识别错误。
-
对于风景图这种与猫咪图片差别很大的图片，识别器能轻松地辨别；
-
对于老虎、老鼠这些与猫咪在特征上有很多相似地方的动物，猫咪识别器显然还不具备能力将他们很好地区分开来。
-
因此在图片识别领域，我们总是需要更合适的网络结构、更大规模的数据以及更合适的超参数选择。
完整代码
import numpy as np
import h5py as h5
import torch
from torch.utils.data import Dataset,DataLoader
import torch.nn.functional as F
from torch import nn, optim
from torch.autograd import Variable
from torchvision import datasets, transforms
from matplotlib import pyplot as plt
batch_size_train = 209
batch_size_test = 50
learning_rate = 0.0075
num_epoches = 3500
momentum = 0.5
train_transformer = transforms.Compose([
transforms.ToPILImage(),
transforms.RandomResizedCrop(48),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.RandomRotation((-15, 15)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
test_transformer = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize(48),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
class MyDataset(Dataset):
def __init__(self, archive,image,label,transform = None):
self.archive = h5.File(archive, 'r')
self.images = self.archive[image]
self.labels = self.archive[label]
self.transform = transform
def __getitem__(self,index):
image = self.images[index]
label = self.labels[index]
if self.transform is not None:
image = self.transform(image)
return image ,label
def __len__(self):
return len(self.labels)
train_dataset = MyDataset('/home/tian/dataset/catvnocat/train/train_catvnoncat.h5','train_set_x','train_set_y',train_transformer)
test_dataset = MyDataset('/home/tian/dataset/catvnocat/test/test_catvnoncat.h5','test_set_x','test_set_y',test_transformer)
train_loader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size_test, shuffle=False)
class Batch_Net(nn.Module):
def __init__(self, in_dim, n_hidden_1,n_hidden_2,out_dim):
super(Batch_Net, self).__init__()
self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1), nn.ReLU(True),nn.Dropout(0.25))#,nn.Dropout(0.3))
self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d(n_hidden_2), nn.ReLU(True),nn.Dropout(0.25))#,nn.Dropout(0.5))#,nn.Dropout(0.3))#,nn.Dropout(0.5))
self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim),nn.Softmax(dim = 1))
def forward(self, x):
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
return x
#构建模型实例
model = Batch_Net(48*48*3,90,10,2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate,weight_decay= 1e-4)
train_losses = []
train_acc = []
train_counter = [i * len(train_loader)*50 for i in range(num_epoches // 50 + 1)]
test_losses = []
test_acc = []
test_counter = [i * len(test_loader)*50 for i in range(num_epoches // 50 + 1)]
for epoch in range(num_epoches+1):
model.train()
for data in train_loader:
img, label = data
img = img.view(img.size(0), -1)
img = Variable(img)
label = Variable(label)
out = model(img.to(torch.float32))
loss = criterion(out, label)
_, pred = torch.max(out, 1)
acc = (pred == label).sum().item() / (len(train_dataset))
optimizer.zero_grad()
loss.backward()
optimizer.step()
model.eval()
eval_loss = 0
eval_acc = 0
for data in test_loader:
img, label = data
img = img.view(img.size(0), -1)
out = model(img.to(torch.float32))
loss_1 = criterion(out, label)
eval_loss += loss_1.data.item()*label.size(0)
_, pred = torch.max(out, 1)
eval_acc += (pred == label).sum().item() / len(test_dataset)
if epoch%50 == 0:
train_losses.append(loss.data.item())
train_acc.append(acc)
test_losses.append(loss_1.data.item())
test_acc.append(eval_acc)
print('epoch: '.format(epoch))
print('Train Loss: :.4, Train_Acc: :.4'.format(loss.data.item(), acc))
print('Test Loss: :.4f, Test_Acc: :.4f'.format(eval_loss / (len(test_dataset)),eval_acc))
fig = plt.figure()
plt.plot(train_counter, train_losses, color='blue')
plt.plot(test_counter, test_losses, '--',color='red')
plt.legend(['Train Loss', 'Test Loss'], loc='upper right')
plt.xlabel('number of training examples seen')
plt.ylabel('negative log likelihood loss')
fig = plt.figure()
plt.plot(train_counter, train_acc, color='blue')
plt.plot(test_counter, test_acc, '--',color='red')
plt.legend(['Train Acc', 'Test Acc'], loc='lower right')
plt.xlabel('number of training examples seen')
plt.ylabel('Acc')
plt.show()以上是关于Pytorch构建ResNet-50V2的主要内容，如果未能解决你的问题，请参考以下文章
图像分类案例 ResNet50 鸟类图像4分类，附Pytorch完整代码
如何使用 Pytorch 中的预训练权重修改具有 4 个通道作为输入的 resnet 50？
TorchVision中使用FasterRCNN+ResNet50+FPN进行目标检测