识别单张数字

import tensorflow as tf
import numpy as np
class MNISTLoader():
    def __init__(self):
        mnist = tf.keras.datasets.mnist
        (self.train_data, self.train_label), (self.test_data, self.test_label) = mnist.load_data()
        # 在 TensorFlow 中，图像数据集的一种典型表示是 [图像数目，长，宽，色彩通道数]
        # MNIST中的图像默认为uint8（0-255的数字）。以下代码将其归一化到0-1之间的浮点数，并在最后增加一维作为颜色通道
        self.train_data = np.expand_dims(self.train_data.astype(np.float32) / 255.0, axis=-1)      # [60000, 28, 28, 1]
        self.test_data = np.expand_dims(self.test_data.astype(np.float32) / 255.0, axis=-1)        # [10000, 28, 28, 1]
        self.train_label = self.train_label.astype(np.int32)    # [60000]
        self.test_label = self.test_label.astype(np.int32)      # [10000]
        self.num_train_data, self.num_test_data = self.train_data.shape[0], self.test_data.shape[0]

    def get_batch(self, batch_size):
        # 从数据集中随机取出batch_size个元素并返回
        index = np.random.randint(0, self.num_train_data, batch_size)
        return self.train_data[index, :], self.train_label[index]
class MLP(tf.keras.Model):
    def __init__(self):
        super().__init__()
        # Flatten层将除第一维（batch_size）以外的维度展平
        self.flatten = tf.keras.layers.Flatten()
        self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

    def call(self, inputs):         # [batch_size, 28, 28, 1]
        x = self.flatten(inputs)    # [batch_size, 784]
        x = self.dense1(x)          # [batch_size, 100]
        x = self.dense2(x)          # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output
# 定义训练参数
num_epochs = 5
batch_size = 50
learning_rate = 0.001

# 实例化模型和数据读取类
model = MLP()
data_loader = MNISTLoader()
# 声明优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate)
# 声明迭代次数
num_batches = int(data_loader.num_train_data // batch_size * num_epochs)
for batch_index in range(num_batches):
    X, y = data_loader.get_batch(batch_size)
    with tf.GradientTape() as tape:
        y_pred = model(X)
        loss = tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred)
        loss = tf.reduce_mean(loss)
        print("batch %d: loss %f" % (batch_index, loss.numpy()))
    grads = tape.gradient(loss, model.variables)
    optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))

sparse_categorical_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()
num_batches = int(data_loader.num_test_data // batch_size)
for batch_index in range(num_batches):
    start_index, end_index = batch_index * batch_size, (batch_index + 1) * batch_size
    y_pred = model.predict(data_loader.test_data[start_index: end_index])
    sparse_categorical_accuracy.update_state(y_true=data_loader.test_label[start_index: end_index], y_pred=y_pred)
print("test accuracy: %f" % sparse_categorical_accuracy.result())
model.save("./model")

import tensorflow as tf

mnist = tf.keras.datasets.mnist
import matplotlib.pyplot as plt
import matplotlib as m
import numpy as np
import  cv2
# 加载模型
model = tf.keras.models.load_model('./model')

# 图片预处理
img = cv2.imread('12.jpg')
# 灰度图
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# print(img.shape)
# plt.imshow(img, cmap='Greys')
#plt.show()
# 取反
img = cv2.bitwise_not(img)
#plt.imshow(img, cmap='Greys')
#plt.show()
# 纯黑 纯白 二值化
img[img <= 100] = 0
img[img >= 140] = 255
plt.imshow(img, cmap='Greys')
plt.show()
# 尺寸
img = cv2.resize(img, (28, 28))
# 归一化
img = img / 255

# 预测
pred = model.predict(img.reshape(1, 28, 28, 1))
print('prediction Number: ', pred.argmax())

# 打印图片信息
plt.imshow(img)
plt.show()