记录一次使用卷积神经网络进行图片二分类的实战

写在前面

笔者目前就读的专业是软件工程，并非人工智能专业，但是由于对人工智能有兴趣，于是课下进行了一些自学。正巧最近有些闲暇时间，就想着使用自学的内容做个小型的实战。这篇文章的主要目的也就是从一个入门者的角度，去记录一下这整个流程，顺便也分享一下自己的心得体会。（这里就假定读者都是有一定的深度学习基础了，一些简单的概念，例如k折交叉验证，就不再具体阐述了）
参考资料采用的是沐神的《动手深度学习》，谷歌一下就能找到这本书的pdf版本

需求分析

在b站上有很多视频，每个视频都会有一个封面，笔者希望能训练出一个模型，这个模型可以帮我们在一大堆视频中找到关于猫的视频。具体而言，就是将封面图片作为输入，将封面中含有猫的确信度作为输出，如果确信度大于50%就认为这个封面里面有猫，从而判断这个视频是和猫相关的。这就相当于一个另类的内容推荐系统了，从一大堆视频中找到自己感兴趣的视频，就是这个模型的实用价值。

准备数据集

数据集是深度学习实战中非常重要而且困难的一个环节，通常在教学中，我们都是使用现成的数据集，来进行模型的训练，例如在CNN教学中最经典的数据集Fashion-MNIST。真正开始自己DIY数据集的时候，摆在我们面前的难题就有2个：

如何选择负例数据？
这个问题确实困扰了作为入门者的笔者一段时间，因为正例非常好找，只需要找一大堆包含猫的图片即可，但是负例呢？只需要不包含猫的图片都行吗？如果是的话，那一大堆纯色图也可以作为负例吗？
在使用教学用的数据集，例如Fashion-MNIST时，我们并没有思考这个问题，因为Fashion-MNIST中的数据只有10个特征都很鲜明的类别，例如，如果我们想要判断一张图是不是衬衫，表面上我们做的事是训练模型来得出这张图是衬衫和这张图不是衬衫的可信度，但实际上我们做的事是，训练模型来得出这张图是衬衫和这张图是大衣，凉鞋，…等另外9个类别物品的可信度，但如果按照这样的思路，那我们在找负例的时候，是不是需要穷举所有图片中不包含猫的情况？例如一些包含狗的图片，一些包含汽车的图片…，如果是这样的话，那就不具备可操作性了，因为工作量太大了。
笔者翻了大量资料，也没有这方面的回答，如果读者对这个问题有所了解，还恳请在评论区赐教。
最终笔者采取了一个比较妥协的方法，就是在b站里面随机找视频，然后保存封面作为负例，在获取了一定量的封面后，笔者再进行人工筛选，剔除掉包含猫的图片。
如何获取到大量的图片？
这一点就比较简单了，只需要使用python爬虫，来爬取b站视频封面即可，具体代码由于可能涉及到版权问题，就不放出来了。
需要注意的一点是，这一步还需要在下载图片后对图片进行缩放，因为之后输入模型的图片的大小都是统一的大小，这里笔者设定的大小是240x240。
处理图片可以使用opencv-python库，安装方法为pip install opencv-python，图片的下载和缩放可以用下面的代码解决（可以稍微注意一下，opencv中读入的图片是以numpy中的ndarray的形式保存的）

def save_img(url,path):
    #Download image
    res = requests.get(url)
    img = res.content
    with open(path, "wb") as f:
        f.write(img)
    print("Downloaded " + path)

    #Resize image
    img = cv2.imread(path)
    img = cv2.resize(img, dsize=(240, 240), fx=1, fy=1, interpolation=cv2.INTER_LINEAR)
    cv2.imwrite(path, img, [cv2.IMWRITE_JPEG_QUALITY, 100])
    print("Processed " + path)

搭建模型

接下来就正式的写深度学习代码了，笔者使用的框架是pytorch
最开始搭建的模型的网络结构参考了著名的LeNet，也就是最开始使用卷积神经网络进行手写数字识别的网络，具体网络结构如下
在这里插入图片描述
激活函数均使用的ReLU，代码表现为

def get_net():
    return nn.Sequential(
        nn.Conv2d(3, 6, kernel_size=45), nn.ReLU(),
        nn.AvgPool2d(kernel_size=18, stride=2),
        nn.Conv2d(6, 9, kernel_size=20), nn.ReLU(),
        nn.AvgPool2d(kernel_size=9, stride=2),
        nn.Flatten(),
        nn.Linear(9216, 544), nn.ReLU(),
        nn.Linear(544, 68),nn.ReLU(),
        nn.Linear(68, 2), nn.Softmax()
    ).to(device)

整个项目的完整代码如下

import random

import torch
from torch import nn

from matplotlib import pyplot as plt
import numpy as np
import cv2
import os

from my_dataset import get_dataloader

device="cuda"
img_size=240


def read_img_to_numpy(img_path):
    img = cv2.imread(img_path)/128  #为了进行归一化
    img = np.concatenate(
        (img[:, :, 0].reshape((1, img_size, img_size)), img[:, :, 1].reshape((1, img_size, img_size)), img[:, :, 2].reshape((1, img_size, img_size))),
        axis=0)
    return img


def read_all_img():
    positive_dir="samples/positive/"
    negative_dir="samples/negative/"

    features=None
    labels=[]

    names=[positive_dir+name for name in os.listdir(positive_dir)]+[negative_dir+name for name in os.listdir(negative_dir)]
    indexes=list(range(len(names)))
    random.shuffle(indexes)

    for index in indexes:
        name=names[index]
        if positive_dir in name:
            label=1
        else:
            label=0

        labels.append(label)
        img = read_img_to_numpy(name).reshape(1, 3, img_size, img_size)
        img = torch.tensor(img,dtype=torch.float32, device=device)
        if features is None:
            features=img
        else:
            features=torch.concat((features,img))

    labels=torch.tensor(labels,dtype=torch.int64,device=device)

    return features,labels


def get_net():
    return nn.Sequential(
        nn.Conv2d(3, 6, kernel_size=45), nn.ReLU(),
        nn.AvgPool2d(kernel_size=18, stride=2),
        nn.Conv2d(6, 9, kernel_size=20), nn.ReLU(),
        nn.AvgPool2d(kernel_size=9, stride=2),
        nn.Flatten(),
        nn.Linear(9216, 544), nn.ReLU(),
        nn.Linear(544, 68),nn.ReLU(),
        nn.Linear(68, 2), nn.Softmax()
    ).to(device)


def eval_accuracy(net,test_iter):
    total=0
    accurate=0
    for X,y in test_iter:
        y_hat=net(X).argmax(axis=1)

        e=(y==y_hat)
        accurate+=e.sum()
        total+=len(X)

    return accurate/total


def train_for_k_fold(net,train_iter,test_iter,lr,epochs,fold):
    def init_weights(m):
        if type(m)==nn.Linear or type(m)==nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    optimizer=torch.optim.Adam(net.parameters(),lr=lr)
    loss=nn.CrossEntropyLoss()
    loss_record=[]
    accuracy_record=[]
    for epoch in range(epochs):
        net.train()
        for X,y in train_iter:
            optimizer.zero_grad()
            y_hat=net(X)
            l=loss(y_hat,y)
            l.backward()
            optimizer.step()
        loss_record.append(l.to("cpu").detach().numpy())
        accuracy=eval_accuracy(net,test_iter)
        accuracy_record.append(accuracy.to("cpu").detach().numpy())

        print(f"Epoch {epoch}, loss {l}, accuracy {accuracy}")
    #plot
    print(f"Loss {loss_record}")
    print(f"Accuracy {accuracy_record}")
    epoch=np.arange(len(loss_record))
    plt.title(f"fold {fold} lr {lr}, epochs {epochs}")
    plt.plot(epoch,np.array(loss_record),label="Loss")
    plt.plot(epoch,np.array(accuracy_record),label="Accuracy")
    plt.legend()
    plt.savefig(f"fold_{fold}_lr_{lr}_epochs_{epochs}.png")


def k_fold(k=4,lr=0.9,epochs=10,batch_size=3):
    features, labels = read_all_img()
    total_len = len(features)
    fold_len = int(total_len / k)

    for fold in range(k):
        print(f"Start fold {fold}")
        test_start = fold_len * fold
        test_end = min((fold + 1) * fold_len, total_len)

        test_features = features[test_start:test_end]
        test_labels = labels[test_start:test_end]

        train_features = torch.concat((features[:test_start], features[test_end:]))
        train_labels = torch.concat((labels[:test_start], labels[test_end:]))

        train_iter=get_dataloader(train_features,train_labels,batch_size)
        test_iter=get_dataloader(test_features,test_labels,batch_size)

        net = get_net()
        train_for_k_fold(net, train_iter, test_iter, lr, epochs,fold)

        #save net
        torch.save(net.state_dict(),f"fold_{fold}.params")


k_fold(lr=1,epochs=100,batch_size=10)

其中，my_dataset.py这个工具文件的代码如下

import torch
from torch.utils import data


class ArrayDataset(data.Dataset):
    def __init__(self,features,labels):
        self.features=features
        self.labels=labels

    def __getitem__(self, item):
        return self.features[item],self.labels[item]


    def __len__(self):
        return len(self.features)


def get_dataloader(features,labels,batch_size,device="cuda"):
    if not torch.is_tensor(features):
        features=torch.tensor(features,dtype=torch.float32,device=device)
        labels=torch.tensor(labels,dtype=torch.int64,device=device)

    return data.DataLoader(ArrayDataset(features,labels),batch_size,shuffle=True)

上面的代码实现的功能主要是做k折交叉验证来帮助我们寻找合适的超参数，正式的训练代码只需要在这基础上简单的改动即可，这里就不放出来了

训练模型

在训练模型阶段，笔者遇到了各种各样的问题，这也是整个过程中最折腾的部分

问题1：显卡显存不足

之前我们使用的模型和数据集都非常简单，所以2G的GTX1050完全能够胜任，但如今数据量是之前的几十倍，一运行起来，数据还没有全部加载完成，就报了显存不足，如下图所示
在这里插入图片描述
这个时候就只能去网上租借GPU服务器了，笔者找到个平台，注册就送10元代金券，目前总共花费了10.3元，其中10元还是平台提供的代金券抵扣的，而且这个平台的计费方式是按使用时长计费，也就是开机时计费，关机后数据会保留，但是不会计费，这对于我们这种只需要短时间使用GPU的学生是非常划算的。为了避免有打广告的嫌疑，平台具体的名字就不放出来了，如果大家有兴趣可以私信笔者
至此，显存不足的问题算是解决了，写到这里，有了一点感悟，这也是沐神在书中提到的一点，早期人工智能领域的发展速度没有当今快，有一个很大的原因就是硬件资源不足。在2000年左右，可能一块2GB显存的显卡都是很贵的硬件，但是后面跑AlexNet至少也需要20GB的显存，所以可见在早期时候，像AlexNet之类的网络，即使能够实现，也很难展开运算

问题2：模型对所有样本的输出相同

相信这是初学者都会碰到的情况，就是无论输入是什么，模型最终的输出都是一样的
具体回到我们这个实战，在训练过程中，我发现每一个epoch的准确率都是相等的，这显然很异常，所以我修改了一下代码，在eval_accuracy函数处做了如下修改

        # y_hat=net(X).argmax(axis=1)
        y_hat=net(X)
        print(y_hat)
        y_hat=y_hat.argmax(axis=1)

这段代码的目的就是为了打印出y_hat，也就是输入为正例和负例的确信度，也就是softmax层的输出
结果输出很奇怪，所有的输出都是一样的，就像下面这张图中的结果
有了上次处理Dead ReLU的经验，这次可以基本确定是学习率太大了，所以尝试把学习率调到1e-3，但是还是一样的结果，最后把学习率调到1e-8，终于不再是清一色的0和1了，但是收敛速度还是略慢，所以继续调高学习率，最终确定为1e-5是个比较合适的值，可以看到，调为1e-5后，输出就正常了
在这里插入图片描述
从这里可以总结出的一个经验就是，遇到输出全部一样的情况，尽管把学习率往小调，直到输出正常，然后再逐步往大调，来提高学习速率，同时需要先解决欠拟合，再考虑解决过拟合

训练结果

最终k折交叉验证的结果如下图（就只取第一个fold的结果展示了，另外3个fold也是类似的）
在这里插入图片描述
最终测试下来，准确率在80%左右，这已经基本达到我的预期了，因为至少这是一个能用的模型了

模型改进

后面笔者也尝试通过更改优化器，学习率，学习周期等方法来增加准确率，但是都没能成功
推测一方面是数据集不够多，例如一张图片里的内容是一个楼梯，但是反例中并没有出现楼梯，所以就会造成反例的确信度降低
另一方面，这个可能是这个网络结构的上限就是如此了，所以我们或许可以通过更改网络结构来提高准确率
其中扩增数据集的工作量较大，而且效果不显著，所以就不再考虑了，这里主要尝试通过修改网络结构来提高准确率
新的网络结构参考了沐神书中提到的AlexNet
在这里插入图片描述
具体代码实现为，将get_net函数修改为如下

def get_net():
    return nn.Sequential(
        nn.Conv2d(3, 96, kernel_size=11,stride=4,padding=1), nn.ReLU(),
        nn.MaxPool2d(kernel_size=3, stride=2),
        nn.Conv2d(96, 256, kernel_size=5,padding=2), nn.ReLU(),
        nn.MaxPool2d(kernel_size=3, stride=2),
        nn.Conv2d(256,384,kernel_size=3,padding=1),nn.ReLU(),
        nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
        nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
        nn.MaxPool2d(kernel_size=3,stride=2),
        nn.Flatten(),
        nn.Linear(9216, 4096), nn.ReLU(),
        nn.Dropout(p=0.5),
        nn.Linear(4096, 4096), nn.ReLU(),
        nn.Dropout(p=0.5),
        nn.Linear(4096, 2), nn.Softmax()
    ).to(device)

可以看到，这个网络结构更为复杂了，所以需要的显存也更大了，在实际测试中，10GB的RTX3080已经顶不住了，需要换上24GB的RTX3090来进行训练，最终训练出的模型在测试数据集中的表现达到了87%
其实这并不奇怪，更多的网络参数就意味着这个模型的拟合能力更强，但同时过拟合的可能性也越大，这也是需要我们去权衡的一个trade off

写在最后

这是笔者第一次进行人工智能方向的实战，能做出成果，自然是非常开心的。在这过程中，最深的感悟有两点：

数据为王
虽然深度学习不需要像早起机器学习一样，去精心处理数据，但是大量且合理的数据仍然是有必要的，还记得在kaggle上做过一个数字识别的题目，当时kaggle给出的训练数据集中包含了40000个，即使是使用比较简单的LeNet，也能做到91%的识别准确率，所以可见，如果增大数据量，这个模型是有进步空间的
硬件决定上限
前面也提到过了，在人工智能发展的早期，硬件资源制约了这个领域的发展。在那个显卡显存可能只有512MB的时代，如果要跑AlexNet这种光是模型参数都有221MB的模型，应该是非常困难的

最后，这篇文章中可能有一些错误或者描述不清的地方，欢迎大家在评论区里批评指正，也欢迎大家在评论区进行探讨与交流