用Pytorch构建一个喵咪识别模型

目录

一、前言

二、问题阐述及理论流程

2.1问题阐述

2.2猫咪图片识别原理

三、用PyTorch 实现

3.1PyTorch介绍

3.2PyTorch 构建模型的五要素

3.3PyTorch 实现的步骤

3.3.1.数据

3.3.2模型

3.3.3损失函数

3.3.4优化器

3.3.5迭代训练

四、我用了哪些方法防止过拟合？

4.1控制网络规模

4.2数据增强

4.3正则化

4.4K 折交叉验证

五、用自己的图片验证

5.1输入数据

5.2代码实现

5.3结果输出及分析

完整代码

一、前言

舍友最近养了只猫咪，看起来很好看，但是你绝对想不到它拉的shi巨臭啊，哈哈哈哈，就很离谱。刚好最近在学习Pytorch，心血来潮，就用Pytorch来做个喵咪识别模型并，于是就有了本篇博文。

二、问题阐述及理论流程

2.1问题阐述

现一共有 259 张图片，总体分为两类：

有猫咪类

无猫咪类

2.2猫咪图片识别原理

三、用PyTorch 实现

3.1PyTorch介绍

  PyTorch 是一个开源的深度学习框架，它的底层基于 Torch ，但实现与运用全部由 python 来完成。该框架主要用于人工智能领域的科学研究与应用开发。

3.2PyTorch 构建模型的五要素

1.数据：包括数据读取，数据清洗，进行数据划分和数据预处理。

2.模型：包括构建模型模块，组织复杂网络，初始化网络参数，定义网络层。

3.损失函数：包括创建损失函数，设置损失函数超参数，要根据不同任务选择合适的损失函数。

4.优化器：包括根据梯度使用某种优化器更新参数，管理模型参数，调整学习率。

5.迭代训练：组织上述 4 个模块进行反复训练。观察训练效果，绘制 Loss/ Accuracy 曲线或者用 TensorBoard 进行可视化分析。

3.3PyTorch 实现的步骤

3.3.1.数据

在深度学习时会遇到各种不同形式的数据，如文本、图片、音频等，而每种数据又有多种文件类型。因此拿到数据，我们首先应该了解它的内部结构。

  h5py 文件是一种 " Dataset " 和 " Group " 二合一的容器：

「Dataset」: 类似数组组织的数据的集合，像 numpy 数组一样工作；

「Group」: 包含了其它 Dataset 和 其它 Group ，像字典一样工作。

读取下载好的 h5py 文件（以含有 209 张图片的测试集为例）

import h5py

f = h5py.File("/home/tian/dataset/catvnocat/train/train_catvnoncat.h5","r")#"r"代表读取模式

for key in f.keys():

print(key)

#输出

#list_classes

#train_set_x

#train_set_y

依次打印出这三个" key "下的内容

print(f["list_classes"])

print(f["train_set_x"])

print(f["train_set_y"])

#输出

#<HDF5 dataset "list_classes": shape (2,), type "|S7">

#<HDF5 dataset "train_set_x": shape (209, 64, 64, 3), type "|u1">

#<HDF5 dataset "train_set_y": shape (209,), type "<i8">

可以得到三个 Dataset 的相关信息：

list_classes：包含两个元素 ' non-cat ' 和' cat '，代表无猫和有猫这两个大类。

train_set_x ：一个四维张量，形状为 209 * 64 * 64 * 3。代表一共有 209 张图片，其中每张图片以像素大小为 64 * 64 的三通道矩阵存储信息。

train_set_y ：一个一维数组，元素全部存储着 209 张图片对应的标签，其中有猫为 1 ，无猫为 0 。

该 h5py 文件的结构如下图所示：

制作数据集

  从torch.utils.data中引入Dataset，Dataset是能够表示数据集的抽象类，一般有三个方法：

「__init__方法」

用于类的初始化，负责创建类的实例属性并进行赋值，并在实例化类后自动执行。这里我创建的 MyData 类中包含以下属性：

Archive：文件的路径及对文件的操作，只读或写入

Image：样本中的图片或者包含全部图片信息的像素矩阵

Label：样本中的标签

Transform：可能要对数据进行的变换或增强

「__getitem__方法」

所有子类都必须重写该方法，该方法通过索引（index）或键（key）访问样本，返回值为 样本和标签。

「__len__方法」

返回数据集的大小。

from torch.utils.data import Dataset

class MyDataset(Dataset):

def __init__(self, archive , image , label , transform = None ):

self.Archive = h5.File(archive, 'r')

self.Images = self.Archive[image]

self.Labels = self.Archive[label]

self.Transform = transform

def __getitem__(self,index):

image = self.Images[index]

label = self.Labels[index]

if self.Transform is not None:

image = self.Transforms(image)

return image ,label

def __len__(self):

return len(self.Labels)

train_dataset = MyDataset('/home/tian/dataset/catvnocat/train/train_catvnoncat.h5','train_set_x','train_set_y',train_transformer)

test_dataset = MyDataset('/home/tian/dataset/catvnocat/test/test_catvnoncat.h5','test_set_x','test_set_y',test_transformer)

读取数据集

  从torch.utils.data引入DataLoader，它帮助我们从Dataset中加载样本数据。它联合了数据集 Dataset 和采样器 Sampler，使其本身可以像一个迭代器一样工作。前者提供数据来源，后者提供索引。

from torch.utils.data import Dataloader

train_loader = DataLoader(train_dataset, batch_size = batch_size_train, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size = batch_size_test, shuffle=False)

shuffle = True指的是将样本打乱，一般只针对训练集。

3.3.2模型

  该神经网络采用简单的 2 隐藏层全连接的方式，并在每一层采用 ReLU 函数作为激活函数，最后通过 Softmax 函数输出预测概率，以达到二分类的目的。

class Net(nn.Module):

def __init__(self, in_dim, n_hidden_1,n_hidden_2,out_dim):

super(Net, self).__init__()

self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1), nn.ReLU(True),nn.Dropout(0.25))

self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d(n_hidden_2), nn.ReLU(True),nn.Dropout(0.25))

self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim), nn.Softmax(dim = 1))

def forward(self, x):

x = self.layer1(x)

x = self.layer2(x)

x = self.layer3(x)

return x

3.3.3损失函数

  交叉熵损失函数是二分类问题常用的损失函数，可以直接在torch.nn里直接调用，其形式为：

criterion = nn.CrossEntropyLoss()

3.3.4优化器

  在 torch.optim中直接调用随机梯度下降法 SGD：

optimizer = optim.SGD(model.parameters(), lr = learning_rate, weight_decay = 1e-4)

3.3.5迭代训练

  一切准备工作就绪，进行迭代训练。也可以根据需要绘制 Loss/ Accuracy 曲线观察 train_loss 和 val_loss，并以此为依据来调试超参数。

for epoch in range(num_epoches 1):

model.train()

for data in train_loader:

img, label = data

img = img.view(img.size(0), -1)

img = Variable(img)

label = Variable(label)

out = model(img.to(torch.float32))

loss = criterion(out, label)

_, pred = torch.max(out, 1)

acc = (pred == label).sum().item() / (len(train_dataset))

optimizer.zero_grad()

loss.backward()

optimizer.step()

model.eval()

eval_loss = 0

eval_acc = 0

for data in test_loader:

img, label = data

img = img.view(img.size(0), -1)

out = model(img.to(torch.float32))

loss_1 = criterion(out, label)

eval_loss = loss_1.data.item()*label.size(0)

_, pred = torch.max(out, 1)

eval_acc = (pred == label).sum().item() / len(test_dataset)

if epochP == 0:

train_losses.append(loss.data.item())

train_acc.append(acc)

test_losses.append(loss_1.data.item())

test_acc.append(eval_acc)

print('epoch: {}'.format(epoch))

print('Train Loss: {:.4}, Train_Acc: {:.4}'.format(loss.data.item(), acc))

print('Test Loss: {:.4f}, Test_Acc: {:.4f}'.format(eval_loss / (len(test_dataset)),eval_acc))

fig = plt.figure()

plt.plot(train_counter, train_losses, color='blue')

plt.plot(test_counter, test_losses, '–',color='red')

plt.legend(['Train Loss', 'Test Loss'], loc='upper right')

plt.xlabel('number of training examples seen')

plt.ylabel('negative log likelihood loss')

fig = plt.figure()

plt.plot(train_counter, train_acc, color='blue')

plt.plot(test_counter, test_acc, '–',color='red')

plt.legend(['Train Acc', 'Test Acc'], loc='lower right')

plt.xlabel('number of training examples seen')

plt.ylabel('Acc')

plt.show()

「结果展示」：

可以看到，过拟合的情况没有发生，并且训练集和测试集的准确率都接近 90%，相对于原本的准确率有了较大的提高。

四、我用了哪些方法防止过拟合？

4.1控制网络规模

  当神经网络具有过多的神经元时，训练集中包含的有限信息量不足以训练隐藏层中的所有神经元，很可能导致过拟合。因此要控制网络规模，既不能太宽也不能太深。

4.2数据增强

  样本量少是造成过拟合的主要原因之一，但我们往往很难从源头上解决这一问题。数据增强通过对现有的样本（以图片为例）进行各种不同的变换（如随机自定义大小裁剪、随机翻转、随机旋转、增加色彩对比度等），然后适当增加训练迭代次数，从而达到样本量扩张的效果。

  本文采用了以下手段进行数据增强：

对输入图片随机裁剪，将原本像素大小为64的图片裁剪成像素大小为48的图片

在水平方向上对一半的图片进行随机翻转

在垂直方向上对一半的图片进行随机翻转

对图在一定角度内进行旋转

from torchvision import transforms

train_transformer = transforms.Compose([

transforms.ToPILImage(),

transforms.RandomResizedCrop(48),

transforms.RandomHorizontalFlip(),

transforms.RandomRotation((-15, 15)),

transforms.ToTensor(),

transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])

])

test_transformer = transforms.Compose([

transforms.ToPILImage(),

transforms.Resize(48),

transforms.ToTensor(),

transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])

])

测试集大多数情况下不进行数据增强，这里为了适应训练集数据增强后的图片大小对测试集进行了尺寸缩放，同样变为像素大小为的图片。

4.3正则化

「Drop_out」

  作为常用的预防过拟合的方法之一，它的主要思想是让隐藏层的节点在每次迭代时有一定几率失效，从而避免对某个节点的强依赖，让反向传播的修正值可以更加平衡的分布到各个参数上。也在一定程度上降低了网络复杂度。

「weight_decay」

  过拟合时模型会拟合很多位置较偏的点，导致拟合函数在某些小区间剧烈变化，权重 w 的绝对值很大。此方法通过控制权重 w 的大小来缓解过拟合的情况。

4.4K 折交叉验证

  以模型调优的思路来缓解过拟合。在训练每种模型时，通过k折交叉验证得到k组不同的训练集和测试集，并将每组的误差平均作为衡量模型泛化能力的准则，从而选择出泛化能力最好的（即最不容易发生过拟合）的模型。

kf = KFold(n_splits = 7, shuffle=True)

五、用自己的图片验证

训练神经网络最终的目的就是为了应用，因此最后一个环节我们用自己的图片来验证“猫咪识别器”的性能如何。

5.1输入数据

有猫咪类

无猫咪类

5.2代码实现

from PIL import Image

def trans_pic(img_dir,width,height):

image = Image.open(img_dir) #打开图片

resized_image = image.resize((width, height), Image.ANTIALIAS)

data = np.asarray(resized_image)#转换为矩阵

image = Image.fromarray(data) #将之前的矩阵转换为图片

#image.show()#调用本地软件显示图片，win10是叫照片的工具

return data

path_cat = [r"/home/tian/Pictures/cat_1.jpg",

r"/home/tian/Pictures/cat_2.jpg",

r"/home/tian/Pictures/cat_3.jpg",

r"/home/tian/Pictures/cat_4.jpg",

r"/home/tian/Pictures/cat_5.jpg"]

path_nocat = [r"/home/tian/Pictures/nocat_1.jpg",

r"/home/tian/Pictures/nocat_2.jpg",

r"/home/tian/Pictures/nocat_3.jpg",

r"/home/tian/Pictures/nocat_4.jpg",

r"/home/tian/Pictures/nocat_5.jpg"]

for i in range(5):

a = test_transformer(trans_pic(path_cat[i],48,48)).view(1, -1)

b = test_transformer(trans_pic(path_nocat[i],48,48)).view(1, -1)

out_1 = model(a.to(torch.float32))

out_2 = model(b.to(torch.float32))

_, pred_1= torch.max(out_1, 1)

_, pred_2= torch.max(out_2, 1)

if pred_1 == 1:

print("第",i 1,"张猫咪图片识别正确")

if pred_1 == 0:

print("第",i 1,"张猫咪图片识别错误")

if pred_2 == 1:

print("第",i 1,"张非猫咪图片识别错误")

if pred_2 == 0:

print("第",i 1,"张非猫咪图片识别正确")

print("n")

5.3结果输出及分析

「结果输出」：

1. 第 1 张猫咪图片识别正确
2. 第 1 张非猫咪图片识别正确
5. 第 2 张猫咪图片识别正确
6. 第 2 张非猫咪图片识别正确
9. 第 3 张猫咪图片识别正确
10. 第 3 张非猫咪图片识别错误
13. 第 4 张猫咪图片识别正确
14. 第 4 张非猫咪图片识别错误
17. 第 5 张猫咪图片识别正确
18. 第 5 张非猫咪图片识别正确

「结果分析」：

猫咪图片：都能识别正确。

非猫咪图片：第三张、第四张图片出现了识别错误。

对于风景图这种与猫咪图片差别很大的图片，识别器能轻松地辨别；

对于老虎、老鼠这些与猫咪在特征上有很多相似地方的动物，猫咪识别器显然还不具备能力将他们很好地区分开来。

  因此在图片识别领域，我们总是需要更合适的网络结构、更大规模的数据以及更合适的超参数选择。

完整代码

import numpy as np

import h5py as h5

import torch

from torch.utils.data import Dataset,DataLoader

import torch.nn.functional as F

from torch import nn, optim

from torch.autograd import Variable

from torchvision import datasets, transforms

from matplotlib import pyplot as plt

batch_size_train = 209

batch_size_test = 50

learning_rate = 0.0075

num_epoches = 3500

momentum = 0.5

train_transformer = transforms.Compose([

transforms.ToPILImage(),

transforms.RandomResizedCrop(48),

transforms.RandomHorizontalFlip(),

transforms.RandomVerticalFlip(),

transforms.RandomRotation((-15, 15)),

transforms.ToTensor(),

transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])

])

test_transformer = transforms.Compose([

transforms.ToPILImage(),

transforms.Resize(48),

transforms.ToTensor(),

transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])

])

class MyDataset(Dataset):

def __init__(self, archive,image,label,transform = None):

self.archive = h5.File(archive, 'r')

self.images = self.archive[image]

self.labels = self.archive[label]

self.transform = transform

def __getitem__(self,index):

image = self.images[index]

label = self.labels[index]

if self.transform is not None:

image = self.transform(image)

return image ,label

def __len__(self):

return len(self.labels)

train_dataset = MyDataset('/home/tian/dataset/catvnocat/train/train_catvnoncat.h5','train_set_x','train_set_y',train_transformer)

test_dataset = MyDataset('/home/tian/dataset/catvnocat/test/test_catvnoncat.h5','test_set_x','test_set_y',test_transformer)

train_loader = DataLoader(train_dataset, batch_size=batch_size_train, shuffle=True)

test_loader = DataLoader(test_dataset, batch_size=batch_size_test, shuffle=False)

class Batch_Net(nn.Module):

def __init__(self, in_dim, n_hidden_1,n_hidden_2,out_dim):

super(Batch_Net, self).__init__()

self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1),nn.BatchNorm1d(n_hidden_1), nn.ReLU(True),nn.Dropout(0.25))#,nn.Dropout(0.3))

self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2),nn.BatchNorm1d(n_hidden_2), nn.ReLU(True),nn.Dropout(0.25))#,nn.Dropout(0.5))#,nn.Dropout(0.3))#,nn.Dropout(0.5))

self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim),nn.Softmax(dim = 1))

def forward(self, x):

x = self.layer1(x)

x = self.layer2(x)

x = self.layer3(x)

return x

#构建模型实例

model = Batch_Net(48*48*3,90,10,2)

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(model.parameters(), lr=learning_rate,weight_decay= 1e-4)

train_losses = []

train_acc = []

train_counter = [i * len(train_loader)*50 for i in range(num_epoches // 50 1)]

test_losses = []

test_acc = []

test_counter = [i * len(test_loader)*50 for i in range(num_epoches // 50 1)]

for epoch in range(num_epoches 1):

model.train()

for data in train_loader:

img, label = data

img = img.view(img.size(0), -1)

img = Variable(img)

label = Variable(label)

out = model(img.to(torch.float32))

loss = criterion(out, label)

_, pred = torch.max(out, 1)

acc = (pred == label).sum().item() / (len(train_dataset))

optimizer.zero_grad()

loss.backward()

optimizer.step()

model.eval()

eval_loss = 0

eval_acc = 0

for data in test_loader:

img, label = data

img = img.view(img.size(0), -1)

out = model(img.to(torch.float32))

loss_1 = criterion(out, label)

eval_loss = loss_1.data.item()*label.size(0)

_, pred = torch.max(out, 1)

eval_acc = (pred == label).sum().item() / len(test_dataset)

if epochP == 0:

train_losses.append(loss.data.item())

train_acc.append(acc)

test_losses.append(loss_1.data.item())

test_acc.append(eval_acc)

print('epoch: {}'.format(epoch))

print('Train Loss: {:.4}, Train_Acc: {:.4}'.format(loss.data.item(), acc))

print('Test Loss: {:.4f}, Test_Acc: {:.4f}'.format(eval_loss / (len(test_dataset)),eval_acc))

fig = plt.figure()

plt.plot(train_counter, train_losses, color='blue')

plt.plot(test_counter, test_losses, '–',color='red')

plt.legend(['Train Loss', 'Test Loss'], loc='upper right')

plt.xlabel('number of training examples seen')

plt.ylabel('negative log likelihood loss')

fig = plt.figure()

plt.plot(train_counter, train_acc, color='blue')

plt.plot(test_counter, test_acc, '–',color='red')

plt.legend(['Train Acc', 'Test Acc'], loc='lower right')

plt.xlabel('number of training examples seen')

plt.ylabel('Acc')

plt.show()

文章知识点与官方知识档案匹配，可进一步学习相关知识