VGG-2

VGG实践练习

代码部分

model.py

import torch.nn as nn
import torch
# 官方权重下载地址
model\_urls = {
'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth'
}
class VGG(nn.Module):
def \_\_init\_\_(self, features, num\_classes=1000, init\_weights=False):
super(VGG, self).\_\_init\_\_()
self.features = features # 卷积层提取特征
self.classifier = nn.Sequential( # 全连接层进行分类
nn.Dropout(p=0.5),#随机失活0.5减少过拟合
nn.Linear(512\*7\*7, 2048),#全连接层 注：这里用2048的原因是示例减少跑到数量
nn.ReLU(True),#Relu激活函数
nn.Dropout(p=0.5),#随机失活0.5减少过拟合
nn.Linear(2048, 2048),#全连接层
nn.ReLU(True),#Relu激活函数
nn.Linear(2048, num\_classes)#全连接层
# #原版本
# nn.Dropout(p=0.5), # 随机失活0.5减少过拟合
# nn.Linear(512 \* 7 \* 7, 4096), # 全连接层
# nn.ReLU(True), # Relu激活函数
# nn.Dropout(p=0.5), # 随机失活0.5减少过拟合
# nn.Linear(4096, 40968), # 全连接层
# nn.ReLU(True), # Relu激活函数
# nn.Linear(4096, num\_classes)
# # 全连接层
)
if init\_weights:
self.\_initialize\_weights()
def forward(self, x):
# N x 3 x 224 x 224
x = self.features(x)
# N x 512 x 7 x 7
x = torch.flatten(x, start\_dim=1)#展平处理
# N x 512\*7\*7
x = self.classifier(x)
return x
#初始化函数
def \_initialize\_weights(self):
for m in self.modules():
if isinstance(m, nn.Conv2d):
# nn.init.kaiming\_normal\_(m.weight, mode='fan\_out', nonlinearity='relu')
nn.init.xavier\_uniform\_(m.weight)
if m.bias is not None:
nn.init.constant\_(m.bias, 0)#初始化偏置为0
elif isinstance(m, nn.Linear):
nn.init.xavier\_uniform\_(m.weight)
# nn.init.normal\_(m.weight, 0, 0.01)
nn.init.constant\_(m.bias, 0)#初始化偏置为0
#定义层
def make\_features(cfg: list):#传入变量
layers = []
in\_channels = 3
for v in cfg:
if v == "M":
layers += [nn.MaxPool2d(kernel\_size=2, stride=2)]#池化层
else:
conv2d = nn.Conv2d(in\_channels, v, kernel\_size=3, padding=1)
layers += [conv2d, nn.ReLU(True)]#ReLu函数
in\_channels = v#深度更新
return nn.Sequential(\*layers)#以元组（非关键字参数）传入
# vgg网络模型配置列表（字典），数字表示卷积核个数，'M'表示最大池化层
cfgs = {
'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], # 模型A
'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], # 模型B
'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'], # 模型D
'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], # 模型E
}
# 卷积层提取特征
def make\_features(cfg: list): # 传入的是具体某个模型的参数列表
layers = []
in\_channels = 3 # 输入的原始图像(rgb三通道)
for v in cfg:
# 最大池化层
if v == "M":
layers += [nn.MaxPool2d(kernel\_size=2, stride=2)]
# 卷积层
else:
conv2d = nn.Conv2d(in\_channels, v, kernel\_size=3, padding=1)
layers += [conv2d, nn.ReLU(True)]
in\_channels = v
return nn.Sequential(\*layers) # 单星号(\*)将参数以元组(tuple)的形式导入
def vgg(model\_name="vgg16", \*\*kwargs): # 双星号(\*\*)将参数以字典的形式导入
try:
cfg = cfgs[model\_name]
except:
print("Warning: model number {} not in cfgs dict!".format(model\_name))
exit(-1)
model = VGG(make\_features(cfg), \*\*kwargs)
return model

train.py

import os
import json
import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt
from model import vgg
def main():
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
data\_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# load image
img\_path = "totest.jpg"
assert os.path.exists(img\_path), "file: '{}' dose not exist.".format(img\_path)
img = Image.open(img\_path)
plt.imshow(img)
# [N, C, H, W]
img = data\_transform(img)
# expand batch dimension
img = torch.unsqueeze(img, dim=0)
# read class\_indict
json\_path = './class\_indices.json'
assert os.path.exists(json\_path), "file: '{}' dose not exist.".format(json\_path)
with open(json\_path, "r") as f:
class\_indict = json.load(f)
# create model
model = vgg(model\_name="vgg16", num\_classes=5).to(device)
# load model weights
weights\_path = "./vgg16Net.pth"
assert os.path.exists(weights\_path), "file: '{}' dose not exist.".format(weights\_path)
model.load\_state\_dict(torch.load(weights\_path, map\_location=device))
model.eval()
with torch.no\_grad():
# predict class
output = torch.squeeze(model(img.to(device))).cpu()
predict = torch.softmax(output, dim=0)
predict\_cla = torch.argmax(predict).numpy()
#此处为预测输出多种可能
print\_res = "class: {} prob: {:.3}".format(class\_indict[str(predict\_cla)],
predict[predict\_cla].numpy())
plt.title(print\_res)
print("可能性为：")
for i in range(len(predict)):
print("class: {:10} prob: {:.3}".format(class\_indict[str(i)],
predict[i].numpy()))
print("最大可能为：",class\_indict[str(predict\_cla)], predict[predict\_cla].item())#输出最大可能
plt.show()
if \_\_name\_\_ == '\_\_main\_\_':
main()

predict,py

import os
import sys
import json
import torch
import torch.nn as nn
from torchvision import transforms, datasets
import torch.optim as optim
from tqdm import tqdm
from model import vgg
def main():
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")
print("using {} device.".format(device))
#数据集预处理
data\_transform = {
"train": transforms.Compose([transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
"val": transforms.Compose([transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
data\_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path
image\_path = os.path.join(data\_root, "data\_set", "flower\_data") # flower data set path
assert os.path.exists(image\_path), "{} path does not exist.".format(image\_path)
train\_dataset = datasets.ImageFolder(root=os.path.join(image\_path, "train"),
transform=data\_transform["train"])
train\_num = len(train\_dataset)
# {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
flower\_list = train\_dataset.class\_to\_idx
cla\_dict = dict((val, key) for key, val in flower\_list.items())
# write dict into json file
json\_str = json.dumps(cla\_dict, indent=4)
with open('class\_indices.json', 'w') as json\_file:
json\_file.write(json\_str)
batch\_size = 32
nw = min([os.cpu\_count(), batch\_size if batch\_size > 1 else 0, 8]) # number of workers
print('Using {} dataloader workers every process'.format(nw))
train\_loader = torch.utils.data.DataLoader(train\_dataset,
batch\_size=batch\_size, shuffle=True,
num\_workers=nw)
validate\_dataset = datasets.ImageFolder(root=os.path.join(image\_path, "val"),
transform=data\_transform["val"])
val\_num = len(validate\_dataset)
validate\_loader = torch.utils.data.DataLoader(validate\_dataset,
batch\_size=batch\_size, shuffle=False,
num\_workers=nw)
print("using {} images for training, {} images for validation.".format(train\_num,
val\_num))
# test\_data\_iter = iter(validate\_loader)
# test\_image, test\_label = test\_data\_iter.next()
#实例化网络
model\_name = "vgg16"
net = vgg(model\_name=model\_name, num\_classes=5, init\_weights=True)
net.to(device)
loss\_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.0001)
epochs = 30
best\_acc = 0.0
save\_path = './{}Net.pth'.format(model\_name)#保存路径
train\_steps = len(train\_loader)
for epoch in range(epochs):
# train
net.train()
running\_loss = 0.0
train\_bar = tqdm(train\_loader, file=sys.stdout)
for step, data in enumerate(train\_bar):
images, labels = data
optimizer.zero\_grad()#清空梯度
outputs = net(images.to(device))#正向传播
loss = loss\_function(outputs, labels.to(device))#代价函数
loss.backward()#反向传播
optimizer.step()# 优化器更新参数
# 打印进度
running\_loss += loss.item()
train\_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
epochs,
loss)
# 验证
net.eval()# 验证过程中关闭 Dropout
acc = 0.0 # accumulate accurate number / epoch
with torch.no\_grad():
val\_bar = tqdm(validate\_loader, file=sys.stdout)
for val\_data in val\_bar:
val\_images, val\_labels = val\_data
outputs = net(val\_images.to(device))
predict\_y = torch.max(outputs, dim=1)[1]# 以output中值最大位置对应的索引（标签）作为预测输出
acc += torch.eq(predict\_y, val\_labels.to(device)).sum().item()#预测正确个数统计
val\_accurate = acc / val\_num#计算准确率
print('[epoch %d] train\_loss: %.3f val\_accuracy: %.3f' %
(epoch + 1, running\_loss / train\_steps, val\_accurate))
if val\_accurate > best\_acc:
best\_acc = val\_accurate
torch.save(net.state\_dict(), save\_path)
print('Finished Training')
if \_\_name\_\_ == '\_\_main\_\_':
main()

知识点

model.py

#定义层
def make\_features(cfg: list):#传入变量
layers = []
in\_channels = 3
for v in cfg:
if v == "M":
layers += [nn.MaxPool2d(kernel\_size=2, stride=2)]#池化层
else:
conv2d = nn.Conv2d(in\_channels, v, kernel\_size=3, padding=1)
layers += [conv2d, nn.ReLU(True)]#ReLu函数
in\_channels = v#深度更新
return nn.Sequential(\*layers)#以元组（非关键字参数）传入
# vgg网络模型配置列表（字典），数字表示卷积核个数，'M'表示最大池化层
cfgs = {
'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], # 模型A
'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'], # 模型B
'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'], # 模型D
'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], # 模型E
}

• 利用字典批量定义层
• 并使用make_features进行定义

train.py函数调用

训练脚本与AlexNet基本一致，需要注意的是实例化网络的过程：

model\_name = "vgg16"
net = vgg(model\_name=model\_name, num\_classes=5, init\_weights=True)
12

函数调用关系：

• 注：VGG网络模型较深，需要使用GPU进行训练(而且要内存大一点的GPU，显存过小（小于2G），pytorch会报错GPU内存不足)

遇到问题以及解决方法

• 与AlexNet差不多
• 如果你的显存不过请降低batch和epoch以及model中全连接节点数试一试