tensorflow2知识总结---5、softmax多分类

tensorflow2知识总结---5、softmax多分类

一、总结

一句话总结：

softmax多分类适用于神经网络输出层是一个多分类的输出的情况

 

1、tensorflow的输出层注意？

如果输出层是一个连续的数字，就不进行其它操作，直接输出

如果输出层是一个二分类（是和否），可以对输出层做一个sigmoid操作，然后输出

如果输出层是一个多分类的输出，我们就可以对输出层做一个softmax输出

二分类：输出层是sigmoid
model.add(tf.keras.layers.Dense(1,activation='sigmoid'))
多分类：输出层是softmax时
model.add(tf.keras.layers.Dense(10,activation='softmax'))

 

2、在tf.keras里，对于多分类问题我们使用categorical_crossentropy和sparse_categorical_crossentropy来计算softmax交叉熵，这两者分别的使用情况是什么？

categorical_crossentropy 使用情况为 one-hot编码，比如北京 [1,0,0]、上海 [0,1,0]、深圳 [0,0,1]

sparse_categorical_crossentropy 使用情况为普通数字编码，比如 0表示北京，1表示上海，2表示深圳

 

 

3、Fashion MNIST 数据集？

Fashion MNIST 数据集包含70000张灰度图像，涵盖10个类别。60000张图像训练网络，10000张测试。

(train_image,train_label),(test_image,test_label) = tf.keras.datasets.fashion_mnist.load_data()

 

4、matplotlib显示图片？

matplotlib的imshow的方法：plt.imshow(train_image[0])

 

 

5、如何对图片数据进行归一化？

因为图片是由像素值组成，rgb，而值得取值范围值0-255，所以除255即可

# 图片数据如何归一化
# 直接除255即可
train_image = train_image/255
test_image = test_image/255

 

 

6、用测试数据评估模型？

model.evaluate(test_image,test_label)

 

 

二、softmax多分类

博客对应课程的视频位置：

 

对数几率回归解决的是二分类的问题，

对于多个选项的问题，我们可以使用softmax函数

它是对数几率回归在N个可能不同的值上的推广

这就是Softmax层的作用

神经网络的原始输出不是一个概率值，

实质上只是输入的数值做了复杂的加权和与非线性处理之后的一个值而已，

那么如何将这个输出变为概率分布？

softmax要求每个样本必须属于某个类别，且所有可能的样本均被覆盖

softmax个样本分量之和为1

当只有两个类别时，与对数几率回归完全相同

---

在tf.keras里，对于多分类问题我们使用

categorical_crossentropy和sparse_categorical_crossentropy

来计算softmax交叉熵

---

categorical_crossentropy 使用情况为 one-hot编码，比如

北京 [1,0,0]
上海 [0,1,0]
深圳 [0,0,1]

sparse_categorical_crossentropy 使用情况，

0表示北京，1表示上海，2表示深圳

Fashion MNIST 数据集

Fashion MNIST的作用是成为经典MNIST数据集的简易替换，

MNIST数据集包含手写数字（0、1、2等）的图像，这些图像的格式与本节课中使用的服饰图像的格式相同。

Fashion MNIST 比常规MNIST手写数据集更具挑战性。

这两个数据集都相对较小，用于验证某个算法能否如期正常运行。它们都是测试和调试代码的良好起点。

MNIST手写数据集将作为作业交给大家自己完成。

---

Fashion MNIST 数据集包含70000张灰度图像，涵盖10个类别。

我们将使用60000张图像训练网络，并使用10000张图像评估经过学习的网络分类图像的准确率。

可以从TensorFlow 直接访问Fashion MNIST，只需导入和加载数据即可

In [1]:

import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

In [2]:

# 获取训练数据集和测试数据集
# 路径：C:\Users\Fan Renyi\.keras\datasets\fashion-mnist
(train_image,train_label),(test_image,test_label) = tf.keras.datasets.fashion_mnist.load_data()

In [3]:

train_image.shape

Out[3]:

(60000, 28, 28)

In [4]:

train_label.shape

Out[4]:

(60000,)

In [5]:

test_image.shape,test_label.shape

Out[5]:

((10000, 28, 28), (10000,))

In [6]:

plt.imshow(train_image[0])

Out[6]:

<matplotlib.image.AxesImage at 0x14ea9ac7e48>

In [7]:

# 像素值 RGB
np.max(train_image[0])

Out[7]:

255

In [8]:

train_label

Out[8]:

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

数据归一化

In [9]:

# 图片数据如何归一化
# 直接除255即可
train_image = train_image/255
test_image = test_image/255

创建模型

In [10]:

# 顺序模型
model = tf.keras.Sequential()
# 将多维数据（60000, 28, 28）变成一维
# 把图像扁平化成一个向量
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) 
# 这里的神经元也不能太多，神经元太多容易产生过拟合
# 神经元太少，会舍弃很多信息
model.add(tf.keras.layers.Dense(128,activation='relu'))
# 输出10个概率值，输出图片属于哪一类
model.add(tf.keras.layers.Dense(10,activation='softmax'))

编译模型

In [11]:

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

In [12]:

history = model.fit(train_image,train_label,epochs=5)

Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.5017 - acc: 0.8235
Epoch 2/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.3768 - acc: 0.8635
Epoch 3/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.3377 - acc: 0.8774
Epoch 4/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.3125 - acc: 0.8864
Epoch 5/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.2949 - acc: 0.8920

用测试数据评价模型

In [14]:

model.evaluate(test_image,test_label)

313/313 [==============================] - 0s 901us/step - loss: 0.3468 - acc: 0.8765

Out[14]:

[0.34679675102233887, 0.8765000104904175]

在测试的训练集上的准确率为0.87

将顺序编码编程one-hot编码

In [15]:

train_label_onehot=tf.keras.utils.to_categorical(train_label)

In [16]:

train_label_onehot

Out[16]:

array([[0., 0., 0., ..., 0., 0., 1.],
       [1., 0., 0., ..., 0., 0., 0.],
       [1., 0., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 0., 0.],
       [1., 0., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]], dtype=float32)

In [17]:

test_label_onehot=tf.keras.utils.to_categorical(test_label)

In [18]:

test_label

Out[18]:

array([9, 2, 1, ..., 8, 1, 5], dtype=uint8)

In [20]:

test_label_onehot

Out[20]:

array([[0., 0., 0., ..., 0., 0., 1.],
       [0., 0., 1., ..., 0., 0., 0.],
       [0., 1., 0., ..., 0., 0., 0.],
       ...,
       [0., 0., 0., ..., 0., 1., 0.],
       [0., 1., 0., ..., 0., 0., 0.],
       [0., 0., 0., ..., 0., 0., 0.]], dtype=float32)

9也就是对应[0., 0., 0., ..., 0., 0., 1.],

In [23]:

model = tf.keras.Sequential()
model.add(tf.keras.layers.Flatten(input_shape=(28,28))) 
model.add(tf.keras.layers.Dense(128,activation='relu'))
model.add(tf.keras.layers.Dense(10,activation='softmax'))

# 模型从 sparse_categorical_crossentropy 变成了 categorical_crossentropy
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['acc'])
# train_label变成了train_label_onehot
history = model.fit(train_image,train_label_onehot,epochs=5)

Epoch 1/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.4968 - acc: 0.8243
Epoch 2/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.3793 - acc: 0.8636
Epoch 3/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3422 - acc: 0.8754
Epoch 4/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.3155 - acc: 0.8850
Epoch 5/5
1875/1875 [==============================] - 2s 1ms/step - loss: 0.2984 - acc: 0.8900

In [24]:

predict=model.predict(test_image)
predict.shape

Out[24]:

(10000, 10)

In [26]:

# 对第一张图片的预测
predict[0]

Out[26]:

array([1.6070395e-05, 3.5059514e-07, 4.9826558e-06, 2.1827427e-07,
       2.1989422e-06, 1.2660904e-01, 3.0896514e-05, 1.1124686e-02,
       1.2446012e-04, 8.6208713e-01], dtype=float32)

所有样本的可能性加起来为1

In [27]:

np.argmax(predict[0])

Out[27]:

9

In [28]:

test_label[0]

Out[28]:

9

In [ ]:

 

 

 

 

softmax多分类适用于神经网络输出层是一个多分类的输出的情况