tensorflow_mnist数据集卷积神经网络实例

程序1：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt

mnist = input_data.read_data_sets('data', one_hot=True)

#train = mnist.next_batch(100)

#print(dir(mnist))
#print(mnist.train.num_examples)
#print(mnist.test.num_examples)
#print(mnist.validation.num_examples)
#print(mnist.train.images.shape)

train_images = mnist.train.images
train_labels = mnist.train.labels
#print(train_labels[1])
#plt.imshow(train_images[1].reshape((28,28)), cmap = 'gray')
#plt.show()
#print(dir(tf.nn))
#print(help(tf.nn.max_pool))
#input_data = mnist.train.next_batch(1)[0].reshape([-1,28,28,1])
x_input = tf.placeholder(tf.float32, [None, 28, 28, 1])
y_input = tf.placeholder(tf.float32, [None, 10])

#Weights1 = tf.Variable(tf.random_normal([5,5,1,32], stddev = 0.1))
Weights1 = tf.Variable(tf.truncated_normal([5,5,1,32], stddev = 0.1))
Biases1 = tf.Variable(tf.zeros([32])+0.01)
#Weights2 = tf.Variable(tf.random_normal([3,3,32,64], stddev = 0.1))
#Weights2 = tf.Variable(tf.truncated_normal([3,3,32,64], stddev = 0.1))
Weights2 = tf.Variable(tf.truncated_normal([5,5,32,64], stddev = 0.1))
Biases2 = tf.Variable(tf.zeros([64])+0.01)
conv1 = tf.nn.relu(tf.nn.conv2d(x_input, filter=Weights1, strides = [1,1,1,1], padding='SAME')+Biases1)
pool1 = tf.nn.max_pool(conv1, ksize = [1,2,2,1], strides = [1,2,2,1], padding = 'SAME')

conv2 = tf.nn.relu(tf.nn.conv2d(pool1, filter = Weights2, strides = [1,1,1,1], padding='SAME')+Biases2)
pool2 = tf.nn.max_pool(conv2, ksize=[1,2,2,1], strides = [1,2,2,1], padding='SAME')

def add_layer(input_data, in_size, out_size, activation_function = None):
    #Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    Weights = tf.Variable(tf.truncated_normal([in_size, out_size], stddev = 0.1))
    Biases = tf.Variable(tf.zeros([1, out_size])+0.0001)
    Wx_plus_b = tf.add(tf.matmul(input_data, Weights), Biases)
    if activation_function==None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
    return outputs
#print(dir(pool2))
fc_input_data = tf.reshape(pool2,[-1, 7*7*64])

fc1 = add_layer(fc_input_data,7*7*64, 1024, tf.nn.relu)
#fc1_drop = tf.nn.dropout(fc1, 0.4)
#fc2 = add_layer(fc1_drop, 1024, 10, tf.nn.softmax)
fc2 = add_layer(fc1, 1024, 10, tf.nn.softmax)

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_input*tf.log(fc2), reduction_indices=[1]))#, reduction_indices=[0])
#cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), reduction_indices=[1]))       # loss

#optimizer = tf.train.GradientDescentOptimizer(0.0001)
#optimizer = tf.train.AdadeltaOptimizer(1e-4)
optimizer = tf.train.AdamOptimizer(1e-4)
train = optimizer.minimize(cross_entropy)

def get_accuracy():
    global fc2, y_input
    accu = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(fc2, axis = 1), tf.argmax(y_input, axis=1)),dtype =tf.float32))
    return accu
    

init = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(init)
    #for i in range(500):
    for i in range(1001):
        train_im, train_la = mnist.train.next_batch(100)
#        print(sess.run(Weights1[:,:,0,0]))
#        print(sess.run(fc1, feed_dict = {x_input: train_im.reshape([-1, 28, 28, 1])}))
#        print(sess.run(fc2, feed_dict = {x_input: train_im.reshape([-1, 28, 28, 1])}))
        sess.run(train, feed_dict = {x_input: train_im.reshape([-1, 28, 28, 1]), y_input:train_la})
        if i%100==0:
            print(sess.run(cross_entropy, feed_dict = {x_input: train_im.reshape([-1, 28, 28, 1]), y_input:train_la}))
            test_images = mnist.test.images
            test_labels = mnist.test.labels
            print(sess.run(get_accuracy(), feed_dict = {x_input: test_images.reshape([-1, 28, 28, 1]), y_input:test_labels}))
#print(out_data[0,:,:,1].shape)
#plt.imshow(out_data[0,:,:,63], cmap = 'gray')
#plt.show()

程序2：

"""
Please note, this code is only for python 3+. If you are using python 2+, please modify the code accordingly.
"""
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# number 1 to 10 data
mnist = input_data.read_data_sets('data', one_hot=True)

def compute_accuracy(v_xs, v_ys):
    global prediction
    y_pre = sess.run(prediction, feed_dict={xs: v_xs, keep_prob: 1})
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys, keep_prob: 1})
    return result

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)

def conv2d(x, W):
    # stride [1, x_movement, y_movement, 1]
    # Must have strides[0] = strides[3] = 1
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
    # stride [1, x_movement, y_movement, 1]
    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

# define placeholder for inputs to network
xs = tf.placeholder(tf.float32, [None, 784]) # 28x28
ys = tf.placeholder(tf.float32, [None, 10])
keep_prob = tf.placeholder(tf.float32)
x_image = tf.reshape(xs, [-1, 28, 28, 1])
# print(x_image.shape)  # [n_samples, 28,28,1]

## conv1 layer ##
W_conv1 = weight_variable([5,5, 1,32]) # patch 5x5, in size 1, out size 32
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # output size 28x28x32
h_pool1 = max_pool_2x2(h_conv1)                                         # output size 14x14x32

## conv2 layer ##
W_conv2 = weight_variable([5,5, 32, 64]) # patch 5x5, in size 32, out size 64
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # output size 14x14x64
h_pool2 = max_pool_2x2(h_conv2)                                         # output size 7x7x64

## func1 layer ##
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
# [n_samples, 7, 7, 64] ->> [n_samples, 7*7*64]
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)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

## func2 layer ##
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)


# the error between prediction and real data
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), reduction_indices=[1]))       # loss
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

sess = tf.Session()
# important step
sess.run(tf.global_variables_initializer())

for i in range(1001):
    #batch_xs, batch_ys = mnist.train.next_batch(100)
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={xs: batch_xs, ys: batch_ys, keep_prob: 0.5})
    if i % 100 == 0:
        print(sess.run(cross_entropy, feed_dict ={xs: batch_xs, ys: batch_ys, keep_prob: 0.5}))
        print(compute_accuracy(
        mnist.test.images, mnist.test.labels))