2.利用tensorflow框架对服装进行分类

TensorFlow程序概述

本篇博文来自网址https://www.tensorflow.org/tutorials/keras/text_classification?hl=zh_cn 我对其代码进行复现，这里需要注意的是访问该网站需要ladder。本文使用了tf.keras,它是TensorFlow中用来构建和训练模型的高级API。

#TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

#Helper Libraries
import numpy as np
import matplotlib.pyplot as plt


print(tf.__version__)

2.8.0

导入Fashion MNIST数据集

本篇博客使用的是Fashion MNIST数据集，该数据集包含10个类别的70000个灰度图像。这些图像以低分辨率（28×28）展示了单件物品。MNIST数据集包含了手写数字（0，1，2等）的图像，其格式与我们用的衣物图像的格式相同。我们使用60000个图像来训练网络，使用10000个图像来评估网络学习对图像分类的准确性。加载数据集的代码如下:

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

加载数据会返回四个Numpy数组：
·train_image和train_labels数组是训练集，即模型用于学习数据。
·测试集、test_image和test_labels数组会被用来对模型进行测试。图像是28×28的Numpy数组，像素介于0到255之间。标签是整数数组，介于0到9之间。这些标签对应于图像所代表的服装类别。
每个图像都会被映射到一个标签。由于数据集不包括类名称，将它们储存在下方，供稍后绘制图像时使用：

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress',
               'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag',
               'Ankle boot']
#class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
#               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

浏览数据

在训练模型之前，我们先浏览一下数据集的格式。以下代码显示训练集中有60000个图像，每个图像由28×28的像素表示。

train_images.shape

(60000, 28, 28)

len(train_labels)

60000

训练集中有60000个标签。

train_labels

array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)

每个标签都是0到9之间的整数

test_images.shape

(10000, 28, 28)

测试集中有10000个图像。同样，每个图像都有28×28个像素表示

len(test_labels)

10000

测试集中包含10000个图像标签

预处理数据

在训练网络之前，必须对数据进行预处理。如果检查训练集中的第一个图像，会看到像素值位于0到255之间。

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

将这些值缩到0到1之间，然后将其馈送到神经网络模型中。为此要将这些值除以255。这里我们务必以相同的方式对训练集和测试集进行预处理。

train_images = train_images / 255.0
test_images = test_images / 255.0

为了验证数据的格式是否正确，以及我们是否准备好构建和训练网络，我们展示训练集中的前25个图像，并在每个图像下方显示类名称。

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

构建模型

构建神经网络模型需要先配置模型的层，然后编译模型。

设置层

神经网络的基本组成部分是层。层会从向其馈送的数据中提取表示形式。大多数深层学习都包括将简单的层链接在一起。大多数层(tf.keras.layers.Dense)都具有在训练期间才会学习参数。

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10)
])

该网络的第一层tf.keras.layers.Flatten将图像格式从二维数组(28×28像素)转换成一维数组(28×28=784像素)。将该层视为图像中未堆叠的像素行并将其排列起来。该层没有要学习的参数，它会重新格式化数据。
展开像素后，网络会包括两个tf.keras.layers.Flatten层的序列。它们是密集连接或全连接神经网络。第一个Dense层128个节点（或者神经元）。第二个（也是最后一个）层会返回一个长度为10的lofits数组。每个节点都包含一个得分，用来表示当前图像属于10个类中的哪一类。

编译模型

在准备对模型进行训练之前，还需要再对其进行一些设置。以下内容是在模型的编译步骤中进行的：

1.损失函数：用来测量模型在训练期间的准确率。我们会希望最小化此函数，以便将模型“引导”到正确的方向上。

2.优化器：决定模型如何根据其看到的数据和自身的损失函数进行更新。

3.指标：用于监测训练和测试步骤。以下示例使用了准确率，即被正确分类的图像的比率。

model.compile(optimizer='adam',
             loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
             metrics=['accuracy'])

训练模型

训练神经网络模型需要执行以下步骤：

1.将训练数据馈送给模型。在本个小项目中，训练数据位于train_images和train_labels数组中。

2.模型学习将图像和标签关联起来

3.要求模型对测试集（在本例中为test_images数组）进行预测

4.验证预测是否与test_labels数组中的标签相匹配。

向模型馈送数据

要开始训练，需要调用model.fit，这样命名是因为该方法会将模型与训练数据进行“拟合”：

model.fit(train_images, train_labels, epochs=10)

Epoch 1/10
1875/1875 [==============================] - 9s 3ms/step - loss: 0.4948 - accuracy: 0.8263
Epoch 2/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.3724 - accuracy: 0.8666
Epoch 3/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.3360 - accuracy: 0.8776
Epoch 4/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.3118 - accuracy: 0.8856
Epoch 5/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2935 - accuracy: 0.8912
Epoch 6/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2810 - accuracy: 0.8959
Epoch 7/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2691 - accuracy: 0.8999
Epoch 8/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2589 - accuracy: 0.9037
Epoch 9/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2504 - accuracy: 0.9058
Epoch 10/10
1875/1875 [==============================] - 6s 3ms/step - loss: 0.2402 - accuracy: 0.9098





<keras.callbacks.History at 0x19925177820>

在模型训练期间（听到了“燃烧CPU的声音了”），会显示损失和准确率指标。此模型在训练数据上的准确率达到了0.91（91%）左右、

评估准确率

接下来，比较模型在测试数据集上的表现：

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)

print('\nTest accuracy:', test_acc)

313/313 - 1s - loss: 0.3376 - accuracy: 0.8815 - 807ms/epoch - 3ms/step

Test accuracy: 0.8815000057220459

结果表明，模型在测试数据集上的准确率略低于训练数据集。训练准确率和测试准确率之间的差距代表过拟合，过拟合是指机器学习模型在新的、以前曾经出现过的输入上的表现不如在训练数据上的表现。过拟合的模型会记住训练数据集中的噪声和细节，从而对模型在新数据上变现产生负面影响。这里我还会将整理<演示过拟合>,<避免过拟合的策略>

进行预测

在模型经过训练后,可以使用它对一些图像进行预测.模型具有线性输出,即logits.我们可以附加一个softmax层,将logits转换成更容易理解的概率.

probability_model = tf.keras.Sequential([model,
                                        tf.keras.layers.Softmax()])

predictions = probability_model.predict(test_images)

predictions[0]

array([9.8330077e-07, 2.0626763e-08, 8.2670876e-10, 2.9593509e-12,
       1.2751320e-07, 3.7031923e-04, 3.7946873e-07, 1.1762976e-02,
       1.1164550e-08, 9.8786515e-01], dtype=float32)

预测结果是一个包含10个数字的数组.他们代表模型对10中不同服装中每一种服装的置信度,我们取值为最大值:

np.argmax(predictions[0])

9

因此,该模型非常确信这个图像是短靴,或者class_names[9].通过检查测试标签发现这个分类是正确的:

test_labels[0]

9

我们可以将其绘制成图表,看看模型对于全部10个类的预测

def plot_image(i, predictions_array, true_label, img):
    prediction_array, true_label, img = predictions_array, true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    
    plt.imshow(img, cmap=plt.cm.binary)
    
    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'
        
    plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                            100*np.max(predictions_array),
                                            class_names[true_label]),
                                            color=color)
    
def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array, true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0,1])
    predicted_label = np.argmax(predictions_array)
        
    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')
    

验证预测结果

在模型经过训练后,可以使用它对一些图像进行预测.
我们来看看第0个图像,预测结果和预测数组.正确的预测标签为蓝色,错误的预测标签为红色,数字表示预测标签的百分比(总计为100)

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i], test_labels)
plt.show()

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i], test_labels)
plt.show()

让我们用模型的预测绘制几张图像,即使置信度很高,模型也会出错.

# 绘制一些测试图像(预测标签和真实标签)
#将正确预测用蓝色表示,错误的预测用红色表示
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2*num_cols, 2*i+1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2*num_cols, 2*i+2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

使用训练好的模型

最后,使用训练好的模型对单个图像进行预测

#从测试集中加载图片
img = test_images[1]

print(img.shape)

(28, 28)

tf.keras模型经过优化,可同时对一个或一组样本进行预测.因此,即便我们只使用一个图像,我们也需要将其添加到列表中.

# 添加图像到只有一个单元的batch中
img = (np.expand_dims(img, 0))

print(img.shape)

(1, 28, 28)

现在预测这个图像的正确标签:

predictions_single = probability_model.predict(img)
print(predictions_single)

[[2.8947479e-06 1.5108573e-15 9.9898154e-01 1.1753938e-12 9.6314441e-04
  4.2196581e-15 5.2470656e-05 1.1998774e-24 2.6323577e-11 1.7504824e-13]]

plot_value_array(1, predictions_single[0], test_labels)
plt.xticks(range(10), class_names, rotation=45)

([<matplotlib.axis.XTick at 0x19a1efd1fa0>,
  <matplotlib.axis.XTick at 0x19a1efd1f70>,
  <matplotlib.axis.XTick at 0x19a1efd16a0>,
  <matplotlib.axis.XTick at 0x19a1efffb80>,
  <matplotlib.axis.XTick at 0x19a1efffe50>,
  <matplotlib.axis.XTick at 0x19a1f007550>,
  <matplotlib.axis.XTick at 0x19a1f007ca0>,
  <matplotlib.axis.XTick at 0x19a1f321220>,
  <matplotlib.axis.XTick at 0x19a1f3219a0>,
  <matplotlib.axis.XTick at 0x19a1f327130>],
 [Text(0, 0, 'T-shirt/top'),
  Text(1, 0, 'Trouser'),
  Text(2, 0, 'Pullover'),
  Text(3, 0, 'Dress'),
  Text(4, 0, 'Coat'),
  Text(5, 0, 'Sandal'),
  Text(6, 0, 'Shirt'),
  Text(7, 0, 'Sneaker'),
  Text(8, 0, 'Bag'),
  Text(9, 0, 'Ankle boot')])

keras.Model.predict会返回一组列表,每个列表对应一批数据中的每个图像.在批次中获取对我们(唯一)图像的预测

np.argmax(predictions_single[0])

2

模型会按照预期预测标签.

总结

上述内容是讲述进行一个基本分类项目的基本步骤,我们对细节不是很了解没有关系,这里只是帮助我们拎起一个大的框架,让我们知道在tensorflow框架下构建项目的简洁性.后面我会继续对该指南进行傻瓜式记录,希望在复现别人项目的基础上逐渐巩固对机器学习的认识.