AlexNet-3

AlexNet实践练习

代码部分

文件预处理

import os
from shutil import copy, rmtree
import random
def mk\_file(file\_path: str):
if os.path.exists(file\_path):
# 如果文件夹存在，则先删除原文件夹在重新创建
rmtree(file\_path)
os.makedirs(file\_path)
def main():
# 保证随机可复现
random.seed(0)
# 将数据集中10%的数据划分到验证集中
split\_rate = 0.1
# 指向你解压后的flower\_photos文件夹
cwd = os.getcwd()
data\_root = os.path.join(cwd, "flower\_data")
origin\_flower\_path = os.path.join(data\_root, "flower\_photos")
assert os.path.exists(origin\_flower\_path), "path '{}' does not exist.".format(origin\_flower\_path)
flower\_class = [cla for cla in os.listdir(origin\_flower\_path)
if os.path.isdir(os.path.join(origin\_flower\_path, cla))]
# 建立保存训练集的文件夹
train\_root = os.path.join(data\_root, "train")
mk\_file(train\_root)
for cla in flower\_class:
# 建立每个类别对应的文件夹
mk\_file(os.path.join(train\_root, cla))
# 建立保存验证集的文件夹
val\_root = os.path.join(data\_root, "val")
mk\_file(val\_root)
for cla in flower\_class:
# 建立每个类别对应的文件夹
mk\_file(os.path.join(val\_root, cla))
for cla in flower\_class:
cla\_path = os.path.join(origin\_flower\_path, cla)
images = os.listdir(cla\_path)
num = len(images)
# 随机采样验证集的索引
eval\_index = random.sample(images, k=int(num\*split\_rate))
for index, image in enumerate(images):
if image in eval\_index:
# 将分配至验证集中的文件复制到相应目录
image\_path = os.path.join(cla\_path, image)
new\_path = os.path.join(val\_root, cla)
copy(image\_path, new\_path)
else:
# 将分配至训练集中的文件复制到相应目录
image\_path = os.path.join(cla\_path, image)
new\_path = os.path.join(train\_root, cla)
copy(image\_path, new\_path)
print("\r[{}] processing [{}/{}]".format(cla, index+1, num), end="") # processing bar
print()
print("processing done!")
if \_\_name\_\_ == '\_\_main\_\_':
main()

model.py

#导入包
import torch.nn as nn
import torch
#创建网络
class AlexNet(nn.Module):
def \_\_init\_\_(self, num\_classes=1000, init\_weights=False):
super(AlexNet, self).\_\_init\_\_()
# 用nn.Sequential()将网络打包成一个模块，精简代码
# '''
# 为了加快训练，代码只使用了一半的网络参数，相当于只用了原论文中网络结构的一半部分（正好原论文中用的双GPU，我的电脑只有一块GPU）
# 后来我又用完整网络跑了遍，发现一半参数跟完整参数的训练结果acc相差无几）
# '''
self.features = nn.Sequential( # 卷积层提取图像特征
nn.Conv2d(3, 48, kernel\_size=11, stride=4, padding=2), # input[3, 224, 224] output[48, 55, 55]
# '''
# 此处paddding=2 是将四周补上2列0；
# padding=（a,b）a代表上下补0行数，b代表左右补0列数；
# 若要实现论文中padding效果 可以使用nn.ZeroPad(a,b,c,d)上下左右
# '''
nn.ReLU(inplace=True), # 直接修改覆盖原值，节省运算内存
nn.MaxPool2d(kernel\_size=3, stride=2), # output[48, 27, 27]
nn.Conv2d(48, 128, kernel\_size=5, padding=2), # output[128, 27, 27]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel\_size=3, stride=2), # output[128, 13, 13]
nn.Conv2d(128, 192, kernel\_size=3, padding=1), # output[192, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(192, 192, kernel\_size=3, padding=1), # output[192, 13, 13]
nn.ReLU(inplace=True),
nn.Conv2d(192, 128, kernel\_size=3, padding=1), # output[128, 13, 13]
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel\_size=3, stride=2), # output[128, 6, 6]
)
self.classifier = nn.Sequential( # 全连接层对图像分类
nn.Dropout(p=0.5), # Dropout 随机失活神经元，默认比例为0.5
nn.Linear(128 \* 6 \* 6, 2048),
nn.ReLU(inplace=True),
nn.Dropout(p=0.5),
nn.Linear(2048, 2048),
nn.ReLU(inplace=True),
nn.Linear(2048, num\_classes),#num\_classes 最后类别个数
)
#卷积池化层提取图像特征，全连接层进行图像分类，代码中写成两个模块，方便调用
if init\_weights:#初始化权重
self.\_initialize\_weights()
# 前向传播过程
def forward(self, x):
x = self.features(x)
x = torch.flatten(x, start\_dim=1) # 展平后再传入全连接层
x = self.classifier(x)
return x#返回预测输出
# 网络权重初始化，实际上 pytorch 在构建网络时会自动初始化权重
def \_initialize\_weights(self):
for m in self.modules():#继承自父类nn.modules 遍历所有结构
if isinstance(m, nn.Conv2d): # 若是卷积层
nn.init.kaiming\_normal\_(m.weight, mode='fan\_out', # 用（何）kaiming\_normal\_法初始化权重w
nonlinearity='relu')
if m.bias is not None:
nn.init.constant\_(m.bias, 0) # 初始化偏重为0
elif isinstance(m, nn.Linear): # 若是全连接层
nn.init.normal\_(m.weight, 0, 0.01) # 正态分布初始化，方差=0.01
nn.init.constant\_(m.bias, 0) # 初始化偏重为0

train.py

#导入包
import os
import sys
import json
import torch
import torch.nn as nn
from torchvision import transforms, datasets, utils
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
from tqdm import tqdm
from model import AlexNet
def main():
# 运算资源调度
device = torch.device("cuda:0" if torch.cuda.is\_available() else "cpu")#调用 第一块 gpu
print("using {} device.".format(device))
#数据处理
data\_transform = {
#训练集处理
"train": transforms.Compose([transforms.RandomResizedCrop(224),# 随机裁剪，再缩放成 224×224
transforms.RandomHorizontalFlip(),# 水平方向随机翻转，概率为 0.5, 即一半的概率翻转, 一半的概率不翻转
transforms.ToTensor(),#标准化格式转换 ToTensor将文件高\*宽\*深度转换诶 深度\*高\*宽
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),#标准化
#验证集处理
"val": transforms.Compose([transforms.Resize((224, 224)), # cannot 224, must (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(), "../..")) # 获取数据集根目录；"../.."返回上上层目录
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())#遍历并反转键值对
# 此时为{0:'daisy', 1:'dandelion', 2:'roses', 3:'sunflower', 4:'tulips'}
# 存储索引字典为json格式
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=True,
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\_\_()#.next在部分版本不可以解决方案\_\_next\_\_
#
# def imshow(img):
# img = img / 2 + 0.5 # unnormalize
# npimg = img.numpy()
# plt.imshow(np.transpose(npimg, (1, 2, 0)))
# plt.show()
#
# print(' '.join('%5s' % cla\_dict[test\_label[j].item()] for j in range(4)))
# imshow(utils.make\_grid(test\_image))
net = AlexNet(num\_classes=5, init\_weights=True)# 实例化网络（输出类型为5，初始化权重）
net.to(device)# 分配网络到指定的设备（GPU/CPU）训练
loss\_function = nn.CrossEntropyLoss()#定义损失函数交叉熵损失
# pata = list(net.parameters())#查看模型参数
optimizer = optim.Adam(net.parameters(), lr=0.0002)#优化参数；学习率0.002
epochs = 10#迭代次数
save\_path = './AlexNet.pth'#保存权重
best\_acc = 0.0#最佳准确率
train\_steps = len(train\_loader)
for epoch in range(epochs):
# 开始训练
net.train()#让训练时使用dropout方法而预测时不使用
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()

predict.py

import torch
from model import AlexNet
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt
import json
# 预处理
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 = Image.open("totest.jpg")
plt.imshow(img)#展示测试图片
# [N, C, H, W]
img = data\_transform(img)
# expand batch dimension
img = torch.unsqueeze(img, dim=0)
# read class\_indict
try:
json\_file = open('./class\_indices.json', 'r')
class\_indict = json.load(json\_file)
except Exception as e:
print(e)
exit(-1)
# create model
model = AlexNet(num\_classes=5)
# load model weights
model\_weight\_path = "./AlexNet.pth"#加载训练好的模型权重
model.load\_state\_dict(torch.load(model\_weight\_path))
model.eval()# 关闭 Dropout
with torch.no\_grad():
# predict class
output = torch.squeeze(model(img)) # 将输出压缩，即压缩掉 batch 这个维度
predict = torch.softmax(output, dim=0)
predict\_cla = torch.argmax(predict).numpy()
print(class\_indict[str(predict\_cla)], predict[predict\_cla].item())
plt.show()

遇到问题以及解决方法

数据集下载以及加载

1. 数据集下载

2. 数据集分割部分数据集需要自行分割出训练集，验证集，测试集

3. 加载路径

   data\_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # 获取数据集根目录；"../.."返回上上层目录

奇怪的报错

AttributeError: ‘_MultiProcessingDataLoaderIter‘ object has no attribute ‘next‘ 问题解决

表示找不到这个方法

问题原因：

test\_image,test\_label=test\_data\_iter.next()

这句中**.next找不到 改为.__next__**即可