IT数码 购物 网址 头条 软件 日历 阅读 图书馆
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
图片批量下载器
↓批量下载图片,美女图库↓
图片自动播放器
↓图片自动播放器↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁
 
   -> 人工智能 -> 关于使用Tensorflow 2进行Fashion Mnist数据集识别提出的八个问题 -> 正文阅读

[人工智能]关于使用Tensorflow 2进行Fashion Mnist数据集识别提出的八个问题

关于使用Tensorflow 2进行Fashion Mnist数据集识别提出的八个问题

本篇文章是参考了Andrew Ng与Laurence Moroney的Tensorflow 2.0课程而作的,其中加入了本人一些浅显的理解,拾人牙慧,实属惭愧。


我们考虑使用神经网络解决一些计算机视觉方面的问题,下面通过一个例子----不同服饰种类的识别来进行关于神经网络一些问题的探究。

一、全连接层神经网络(DNN)的建立

导入第三方库,并查看Tensorflow版本,确保使用2.0以上版本,如果版本过低,建议先进行新版本的安装再进行下面的学习。

import tensorflow as tf
print(tf.__version__)

Fahion Mnist 数据集已经封装在tf.keras.datasets当中,在使用时,我们只需要载入即可。

mnist = tf.keras.datasets.fashion_mnist

load_data命令将整个数据集分成两部分,一部分作为训练数据,另一部分作为测试数据。

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

数据集当中的数据具体是什么呢,我们接下来通过输出结果观察一下。

import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

展示出训练集第一张图片的图片数据信息,标签以及在画布上的该图片。

9
[[  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0]
 [  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0
    0   0   0   0   0   0   0   0   0   0]
 [  0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   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]]

在这里插入图片描述
标签为9,从画布上展示的图片大概可以看出训练集第一个图片为踝靴,我们也知道标签9代表的就是踝靴。

然后我们展示不同种类的服饰,发现这些服饰各异,有上衣下装,也包含着鞋靴等。

plt.figure(figsize=(10,10))
for i in range(1,17):
    plt.subplot(4,4,i)
    plt.imshow(training_images[i])

在这里插入图片描述
从上面输出的图片数据可知,每个图片数据矩阵当中的数值均处于0到255之间,我们想到如果所有数据均在0到1之间,那么我们的神经网络训练将会非常好,但是这也并不困难,我们只需对其进行标准化,所有数据均除以255即可。

training_images  = training_images / 255.0
test_images = test_images / 255.0

这里需要注意的是不仅训练集要进行标准化,对测试集也同样需要进行标准化。

接下来进行模型的建立

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10,activation=tf.nn.softmax)
                                    ])
  • Sequential:定义了神经网络当中层的一种顺序结构。
  • Flatten: 从开始对训练数据集中图片的输出可知,图片数据均是二维的,Flatten的作用即是将数据转变为一维数据
  • Dense: 添加一层全连接层的神经网络。
    每一层网络均需要一个激活函数(均是非线性的函数),有许多可供选择,这里暂时不做讨论。
  • Relu :意味着当 x > 0 x>0 x>0时,返回 x x x,当 x < 0 x<0 x<0时,返回 0 0 0。这意味着这有0和大于0的数会进入到下一层神经网络当中。
  • Softmax :在一系列数据当中选择最大的。例如,我们的输出层得到[0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05],它将选取数据当中最大值,而不需人为地再去观察,将该列表数据即转换为 [0,0,0,0,1,0,0,0,0] ,softmax适用于多分类问题。

下面进行模型的编译(compile)与训练(fit),优化方法采用adam,损失函数选用交叉熵,评判指标选用accuracy.

使用训练集中的数据对模型训练五次。

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

结果如下,发现在训练到第五次的时候精度已经到达了0.8266,这说明该神经网络模型在匹配其图片与其对应标签中,有82.66%的概率匹配正确。

Epoch 1/5
1875/1875 [==============================] - 1s 770us/step - loss: 2.9202 - accuracy: 0.7058
Epoch 2/5
1875/1875 [==============================] - 2s 860us/step - loss: 0.6286 - accuracy: 0.7741
Epoch 3/5
1875/1875 [==============================] - 1s 785us/step - loss: 0.5599 - accuracy: 0.8029
Epoch 4/5
1875/1875 [==============================] - 1s 762us/step - loss: 0.5229 - accuracy: 0.8216
Epoch 5/5
1875/1875 [==============================] - 1s 750us/step - loss: 0.5170 - accuracy: 0.8266

接下来来看一下模型对陌生数据预测结果如何,使用测试集对模型进行评估,输入两个数据集,包括测试图片集与测试图片集的标签,得到损失值与精度。

model.evaluate(test_images, test_labels)

结果如下所示,精度达到了0.8260,说明在一定程度上模型具有一定的识别能力。

313/313 [==============================] - 0s 618us/step - loss: 0.5208 - accuracy: 0.8260
[0.5207503437995911, 0.8259999752044678]

二、八个问题

1.模型预测结果的探究

使用model.predict()得到模型对测试图片的预测结果。

classifications = model.predict(test_images)

print(classifications[0])

[7.9142317e-18 9.2104990e-15 3.4202259e-35 1.5384416e-16 1.3053542e-24
2.7295727e-02 8.0706191e-29 3.7396610e-02 1.4129637e-11 9.3530768e-01]

我们得到了一组这样的数据,但我们思考,得到结果的一系列数字究竟有何含义?
我们尝试运行下列代码,发现

print(test_labels[0])
print(np.argmax(classifications[0]))

发现输出结果均为7,model.predict()得到的预测结果意味着什么,我们有以下猜测:

  1. 输出结果是10个没有任何意义的值。
  2. 输出结果是10个计算机制作的10个不同种类。
  3. 输出结果为10个不同服饰种类的可能性。

显然答案便是第3个,输出的结果恰为10个不同服饰种类的概率。

怎样通过输出列表当中的值知道预测结果?我们有以下的猜测:

  1. 没有足够的信息回答这一个问题
  2. 哪一个元素最大,则预测结果为该元素位置
  3. 有几个元素则预测结果为多少

正确答案显然为2,在每个位置上的数据代表着是否为该结果概率,数值越大的也就意味着是该结果的可能性越大。

2.神经元的数量的影响

下面来观察一下将神经网络当中第一层神经元数量改为1024个,输出的损失值大小以及耗费的时间。

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(1024, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])

输出结果如下:

2.3.0
Epoch 1/5
1875/1875 [==============================] - 10s 5ms/step - loss: 0.1832
Epoch 2/5
1875/1875 [==============================] - 10s 5ms/step - loss: 0.0755
Epoch 3/5
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0477
Epoch 4/5
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0353
Epoch 5/5
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0255
313/313 [==============================] - 0s 1ms/step - loss: 0.0711
[2.17035829e-08 6.24947845e-08 1.41845042e-08 1.13515984e-04
 1.89369367e-10 5.86703264e-09 5.19989087e-11 9.99870062e-01
 8.58290718e-07 1.54760037e-05]
7

问题1:将神经元个数增加到1024个产生的影响?我们作出了如下的猜想。

  1. 时间变长,精度变高
  2. 时间变长,精度相同
  3. 时间不变,精度变高

正确答案为1,通过增加神经元个数我们做了更多的运算,减缓了训练过程,但我们也获得了更好的影响,得到了更高的精确度,但这并不意味着训练次数越多越好,这也需要在一定程度上合理选择。

3.删除展平层(Flatten)

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels),(test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([#tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(64, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])

在这里插入图片描述
我们发现将会报错,说明展平层的存在是必要的,但是原因我们却是不明确的。现在我们数据集每一张图片都是2828形状的,所以要想进行神经网络的建立需要28层28个神经元的神经网络,所以我们将其展平为7841形状的数据更有意义。

4.输出层神经元的个数

考虑输出层神经元的个数,为什么一定要是10个,如果我们将其改为5个会发生什么呢?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(64, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(5, activation=tf.nn.softmax)])#因为是五个神经元所以会报错

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])

在这里插入图片描述

同样的,程序将会报错,所以这引出第二个原则----最后一层神经元个数一定要等于分类的种类数量。

5.增加隐藏层

考虑增加一层神经网络层对结果影响,在512个神经元的层与10个神经元的输出层当中插入一层包括256个神经元的层。

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(512, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(256, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=5)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[0])
print(test_labels[0])

输出结果如下:

2.3.0
Epoch 1/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.1825
Epoch 2/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0773
Epoch 3/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0553
Epoch 4/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0410
Epoch 5/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0306
313/313 [==============================] - 0s 955us/step - loss: 0.0757
[1.1087765e-11 1.7926065e-07 5.5143340e-07 3.6257799e-08 8.3221478e-11
 1.4963332e-08 6.8053222e-14 9.9999893e-01 3.5755072e-09 2.3824717e-07]
7

我们看不出增添一层神经网络隐藏层对我们结果产生了什么影响,这是因为我们使用的就是普通的数据,例如带有多种颜色的图片,增添神经网络层往往是很有必要的。

6.改变模型训练次数

考虑如果我们使用更多或者更少的训练次数,我们将得到什么结果呢?

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.mnist

(training_images, training_labels) ,  (test_images, test_labels) = mnist.load_data()

training_images = training_images/255.0
test_images = test_images/255.0

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu),
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

model.compile(optimizer = 'adam',
              loss = 'sparse_categorical_crossentropy')

model.fit(training_images, training_labels, epochs=30)

model.evaluate(test_images, test_labels)

classifications = model.predict(test_images)

print(classifications[34])
print(test_labels[34])

训练次数改为15次,我们发现训练结果更加精确,损失值变得更小。
训练次数改为30次时,我们发现训练后期损失值变得忽大忽小,这就是因为数据产生了过拟合的结果,在以后的神经网络训练当中,我们需要极力避免这种现象的发生。

7.标准化(Normalization)

在训练一开始,我们对数据进行了标准化,将大小在0到255之间的数据都转化成了0到1之间的数据。所以我们考虑取消这一操作对结果有何影响。

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images
test_images=test_images
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])

输出结果如下:

2.3.0
Epoch 1/5
1875/1875 [==============================] - 5s 3ms/step - loss: 2.7173
Epoch 2/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.3359
Epoch 3/5
1875/1875 [==============================] - 5s 2ms/step - loss: 0.3222
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2772
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2551
313/313 [==============================] - 0s 765us/step - loss: 0.2600
[0.0000000e+00 3.7754320e-21 3.5940075e-12 4.2507407e-24 6.5570809e-32
 1.1645400e-27 0.0000000e+00 1.0000000e+00 9.0640749e-23 4.9115202e-22]
7

8.回调函数(Callbacks)

在实际操作当中,我们发现随着训练次数的增加,损失值,精确度都会随之改变,在一些情况下,这并不会得到更好的效果,一般而言,95%的精确度就是一个比较不错的标准,如果我们在训练三次就得到该精度,后面的训练便不太有意义,我们可以采用什么办法让训练停下来呢?我们接下来考虑使用callbacks

示例:
下面代码实现了在损失值小于0.4时终止模型的功能。

import tensorflow as tf
print(tf.__version__)

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('loss')<0.4):
      print("\nReached 60% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

输出结果如下:

2.3.0
Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.4719
Epoch 2/5
1866/1875 [============================>.] - ETA: 0s - loss: 0.3576
Reached 60% accuracy so cancelling training!
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3577
  人工智能 最新文章
2022吴恩达机器学习课程——第二课(神经网
第十五章 规则学习
FixMatch: Simplifying Semi-Supervised Le
数据挖掘Java——Kmeans算法的实现
大脑皮层的分割方法
【翻译】GPT-3是如何工作的
论文笔记:TEACHTEXT: CrossModal Generaliz
python从零学(六)
详解Python 3.x 导入(import)
【答读者问27】backtrader不支持最新版本的
上一篇文章      下一篇文章      查看所有文章
加:2021-07-23 10:47:03  更:2021-07-23 10:48:08 
 
开发: C++知识库 Java知识库 JavaScript Python PHP知识库 人工智能 区块链 大数据 移动开发 嵌入式 开发工具 数据结构与算法 开发测试 游戏开发 网络协议 系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑 笔记本 显卡 显示器 固态硬盘 硬盘 耳机 手机 iphone vivo oppo 小米 华为 单反 装机 图拉丁

360图书馆 购物 三丰科技 阅读网 日历 万年历 2024年3日历 -2024/3/29 14:00:04-

图片自动播放器
↓图片自动播放器↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  IT数码