def main(_):
'''
Main body of code for loading a pre-trained model and accessing
various functionalities of the system.
'''
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=False,
shuffle_per_epoch=True)
img_size = mnist.original_image_shape
num_classes = mnist.return_num_classes()
# Load model
model = tf.keras.models.load_model('best_model.h5')
logits = model.predict(x=mnist.test_x)
predictions = np.argmax(logits, axis=1)
# Plot the confusion matrix
print_confusion_matrix(labels=mnist.test_y_cls,
predictions=predictions,
num_classes=num_classes)
# Plot images that are classified incorrectly
wrong_indeces, wrong_images, wrong_labels, correct_labels = find_wrong_predictions(
labels=mnist.test_y_cls, predictions=predictions, images=mnist.test_x)
incorrect_logits = model.predict(wrong_images)
# Need to find a way to get the output on the different layers of the
# model. Here, the pre-activation dense layer values are necessary for
# plotting.
plot_images(images=wrong_images[:5],
y_pred=incorrect_logits[:5],
logits=incorrect_logits[:5],
cls_true=correct_labels[:5],
cls_pred=wrong_labels[:5],
img_shape=img_size)
# Get model summary
model.summary()
model.evaluate(x=mnist.test_x, y=mnist.test_y)
# Get the input layer
input_layer = model.layers[0]
# Retrieve convolutional layers and weights
conv1_layer = model.layers[2]
conv1_weights = conv1_layer.get_weights()[0]
conv2_layer = model.layers[5]
conv2_weights = conv2_layer.get_weights()[0]
# Plot convolutional weights
plot_conv_weights(conv1_weights)
plot_conv_weights(conv2_weights)
# Output of convolutions
conv1_output = tf.keras.backend.function(inputs=[input_layer.input],
outputs=[conv1_layer.output])
conv2_output = tf.keras.backend.function(inputs=[input_layer.input],
outputs=[conv2_layer.output])
# Get an example image to plot the convolutions
image_instance = np.array([mnist.test_x[0]])
conv_1_ex_output = conv1_output(image_instance)[0]
conv_2_ex_output = conv2_output(image_instance)[0]
plot_conv_layer(conv_1_ex_output)
plot_conv_layer(conv_2_ex_output)
def main(_):
'''
Main body of code for loading the pre-trained models and accessing
various functionalities of the system.
'''
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=False,
shuffle_per_epoch=True)
img_size = mnist.original_image_shape
num_classes = mnist.return_num_classes()
# Find number of models in folder
model_files = os.listdir(FLAGS.ensemble_networks_path)
num_models = len(model_files)
# Lists to append the models and the logits
ensemble_models = []
ensemble_logits = []
for i in range(1, num_models + 1):
print("Loading model {}/{}".format(i, num_models))
# Load model and get the performance
model = tf.keras.models.load_model(
os.path.join(FLAGS.ensemble_networks_path,
'ensemble_network_{}.h5'.format(i)))
model.evaluate(x=mnist.test_x,
y=mnist.test_y,
batch_size=FLAGS.batch_size)
logits = model.predict(x=mnist.test_x)
ensemble_logits.append(logits)
predictions = np.argmax(logits, axis=1)
# Get the mean of the logits from the models and
# their predictions
ensemble_logits = np.array(ensemble_logits)
mean_logits = np.mean(ensemble_logits, axis=0)
predictions = np.argmax(mean_logits, axis=1)
# Plot the confusion matrix
print_confusion_matrix(labels=mnist.test_y_cls,
predictions=predictions,
num_classes=num_classes)
# Get images that are classified incorrectly
wrong_indeces, wrong_images, wrong_labels, correct_labels = find_wrong_predictions(
labels=mnist.test_y_cls, predictions=predictions, images=mnist.test_x)
incorrect_logits = mean_logits[wrong_indeces]
plot_images(images=wrong_images[:5],
y_pred=incorrect_logits[:5],
logits=incorrect_logits[:5],
cls_true=correct_labels[:5],
cls_pred=wrong_labels[:5],
img_shape=img_size)
# Get the accuracy of the ensemble, to compare to the accuracy
# of the individual networks.
print("Accuracy of ensemble network: {}".format(1 -
(wrong_images.shape[0] /
mnist.test_x.shape[0])))
def main(_):
'''
Main body of code for creating a two-layer convolutional neural
network, with max pooling, flatten dense layer and softmax output.
'''
check_and_create_folder(FLAGS.model_filepath)
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size, normalize_data=True,
one_hot_encoding=True, flatten_images=False,
shuffle_per_epoch=True)
for i in range(1, FLAGS.ensemble_size+1):
# Path to save the model
model_filepath = os.path.join(FLAGS.model_filepath, 'ensemble_network_{}.h5'.format(i))
# Partition the train set randomly and train the network
partition = (mnist.train_y.shape[0]/FLAGS.ensemble_size)/mnist.train_y.shape[0]
train_x, train_y = random_partition_test_set(mnist.train_x, mnist.train_y,
partition=partition)
# Data information
img_size = mnist.original_image_shape
num_classes = mnist.return_num_classes()
num_channels = 1 # Because this is greyscale (need to introduce in the MNIST class)
# Construct the model
inputs = tf.keras.layers.Input(shape=(img_size[0], img_size[1]))
net = inputs
net = tf.keras.layers.Reshape((img_size[0], img_size[1], num_channels))(net)
net = tf.keras.layers.Conv2D(kernel_size=FLAGS.filter_size_1, strides=1,
filters=FLAGS.num_filters_1, padding='same',
activation='relu', name='conv_layer1')(net)
net = tf.keras.layers.MaxPooling2D(pool_size=2, strides=2)(net)
net = tf.keras.layers.Dropout(FLAGS.dropout_rate)(net)
net = tf.keras.layers.Conv2D(kernel_size=FLAGS.filter_size_2, strides=1,
filters=FLAGS.num_filters_2, padding='same',
activation='relu', name='conv_layer2')(net)
net = tf.keras.layers.MaxPooling2D(pool_size=2, strides=2)(net)
net = tf.keras.layers.Dropout(FLAGS.dropout_rate)(net)
net = tf.keras.layers.Flatten()(net)
net = tf.keras.layers.Dense(FLAGS.fc_size, activation='relu')(net)
net = tf.keras.layers.Dropout(FLAGS.dropout_rate)(net)
net = tf.keras.layers.Dense(num_classes, activation='softmax')(net)
outputs = net
# Construct keras model by passing inputs and outputs to the graph
model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
# Optimization and cost
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Callbacks for saving and early stopping
callbacks = [tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5),
tf.keras.callbacks.ModelCheckpoint(filepath=model_filepath,
monitor='val_loss',
save_best_only=True)]
print("Training model {}/{}".format(i, FLAGS.ensemble_size))
model.fit(x=train_x, y=train_y,
epochs=FLAGS.epochs, batch_size=FLAGS.batch_size,
callbacks=callbacks,
validation_data=(mnist.test_x, mnist.test_y))
def main(_):
'''
Main body of code for constructing a denoising autoencoder
model for reconstructing the MNIST dataset
'''
# Load MNIST dataset
mnist = MNIST(batch_size=FLAGS.batch_size, normalize_data=True,
one_hot_encoding=True, flatten_images=True,
shuffle_per_epoch=True)
# Data information
img_size = mnist.return_input_shape()
# Input placeholder and corruption mask
x_input = tf.placeholder(tf.float32, [None, img_size], name='input')
# Build the graph
autoencoder = AutoencoderLayer(input_data=x_input,
num_inputs=img_size,
num_outputs=FLAGS.autoencoder_size)
# Cost and optimization
cost = tf.reduce_sum(tf.pow(x_input-autoencoder.decoded_input, 2))
train_op = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(cost)
predict_op = autoencoder.decoded_input
# Initialize tensorflow session
session = tf.Session()
session.run(tf.global_variables_initializer())
loss = 0
with tqdm(total=FLAGS.epochs, postfix='Loss = {:.3f}'.format(loss)) as epoch_progress:
# Iterate through epochs
for epoch in range(FLAGS.epochs):
with tqdm(total=len(mnist), postfix='Loss: {:.3f}'.format(loss), mininterval=1e-4,
leave=True) as batch_progress:
# Train model per batch
for batch, (batch_x, _) in enumerate(mnist):
batch_noise = corrupt_data_with_noise(batch_x.shape, FLAGS.corruption_level)
feed_dict_train = {x_input:batch_x, autoencoder.mask:batch_noise}
_, loss = session.run([train_op, cost], feed_dict=feed_dict_train)
# Update bar
batch_progress.set_postfix(Loss=loss)
batch_progress.update()
test_set_noise = corrupt_data_with_noise(mnist.test_x.shape, FLAGS.corruption_level)
feed_dict_test = {x_input: mnist.test_x, autoencoder.mask: test_set_noise}
test_loss = session.run(cost, feed_dict=feed_dict_test)
# Update bar
epoch_progress.set_postfix(Loss=test_loss)
epoch_progress.update()
weights = transform_tf_variable(session, autoencoder.weights)
plot_autoencoder_weights(weights)
subset = mnist.test_x[:100]
save_images(subset, x_input, autoencoder.mask, predict_op, session)
def main(_):
'''
Main body of code for creating a two-layer convolutional neural
network, with max pooling, flatten dense layer and softmax output.
'''
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=False,
shuffle_per_epoch=True)
# Data information
img_size = mnist.original_image_shape
num_classes = mnist.return_num_classes()
num_channels = 1 # Because this is greyscale (need to introduce in the MNIST class)
# Construct the model
model = tf.keras.models.Sequential()
model.add(
tf.keras.layers.InputLayer(input_shape=(img_size[0], img_size[1])))
model.add(tf.keras.layers.Reshape(
(img_size[0], img_size[1], num_channels)))
model.add(
tf.keras.layers.Conv2D(kernel_size=FLAGS.filter_size_1,
strides=1,
filters=FLAGS.num_filters_1,
padding='same',
activation='relu',
name='conv_layer1'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=2, strides=2))
model.add(tf.keras.layers.Dropout(FLAGS.dropout_rate))
model.add(
tf.keras.layers.Conv2D(kernel_size=FLAGS.filter_size_1,
strides=1,
filters=FLAGS.num_filters_1,
padding='same',
activation='relu',
name='conv_layer2'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=2, strides=2))
model.add(tf.keras.layers.Dropout(FLAGS.dropout_rate))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(FLAGS.fc_size, activation='relu'))
model.add(tf.keras.layers.Dropout(FLAGS.dropout_rate))
model.add(tf.keras.layers.Dense(num_classes, activation='softmax'))
# Optimization and cost for compiling the model
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Training
model.fit(x=mnist.train_x,
y=mnist.train_y,
epochs=FLAGS.epochs,
batch_size=FLAGS.batch_size)
# Evaluation
model.evaluate(x=mnist.test_x, y=mnist.test_y)
logits = model.predict(x=mnist.test_x)
predictions = np.argmax(logits, axis=1)
# Plot the confusion matrix
print_confusion_matrix(labels=mnist.test_y_cls,
predictions=predictions,
num_classes=num_classes)
# Plot images that are classified incorrectly
wrong_indeces, wrong_images, wrong_labels, correct_labels = find_wrong_predictions(
labels=mnist.test_y_cls, predictions=predictions, images=mnist.test_x)
incorrect_logits = model.predict(wrong_images)
# Need to find a way to get the output on the different layers of the
# model. Here, the pre-activation dense layer values are necessary for
# plotting.
plot_images(images=wrong_images[:5],
y_pred=incorrect_logits[:5],
logits=incorrect_logits[:5],
cls_true=correct_labels[:5],
cls_pred=wrong_labels[:5],
img_shape=img_size)
def main(_):
'''
Main body of code for creating a two-layer convolutional neural
network, with max pooling, flatten dense layer and softmax output.
'''
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=False,
shuffle_per_epoch=True)
# Data information
img_size = mnist.original_image_shape
num_classes = mnist.return_num_classes()
num_channels = 1 # Because this is greyscale (need to introduce in the MNIST class)
# Placeholders
x_input = tf.placeholder(tf.float32,
shape=[None, img_size[0], img_size[1]],
name='x_input')
x_image = tf.reshape(x_input,
shape=[-1, img_size[0], img_size[1], num_channels])
y_true = tf.placeholder(tf.float32,
shape=[None, num_classes],
name='y_true')
y_true_cls = tf.argmax(y_true, axis=1)
dropout_rate = tf.placeholder_with_default(0.0,
shape=(),
name='dropout_rate')
# First convolutional layer
conv_1 = Conv2DLayer(input_data=x_image,
num_input_channels=num_channels,
filter_size=FLAGS.filter_size_1,
num_filters=FLAGS.num_filters_1)
max_pool1 = MaxPoolLayer(input_layer=conv_1.output_layer)
# Second convolutional layer
conv_2 = Conv2DLayer(input_data=max_pool1.output_layer,
num_input_channels=FLAGS.num_filters_1,
filter_size=FLAGS.filter_size_2,
num_filters=FLAGS.num_filters_2)
max_pool2 = MaxPoolLayer(input_layer=conv_2.output_layer)
# Flatten layer and pass to dense layer
layer_flat = FlattenLayer(input_layer=max_pool2.output_layer)
dense_1 = DenseLayer(input_data=layer_flat.output_layer,
num_inputs=layer_flat.num_features,
num_outputs=FLAGS.fc_size)
dropout_layer = tf.nn.dropout(x=dense_1.output_layer, rate=dropout_rate)
# Softmax layer
softmax_layer = DenseLayer(input_data=dropout_layer,
num_inputs=FLAGS.fc_size,
num_outputs=num_classes,
activation=tf.nn.softmax)
# Predictions
y_pred = softmax_layer.output_layer
y_pred_cls = tf.argmax(y_pred, axis=1)
# Loss
cross_entropy = tf.losses.softmax_cross_entropy(
onehot_labels=y_true, logits=softmax_layer.pre_activation_layer)
cost = tf.reduce_mean(cross_entropy)
# Optimizer
optimizer = tf.train.AdamOptimizer(
learning_rate=FLAGS.learning_rate).minimize(cost)
# Performance measure
correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Run session
session = tf.Session()
session.run(tf.global_variables_initializer())
loss = 0
acc = 0
with tqdm(total=FLAGS.epochs,
postfix='Accuracy = {:.3f}'.format(acc)) as epoch_progress:
for epoch in range(FLAGS.epochs):
with tqdm(total=len(mnist),
postfix='Loss: {:.3f}'.format(loss),
mininterval=1e-4,
leave=True) as batch_progress:
# Train model per batch
for batch_x, batch_y in mnist:
feed_dict_train = {
x_input: batch_x,
y_true: batch_y,
dropout_rate: FLAGS.dropout_rate
}
_, loss = session.run([optimizer, cost],
feed_dict=feed_dict_train)
batch_progress.set_postfix(Loss=loss)
batch_progress.update()
# Test model for entire test set
feed_dict_test = {
x_input: mnist.test_x,
y_true: mnist.test_y,
y_true_cls: mnist.test_y_cls
}
acc, predictions = session.run([accuracy, y_pred_cls],
feed_dict=feed_dict_test)
epoch_progress.set_postfix(Accuracy=acc)
epoch_progress.update()
# Plot the filter weights for the convolutional layers
conv_1_weights = transform_tf_variable(session, conv_1.weights)
conv_2_weights = transform_tf_variable(session, conv_2.weights)
plot_conv_weights(conv_1_weights)
plot_conv_weights(conv_2_weights)
# Plot the outputs of the convolutional layers.
conv_1_layer_output = get_layer_output(session, x_input, [mnist.test_x[0]],
conv_1.output_layer)
max_pool_1_layer_output = get_layer_output(session, x_input,
[mnist.test_x[0]],
max_pool1.output_layer)
conv_2_layer_output = get_layer_output(session, x_input, [mnist.test_x[0]],
conv_2.output_layer)
max_pool_2_layer_output = get_layer_output(session, x_input,
[mnist.test_x[0]],
max_pool2.output_layer)
plot_conv_layer(conv_1_layer_output)
plot_conv_layer(max_pool_1_layer_output)
plot_conv_layer(conv_2_layer_output)
plot_conv_layer(max_pool_2_layer_output)
# Plot the confusion matrix
print_confusion_matrix(labels=mnist.test_y_cls,
predictions=predictions,
num_classes=num_classes)
# Plot images that are classified incorrectly
wrong_indeces, wrong_images, wrong_labels, correct_labels = find_wrong_predictions(
labels=mnist.test_y_cls, predictions=predictions, images=mnist.test_x)
incorrect_logits = get_layer_output(session, x_input, wrong_images,
softmax_layer.pre_activation_layer)
incorrect_predictions = get_layer_output(session, x_input, wrong_images,
softmax_layer.output_layer)
plot_images(images=wrong_images[:5],
y_pred=incorrect_predictions[:5],
logits=incorrect_logits[:5],
cls_true=correct_labels[:5],
cls_pred=wrong_labels[:5],
img_shape=img_size)
def main(_):
'''
Main body of code for constructing a stacked denoising autoencoder
model for reconstructing the MNIST dataset.
'''
# Load MNIST dataset
mnist = MNIST(batch_size=FLAGS.batch_size, normalize_data=True,
one_hot_encoding=True, flatten_images=True,
shuffle_per_epoch=True)
# Data information
img_size = mnist.return_input_shape()
# Input placeholder and corruption mask
x_input = tf.placeholder(tf.float32, [None, img_size], name='input')
# Build the graph
# Encoder part
autoencoder_1 = AutoencoderLayer(input_data=x_input,
num_inputs=img_size,
num_outputs=FLAGS.autoencoder_size,
encoder_activation=tf.nn.relu,
decoder_activation=tf.nn.sigmoid)
autoencoder_2 = AutoencoderLayer(input_data=autoencoder_1.encoded_input,
num_inputs=FLAGS.autoencoder_size,
num_outputs=512,
encoder_activation=tf.nn.relu,
decoder_activation=tf.nn.softplus)
autoencoder_3 = AutoencoderLayer(input_data=autoencoder_2.encoded_input,
num_inputs=512,
num_outputs=256,
encoder_activation=tf.nn.relu,
decoder_activation=tf.nn.softplus)
# Latent space
latent_space = autoencoder_3.encoded_input
# Reconstructed input
layer_3_reconstruction = autoencoder_3.decoder(latent_space)
layer_2_reconstruction = autoencoder_2.decoder(layer_3_reconstruction)
layer_1_reconstruction = autoencoder_1.decoder(layer_2_reconstruction)
input_reconstruction = layer_1_reconstruction
# Cost and optimization
cost = tf.reduce_sum(tf.abs(input_reconstruction - x_input))
train_op = tf.train.AdamOptimizer(FLAGS.learning_rate).minimize(cost)
predict_op = autoencoder_1.decoded_input
# Initialize tensorflow session
session = tf.Session()
session.run(tf.global_variables_initializer())
loss = 0
with tqdm(total=FLAGS.epochs, postfix='Loss = {:.3f}'.format(loss)) as epoch_progress:
# Iterate through epochs
for epoch in range(FLAGS.epochs):
with tqdm(total=len(mnist), postfix='Loss: {:.3f}'.format(loss), mininterval=1e-4,
leave=True) as batch_progress:
# Train model per batch
for batch, (batch_x, _) in enumerate(mnist):
batch_noise_1 = corrupt_data_with_noise(batch_x.shape, FLAGS.corruption_level)
batch_noise_2 = corrupt_data_with_noise([batch_x.shape[0],
autoencoder_1.num_outputs],
FLAGS.corruption_level)
batch_noise_3 = corrupt_data_with_noise([batch_x.shape[0],
autoencoder_2.num_outputs],
FLAGS.corruption_level)
feed_dict_train = {x_input:batch_x,
autoencoder_1.mask:batch_noise_1,
autoencoder_2.mask:batch_noise_2,
autoencoder_3.mask:batch_noise_3}
_, loss = session.run([train_op, cost], feed_dict=feed_dict_train)
# Update bar
batch_progress.set_postfix(Loss=loss)
batch_progress.update()
# Noise for the different layers
test_set_noise_layer_1 = corrupt_data_with_noise(mnist.test_x.shape,
FLAGS.corruption_level)
test_set_noise_layer_2 = corrupt_data_with_noise([mnist.test_x.shape[0],
autoencoder_1.num_outputs],
FLAGS.corruption_level)
test_set_noise_layer_3 = corrupt_data_with_noise([mnist.test_x.shape[0],
autoencoder_2.num_outputs],
FLAGS.corruption_level)
feed_dict_test = {x_input: mnist.test_x,
autoencoder_1.mask: test_set_noise_layer_1,
autoencoder_2.mask: test_set_noise_layer_2,
autoencoder_3.mask: test_set_noise_layer_3}
test_loss = session.run(cost, feed_dict=feed_dict_test)
# Update bar
epoch_progress.set_postfix(Loss=test_loss)
epoch_progress.update()
weights = transform_tf_variable(session, autoencoder_1.weights)
plot_autoencoder_weights(weights)
# Define a subset of the test set for reconstruction visualization.
subset = mnist.test_x[:100]
# Noise for the different layers
subset_layer_1 = corrupt_data_with_noise(subset.shape,
FLAGS.corruption_level)
subset_layer_2 = corrupt_data_with_noise([subset.shape[0], autoencoder_1.num_outputs],
FLAGS.corruption_level)
subset_layer_3 = corrupt_data_with_noise([subset.shape[0], autoencoder_2.num_outputs],
FLAGS.corruption_level)
feed_dict_vis = {x_input: subset,
autoencoder_1.mask: subset_layer_1,
autoencoder_2.mask: subset_layer_2,
autoencoder_3.mask: subset_layer_3}
save_images(subset, feed_dict_vis, predict_op, session)
def main(_):
'''
Main body of code for creating a deep denoising autoencoder
network, for performing deep reconstruction of a noisy dataset.
'''
# Import data
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=True,
shuffle_per_epoch=True)
# Data information
img_size = mnist.return_input_shape()
# First layer
layer1_input, layer1_encoder, layer1_decoder, \
layer1_encoded_data = autoencoder_layer(
input_shape=img_size,
layer_size=FLAGS.autoencoder1_size,
target_data=mnist.train_x,
noise_rate=FLAGS.corruption_level_1)
# Second layer
layer2_input, layer2_encoder, layer2_decoder, \
layer2_encoded_data = autoencoder_layer(
input_shape=FLAGS.autoencoder1_size,
layer_size=FLAGS.autoencoder2_size,
target_data=layer1_encoded_data,
noise_rate=FLAGS.corruption_level_2)
# Third layer
layer3_input, layer3_encoder, layer3_decoder, \
layer3_encoded_data = autoencoder_layer(
input_shape=FLAGS.autoencoder2_size,
layer_size=FLAGS.autoencoder3_size,
target_data=layer2_encoded_data,
noise_rate=FLAGS.corruption_level_3)
# Deep reconstruction
# Connect the various layers together
reconstruction_input = layer1_input
first_layer_encoder = layer1_encoder(reconstruction_input)
second_layer_encoder = layer2_encoder(first_layer_encoder)
third_layer_encoder = layer3_encoder(second_layer_encoder)
third_layer_decoder = layer3_decoder(third_layer_encoder)
second_layer_decoder = layer2_decoder(third_layer_decoder)
first_layer_decoder = layer1_decoder(second_layer_decoder)
# Define the mode with inputs and outputs
reconstruction_model = tf.keras.models.Model(inputs=reconstruction_input,
outputs=first_layer_decoder)
# Corrupt the input and output data
corrupted_train_data = add_noise(mnist.train_x, FLAGS.corruption_level_1)
corrupted_test_data = add_noise(mnist.test_x, FLAGS.corruption_level_1)
# Optimize and fit the model
reconstruction_model.compile(optimizer='adam', loss='binary_crossentropy')
reconstruction_model.fit(x=corrupted_train_data,
y=mnist.train_x,
epochs=FLAGS.finetuning_epochs,
batch_size=FLAGS.batch_size,
shuffle=True,
validation_data=(corrupted_test_data,
mnist.test_x))
# Retrieve the reconstructions and plot
reconstructions = reconstruction_model.predict(corrupted_test_data,
batch_size=FLAGS.batch_size)
plotting_function(corrupted_test_data, reconstructions)
def main(_):
'''
Main function to execute. Loading MNIST and training model.
'''
# Load MNIST dataset
mnist = MNIST(batch_size=FLAGS.batch_size,
normalize_data=True,
one_hot_encoding=True,
flatten_images=True,
shuffle_per_epoch=True)
epochs = 1
original_image_shape = mnist.original_image_shape
img_size_flat = mnist.return_input_shape()
num_classes = mnist.return_num_classes()
# Call model
model = LogisticRegression(batch_size=FLAGS.batch_size,
num_iterations=FLAGS.epochs,
input_size=img_size_flat,
output_layer_size=num_classes)
# Main train loop to iterate over epochs and then
# over batches. Once per epoch we validate the system's
# accuracy on the test set.
# Predefine loss and acc for printing
loss = 0
acc = 0
with tqdm(total=epochs,
postfix='Accuracy = {:.3f}'.format(acc)) as epoch_progress:
for epoch in range(epochs):
with tqdm(total=len(mnist),
postfix='Loss: {:.3f}'.format(loss),
mininterval=1e-4,
leave=True) as batch_progress:
for batch, (batch_x, batch_y) in enumerate(mnist):
loss = model.train_step(batch_x, batch_y)
batch_progress.set_postfix(Loss=loss)
batch_progress.update()
acc = model.validation_cycle(mnist.test_x, mnist.test_y,
mnist.test_y_cls)
epoch_progress.set_postfix(Accuracy=acc)
epoch_progress.update()
# Plot weights
weights = model.return_weights()
plot_weights(weights, original_image_shape)
# Plot confusion matrix
predictions = model.return_predictions(test_x=mnist.test_x,
test_y=mnist.test_y,
test_y_cls=mnist.test_y_cls)
print_confusion_matrix(labels=mnist.test_y_cls,
predictions=predictions,
num_classes=num_classes)
# Plot images that are classified incorrectly
wrong_indeces, wrong_images, wrong_labels, correct_labels = find_wrong_predictions(
labels=mnist.test_y_cls, predictions=predictions, images=mnist.test_x)
logits, y_pred = model.return_logits(data=wrong_images)
plot_images(images=wrong_images[:5],
y_pred=y_pred[:5],
logits=logits[:5],
cls_true=correct_labels[:5],
cls_pred=wrong_labels[:5],
img_shape=original_image_shape)