CNN入门学习笔记（2）AlexNet

• model.py文件

from torch import nn

class AlexNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.cov1 = nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=1)#输入尺寸为227*227*3 输出为55*55*96
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2)#输入尺寸为55*55*96 输出为27*27*96
        self.cov2 = nn.Conv2d(96, 256, kernel_size=5, padding=2)#输入尺寸为27*27*96 输出为27*27*256
        self.pool2 = nn.MaxPool2d(kernel_size=3, stride=2)#输入尺寸为27*27*256 输出为13*13*256
        self.cov3 = nn.Conv2d(256, 384, kernel_size=3, padding=1)  # 输入尺寸为13*13*256 输出为13*13*384
        self.cov4 = nn.Conv2d(384, 384, kernel_size=3, padding=1)  # 输入尺寸为13*13*384 输出为13*13*384
        self.cov5 = nn.Conv2d(384, 256, kernel_size=3, padding=1)  # 输入尺寸为13*13*384 输出为13*13*256
        self.pool3 =nn.MaxPool2d(kernel_size=3, stride=2)#输入尺寸为13*13*256 输出为5*5*256
        self.feture = nn.Sequential(
            self.cov1,
            nn.ReLU(),
            self.pool1,
            self.cov2,
            nn.ReLU(),
            self.pool2,
            self.cov3,
            nn.ReLU(),
            self.cov4,
            nn.ReLU(),
            self.cov5,
            nn.ReLU(),
            self.pool3
        )


        self.linear1 = nn.Linear(256*5*5,9216)
        self.linear2 = nn.Linear(9216,4096)
        self.linear3 = nn.Linear(4096, 4096)
        self.linear4 = nn.Linear(4096, 10)
        self.classficar = nn.Sequential(
            self.linear1,
            nn.ReLU(),
            nn.Dropout(0.5),
            self.linear2,
            nn.ReLU(),
            nn.Dropout(0.5),
            self.linear3,
            nn.ReLU(),
            nn.Dropout(0.5),
            self.linear4,
        )

    def forward(self,input):
        out = self.feture(input)
        out = out.view(-1,6400)
        out = self.classficar(out)
        return out

AlexNet和LeNet主要区别在以下几点：

1. 传统的LeNet的激活函数使用的是sigmoid，而AlexNet使用的是ReLU函数。
2. 结构不同，AlexNet比LeNet更深。
3. AlexNet引入了Dropout，降低了过拟合的风险。

• train.py

from torch.utils.tensorboard import SummaryWriter
import model
import torchvision
import torch
import torch.nn as nn
import  torchvision.transforms as transforms
from torchvision.transforms.functional import InterpolationMode
transform = transforms.Compose([transforms.Resize((224, 224), interpolation=InterpolationMode.BICUBIC),
                                transforms.ToTensor(),
                                transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.247, 0.2435, 0.2616]) # 此为训练集上的均值与方差
                                ])
train_set = torchvision.datasets.CIFAR10(root='../data', train=True,transform=transform,
                                         download=True)
train_loader = torch.utils.data.DataLoader(train_set,batch_size=256,shuffle=True)
test_set = torchvision.datasets.CIFAR10(root='../data', train=False,transform=transform,
                                        download=True)
test_loader = torch.utils.data.DataLoader(test_set,batch_size=256,shuffle=True)

device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')

epoch = 60
train_num = 0
test_num = 0

writer = SummaryWriter("../logs")
# net = model.AlexNet().to(device)
net = torch.load("../model/Alexnet.pth",map_location=torch.device('cpu'))
loss_fn = nn.CrossEntropyLoss()
optmizer = torch.optim.SGD(net.parameters(),lr=0.01)

for i in range(epoch):
    print("----------------第{}轮训练开始----------------".format(i+1))
    for data in train_loader:
        pics,targets = data
        pics = pics.to(device)
        targets = targets.to(device)
        outputs = net(pics)
        loss = loss_fn(outputs,targets)
        optmizer.zero_grad()
        loss.backward()
        optmizer.step()
        train_num = train_num + 1
        # if train_num %1000 == 0:
        #     print("----->>已训练{}次".format(train_num))

    total_loss = 0
    accuracy = 0

    with torch.no_grad():
        for data in test_loader:
            pics, targets = data
            pics = pics.to(device)
            targets = targets.to(device)
            outputs = net(pics)
            loss = loss_fn(outputs,targets)
            total_loss += loss.item()
            accuracy += (outputs.argmax(1) == targets).sum()

    test_set_size =len(test_set)
    print("整体测试集上的正确率为{}%".format(100*accuracy/test_set_size))
    writer.add_scalar("acc",accuracy,i)

torch.save(net, "../model/Alexnet.pth")
print(">>>模型已保存")

基于cifar10数据集对模型进行训练，并保存为Alexnet.pth文件，最后在测试集上的准确率保持在70%以上，与LeNet相比准确率显著提升。

• detect.py

import cv2
import torch
from PIL import Image
from torchvision.transforms import transforms
from torchvision.transforms.functional import InterpolationMode
import numpy as np
classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')
img = Image.open("../detect_pic/dear1.jpeg")

transform = transforms.Compose([transforms.Resize((224, 224), interpolation=InterpolationMode.BICUBIC),
                                transforms.ToTensor(),
                                transforms.Normalize(mean=[0.4914, 0.4822, 0.4465], std=[0.247, 0.2435, 0.2616]) # 此为训练集上的均值与方差
                                ])
img = transform(img)
net = torch.load("../model/Alexnet.pth")

# net.eval()
with torch.no_grad():
    outputs = net(img)
    predict = torch.max(outputs, dim=1)[1].data.numpy() # 索引即classed中的类别
print(classes[int(predict)])


with torch.no_grad():
    outputs = net(img)
    predict = torch.softmax(outputs,dim=1) # [batch，channel，height，width],这里因为对batch不需要处理

print(predict)

im = cv2.imread("../detect_pic/dear1.jpeg")
cv2.imshow("",im)
cv2.waitKey()

对输入的单张图片进行预测，预测效果如下：