20210608 TensorFlow 实现数字图片分类

Posted 2021-08-24 ATaburiss

0-1 导包

import warnings
warnings.filterwarnings("ignore")

import keras
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

1-1 构造数据
调用接口去下载数据

mnist = keras.datasets.mnist     # 导入 mnist 
(train_images, train_labels),(test_images,test_labels) = mnist.load_data()

60000条训练集，10000条测试集

print("train image shape:",train_images.shape,"train label",train_labels.shape)
print("test image shape:",test_images.shape,"test label",test_labels.shape)

-->
train image shape: (60000, 28, 28) train label (60000,)
test image shape: (10000, 28, 28) test label (10000,)
60000条训练集分为训练的图片和标签，图片是手写的数字图片，长和宽都是 28，标签就是数字集，测试集是 10000 个图片，测试标签也是 10000

1-1-1 显示数据和标签

print("image data:",train_images[0])
print("label data:",train_labels[0])

# 数据太多太大，这里便不展示了
# label data: 5

1-1-2

defplot_img(img):
    plt.imshow(img.reshape(28,28),cmap="binary")    # camp = "binary" 使用灰度图表示
    plt.show()
# 查看图片
plot_img(train_images[3])
plot_img(train_images[0])

1-1-3 现在进行一个 0 1 的二分类

data_0 = []
data_1 = []
# zip 把里面的子数据 拿出来了，img是(28,28)；label 标签是一个值
for img,label in zip(train_images, train_labels):
    if label == 0:
        # 首先需要把图片拍平，现在的训练是一种类似 DNN 神经网络的模式
        # 所以无法传入 28*28 的图片进行训练，reshape(28*28)，将二阶变为一阶的 784
        # 除以 255 的作用是，约束到 0 到 1 之间
        img = img.reshape(28*28)/255    
        # 将图片和 label 放一起，变成 785 个数据，赋给 img
        img = np.append(img,label)
        data_0.append(img)  
    if label == 1:
        img = img.reshape(28*28)/255
        img = np.append(img,label)
        data_1.append(img)
data_0 = np.array(data_0)
data_1 = np.array(data_1)
all_data = np.concatenate([data_0,data_1])
print(all_data.shape)

# --> (12665, 785)
# 前 784 是像素，最后的 1 是标签

np.random.shuffle(all_data)     # np.random.shuffle 打乱顺序，避免前面全是0，后面全是 1
# 切分训练集和数据集，按理说 20% 测试集，80%训练集，这里只是简单的 前面的作为训练集，后200个作为测试集
train_data = all_data[:-200]
test_data = all_data[-200:]

2-1 数据分块

# 生成器
def gen_batch(data,batch_size):
    np.random.shuffle(data)     # 打乱，增加随机性
    for i in range(len(data) // batch_size):
        cursor = batch_size * i
        batch_data = data[cursor : cursor + batch_size]
        x = batch_data[:, 0:784]    # 第一维度全取，第二维度取前 784 个像素，最后一个是标签
        y = batch_data[:, 784]
        yield x,y.reshape(-1,1)
    remainder = len(data) % batch_size
    if remainder != 0:
        x, y = data[-remainder:, 0:784], data[-remainder:, 784]
        yield x, y.reshape(-1,1)
for x_,y_ in gen_batch(train_data,128):
    print(x_.shape)
    print(y_.shape)
    print(\'-------\')
    break

# -->
# (128, 784)
# (128, 1)
# -------

3-1 超参数

learing_rate = 0.01
num_train_epochs = 50      # 循环训练集总轮数
display_per_step = 100
batch_size = 128

4-1 计算图

graph = tf.Graph()
with graph.as_default():
    x = tf.placeholder(shape=[None,784], dtype=tf.float32, name=\'x\')
    y = tf.placeholder(shape=[None,1], dtype=tf.float32, name=\'y\')
    w =  tf.Variable(tf.ones(shape=[784,1]), dtype=tf.float32)
    b =  tf.Variable(0, dtype=tf.float32)
    logits = tf.matmul(x, w) + b    
    y_pred = tf.sigmoid(logits)
    # 定义loss
    with tf.name_scope("loss"):
        loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits), name="calculate_loss")
    # 定义优化器
    with tf.name_scope("SGD"):
        optimizer = tf.train.GradientDescentOptimizer(learing_rate)
        train_step = optimizer.minimize(loss)
    # 定义正确率
    with tf.name_scope("calculation_accuracy"):
        res_pred = tf.cast(tf.greater_equal(y_pred, 0.5), dtype=tf.float32)
        acc = tf.reduce_mean(tf.cast(tf.equal(res_pred, y), dtype=tf.float32))

5-1 运行计算图

with tf.Session(graph=graph) as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    step = 0
    for epoch in range(num_train_epochs):
        for x_, y_ in gen_batch(train_data, batch_size):
            step += 1
            _, l, acc_ = sess.run([train_step, loss, acc], feed_dict={x: x_, y: y_})
            if step % display_per_step == 0:
                print("step: {:>4}, loss: {:.4}, acc: {:.4%}".format(step, l, acc_))
    print(\'training over\')
    x_test,y_test = next(gen_batch(test_data,200))   # 取出全部测试集数据
    # 查看测试集的 loss 和正确率
    loss_test, acc_test = sess.run([loss, acc],feed_dict={x: x_test, y: y_test})
    print("test loss is {:.4}, acc is {:.4%}".format(loss_test, acc_test))
    res_weights = sess.run([w, b])
    # res_weights 存在的目的是进行模型的预测，给出一张图片，判断能否正确预测

-->
step:  100, loss: 43.14, acc: 60.1562%
step:  200, loss: 34.86, acc: 50.7812%
step:  300, loss: 19.21, acc: 52.3438%
……
step: 4700, loss: 0.09711, acc: 96.8750%
step: 4800, loss: 0.1117, acc: 97.6562%
step: 4900, loss: 0.0001993, acc: 100.0000%
training over
test loss is 0.04518, acc is 99.0000%

6-1 模型预测

def plot_img(img):
    plt.imshow(img.reshape(28,28),cmap="binary")
    plt.show()
test_img = test_data[7,:784]
plot_img(test_img)

6-2

graph = tf.Graph()
with graph.as_default():
    x = tf.placeholder(shape=[None,784], dtype=tf.float32, name=\'x\')
    y = tf.placeholder(shape=[None,1], dtype=tf.float32, name=\'y\')
    # w 和 b 是前面训练好的值
    w =  tf.Variable(res_weights[0], dtype=tf.float32)
    b =  tf.Variable(res_weights[1], dtype=tf.float32)
    logits = tf.matmul(x, w) + b
    y_pred = tf.sigmoid(logits)
    # 定义loss
    with tf.name_scope("loss"):
        loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits), name="calculate_loss")
    # 定义优化器
    with tf.name_scope("SGD"):
        optimizer = tf.train.GradientDescentOptimizer(learing_rate)
        train_step = optimizer.minimize(loss)
    # 定义正确率
    with tf.name_scope("calculation_accuracy"):
        res_pred = tf.cast(tf.greater_equal(y_pred, 0.5), dtype=tf.float32)
        acc = tf.reduce_mean(tf.cast(tf.equal(res_pred, y), dtype=tf.float32))

with tf.Session(graph=graph) as sess:
    # 初始化权重，将前面训练好的权重，放到计算图里
    init = tf.global_variables_initializer()
    sess.run(init)
    # test_data[7,:784].shape 是 (784,)
    # 但是   x = tf.placeholder(shape=[None,784], dtype=tf.float32, name=\'x\')
    # 所以需要 reshape 成为 (1,-1)，也就是第一维是 1，第二维就是 784/1
    # 所以 当前这里图片 的 shape 就是 (1,784)
    x_ = test_data[7,:784].reshape(1,-1)
    # 从这地方可以看出，预测输出的时候，并没有使用标签，所以传参时只传 x 就可以
    res_p = sess.run(res_pred, feed_dict={x: x_})
    print(res_p)

# --> [[0.]]
预测出的结果是 0，所以简单的网络结构确实可以对测试集的手写数字图片进行预测，这就是一个数字的图片分类

部分代码解释：
1. 1-1-3 中的 zip()
https://blog.51cto.com/u_15149862/2847102
2. 1-1-3 中列表的使用，比如 train_data = all_data[:-200]
https://blog.51cto.com/u_15149862/2704954
3. 2-1 中的生成器
https://blog.51cto.com/u_15149862/2844458
4. TensorFlow 基本用法
https://blog.51cto.com/u_15149862/2825353