def train():
"""
Performs training and evaluation of ConvNet model.
First define your graph using class ConvNet and its methods. Then define
necessary operations such as trainer (train_step in this case), savers
and summarizers. Finally, initialize your model within a tf.Session and
do the training.
---------------------------
How to evaluate your model:
---------------------------
Evaluation on test set should be conducted over full batch, i.e. 10k images,
while it is alright to do it over minibatch for train set.
---------------------------------
How often to evaluate your model:
---------------------------------
- on training set every print_freq iterations
- on test set every eval_freq iterations
------------------------
Additional requirements:
------------------------
Also you are supposed to take snapshots of your model state (i.e. graph,
weights and etc.) every checkpoint_freq iterations. For this, you should
study TensorFlow's tf.train.Saver class. For more information, please
checkout:
[https://www.tensorflow.org/versions/r0.11/how_tos/variables/index.html]
"""
# Set the random seeds for reproducibility. DO NOT CHANGE.
tf.set_random_seed(42)
np.random.seed(42)
########################
# PUT YOUR CODE HERE #
########################
# Cifar10 stuff
cifar10, image_shape, num_classes = standard_cifar10_get(FLAGS)
# Placeholder variables
x = tf.placeholder(tf.float32, shape=[None] + list(image_shape), name='x')
y = tf.placeholder(tf.float32, shape=(None, num_classes), name='y')
is_training = tf.placeholder(dtype=tf.bool, shape=(), name='isTraining')
# CNN model
model = ConvNet(is_training=is_training,
dropout_rate=FLAGS.dropout_rate,
save_stuff=FLAGS.save_stuff,
fc_reg_str=FLAGS.fc_reg_str)
# Get logits, loss, accuracy, train optimisation step
logits = model.inference(x)
accuracy = model.accuracy(logits, y)
reg_loss = sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
loss = model.loss(logits, y) + reg_loss
tf.scalar_summary('loss_incl_reg', loss)
train_op = train_step(loss)
# Function for getting feed dicts
def get_feed(c, train=True):
if train:
xd, yd = c.train.next_batch(FLAGS.batch_size)
return {x: xd, y: yd, is_training: True}
else:
xd, yd = c.test.images[:FLAGS.test_size], c.test.labels[:FLAGS.
test_size]
return {x: xd, y: yd, is_training: False}
# For saving checkpoints
saver = tf.train.Saver()
with tf.Session() as sess:
# Initialise all variables
tf.initialize_all_variables().run(session=sess)
# Merge all the summaries
merged = tf.merge_all_summaries()
if FLAGS.save_stuff:
train_writer = tf.train.SummaryWriter(FLAGS.log_dir + '/train',
sess.graph)
test_writer = tf.train.SummaryWriter(FLAGS.log_dir + '/test')
# Start training loops
for epoch in range(0, FLAGS.max_steps):
if epoch % 100 == 0:
# Print accuracy and loss on test set
summary, acc, loss_val = \
sess.run([merged, accuracy, loss], get_feed(cifar10, False))
if FLAGS.save_stuff:
test_writer.add_summary(summary, epoch)
print('\nEpoch', epoch, '\nTest accuracy:', acc,
'\nTest loss :', loss_val)
if epoch % FLAGS.checkpoint_freq == 0:
# Save model checkpoint
if epoch > 0:
save_path = saver.save(sess, FLAGS.checkpoint_dir + \
'/epoch'+ str(epoch) + '.ckpt')
print("Model saved in file: %s" % save_path)
# Do training update
if FLAGS.save_stuff:
summary, _ = sess.run([merged, train_op],
feed_dict=get_feed(cifar10, True))
train_writer.add_summary(summary, epoch)
else:
sess.run([train_op], feed_dict=get_feed(cifar10, True))
# Print the final accuracy
summary, acc, loss_val = \
sess.run([merged, accuracy, loss], get_feed(cifar10, False))
if FLAGS.save_stuff:
test_writer.add_summary(summary, epoch + 1)
print('\nFinal test accuracy:', acc, '\nFinal test loss :',
loss_val)
save_path = saver.save(sess, FLAGS.checkpoint_dir + \
'/epoch'+ str(epoch + 1) + '.ckpt')
print("Model saved in file: %s" % save_path)
def train():
"""
Performs training and evaluation of ConvNet model.
First define your graph using class ConvNet and its methods. Then define
necessary operations such as trainer (train_step in this case), savers
and summarizers. Finally, initialize your model within a tf.Session and
do the training.
---------------------------
How to evaluate your model:
---------------------------
Evaluation on test set should be conducted over full batch, i.e. 10k images,
while it is alright to do it over minibatch for train set.
---------------------------------
How often to evaluate your model:
---------------------------------
- on training set every print_freq iterations
- on test set every eval_freq iterations
------------------------
Additional requirements:
------------------------
Also you are supposed to take snapshots of your model state (i.e. graph,
weights and etc.) every checkpoint_freq iterations. For this, you should
study TensorFlow's tf.train.Saver class. For more information, please
checkout:
[https://www.tensorflow.org/versions/r0.11/how_tos/variables/index.html]
"""
# Set the random seeds for reproducibility. DO NOT CHANGE.
tf.set_random_seed(42)
np.random.seed(42)
########################
# PUT YOUR CODE HERE #
########################
cifar10 = cifar10_utils.get_cifar10(FLAGS.data_dir)
x_test, y_test = cifar10.test.images[0:1000], cifar10.test.labels[0:1000]
#### PARAMETERS
classes = [
'plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship',
'truck'
]
n_classes = len(classes)
input_data_dim = cifar10.test.images.shape[1]
#####
cnn = ConvNet()
cnn.is_training = tf.placeholder(tf.bool)
cnn.dropout_rate = 0.5
x = tf.placeholder(tf.float32,
shape=(None, input_data_dim, input_data_dim, 3),
name="x")
y = tf.placeholder(tf.float32, shape=(None, n_classes), name="y")
with tf.name_scope('train_cnn'):
infs = cnn.inference(x)
with tf.name_scope('cross-entropy-loss'):
loss = cnn.loss(infs, y)
with tf.name_scope('accuracy'):
accuracy = cnn.accuracy(infs, y)
fc2 = cnn.fc2
merged = tf.merge_all_summaries()
opt_operation = train_step(loss)
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.initialize_all_variables())
test_acc = sess.run(accuracy,
feed_dict={
x: x_test,
y: y_test,
cnn.is_training: False
})
print("Initial Test Accuracy = {0:.3f}".format(test_acc))
train_writer = tf.train.SummaryWriter(FLAGS.log_dir + "/train/",
sess.graph)
test_writer = tf.train.SummaryWriter(FLAGS.log_dir + "/test/",
sess.graph)
for iteration in range(FLAGS.max_steps + 1):
x_batch, y_batch = cifar10.train.next_batch(FLAGS.batch_size)
_ = sess.run([opt_operation],
feed_dict={
x: x_batch,
y: y_batch,
cnn.is_training: False
})
if iteration % FLAGS.print_freq == 0:
[train_acc, train_loss,
summary_train] = sess.run([accuracy, loss, merged],
feed_dict={
x: x_batch,
y: y_batch,
cnn.is_training: False
})
train_writer.add_summary(summary_train, iteration)
print(
"Iteration {0:d}/{1:d}. Train Loss = {2:.3f}, Train Accuracy = {3:.3f}"
.format(iteration, FLAGS.max_steps, train_loss, train_acc))
if iteration % FLAGS.eval_freq == 0:
[test_acc, test_loss,
summary_test] = sess.run([accuracy, loss, merged],
feed_dict={
x: x_test,
y: y_test,
cnn.is_training: False
})
test_writer.add_summary(summary_test, iteration)
print(
"Iteration {0:d}/{1:d}. Test Loss = {2:.3f}, Test Accuracy = {3:.3f}"
.format(iteration, FLAGS.max_steps, test_loss, test_acc))
if iteration > 0 and iteration % FLAGS.checkpoint_freq == 0:
saver.save(sess, FLAGS.checkpoint_dir + '/cnn_model.ckpt')
train_writer.flush()
test_writer.flush()
train_writer.close()
test_writer.close()
test_acc = sess.run(accuracy,
feed_dict={
x: x_test,
y: y_test,
cnn.is_training: False
})
print("Final Test Accuracy = {0:.3f}".format(test_acc))
sess.close()
from tensorflow.keras import datasets, layers, models
import tensorflow as tf
from sklearn.model_selection import train_test_split
(x, y), (x2, y2) = datasets.mnist.load_data()
# Normalise data
x = ((x / 255) - 0.5)
x2 = ((x2 / 255) - 0.5)
# Create instance of NeuralNetwork
model = ConvNet()
X = np.random.randn(1, 28, 28)
model.addInput(X) # Input layer
model.cvolume(
1, 3,
10) # Add Convolutional volume (stride length, receptive field, filters)
model.pmaxvolume(2) # Add Pooling layer (receptive field)
model.FCLayer(10) # Add FC Layer (number of classifiers)
# Get final output layer. It is advised to run it once before training, so that all variables are initialised.
print('Test Run Output: ', model.getVolumeOutput(3))
#Since we test the CNN with MNIST data, we write the target output in the required format before sent to training/testing.
results = np.zeros((len(y), 10))
for i in range(len(y)):
results[i, y[i]] = 1
model.train(x[0:2000], results[0:2000],
5) # Train model with 2000 images for 5 epochs
model.accuracy(x[2000:4000],
results[2000:4000]) # Predict accuracy using test data
def train():
"""
Performs training and evaluation of ConvNet model.
First define your graph using class ConvNet and its methods. Then define
necessary operations such as trainer (train_step in this case), savers
and summarizers. Finally, initialize your model within a tf.Session and
do the training.
---------------------------
How to evaluate your model:
---------------------------
Evaluation on test set should be conducted over full batch, i.e. 10k images,
while it is alright to do it over minibatch for train set.
---------------------------------
How often to evaluate your model:
---------------------------------
- on training set every print_freq iterations
- on test set every eval_freq iterations
------------------------
Additional requirements:
------------------------
Also you are supposed to take snapshots of your model state (i.e. graph,
weights and etc.) every checkpoint_freq iterations. For this, you should
study TensorFlow's tf.train.Saver class. For more information, please
checkout:
[https://www.tensorflow.org/versions/r0.11/how_tos/variables/index.html]
"""
# Set the random seeds for reproducibility. DO NOT CHANGE.
tf.set_random_seed(42)
np.random.seed(42)
########################
# PUT YOUR CODE HERE #
########################
#first lets test that out model works:
#initialize:
weight_init_scale = 0.001
cifar10 = cifar10_utils.get_cifar10(validation_size=100)
cnet = ConvNet(10)
x_in = tf.placeholder(tf.float32, [None, 32, 32, 3])
y_true = tf.placeholder(tf.float32, [None, 10])
with tf.variable_scope("ConvNet", reuse=None):
filter1 = tf.get_variable("filter1",
initializer=tf.random_normal(
[5, 5, 3, 64],
stddev=weight_init_scale,
dtype=tf.float32))
filter2 = tf.get_variable("filter2",
initializer=tf.random_normal(
[5, 5, 64, 64],
stddev=weight_init_scale,
dtype=tf.float32))
W1 = tf.get_variable("W1",
initializer=tf.random_normal(
[4096, 384],
stddev=weight_init_scale,
dtype=tf.float32))
W2 = tf.get_variable("W2",
initializer=tf.random_normal(
[384, 192],
stddev=weight_init_scale,
dtype=tf.float32))
W3 = tf.get_variable("W3",
initializer=tf.random_normal(
[192, 10],
stddev=weight_init_scale,
dtype=tf.float32))
sess = tf.Session()
saver = tf.train.Saver()
#define things
logits, flatten, fc1, fc2 = cnet.inference(x_in)
loss = cnet.loss(logits, y_true)
acc = cnet.accuracy(logits, y_true)
opt_iter = train_step(loss)
sess.run(tf.initialize_all_variables())
swriter = tf.train.SummaryWriter(FLAGS.log_dir + '/ConvNet', sess.graph)
#xbat, ybat = cifar10.train.next_batch(100)
#begin the training
with sess:
# loop
for i in range(FLAGS.max_steps + 1):
xbat, ybat = cifar10.train.next_batch(FLAGS.batch_size)
sess.run(opt_iter, feed_dict={x_in: xbat, y_true: ybat})
if i % FLAGS.print_freq == 0:
xbat, ybat = cifar10.validation.next_batch(100)
val_acc, val_loss = sess.run([acc, loss],
feed_dict={
x_in: xbat,
y_true: ybat
})
sys.stderr.write("iteration : " + str(i) +
", validation loss : " + str(val_loss) +
", validation_accuracy" + str(val_acc) + "\n")
swriter.add_summary(
sess.run(tf.scalar_summary("accuracy", val_acc),
feed_dict={
x_in: xbat,
y_true: ybat
}), i)
if i % FLAGS.checkpoint_freq == 0:
lo, flatsave, fc1save, fc2save = sess.run(cnet.inference(x_in),
feed_dict={
x_in: xbat,
y_true: ybat
})
np.save(FLAGS.checkpoint_dir + "/ConvNet/flatten", flatsave)
np.save(FLAGS.checkpoint_dir + "/ConvNet/fc1", fc1save)
np.save(FLAGS.checkpoint_dir + "/ConvNet/fc2", fc2save)
np.save(FLAGS.checkpoint_dir + "/ConvNet/labels", ybat)
saver.save(
sess,
FLAGS.checkpoint_dir + "/ConvNet/" + "checkpoint.ckpt")
if i % FLAGS.eval_freq == 0:
xbat, ybat = cifar10.test.next_batch(100)
sys.stderr.write(
"test accuracy:" +
str(sess.run(acc, feed_dict={
x_in: xbat,
y_true: ybat
})) + "\n")
