pytorch实现kaggle猫狗识别

参考：https://blog.csdn.net/weixin_37813036/article/details/90718310

kaggle是一个为开发商和数据科学家提供举办机器学习竞赛、托管数据库、编写和分享代码的平台，在这上面有非常多的好项目、好资源可供机器学习、深度学习爱好者学习之用。碰巧最近入门了一门非常的深度学习框架：pytorch（如果你对pytorch不甚了解，请点击这里），所以今天我和大家一起用pytorch实现一个图像识别领域的入门项目：猫狗图像识别。
深度学习的基础就是数据，咱们先从数据谈起。此次使用的猫狗分类图像一共25000张，猫狗分别有12500张。下载地址：https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition/data我们先来简单的看看都是一些什么图片。我们从下载文件里可以看到有两个文件夹：train和test1，分别用于训练和测试。打开train文件夹可以看到有25000 张小猫小狗的图片，图片名字为cat.0.jpg，cat.1.jpg，dog.0.jpg，dog.1.jpg。

 

仔细看小猫小狗，可以发现它们姿态不一，有的站着，有的眯着眼睛，有的甚至和其他可识别物体比如桶、人混在一起。同时，小猫们的图片尺寸也不一致，有的是竖放的长方形，有的是横放的长方形，但我们最终需要是合理尺寸的图片。所以需要进行图片处理，并把图片转化成Tensor作为模型的输入。代码如下：

data_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

train_dataset = datasets.ImageFolder(root='./data2/train/', 
                                     transform=data_transform)
train_loader = torch.utils.data.DataLoader(train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True,
                                           num_workers=num_workers)

为方便训练过程，需要把训练集进行处理：把猫狗的图片分别放在cat，dog文件夹中，并划分出一部分图片作为测试集（与下载的测试集不同）。代码如下：

#接下来的数据是把原训练集90%的数据做训练，10%做测试集，其中把分为训练集的数据内的猫和狗分开，分为测试集的数据的猫和狗进行分开保存在新的各自的目录下
# kaggle原始数据集地址
original_dataset_dir = 'D:\Code\Python\Kaggle-Dogs_vs_Cats_PyTorch-master\data\train'  #训练集地址
total_num = int(len(os.listdir(original_dataset_dir)) )  #训练集数据总数，包含猫和狗
random_idx = np.array(range(total_num))
np.random.shuffle(random_idx)#打乱图片顺序

# 待处理的数据集地址
base_dir = 'D:\Code\dogvscat\data2' #把原训练集数据分类后的数据存储在该目录下
if not os.path.exists(base_dir):
    os.mkdir(base_dir)

# 训练集、测试集的划分
sub_dirs = ['train', 'test']
animals = ['cats', 'dogs']
train_idx = random_idx[:int(total_num * 0.9)] #打乱后的数据的90%是训练集，10是测试集
test_idx = random_idx[int(total_num * 0.9):int(total_num * 1)]
numbers = [train_idx, test_idx]
for idx, sub_dir in enumerate(sub_dirs):
    dir = os.path.join(base_dir, sub_dir)#'D:\Code\dogvscat\data2\train'或'D:\Code\dogvscat\data2\test'
    if not os.path.exists(dir):
        os.mkdir(dir)

    animal_dir = ""

    #fnames = ['.{}.jpg'.format(i) for i in numbers[idx]]
    fnames = ""
    if sub_dir == 'train':
        idx = 0
    else:
        idx =1
    for i in numbers[idx]:
        #print(i)
        if i>=12500:#把数据保存在dogs目录下
            fnames = str('dog'+'.{}.jpg'.format(i))
            animal_dir = os.path.join(dir,'dogs')

            if not os.path.exists(animal_dir):
                os.mkdir(animal_dir)
        if i<12500:#图片是猫，数据保存在cats目录下
            fnames = str('cat'+'.{}.jpg'.format(i))
            animal_dir = os.path.join(dir, 'cats')
            if not os.path.exists(animal_dir):
                os.mkdir(animal_dir)
        src = os.path.join(original_dataset_dir, str(fnames)) #原数据地址
        #print(src)
        dst = os.path.join(animal_dir, str(fnames))#新地址
        #print(dst)
        shutil.copyfile(src, dst)#复制


        # 验证训练集、测试集的划分的照片数目
    print(dir + ' total images : %d' % (len(os.listdir(dir+'\dogs'))+len(os.listdir(dir+'\cats'))))
    # coding=utf-8

紧接着我们了解一下特别适用于图像识别领域的神经网络：卷积神经网络。学习过神经网络的同学可能或多或少地听说过卷积神经网络。这是一种典型的多层神经网络，擅长处理图像特别是大图像的相关机器学习问题。卷积神经网络通过一系列的方法，成功地将大数据量的图像识别问题不断降维，最终使其能够被训练。CNN最早由Yann LeCun提出并应用在手写体识别上。一个典型的CNN网络架构如下：

这是一个典型的CNN架构，由卷基层、池化层、全连接层组合而成。其中卷基层与池化层配合，组成多个卷积组，逐层提取特征，最终完成分类。听到上述一连串的术语如果你有点蒙了，也别怕，因为这些复杂、抽象的技术都已经在pytorch中一一实现，我们要做的不过是正确的调用相关函数。

# 创建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 53 * 53, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 2)

    def forward(self, x):
        x = self.maxpool(F.relu(self.conv1(x)))
        x = self.maxpool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 53 * 53)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)

        return x
class Net2(nn.Module):
    def __init__(self):
        super(Net2, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 53 * 53, 1024)
        torch.nn.Dropout(0.5)
        self.fc2 = nn.Linear(1024, 512)
        torch.nn.Dropout(0.5)
        self.fc3 = nn.Linear(512, 2)

    def forward(self, x):
        x = self.maxpool(F.relu(self.conv1(x)))
        x = self.maxpool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 53 * 53)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)

        return x

我们从conv1说起。conv1实际上就是定义一个卷积层，3,6,5分别是什么意思？3代表的是输入图像的像素数组的层数，一般来说就是你输入的图像的通道数，比如这里使用的小猫图像都是彩色图像，由R、G、B三个通道组成，所以数值为3；6代表的是我们希望进行6次卷积，每一次卷积都能生成不同的特征映射数组，用于提取小猫和小狗的6种特征。每一个特征映射结果最终都会被堆叠在一起形成一个图像输出，再作为下一步的输入；5就是过滤框架的尺寸，表示我们希望用一个5 * 5的矩阵去和图像中相同尺寸的矩阵进行点乘再相加，形成一个值。定义好了卷基层，我们接着定义池化层。池化层所做的事说来简单，其实就是因为大图片生成的像素矩阵实在太大了，我们需要用一个合理的方法在降维的同时又不失去物体特征，所以深度学习学者们想出了一个称为池化的技术，说白了就是从左上角开始，每四个元素(2 * 2)合并成一个元素，用这一个元素去代表四个元素的值，所以图像体积一下子降为原来的四分之一。再往下一行，我们又一次碰见了一个卷积层：conv2,和conv1一样，它的输入也是一个多层像素数组，输出也是一个多层像素数组，不同的是这一次完成的计算量更大了，我们看这里面的参数分别是6，16，5。之所以为6是因为conv1的输出层数为6，所以这里输入的层数就是6；16代表conv2的输出层数，和conv1一样，16代表着这一次卷积操作将会学习小猫小狗的16种映射特征，特征越多理论上能学习的效果就越好，大家可以尝试一下别的值，看看效果是否真的编变好。conv2使用的过滤框尺寸和conv1一样，所以不再重复。

关于53这个数字可以根据（（n+2p-f）/ s）+1计算出来。而三个全连接层所做的事很类似，就是不断训练，最后输出一个二分类数值。net类的forward函数表示前向计算的整个过程。forward接受一个input，返回一个网络输出值，中间的过程就是一个调用init函数中定义的层的过程。F.relu是一个激活函数，把所有的非零值转化成零值。此次图像识别的最后关键一步就是真正的循环训练操作。

进行训练的代码：

def train():

    for epoch in range(epochs):
        running_loss = 0.0
        train_correct = 0
        train_total = 0
        for step, data in enumerate(train_loader, 0):#第二个参数表示指定索引从0开始
            inputs, train_labels = data
            if use_gpu:
                inputs, labels = Variable(inputs.cuda()), Variable(train_labels.cuda())
            else:
                inputs, labels = Variable(inputs), Variable(train_labels)
            optimizer.zero_grad()
            outputs = net(inputs)
            _, train_predicted = torch.max(outputs.data, 1)  #返回每一行最大值的数值和索引，索引对应分类
            train_correct += (train_predicted == labels.data).sum()
            loss = cirterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            train_total += train_labels.size(0)

        print('train %d epoch loss: %.3f  acc: %.3f ' % (
            epoch + 1, running_loss / train_total, 100 * train_correct / train_total))
        # 模型测试
        correct = 0
        test_loss = 0.0
        test_total = 0
        test_total = 0
        net.eval() #测试的时候整个模型的参数不再变化
        for data in test_loader:
            images, labels = data
            if use_gpu:
                images, labels = Variable(images.cuda()), Variable(labels.cuda())
            else:
                images, labels = Variable(images), Variable(labels)
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            loss = cirterion(outputs, labels)
            test_loss += loss.item()
            test_total += labels.size(0)
            correct += (predicted == labels.data).sum()

完整的代码如下

# coding=utf-8
import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
from torch.utils.data import Dataset
from torchvision import transforms, datasets, models
import shutil
from matplotlib import pyplot as plt
# 随机种子设置
random_state = 42
np.random.seed(random_state)
#接下来的数据是把原训练集90%的数据做训练，10%做测试集，其中把分为训练集的数据内的猫和狗分开，分为测试集的数据的猫和狗进行分开保存在新的各自的目录下
# kaggle原始数据集地址
original_dataset_dir = 'D:\Code\Python\Kaggle-Dogs_vs_Cats_PyTorch-master\data\train'  #训练集地址
total_num = int(len(os.listdir(original_dataset_dir)) )  #训练集数据总数，包含猫和狗
random_idx = np.array(range(total_num))
np.random.shuffle(random_idx)#打乱图片顺序

# 待处理的数据集地址
base_dir = 'D:\Code\dogvscat\data2' #把原训练集数据分类后的数据存储在该目录下
if not os.path.exists(base_dir):
    os.mkdir(base_dir)

# 训练集、测试集的划分
sub_dirs = ['train', 'test']
animals = ['cats', 'dogs']
train_idx = random_idx[:int(total_num * 0.9)] #打乱后的数据的90%是训练集，10是测试集
test_idx = random_idx[int(total_num * 0.9):int(total_num * 1)]
numbers = [train_idx, test_idx]
for idx, sub_dir in enumerate(sub_dirs):
    dir = os.path.join(base_dir, sub_dir)#'D:\Code\dogvscat\data2\train'或'D:\Code\dogvscat\data2\test'
    if not os.path.exists(dir):
        os.mkdir(dir)

    animal_dir = ""

    #fnames = ['.{}.jpg'.format(i) for i in numbers[idx]]
    fnames = ""
    if sub_dir == 'train':
        idx = 0
    else:
        idx =1
    for i in numbers[idx]:
        #print(i)
        if i>=12500:#把数据保存在dogs目录下
            fnames = str('dog'+'.{}.jpg'.format(i))
            animal_dir = os.path.join(dir,'dogs')

            if not os.path.exists(animal_dir):
                os.mkdir(animal_dir)
        if i<12500:#图片是猫，数据保存在cats目录下
            fnames = str('cat'+'.{}.jpg'.format(i))
            animal_dir = os.path.join(dir, 'cats')
            if not os.path.exists(animal_dir):
                os.mkdir(animal_dir)
        src = os.path.join(original_dataset_dir, str(fnames)) #原数据地址
        #print(src)
        dst = os.path.join(animal_dir, str(fnames))#新地址
        #print(dst)
        shutil.copyfile(src, dst)#复制


        # 验证训练集、测试集的划分的照片数目
    print(dir + ' total images : %d' % (len(os.listdir(dir+'\dogs'))+len(os.listdir(dir+'\cats'))))
    # coding=utf-8

# 配置参数
random_state = 1
torch.manual_seed(random_state)  # 设置随机数种子，确保结果可重复
torch.cuda.manual_seed(random_state)# #为GPU设置种子用于生成随机数，以使得结果是确定的
torch.cuda.manual_seed_all(random_state) #为所有GPU设置种子用于生成随机数，以使得结果是确定的
np.random.seed(random_state)
# random.seed(random_state)

epochs = 10 # 训练次数
batch_size = 4  # 批处理大小
num_workers = 0  # 多线程的数目
use_gpu = torch.cuda.is_available()
PATH='D:\Code\dogvscat\model.pt'
# 对加载的图像作归一化处理， 并裁剪为[224x224x3]大小的图像
data_transform = transforms.Compose([
    transforms.Resize(256),#重置图像分辨率
    transforms.CenterCrop(224), #中心裁剪
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  #归一化
])

train_dataset = datasets.ImageFolder(root='D:\Code\dogvscat\data2\train',
                                     transform=data_transform)
print(train_dataset)
train_loader = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=num_workers)

test_dataset = datasets.ImageFolder(root='D:\Code\dogvscat\data2\test', transform=data_transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)


# 创建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 53 * 53, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 2)

    def forward(self, x):
        x = self.maxpool(F.relu(self.conv1(x)))
        x = self.maxpool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 53 * 53)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)

        return x
class Net2(nn.Module):
    def __init__(self):
        super(Net2, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.maxpool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 53 * 53, 1024)
        torch.nn.Dropout(0.5)
        self.fc2 = nn.Linear(1024, 512)
        torch.nn.Dropout(0.5)
        self.fc3 = nn.Linear(512, 2)

    def forward(self, x):
        x = self.maxpool(F.relu(self.conv1(x)))
        x = self.maxpool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 53 * 53)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)

        return x


net = Net2()
if(os.path.exists('D:\Code\dogvscat\model.pt')):
    net=torch.load('D:\Code\dogvscat\model.pt')

if use_gpu:
    print('gpu is available')
    net = net.cuda()
else:
    print('gpu is unavailable')

print(net)
trainLoss = []
trainacc = []
testLoss = []
testacc = []
x = np.arange(1,11)
# 定义loss和optimizer
cirterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

def train():

    for epoch in range(epochs):
        running_loss = 0.0
        train_correct = 0
        train_total = 0
        for step, data in enumerate(train_loader, 0):#第二个参数表示指定索引从0开始
            inputs, train_labels = data
            if use_gpu:
                inputs, labels = Variable(inputs.cuda()), Variable(train_labels.cuda())
            else:
                inputs, labels = Variable(inputs), Variable(train_labels)
            optimizer.zero_grad()
            outputs = net(inputs)
            _, train_predicted = torch.max(outputs.data, 1)  #返回每一行最大值的数值和索引，索引对应分类
            train_correct += (train_predicted == labels.data).sum()
            loss = cirterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
            train_total += train_labels.size(0)

        print('train %d epoch loss: %.3f  acc: %.3f ' % (
            epoch + 1, running_loss / train_total, 100 * train_correct / train_total))
        # 模型测试
        correct = 0
        test_loss = 0.0
        test_total = 0
        test_total = 0
        net.eval() #测试的时候整个模型的参数不再变化
        for data in test_loader:
            images, labels = data
            if use_gpu:
                images, labels = Variable(images.cuda()), Variable(labels.cuda())
            else:
                images, labels = Variable(images), Variable(labels)
            outputs = net(images)
            _, predicted = torch.max(outputs.data, 1)
            loss = cirterion(outputs, labels)
            test_loss += loss.item()
            test_total += labels.size(0)
            correct += (predicted == labels.data).sum()

        print('test  %d epoch loss: %.3f  acc: %.3f ' % (epoch + 1, test_loss / test_total, 100 * correct / test_total))
        trainLoss.append(running_loss / train_total)
        trainacc.append(100 * train_correct / train_total)
        testLoss.append(test_loss / test_total)
        testacc.append(100 * correct / test_total)
    plt.figure(1)
    plt.title('train')
    plt.plot(x,trainacc,'r')
    plt.plot(x,trainLoss,'b')
    plt.show()
    plt.figure(2)
    plt.title('test')
    plt.plot(x,testacc,'r')
    plt.plot(x,testLoss,'b')
    plt.show()



    torch.save(net, 'D:\Code\dogvscat\model.pt')


train()

看一下某次的运行结果

D:anacondaanacondapythonw.exe D:/Code/Python/pytorch入门与实践/第六章_pytorch实战指南/猫和狗二分类.py
D:Codedogvscatdata2	raincats total images : 11253
D:Codedogvscatdata2	estdogs total images : 1253
Net(
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (maxpool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=44944, out_features=1024, bias=True)
  (fc2): Linear(in_features=1024, out_features=512, bias=True)
  (fc3): Linear(in_features=512, out_features=2, bias=True)
)
train 1 epoch loss: 0.162  acc: 61.000 
test  1 epoch loss: 0.153  acc: 66.000 
train 2 epoch loss: 0.148  acc: 68.000 
test  2 epoch loss: 0.143  acc: 71.000 
train 3 epoch loss: 0.138  acc: 71.000 
test  3 epoch loss: 0.138  acc: 72.000 
train 4 epoch loss: 0.130  acc: 74.000 
test  4 epoch loss: 0.137  acc: 72.000 
train 5 epoch loss: 0.119  acc: 77.000 
test  5 epoch loss: 0.132  acc: 74.000 
train 6 epoch loss: 0.104  acc: 81.000 
test  6 epoch loss: 0.129  acc: 75.000 
train 7 epoch loss: 0.085  acc: 85.000 
test  7 epoch loss: 0.132  acc: 75.000 
train 8 epoch loss: 0.060  acc: 90.000 
test  8 epoch loss: 0.146  acc: 75.000 
train 9 epoch loss: 0.036  acc: 94.000 
test  9 epoch loss: 0.200  acc: 74.000 
train 10 epoch loss: 0.022  acc: 97.000 
test  10 epoch loss: 0.207  acc: 75.000 

Process finished with exit code 0

发现这个程序运行结果训练集准确率很高，测试集准确率为75%左右，因此Net类有点过拟合，Net2加入了Dropout降低网络复杂度处理过拟合。这个程序属于最基础的分类算法，因此准确率并不是很高，但是我认为初学者可以先会这个程序，再继续提高网络的准确率。