深度学习入坑笔记之三---服装图像识别问题_服装图像识别标签集

目录

输入数据

这里我们还是以MNIST数据为例，与上一篇的不同在于上一篇是关于手写体数字识别，本篇是关于服装的简单识别。
首先第一步是数据的录入，该数据及相关代码来自tensorflow官方教程，具体的代码实现如下：

from __future__ import absolute_import, division, print_function, unicode_literals #这一句一定放在第一行，否则系统提示错误
# 忽略系统的警告信息
import warnings
warnings.filterwarnings('ignore')
import tensorflow as tf
from tensorflow import keras
import numpy as np 
import matplotlib.pyplot as plt

#下载fashion_mnist服装分类数据集，并将相应数据添加进入对应的测试及训练图像和标签
fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
1
2
3
4
5
6
7
8
9
10
11

简单的说一下上述下载的数据集是个什么东西，首先看一下解析后的图片。如下图所示，该数据集是一个图像识别的入门级数据图像库，包含了训练集、验证机、以及标注好的标签。

但是tensorflow处理的数据都是‘张量’的形式，所以这些图片实际是什么形式，我们可以通过如下代码略窥一二~

train_images.shape #训练数据的格式，训练数据共有60000张图片，每张图片由28*28像素大小的图片组成
len(train_images) #训练数据的长度
len(train_labels) #训练数据标签长度，这里与训练数据图像数量相等
1
2

(60000, 28, 28)
 60000
 60000
1
2
3

以训练数据为例，该数据集的训练数据共有60000张图片，每个图片均为28*28像素的图片组成，相应的，训练数据的标签也是60000个

train_labels #训练标签的数据格式

array([9, 0, 0, ..., 3, 0, 5], dtype=uint8) #共有60000组标签，取值范围0-9，分别对应十类服装类型
1

训练标签共有60000组数据，取值范围0-9，分别对应了十个不同的服装类型

train_images #训练图片的数据格式

array([[[0, 0, 0, ..., 0, 0, 0],   #60000组数据，每组数据包含784个像素点（28*28）
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]],

   [[0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]],

   [[0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]],

   ...,

   [[0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]],

   [[0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]],

   [[0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    ...,
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0],
    [0, 0, 0, ..., 0, 0, 0]]], dtype=uint8)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

60000张训练数据的格式，60000组张量，每组张量为28*28的二维数组组成。

数据处理

在训练网络之前，必须对数据进行预处理。当前数据的像素值在0-255之间，统一不同数据间的量纲，有助于我们接下来对数据进行分析和计算，即对数据进行归一化处理。处理之前我们可以显性的观察一下当前的数据。

# 利用tensorflow的绘图工具将图片显示出来
plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()
1
2
3
4
5

从上图看出，当前图片的像素点分布在0-255之间。

print(train_images[0]) 显示图1的数据格式，与图像互相对应

[[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   1   0   0  13  73   0
0   1   4   0   0   0   0   1   1   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   3   0  36 136 127  62
54   0   0   0   1   3   4   0   0   3]
[  0   0   0   0   0   0   0   0   0   0   0   0   6   0 102 204 176 134
144 123  23   0   0   0   0  12  10   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0   0 155 236 207 178
107 156 161 109  64  23  77 130  72  15]
[  0   0   0   0   0   0   0   0   0   0   0   1   0  69 207 223 218 216
216 163 127 121 122 146 141  88 172  66]
[  0   0   0   0   0   0   0   0   0   1   1   1   0 200 232 232 233 229
223 223 215 213 164 127 123 196 229   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0 183 225 216 223 228
235 227 224 222 224 221 223 245 173   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0 193 228 218 213 198
180 212 210 211 213 223 220 243 202   0]
[  0   0   0   0   0   0   0   0   0   1   3   0  12 219 220 212 218 192
169 227 208 218 224 212 226 197 209  52]
[  0   0   0   0   0   0   0   0   0   0   6   0  99 244 222 220 218 203
198 221 215 213 222 220 245 119 167  56]
[  0   0   0   0   0   0   0   0   0   4   0   0  55 236 228 230 228 240
232 213 218 223 234 217 217 209  92   0]
[  0   0   1   4   6   7   2   0   0   0   0   0 237 226 217 223 222 219
222 221 216 223 229 215 218 255  77   0]
[  0   3   0   0   0   0   0   0   0  62 145 204 228 207 213 221 218 208
211 218 224 223 219 215 224 244 159   0]
[  0   0   0   0  18  44  82 107 189 228 220 222 217 226 200 205 211 230
224 234 176 188 250 248 233 238 215   0]
[  0  57 187 208 224 221 224 208 204 214 208 209 200 159 245 193 206 223
255 255 221 234 221 211 220 232 246   0]
[  3 202 228 224 221 211 211 214 205 205 205 220 240  80 150 255 229 221
188 154 191 210 204 209 222 228 225   0]
[ 98 233 198 210 222 229 229 234 249 220 194 215 217 241  65  73 106 117
168 219 221 215 217 223 223 224 229  29]
[ 75 204 212 204 193 205 211 225 216 185 197 206 198 213 240 195 227 245
239 223 218 212 209 222 220 221 230  67]
[ 48 203 183 194 213 197 185 190 194 192 202 214 219 221 220 236 225 216
199 206 186 181 177 172 181 205 206 115]
[  0 122 219 193 179 171 183 196 204 210 213 207 211 210 200 196 194 191
195 191 198 192 176 156 167 177 210  92]
[  0   0  74 189 212 191 175 172 175 181 185 188 189 188 193 198 204 209
210 210 211 188 188 194 192 216 170   0]
[  2   0   0   0  66 200 222 237 239 242 246 243 244 221 220 193 191 179
182 182 181 176 166 168  99  58   0   0]
[  0   0   0   0   0   0   0  40  61  44  72  41  35   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]
[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
0   0   0   0   0   0   0   0   0   0]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

从上面的结果可以看出来，图1是一组28*28的二维张量，且每个值均落在0-255范围内。下面对该数据进行归一化处理，具体的代码如下所示：

#将训练集和测试集的数据除以255，使得像素点分布为0-1
train_images = train_images / 255.0
test_images = test_images / 255.0
1
2

现在图片像素均落在0-1范围内，相对应的数据格式不在赘述，大家可以按照上面的代码自行查看。

搭建模型

神经网络的基本组成是层，层会从输入到他们的数据中提取特征并进行相应的处理。大部分神经网络都是把层简单的连接在一起，比如keras。

#搭建层的序列，输入数据格式28*28的张量
#添加全连接层，采用激活函数relu
#添加全连接层，激活函数为softmax
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
 ])
1
2
3
4
5
6
7

#编译模型，网络结构搭建好，需要对模型进行编译
#采用adam作为优化器，交叉熵表示损失函数
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
1
2
3
4

#训练模型，将图片与标签进行一一对应，设置10个循环
model.fit(train_images, train_labels, epochs=10)
1

Epoch 1/10
60000/60000 [==============================] - 2s 28us/sample - loss: 0.4988 - acc: 0.8266
Epoch 2/10
60000/60000 [==============================] - 2s 27us/sample - loss: 0.3777 - acc: 0.8644
Epoch 3/10
60000/60000 [==============================] - 2s 27us/sample - loss: 0.3368 - acc: 0.8773
Epoch 4/10
60000/60000 [==============================] - 2s 29us/sample - loss: 0.3135 - acc: 0.8855
Epoch 5/10
60000/60000 [==============================] - 2s 29us/sample - loss: 0.2967 - acc: 0.8907
Epoch 6/10
60000/60000 [==============================] - 2s 27us/sample - loss: 0.2835 - acc: 0.8954
Epoch 7/10
60000/60000 [==============================] - 2s 27us/sample - loss: 0.2711 - acc: 0.8996
Epoch 8/10
60000/60000 [==============================] - 2s 26us/sample - loss: 0.2577 - acc: 0.9040
Epoch 9/10
60000/60000 [==============================] - 2s 26us/sample - loss: 0.2504 - acc: 0.9066
Epoch 10/10
60000/60000 [==============================] - 2s 28us/sample - loss: 0.2411 - acc: 0.9099
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

评估模型

模型训练完毕之后，我们需要判断该模型是否精确，因此可以对图片进行预测，比较结果：

predictions = model.predict(test_images)#对所有标签与图片进行预测
predictions[0]#对第一个图片进行预测
1

array([1.06123218e-06, 8.76374884e-09, 4.13958730e-07, 9.93547733e-09,
   2.39135318e-07, 2.61428091e-03, 2.91701099e-07, 6.94991834e-03,
   1.02351805e-07, 9.90433693e-01], dtype=float32)
1
2
3

预测结果是由10个数字组成的数组。它们代表了模型相对于十个标签的“自信”程度。您可以看到哪个标签具有最高的置信值，很明显第9个数字的‘自信’度最高（0-9）：

np.argmax(predictions[0])

9
1

#图1对应的标签
test_labels[0]
1

9
1

最后，我们看一下训练模型在整个测试数据集的表现情况

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)
1

10000/1 - 1s - loss: 0.2934 - accuracy: 0.8830

Test accuracy: 0.883
1
2
3

该模型的精度为88.3%