def image_retrieval(constant_overwrites):
img_shape, attr, x_train, x_test = load_faces_dataset()
constants = merge_dict(get_constants(), constant_overwrites)
constants['img_shape'] = img_shape
encoder_filename = constants['encoder_filename']
decoder_filename = constants['decoder_filename']
reset_tf_session()
autoencoder, encoder, decoder = model_builder(network_builder, constants)
if os.path.exists(encoder_filename) and not constants['retrain']:
encoder.load_weights(encoder_filename)
else:
data = {'X_train': x_train, 'X_test': x_test}
train(autoencoder, data, constants)
encoder.save_weights(encoder_filename)
decoder.save_weights(decoder_filename)
images = x_train
codes = encoder.predict(images)
assert len(codes) == len(images)
nei_clf = NearestNeighbors(metric="euclidean")
nei_clf.fit(codes)
# Cherry-picked examples:
# smiles
show_similar(x_test[247], nei_clf, encoder, images)
# ethnicity
show_similar(x_test[56], nei_clf, encoder, images)
# glasses
show_similar(x_test[63], nei_clf, encoder, images)
def denoising_autoencoder(constant_overwrites):
img_shape, attr, x_train, x_test = load_faces_dataset()
constants = merge_dict(get_constants(), constant_overwrites)
constants['img_shape'] = img_shape
constants['code_size'] = 512
autoencoder, encoder, decoder = model_builder(network_builder, constants)
reset_tf_session()
iterations = 25
for i in range(iterations):
print('Epoch %i/%i, Generating corrupted samples...' %
(i + 1, iterations))
x_train_noise = apply_gaussian_noise(x_train)
x_test_noise = apply_gaussian_noise(x_test)
# continue to train model with new noise-augmented data
autoencoder.fit(x=x_train_noise,
y=x_train,
epochs=1,
validation_data=[x_test_noise, x_test],
callbacks=[TQDMProgressCallback()],
verbose=0)
x_test_noise = apply_gaussian_noise(x_test)
denoising_mse = autoencoder.evaluate(x_test_noise, x_test, verbose=0)
print('Denoising MSE:', denoising_mse)
for i in range(5):
img = x_test_noise[i]
visualize(img, encoder, decoder)
def run(constant_overwrites):
constants = merge_dict(get_constants(), constant_overwrites)
tar_filename = constants['tar_filename']
img_size = constants['img_size']
train_files, test_files, train_labels, test_labels, n_classes = \
load_flowers(os.path.dirname(os.path.abspath(__file__)))
data = {
'train_files': train_files,
'train_labels': train_labels,
'test_files': test_files,
'test_labels': test_labels,
'n_classes': n_classes
}
# test cropping
raw_bytes = read_raw_from_tar(tar_filename, 'jpg/image_00001.jpg')
img = decode_image_from_raw_bytes(raw_bytes)
print('')
print('original image shape:', img.shape)
print('')
plt.imshow(img)
plt.show()
img = prepare_raw_bytes_for_model(raw_bytes, img_size, normalize_for_model=False)
print('')
print('cropped image shape:', img.shape)
print('')
plt.imshow(img)
plt.show()
# remember to clear session if you start building graph from scratch!
# don't call K.set_learning_phase() !!! (otherwise will enable dropout
# in train/test simultaneously)
_ = reset_tf_session() # returns session
model = model_builder(n_classes, constants)
print('')
print(model.summary())
print('')
compile_model(model, constants)
# model_file_exists = any(f.startswith('flowers') for f in os.listdir('.') if os.path.isfile(f))
last_finished_epoch = constants['last_finished_epoch']
if last_finished_epoch:
model = load_model(constants['model_filename'].format(last_finished_epoch))
train(model, data, constants)
# Accuracy on test set
test_accuracy = model.evaluate_generator(
train_generator(tar_filename, test_files, test_labels, n_classes, constants),
len(test_files) // constants['batch_size'] // 2
)[1]
print('\nTest accuracy: %.5f' % test_accuracy)
def run(constant_overwrites):
img_shape, attr, x_train, x_test = load_faces_dataset()
plt.figure(figsize=[6, 6])
plt.title('Sample images')
for i in range(6):
plt.subplot(2, 3, i + 1)
show_image(x_train[i])
print('X shape:', x_train.shape)
print('attr shape:', attr.shape)
constants = merge_dict(get_constants(), constant_overwrites)
constants['img_shape'] = img_shape
model_filename = constants['model_filename']
encoder_filename = constants['encoder_filename']
decoder_filename = constants['decoder_filename']
# files = [model_filename, encoder_filename, decoder_filename]
reset_tf_session()
autoencoder, encoder, decoder = model_builder(network_builder, constants)
# if all([os.path.exists(f) for f in files]) and not constants['retrain']:
if os.path.exists(model_filename) and not constants['retrain']:
autoencoder = load_model(model_filename.format(constants['n_epochs']))
# encoder.load_weights(encoder_filename)
# decoder.load_weights(decoder_filename)
encoder = autoencoder.layers[1]
decoder = autoencoder.layers[2]
else:
data = {'X_train': x_train, 'X_test': x_test}
train(autoencoder, data, constants)
encoder.save_weights(encoder_filename)
decoder.save_weights(decoder_filename)
reconstruction_mse = autoencoder.evaluate(x_test, x_test, verbose=0)
print('Convolutional autoencoder MSE:', reconstruction_mse)
for i in range(5):
img = x_test[i]
visualize(img, encoder, decoder)
print(autoencoder.evaluate(x_test, x_test, verbose=0))
print(reconstruction_mse)
def image_morphing(constant_overwrites):
"""
We can take linear combinations of image codes to produce new images with decoder.
:param constant_overwrites:
:return:
"""
img_shape, attr, x_train, x_test = load_faces_dataset()
constants = merge_dict(get_constants(), constant_overwrites)
constants['img_shape'] = img_shape
encoder_filename = constants['encoder_filename']
decoder_filename = constants['decoder_filename']
files = [encoder_filename, decoder_filename]
reset_tf_session()
autoencoder, encoder, decoder = model_builder(network_builder, constants)
if all([os.path.exists(f) for f in files]) and not constants['retrain']:
encoder.load_weights(encoder_filename)
decoder.load_weights(decoder_filename)
else:
data = {'X_train': x_train, 'X_test': x_test}
train(autoencoder, data, constants)
encoder.save_weights(encoder_filename)
decoder.save_weights(decoder_filename)
for _ in range(5):
image1, image2 = x_test[np.random.randint(0, len(x_test), size=2)]
code1, code2 = encoder.predict(np.stack([image1, image2]))
plt.figure(figsize=[10, 4])
for i, a in enumerate(np.linspace(0, 1, num=7)):
output_code = code1 * (1 - a) + code2 * a
output_image = decoder.predict(output_code[None])[0]
plt.subplot(1, 7, i + 1)
show_image(output_image)
plt.title('a=%.2f' % a)
plt.show()
def run(constant_overwrites):
x_train, y_train, x_test, y_test = load_cifar10_dataset()
print('X shape:', x_train.shape)
n_classes = 10
classes = [
'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog',
'horse', 'ship', 'truck'
]
# show random images from training set
cols = 8
rows = 2
fig = plt.figure(figsize=(2 * cols - 1, 2.5 * rows - 1))
for i in range(cols):
for j in range(rows):
idx = np.random.randint(0, len(y_train))
ax = fig.add_subplot(rows, cols, i * rows + j + 1)
ax.grid('off')
ax.axis('off')
ax.imshow(x_train[idx, :])
ax.set_title(classes[y_train[idx, 0]])
plt.show()
constants = merge_dict(get_constants(), constant_overwrites)
constants['img_shape'] = x_train.shape[1:]
constants['n_classes'] = n_classes
model_filename = constants['model_filename']
reset_tf_session()
model = model_builder(network_builder, constants)
if os.path.exists(model_filename) and not constants['retrain']:
model = load_model(model_filename.format(constants['n_epochs']))
else:
initial_learning_rate = constants['learning_rate']
# scheduler of learning rate (decay with epochs)
def lr_scheduler(epoch):
return initial_learning_rate * 0.9**epoch
# callback for printing of actual learning rate used by optimizer
class LrHistory(Callback):
def on_epoch_begin(self, epoch, logs=None):
# if logs is None:
# logs = {}
print('Learning rate:', ke.get_value(model.optimizer.lr))
last_finished_epoch = None
model.fit(x_train,
y_train,
batch_size=constants['batch_size'],
epochs=constants['n_epochs'],
callbacks=[
LearningRateScheduler(lr_scheduler),
LrHistory(),
TQDMProgressCallback(),
ModelSaveCallback(model_filename)
],
validation_data=(x_test, y_test),
shuffle=True,
verbose=0,
initial_epoch=last_finished_epoch or 0)
model.save_weights('weights.h5')