MNIST For ML Beginners - https://www.tensorflow.org/get_started/mnist/beginners
Deep MNIST for Experts - https://www.tensorflow.org/get_started/mnist/pros
Version:
TensorFlow 1.2.0+ Flask 0.12 + Gunicorn 19.6
related articles:
TensorFlow's entry experience
TensorFlow's handwritten digit recognition MNIST
TensorFlow's object detection
TensorFlow's construction of a character recognition system
MNIST is equivalent to the Hello World of machine learning.
Here, a number is drawn on the page through Canvas, and then passed to TensorFlow for recognition, and the recognition results of the Softmax regression model and the multi-layer convolutional network are given respectively.
(1) File structure
│ main.py
│ requirements.txt
│ runtime.txt
├─mnist
│ │ convolutional.py
│ │ model.py │
│ regression.py
│ │ __init__.py
│ └─data
│ convolutional.ckpt.data-00000-of-00001
│ convolutional.ckpt.index
│ regression.ckpt.data-00000-of-00001
│ regression.ckpt.index
├─src
│ └─js
│ main. js
├─static
│ ├─css
│ │ bootstrap.min.css
│ └─js
│ jquery.min.js
│
main.js └─templates
index.html
(2) Download the training data
and put the following files in /tmp/data/ , without decompression, the training code will be decompressed automatically.
quote
http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Execute command training data (Softmax regression model, multi-layer convolutional network)
# python regression.py # python convolutional.py
After the execution is completed, the following files will be generated in mnist/data/. These files need to be deleted before retraining.
quote
convolutional.ckpt.data-00000-of-00001
convolutional.ckpt.index
regression.ckpt.data-00000-of-00001
regression.ckpt.index
convolutional.ckpt.index
regression.ckpt.data-00000-of-00001
regression.ckpt.index
(3) Start the web service test
# cd /usr/local/tensorflow2/tensorflow-models/tf-mnist # pip install -r requirements.txt # gunicorn main:app --log-file=- --bind=localhost:8000
Access in the browser: http://localhost:8000
*** The running version of TensorFlow, the model trained by the data, and the conversion of Canvas here all have a certain impact on the recognition rate~!
(4) The Web part of the source code
is relatively simple. A Canvas is placed on the page. When the mouse is lifted, the image of the Canvas is passed to the background API through Ajax, and then the API results are displayed.
quote
src/js/main.js -> static/js/main.js
templates/index.html
templates/index.html
main.py
import numpy as np
import tensorflow as tf
from flask import Flask, jsonify, render_template, request
from mnist import model
x = tf.placeholder("float", [None, 784])
sex = tf.Session ()
# restore trained data
with tf.variable_scope("regression"):
y1, variables = model.regression(x)
saver = tf.train.Saver(variables)
saver.restore(sess, "mnist/data/regression.ckpt")
with tf.variable_scope("convolutional"):
keep_prob = tf.placeholder("float")
y2, variables = model.convolutional(x, keep_prob)
saver = tf.train.Saver(variables)
saver.restore(sess, "mnist/data/convolutional.ckpt")
def regression(input):
return sess.run(y1, feed_dict={x: input}).flatten().tolist()
def convolutional(input):
return sess.run(y2, feed_dict={x: input, keep_prob: 1.0}).flatten().tolist()
# webapp
app = Flask(__name__)
@app.route('/api/mnist', methods=['POST'])
def mnist():
input = ((255 - np.array(request.json, dtype=np.uint8)) / 255.0).reshape(1, 784)
output1 = regression(input)
output2 = convolutional(input)
print(output1)
print(output2)
return jsonify(results=[output1, output2])
@app.route('/')
def main():
return render_template('index.html')
if __name__ == '__main__':
app.run()
mnist/model.py
import tensorflow as tf
# Softmax Regression Model
def regression(x):
W = tf.Variable(tf.zeros([784, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
y = tf.nn.softmax(tf.matmul(x, W) + b)
return y, [W, b]
# Multilayer Convolutional Network
def convolutional(x, keep_prob):
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
# First Convolutional Layer
x_image = tf.reshape(x, [-1, 28, 28, 1])
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
# Second Convolutional Layer
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
# Densely Connected Layer
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# Dropout
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# Readout Layer
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
return y, [W_conv1, b_conv1, W_conv2, b_conv2, W_fc1, b_fc1, W_fc2, b_fc2]
mnist/convolutional.py
import them
import model
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets("/tmp/data/", one_hot=True)
# model
with tf.variable_scope("convolutional"):
x = tf.placeholder(tf.float32, [None, 784])
keep_prob = tf.placeholder(tf.float32)
y, variables = model.convolutional(x, keep_prob)
# train
y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver(variables)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(20000):
batch = data.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0})
print("step %d, training accuracy %g" % (i, train_accuracy))
sess.run(train_step, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print(sess.run(accuracy, feed_dict={x: data.test.images, y_: data.test.labels, keep_prob: 1.0}))
path = saver.save(
sess, os.path.join(os.path.dirname(__file__), 'data', 'convolutional.ckpt'),
write_meta_graph=False, write_state=False)
print("Saved:", path)
mnist/regression.py
import them
import model
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets("/tmp/data/", one_hot=True)
# model
with tf.variable_scope("regression"):
x = tf.placeholder(tf.float32, [None, 784])
y, variables = model.regression(x)
# train
y_ = tf.placeholder("float", [None, 10])
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
saver = tf.train.Saver(variables)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for _ in range(1000):
batch_xs, batch_ys = data.train.next_batch(100)
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
print(sess.run(accuracy, feed_dict={x: data.test.images, y_: data.test.labels}))
path = saver.save(
sess, os.path.join(os.path.dirname(__file__), 'data', 'regression.ckpt'),
write_meta_graph=False, write_state=False)
print("Saved:", path)
Reference:
http://memo.sugyan.com/entry/20151124/1448292129