import tensorflow as tf

import tensorlayer as tl

sess = tf.InteractiveSession()

X_train, y_train, X_val, y_val, X_test, y_test = \

tl.files.load_mnist_dataset(shape=(-1,784))

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

y_ = tf.placeholder(tf.int64, shape=[None, ], name='y_')

def mlp(x, is_train=True, reuse=False):

return network

net_train = mlp(x, is_train=True, reuse=False)

net_test = mlp(x, is_train=False, reuse=True)

y = net_train.outputs

cost = tl.cost.cross_entropy(y, y_, name='xentropy')

y2 = net_test.outputs

cost_test = tl.cost.cross_entropy(y2, y_, name='xentropy2')

correct_prediction = tf.equal(tf.argmax(y2, 1), y_)

acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

train_params = tl.layers.get_variables_with_name('MLP', train_only=True, printable=False)

train_op = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.9, beta2=0.999,

epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)

tl.layers.initialize_global_variables(sess)

import time

n_epoch = 500

batch_size = 500

print_freq = 5

for epoch in range(n_epoch):

start_time = time.time()

for X_train_a, y_train_a in tl.iterate.minibatches(

X_train, y_train, batch_size, shuffle=True):

sess.run(train_op, feed_dict={x: X_train_a, y_: y_train_a})

if epoch + 1 == 1 or (epoch + 1) % print_freq == 0:

print("Epoch %d of %d took %fs" % (epoch + 1, n_epoch, time.time() - start_time))

train_loss, train_acc, n_batch = 0, 0, 0

for X_train_a, y_train_a in tl.iterate.minibatches(

X_train, y_train, batch_size, shuffle=True):

err, ac = sess.run([cost_test, acc], feed_dict={x: X_train_a, y_: y_train_a})

train_loss += err; train_acc += ac; n_batch += 1

print(" train loss: %f" % (train_loss/ n_batch))

print(" train acc: %f" % (train_acc/ n_batch))

val_loss, val_acc, n_batch = 0, 0, 0

for X_val_a, y_val_a in tl.iterate.minibatches(

X_val, y_val, batch_size, shuffle=True):

err, ac = sess.run([cost_test, acc], feed_dict={x: X_val_a, y_: y_val_a})

val_loss += err; val_acc += ac; n_batch += 1

print(" val loss: %f" % (val_loss/ n_batch))

print(" val acc: %f" % (val_acc/ n_batch))

print('Evaluation')

test_loss, test_acc, n_batch = 0, 0, 0

for X_test_a, y_test_a in tl.iterate.minibatches(

X_test, y_test, batch_size, shuffle=True):

err, ac = sess.run([cost_test, acc], feed_dict={x: X_test_a, y_: y_test_a})

test_loss += err; test_acc += ac; n_batch += 1

print(" test loss: %f" % (test_loss/n_batch))

print(" test acc: %f" % (test_acc/n_batch))