如何使用 Keras 模型进行手写字符识别预测

Question

We have already the trained model but we can't write the part of the program that makes the predictions. We can open the picture but we can't process it with TensorFlow.

Any help would be appreciated. Here is what we already have.

 from __future__ import absolute_import, division, print_function, unicode_literals

# Install TensorFlow

import tensorflow as tf
mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='tanh'),    #relu, softmax, tanh
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='tanh')
])

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

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Answer 1

You can use the model object's .predict() method as follows:

import numpy as np

predictions = model.predict([x_test]) # Make prediction
print(np.argmax(predictions[1000])) # Print out the number

Anyway I advice you to study a nice, simple example of how to use tensorflow for classifying handwritten digits by Abdelhakim Ouafi. I'm including the main parts here for future readers for the case, if the link would be available:

Description of the MNIST Handwritten Digit.

The MNIST Handwritten Digit is a dataset for evaluating machine learning and deep learning models on the handwritten digit classification problem, it is a dataset of 60,000 small square 28×28 pixel grayscale images of handwritten single digits between 0 and 9.

Import the TensorFlow library

import tensorflow as tf # Import tensorflow library
import matplotlib.pyplot as plt # Import matplotlib library

Create a variable named mnist, and set it to an object of the MNIST dataset from the Keras library and we're gonna unpack it to a training dataset (x_train, y_train) and testing dataset (x_test, y_test) :

mnist = tf.keras.datasets.mnist # Object of the MNIST dataset
(x_train, y_train),(x_test, y_test) = mnist.load_data() # Load data

Preprocess the data

To make sure that our data was imported correctly, we are going to plot the first image from the training dataset using matplotlib:

plt.imshow(x_train[0], cmap="gray") # Import the image
plt.show() # Plot the image

Before we feed the data into the neural network we need to normalize it by scaling the pixels value in a range from 0 to 1 instead of being from 0 to 255 and that make the neural network needs less computational power:

# Normalize the train dataset
x_train = tf.keras.utils.normalize(x_train, axis=1)
# Normalize the test dataset
x_test = tf.keras.utils.normalize(x_test, axis=1)

Build the model Now, we are going to build the model or in other words the neural network that will train and learn how to classify these images.

It worth noting that the layers are the most important thing in building an artificial neural network since it will extract the features of the data.

First and foremost, we start by creating a model object that lets you add the different layers.

Second, we are going to flatten the data which is the image pixels in this case. So the images are 28×28 dimensional we need to make it 1×784 dimensional so the input layer of the neural network can read it or deal with it. This is an important concept you need to know.

Third, we define input and a hidden layer with 128 neurons and an activation function which is the relu function.

And the Last thing we create the output layer with 10 neurons and a softmax activation function that will transform the score returned by the model to a value so it will be interpreted by humans.

#Build the model object
model = tf.keras.models.Sequential()
# Add the Flatten Layer
model.add(tf.keras.layers.Flatten())
# Build the input and the hidden layers
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
# Build the output layer
model.add(tf.keras.layers.Dense(10, activation=tf.nn.softmax))

Compile the model Since we finished building the neural network we need to compile the model by adding some few parameters that will tell the neural network how to start the training process.

First, we add the optimizer which will create or in other word update the parameter of the neural network to fit our data.

Second, the loss function that will tell you the performance of your model.

Third, the Metrics which give indicative tests of the quality of the model.

# Compile the model
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])

Train the model We are ready to train our model, we call the fit subpackage and feed it with the training data and the labeled data that correspond to the training dataset and how many epoch should run or how many times should make a guess.

model.fit(x=x_train, y=y_train, epochs=5) # Start training process

Evaluate the model Let's see how the model performs after the training process has finished.

# Evaluate the model performance
test_loss, test_acc = model.evaluate(x=x_test, y=y_test)
# Print out the model accuracy 
print('\nTest accuracy:', test_acc)

Evaluating the Model Performance It shows that the neural network has reached 97.39% accuracy which is pretty good since we train the model just with 5 epochs.

Make predictions Now, we will start making a prediction by importing the test dataset images.

predictions = model.predict([x_test]) # Make prediction

We are going to make a prediction for numbers or images that the model has never seen before.

For instance, we try to predict the number that corresponds to the image number 1000 in the test dataset:

print(np.argmax(predictions[1000])) # Print out the number

As you see, the prediction is number nine but how we can make sure that this prediction was true? well, we need to plot the image number 1000 in the test dataset using matplotlib:

plt.imshow(x_test[1000], cmap="gray") # Import the image
plt.show() # Show the image