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作为模型的输入。代码如下：
1 data_transform = transforms.Compose([
2 transforms.Resize(256),
3 transforms.CenterCrop(224),
4 transforms.ToTensor(),
5 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
6 ])
7
8 train_dataset = datasets.ImageFolder(root='./data2/train/',
9 transform=data_transform)
10 train_loader = torch.utils.data.DataLoader(train_dataset,
11 batch_size=batch_size,
12 shuffle=True,
13 num_workers=num_workers)为方便训练过程，需要把训练集进行处理：把猫狗的图片分别放在cat，dog文件夹中，并划分出一部分图片作为测试集（与下载的测试集不同）。代码如下：
1 #接下来的数据是把原训练集90%的数据做训练，10%做测试集，其中把分为训练集的数据内的猫和狗分开，分为测试集的数据的猫和狗进行分开保存在新的各自的目录下
2 # kaggle原始数据集地址
3 original_dataset_dir = 'D:\\Code\\Python\\Kaggle-Dogs_vs_Cats_PyTorch-master\\data\\train' #训练集地址
4 total_num = int(len(os.listdir(original_dataset_dir)) ) #训练集数据总数，包含猫和狗
5 random_idx = np.array(range(total_num))
6 np.random.shuffle(random_idx)#打乱图片顺序
7
8 # 待处理的数据集地址
9 base_dir = 'D:\\Code\\dogvscat\\data2' #把原训练集数据分类后的数据存储在该目录下
10 if not os.path.exists(base_dir):
11 os.mkdir(base_dir)
12
13 # 训练集、测试集的划分
14 sub_dirs = ['train', 'test']
15 animals = ['cats', 'dogs']
16 train_idx = random_idx[:int(total_num * 0.9)] #打乱后的数据的90%是训练集，10是测试集
17 test_idx = random_idx[int(total_num * 0.9):int(total_num * 1)]
18 numbers = [train_idx, test_idx]
19 for idx, sub_dir in enumerate(sub_dirs):
20 dir = os.path.join(base_dir, sub_dir)#'D:\\Code\\dogvscat\\data2\\train'或'D:\\Code\\dogvscat\\data2\\test'
21 if not os.path.exists(dir):
22 os.mkdir(dir)
23
24 animal_dir = ""
25
26 #fnames = ['.{}.jpg'.format(i) for i in numbers[idx]]
27 fnames = ""
28 if sub_dir == 'train':
29 idx = 0
30 else:
31 idx =1
32 for i in numbers[idx]:
33 #print(i)
34 if i>=12500:#把数据保存在dogs目录下
35 fnames = str('dog'+'.{}.jpg'.format(i))
36 animal_dir = os.path.join(dir,'dogs')
37
38 if not os.path.exists(animal_dir):
39 os.mkdir(animal_dir)
40 if i<12500:#图片是猫，数据保存在cats目录下
41 fnames = str('cat'+'.{}.jpg'.format(i))
42 animal_dir = os.path.join(dir, 'cats')
43 if not os.path.exists(animal_dir):
44 os.mkdir(animal_dir)
45 src = os.path.join(original_dataset_dir, str(fnames)) #原数据地址
46 #print(src)
47 dst = os.path.join(animal_dir, str(fnames))#新地址
48 #print(dst)
49 shutil.copyfile(src, dst)#复制
50
51
52 # 验证训练集、测试集的划分的照片数目
53 print(dir + ' total images : %d' % (len(os.listdir(dir+'\\dogs'))+len(os.listdir(dir+'\\cats'))))
54 # 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是一个激活函数，把所有的非零值转化成零值。此次图像识别的最后关键一步就是真正的循环训练操作。
进行训练的代码：
1 def train():
2
3 for epoch in range(epochs):
4 running_loss = 0.0
5 train_correct = 0
6 train_total = 0
7 for step, data in enumerate(train_loader, 0):#第二个参数表示指定索引从0开始
8 inputs, train_labels = data
9 if use_gpu:
10 inputs, labels = Variable(inputs.cuda()), Variable(train_labels.cuda())
11 else:
12 inputs, labels = Variable(inputs), Variable(train_labels)
13 optimizer.zero_grad()
14 outputs = net(inputs)
15 _, train_predicted = torch.max(outputs.data, 1) #返回每一行最大值的数值和索引，索引对应分类
16 train_correct += (train_predicted == labels.data).sum()
17 loss = cirterion(outputs, labels)
18 loss.backward()
19 optimizer.step()
20 running_loss += loss.item()
21 train_total += train_labels.size(0)
22
23 print('train %d epoch loss: %.3f acc: %.3f ' % (
24 epoch + 1, running_loss / train_total, 100 * train_correct / train_total))
25 # 模型测试
26 correct = 0
27 test_loss = 0.0
28 test_total = 0
29 test_total = 0
30 net.eval() #测试的时候整个模型的参数不再变化
31 for data in test_loader:
32 images, labels = data
33 if use_gpu:
34 images, labels = Variable(images.cuda()), Variable(labels.cuda())
35 else:
36 images, labels = Variable(images), Variable(labels)
37 outputs = net(images)
38 _, predicted = torch.max(outputs.data, 1)
39 loss = cirterion(outputs, labels)
40 test_loss += loss.item()
41 test_total += labels.size(0)
42 correct += (predicted == labels.data).sum()完整的代码如下
1 # coding=utf-8
2 import os
3 import numpy as np
4 import torch
5 import torch.nn as nn
6 import torch.nn.functional as F
7 import torch.optim as optim
8 from torch.autograd import Variable
9 from torch.utils.data import Dataset
10 from torchvision import transforms, datasets, models
11 import shutil
12 from matplotlib import pyplot as plt
13 # 随机种子设置
14 random_state = 42
15 np.random.seed(random_state)
16 #接下来的数据是把原训练集90%的数据做训练，10%做测试集，其中把分为训练集的数据内的猫和狗分开，分为测试集的数据的猫和狗进行分开保存在新的各自的目录下
17 # kaggle原始数据集地址
18 original_dataset_dir = 'D:\\Code\\Python\\Kaggle-Dogs_vs_Cats_PyTorch-master\\data\\train' #训练集地址
19 total_num = int(len(os.listdir(original_dataset_dir)) ) #训练集数据总数，包含猫和狗
20 random_idx = np.array(range(total_num))
21 np.random.shuffle(random_idx)#打乱图片顺序
22
23 # 待处理的数据集地址
24 base_dir = 'D:\\Code\\dogvscat\\data2' #把原训练集数据分类后的数据存储在该目录下
25 if not os.path.exists(base_dir):
26 os.mkdir(base_dir)
27
28 # 训练集、测试集的划分
29 sub_dirs = ['train', 'test']
30 animals = ['cats', 'dogs']
31 train_idx = random_idx[:int(total_num * 0.9)] #打乱后的数据的90%是训练集，10是测试集
32 test_idx = random_idx[int(total_num * 0.9):int(total_num * 1)]
33 numbers = [train_idx, test_idx]
34 for idx, sub_dir in enumerate(sub_dirs):
35 dir = os.path.join(base_dir, sub_dir)#'D:\\Code\\dogvscat\\data2\\train'或'D:\\Code\\dogvscat\\data2\\test'
36 if not os.path.exists(dir):
37 os.mkdir(dir)
38
39 animal_dir = ""
40
41 #fnames = ['.{}.jpg'.format(i) for i in numbers[idx]]
42 fnames = ""
43 if sub_dir == 'train':
44 idx = 0
45 else:
46 idx =1
47 for i in numbers[idx]:
48 #print(i)
49 if i>=12500:#把数据保存在dogs目录下
50 fnames = str('dog'+'.{}.jpg'.format(i))
51 animal_dir = os.path.join(dir,'dogs')
52
53 if not os.path.exists(animal_dir):
54 os.mkdir(animal_dir)
55 if i<12500:#图片是猫，数据保存在cats目录下
56 fnames = str('cat'+'.{}.jpg'.format(i))
57 animal_dir = os.path.join(dir, 'cats')
58 if not os.path.exists(animal_dir):
59 os.mkdir(animal_dir)
60 src = os.path.join(original_dataset_dir, str(fnames)) #原数据地址
61 #print(src)
62 dst = os.path.join(animal_dir, str(fnames))#新地址
63 #print(dst)
64 shutil.copyfile(src, dst)#复制
65
66
67 # 验证训练集、测试集的划分的照片数目
68 print(dir + ' total images : %d' % (len(os.listdir(dir+'\\dogs'))+len(os.listdir(dir+'\\cats'))))
69 # coding=utf-8
70
71 # 配置参数
72 random_state = 1
73 torch.manual_seed(random_state) # 设置随机数种子，确保结果可重复
74 torch.cuda.manual_seed(random_state)# #为GPU设置种子用于生成随机数，以使得结果是确定的
75 torch.cuda.manual_seed_all(random_state) #为所有GPU设置种子用于生成随机数，以使得结果是确定的
76 np.random.seed(random_state)
77 # random.seed(random_state)
78
79 epochs = 10 # 训练次数
80 batch_size = 4 # 批处理大小
81 num_workers = 0 # 多线程的数目
82 use_gpu = torch.cuda.is_available()
83 PATH='D:\\Code\\dogvscat\\model.pt'
84 # 对加载的图像作归一化处理， 并裁剪为[224x224x3]大小的图像
85 data_transform = transforms.Compose([
86 transforms.Resize(256),#重置图像分辨率
87 transforms.CenterCrop(224), #中心裁剪
88 transforms.ToTensor(),
89 transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) #归一化
90 ])
91
92 train_dataset = datasets.ImageFolder(root='D:\\Code\\dogvscat\\data2\\train',
93 transform=data_transform)
94 print(train_dataset)
95 train_loader = torch.utils.data.DataLoader(train_dataset,
96 batch_size=batch_size,
97 shuffle=True,
98 num_workers=num_workers)
99
100 test_dataset = datasets.ImageFolder(root='D:\\Code\\dogvscat\\data2\\test', transform=data_transform)
101 test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers)
102
103
104 # 创建模型
105 class Net(nn.Module):
106 def __init__(self):
107 super(Net, self).__init__()
108 self.conv1 = nn.Conv2d(3, 6, 5)
109 self.maxpool = nn.MaxPool2d(2, 2)
110 self.conv2 = nn.Conv2d(6, 16, 5)
111 self.fc1 = nn.Linear(16 * 53 * 53, 1024)
112 self.fc2 = nn.Linear(1024, 512)
113 self.fc3 = nn.Linear(512, 2)
114
115 def forward(self, x):
116 x = self.maxpool(F.relu(self.conv1(x)))
117 x = self.maxpool(F.relu(self.conv2(x)))
118 x = x.view(-1, 16 * 53 * 53)
119 x = F.relu(self.fc1(x))
120 x = F.relu(self.fc2(x))
121 x = self.fc3(x)
122
123 return x
124 class Net2(nn.Module):
125 def __init__(self):
126 super(Net2, self).__init__()
127 self.conv1 = nn.Conv2d(3, 6, 5)
128 self.maxpool = nn.MaxPool2d(2, 2)
129 self.conv2 = nn.Conv2d(6, 16, 5)
130 self.fc1 = nn.Linear(16 * 53 * 53, 1024)
131 torch.nn.Dropout(0.5)
132 self.fc2 = nn.Linear(1024, 512)
133 torch.nn.Dropout(0.5)
134 self.fc3 = nn.Linear(512, 2)
135
136 def forward(self, x):
137 x = self.maxpool(F.relu(self.conv1(x)))
138 x = self.maxpool(F.relu(self.conv2(x)))
139 x = x.view(-1, 16 * 53 * 53)
140 x = F.relu(self.fc1(x))
141 x = F.relu(self.fc2(x))
142 x = self.fc3(x)
143
144 return x
145
146
147 net = Net2()
148 if(os.path.exists('D:\\Code\\dogvscat\\model.pt')):
149 net=torch.load('D:\\Code\\dogvscat\\model.pt')
150
151 if use_gpu:
152 print('gpu is available')
153 net = net.cuda()
154 else:
155 print('gpu is unavailable')
156
157 print(net)
158 trainLoss = []
159 trainacc = []
160 testLoss = []
161 testacc = []
162 x = np.arange(1,11)
163 # 定义loss和optimizer
164 cirterion = nn.CrossEntropyLoss()
165 optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)
166
167 def train():
168
169 for epoch in range(epochs):
170 running_loss = 0.0
171 train_correct = 0
172 train_total = 0
173 for step, data in enumerate(train_loader, 0):#第二个参数表示指定索引从0开始
174 inputs, train_labels = data
175 if use_gpu:
176 inputs, labels = Variable(inputs.cuda()), Variable(train_labels.cuda())
177 else:
178 inputs, labels = Variable(inputs), Variable(train_labels)
179 optimizer.zero_grad()
180 outputs = net(inputs)
181 _, train_predicted = torch.max(outputs.data, 1) #返回每一行最大值的数值和索引，索引对应分类
182 train_correct += (train_predicted == labels.data).sum()
183 loss = cirterion(outputs, labels)
184 loss.backward()
185 optimizer.step()
186 running_loss += loss.item()
187 train_total += train_labels.size(0)
188
189 print('train %d epoch loss: %.3f acc: %.3f ' % (
190 epoch + 1, running_loss / train_total, 100 * train_correct / train_total))
191 # 模型测试
192 correct = 0
193 test_loss = 0.0
194 test_total = 0
195 test_total = 0
196 net.eval() #测试的时候整个模型的参数不再变化
197 for data in test_loader:
198 images, labels = data
199 if use_gpu:
200 images, labels = Variable(images.cuda()), Variable(labels.cuda())
201 else:
202 images, labels = Variable(images), Variable(labels)
203 outputs = net(images)
204 _, predicted = torch.max(outputs.data, 1)
205 loss = cirterion(outputs, labels)
206 test_loss += loss.item()
207 test_total += labels.size(0)
208 correct += (predicted == labels.data).sum()
209
210 print('test %d epoch loss: %.3f acc: %.3f ' % (epoch + 1, test_loss / test_total, 100 * correct / test_total))
211 trainLoss.append(running_loss / train_total)
212 trainacc.append(100 * train_correct / train_total)
213 testLoss.append(test_loss / test_total)
214 testacc.append(100 * correct / test_total)
215 plt.figure(1)
216 plt.title('train')
217 plt.plot(x,trainacc,'r')
218 plt.plot(x,trainLoss,'b')
219 plt.show()
220 plt.figure(2)
221 plt.title('test')
222 plt.plot(x,testacc,'r')
223 plt.plot(x,testLoss,'b')
224 plt.show()
225
226
227
228 torch.save(net, 'D:\\Code\\dogvscat\\model.pt')
229
230
231 train()看一下某次的运行结果
D:\anaconda\anaconda\pythonw.exe D:/Code/Python/pytorch入门与实践/第六章_pytorch实战指南/猫和狗二分类.py
D:\Code\dogvscat\data2\train\cats total images : 11253
D:\Code\dogvscat\data2\test\dogs 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降低网络复杂度处理过拟合。这个程序属于最基础的分类算法，因此准确率并不是很高，但是我认为初学者可以先会这个程序，再继续提高网络的准确率。
作者：你的雷哥
本文版权归作者所有，欢迎转载，但未经作者同意必须在文章页面给出原文连接，否则保留追究法律责任的权利。
