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

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 epoch%50 == 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 张猫咪图片识别正确
第 2 张非猫咪图片识别正确

第 3 张猫咪图片识别正确
第 3 张非猫咪图片识别错误

第 4 张猫咪图片识别正确
第 4 张非猫咪图片识别错误

第 5 张猫咪图片识别正确
第 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 epoch%50 == 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()

本站大部分文章、数据、图片均来自互联网,一切版权均归源网站或源作者所有。

如果侵犯了您的权益请来信告知我们删除。邮箱：1451803763@qq.com

标签：技术应用人工智能深度学习

上一篇:深度学习环境配置超详细教程【Anaconda+PyTorch(GPU版)+CUDA+cuDNN】

下一篇:处理错误：Access to the path 'C:\Windows\TEMP\xxx.tmp' is denied.