tensorflow 基础模型应用4 —— 卷积神经网络 【转】

v

1.convolutional_network

from __future__ import print_function



import tensorflow as tf



# Import MNIST data

from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)



# Parameters

learning_rate = 0.001

training_iters = 200000

batch_size = 128

display_step = 10



# Network Parameters

n_input = 784 # MNIST data input (img shape: 28*28)

n_classes = 10 # MNIST total classes (0-9 digits)

dropout = 0.75 # Dropout, probability to keep units



# tf Graph input

x = tf.placeholder(tf.float32, [None, n_input])

y = tf.placeholder(tf.float32, [None, n_classes])

keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)





# Create some wrappers for simplicity

def conv2d(x, W, b, strides=1):

    # Conv2D wrapper, with bias and relu activation

    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')

    x = tf.nn.bias_add(x, b)

    return tf.nn.relu(x)





def maxpool2d(x, k=2):

    # MaxPool2D wrapper

    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],

                          padding='SAME')





# Create model

def conv_net(x, weights, biases, dropout):

    # Reshape input picture

    x = tf.reshape(x, shape=[-1, 28, 28, 1])



    # Convolution Layer

    conv1 = conv2d(x, weights['wc1'], biases['bc1'])

    # Max Pooling (down-sampling)

    conv1 = maxpool2d(conv1, k=2)



    # Convolution Layer

    conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])

    # Max Pooling (down-sampling)

    conv2 = maxpool2d(conv2, k=2)



    # Fully connected layer

    # Reshape conv2 output to fit fully connected layer input

    fc1 = tf.reshape(conv2, [-1, weights['wd1'].get_shape().as_list()[0]])

    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])

    fc1 = tf.nn.relu(fc1)

    # Apply Dropout

    fc1 = tf.nn.dropout(fc1, dropout)



    # Output, class prediction

    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])

    return out



# Store layers weight & bias

weights = {

    # 5x5 conv, 1 input, 32 outputs

    'wc1': tf.Variable(tf.random_normal([5, 5, 1, 32])),

    # 5x5 conv, 32 inputs, 64 outputs

    'wc2': tf.Variable(tf.random_normal([5, 5, 32, 64])),

    # fully connected, 7*7*64 inputs, 1024 outputs

    'wd1': tf.Variable(tf.random_normal([7*7*64, 1024])),

    # 1024 inputs, 10 outputs (class prediction)

    'out': tf.Variable(tf.random_normal([1024, n_classes]))

}



biases = {

    'bc1': tf.Variable(tf.random_normal([32])),

    'bc2': tf.Variable(tf.random_normal([64])),

    'bd1': tf.Variable(tf.random_normal([1024])),

    'out': tf.Variable(tf.random_normal([n_classes]))

}



# Construct model

pred = conv_net(x, weights, biases, keep_prob)



# Define loss and optimizer

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)



# Evaluate model

correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))

accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))



# Initializing the variables

init = tf.initialize_all_variables()



# Launch the graph

with tf.Session() as sess:

    sess.run(init)

    step = 1

    # Keep training until reach max iterations

    while step * batch_size < training_iters:

        batch_x, batch_y = mnist.train.next_batch(batch_size)

        # Run optimization op (backprop)

        sess.run(optimizer, feed_dict={x: batch_x, y: batch_y,

                                       keep_prob: dropout})

        if step % display_step == 0:

            # Calculate batch loss and accuracy

            loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x,

                                                              y: batch_y,

                                                              keep_prob: 1.})

            print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \

                  "{:.6f}".format(loss) + ", Training Accuracy= " + \

                  "{:.5f}".format(acc))

        step += 1

    print("Optimization Finished!")



    # Calculate accuracy for 256 mnist test images

    print("Testing Accuracy:", \

        sess.run(accuracy, feed_dict={x: mnist.test.images[:256],

                                      y: mnist.test.labels[:256],

keep_prob: 1.}))

2.卷积神经网络

import tensorflow as tf

import numpy as np

import input_data



batch_size = 128

test_size = 256



def init_weights(shape):

    return tf.Variable(tf.random_normal(shape, stddev=0.01))





def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):

    l1a = tf.nn.relu(tf.nn.conv2d(X, w,                       # l1a shape=(?, 28, 28, 32)

                        strides=[1, 1, 1, 1], padding='SAME'))

    l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1],              # l1 shape=(?, 14, 14, 32)

                        strides=[1, 2, 2, 1], padding='SAME')

    l1 = tf.nn.dropout(l1, p_keep_conv)



    l2a = tf.nn.relu(tf.nn.conv2d(l1, w2,                     # l2a shape=(?, 14, 14, 64)

                        strides=[1, 1, 1, 1], padding='SAME'))

    l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1],              # l2 shape=(?, 7, 7, 64)

                        strides=[1, 2, 2, 1], padding='SAME')

    l2 = tf.nn.dropout(l2, p_keep_conv)



    l3a = tf.nn.relu(tf.nn.conv2d(l2, w3,                     # l3a shape=(?, 7, 7, 128)

                        strides=[1, 1, 1, 1], padding='SAME'))

    l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1],              # l3 shape=(?, 4, 4, 128)

                        strides=[1, 2, 2, 1], padding='SAME')

    l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]])    # reshape to (?, 2048)

    l3 = tf.nn.dropout(l3, p_keep_conv)



    l4 = tf.nn.relu(tf.matmul(l3, w4))

    l4 = tf.nn.dropout(l4, p_keep_hidden)



    pyx = tf.matmul(l4, w_o)

    return pyx



mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

trX = trX.reshape(-1, 28, 28, 1)  # 28x28x1 input img

teX = teX.reshape(-1, 28, 28, 1)  # 28x28x1 input img



X = tf.placeholder("float", [None, 28, 28, 1])

Y = tf.placeholder("float", [None, 10])



w = init_weights([3, 3, 1, 32])       # 3x3x1 conv, 32 outputs

w2 = init_weights([3, 3, 32, 64])     # 3x3x32 conv, 64 outputs

w3 = init_weights([3, 3, 64, 128])    # 3x3x32 conv, 128 outputs

w4 = init_weights([128 * 4 * 4, 625]) # FC 128 * 4 * 4 inputs, 625 outputs

w_o = init_weights([625, 10])         # FC 625 inputs, 10 outputs (labels)



p_keep_conv = tf.placeholder("float")

p_keep_hidden = tf.placeholder("float")

py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden)



cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(py_x, Y))

train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)

predict_op = tf.argmax(py_x, 1)



# Launch the graph in a session

with tf.Session() as sess:

    # you need to initialize all variables

    tf.initialize_all_variables().run()



    for i in range(100):

        training_batch = zip(range(0, len(trX), batch_size),

                             range(batch_size, len(trX)+1, batch_size))

        for start, end in training_batch:

            sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end],

                                          p_keep_conv: 0.8, p_keep_hidden: 0.5})



        test_indices = np.arange(len(teX)) # Get A Test Batch

        np.random.shuffle(test_indices)

        test_indices = test_indices[0:test_size]



        print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==

                         sess.run(predict_op, feed_dict={X: teX[test_indices],

                                                         p_keep_conv: 1.0,

p_keep_hidden: 1.0})))

3.modern convnet

import tensorflow as tf

from libs.batch_norm import batch_norm

from libs.activations import lrelu

from libs.connections import conv2d, linear

from libs.datasets import MNIST





# %% Setup input to the network and true output label.  These are

# simply placeholders which we'll fill in later.

mnist = MNIST()

x = tf.placeholder(tf.float32, [None, 784])

y = tf.placeholder(tf.float32, [None, 10])



# %% We add a new type of placeholder to denote when we are training.

# This will be used to change the way we compute the network during

# training/testing.

is_training = tf.placeholder(tf.bool, name='is_training')



# %% We'll convert our MNIST vector data to a 4-D tensor:

# N x W x H x C

x_tensor = tf.reshape(x, [-1, 28, 28, 1])



# %% We'll use a new method called  batch normalization.

# This process attempts to "reduce internal covariate shift"

# which is a fancy way of saying that it will normalize updates for each

# batch using a smoothed version of the batch mean and variance

# The original paper proposes using this before any nonlinearities

h_1 = lrelu(batch_norm(conv2d(x_tensor, 32, name='conv1'),

                       is_training, scope='bn1'), name='lrelu1')

h_2 = lrelu(batch_norm(conv2d(h_1, 64, name='conv2'),

                       is_training, scope='bn2'), name='lrelu2')

h_3 = lrelu(batch_norm(conv2d(h_2, 64, name='conv3'),

                       is_training, scope='bn3'), name='lrelu3')

h_3_flat = tf.reshape(h_3, [-1, 64 * 4 * 4])

h_4 = linear(h_3_flat, 10)

y_pred = tf.nn.softmax(h_4)



# %% Define loss/eval/training functions

cross_entropy = -tf.reduce_sum(y * tf.log(y_pred))

train_step = tf.train.AdamOptimizer().minimize(cross_entropy)



correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))



# %% We now create a new session to actually perform the initialization the

# variables:

sess = tf.Session()

sess.run(tf.initialize_all_variables())



# %% We'll train in minibatches and report accuracy:

n_epochs = 10

batch_size = 100

for epoch_i in range(n_epochs):

    for batch_i in range(mnist.train.num_examples // batch_size):

        batch_xs, batch_ys = mnist.train.next_batch(batch_size)

        sess.run(train_step, feed_dict={

            x: batch_xs, y: batch_ys, is_training: True})

    print(sess.run(accuracy,

                   feed_dict={

                       x: mnist.validation.images,

                       y: mnist.validation.labels,

                       is_training: False

}))