def evaluate(args):
if args.dataset == 'CIFAR-10':
print('Loading test data from: {}'.format(args.cifar10), file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(args.cifar10, 'test_batch'))
elif args.dataset == 'CIFAR-10-DISTORTED':
print('Loading test data from: {}'.format(args.cifar10_distorted), file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(args.cifar10_distorted, 'test_batch'))
else:
raise ValueError('You should choose one of these datasets: {}.'.format(', '.join(DATASETS)))
X, Y = cifar_utils.batch_preprocessing(X, y)
for model_name, create_fn in MODELS.items():
if model_name in args.allowed_models:
# Find last trained model.
weights_filepath = find_last_trained_model(args.trained_dir, args.dataset, model_name)
# Evaluate if a trained model is found.
if weights_filepath:
print('Creating {} model...'.format(model_name))
model = create_fn(input_shape=args.input_shape, output_dim=10)
print('Loading {} weights...'.format(model_name))
model.load_weights(weights_filepath)
print('Evaluating {}...'.format(model_name))
begin = time.time()
loss_and_metrics = model.evaluate(X, Y, batch_size=128)
end = time.time()
duration = datetime.timedelta(seconds=end-begin)
print('\nEvaluation of {} lasted {}.'.format(model_name, duration))
print('Metrics on test data using {}:'.format(model_name))
for metric_name, metric_value in zip(model.metrics_names, loss_and_metrics):
print(' - {}: {}'.format(metric_name, metric_value))
print()
else:
print('Could not find trained model for "{}". Skipping.'.format(model_name))
def check(args):
import time
import datetime
test_batch_path = os.path.join(CIFAR_10_DIR, 'test_batch')
print('Loading test batch from {}...'.format(test_batch_path),
file=sys.stderr)
X, y = cifar_utils.load_batch(test_batch_path)
# 10000 images using pillow.
print('Applying distortions...', file=sys.stderr)
begin = time.time()
Xz = cifar_utils.distort_batch(X, horizontal_flip=False)
end = time.time()
dt_using_pillow = datetime.timedelta(seconds=end - begin)
print('It took {} to mess {} images, using pillow.'.format(
dt_using_pillow, len(X)))
# 128 images using pillow.
begin = time.time()
Xz = cifar_utils.distort_batch(X[:128, ...], horizontal_flip=False)
end = time.time()
dt_using_pillow = datetime.timedelta(seconds=end - begin)
print('It took {} to mess {} images, using pillow.'.format(
dt_using_pillow, 128))
# Compare original and distorted images, side by side.
print('Showing results...', file=sys.stderr)
for i in range(int(6 * 6 / 2)):
plt.subplot(6, 6, i * 2 + 1)
plt.imshow(X[i])
plt.axis('off')
plt.subplot(6, 6, i * 2 + 2)
plt.imshow(Xz[i])
plt.axis('off')
plt.show()
def visualize(args):
if args.dataset == 'CIFAR-10':
print('Loading test data from: {}'.format(args.cifar10), file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(args.cifar10, 'test_batch'))
elif args.dataset == 'CIFAR-10-DISTORTED':
print('Loading test data from: {}'.format(args.cifar10_distorted), file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(args.cifar10_distorted, 'test_batch'))
else:
raise ValueError('You should choose one of these datasets: {}.'.format(', '.join(DATASETS)))
X, Y = cifar_utils.batch_preprocessing(X, y)
# Find last trained STN model.
weights_filepath = find_last_trained_model(args.trained_dir, args.dataset, 'stn')
if weights_filepath:
print('Creating stn model...')
stn = create_stn_model(input_shape=args.input_shape, output_dim=10)
print('Loading stn weights...')
stn.load_weights(weights_filepath)
pass_through_st = K.function([stn.input], [stn.layers[0].output])
samples = X[:25]
samples_transformed = pass_through_st([samples.astype('float32')])
# Input images.
for i in range(25):
plt.subplot(5, 5, i+1)
plt.imshow(np.squeeze(samples[i]), cmap='gray')
plt.title('Label: {}'.format(y[i]))
plt.axis('off')
plt.show()
# Output from STN.
for i in range(25):
plt.subplot(5, 5, i+1)
plt.imshow(np.squeeze(samples_transformed[0][i]), cmap='gray')
plt.title('Label: {}'.format(y[i]))
plt.axis('off')
plt.show()
else:
print('No trained model found for STN.')
def build(args):
"""Downloads CIFAR-10 and create distorted version."""
# Download CIFAR 10 dataset.
if not os.path.isfile(CIFAR_10_TARGZ_FILEPATH):
print(
"Downloading CIFAR 10 to `{}`...".format(CIFAR_10_TARGZ_FILEPATH),
file=sys.stderr)
r = requests.get(CIFAR_10_DOWNLOAD_URL, stream=True)
if r.ok:
with open(CIFAR_10_TARGZ_FILEPATH, 'wb') as f:
shutil.copyfileobj(r.raw, f)
else:
print("CIFAR 10 already downloaded to `{}`.".format(
CIFAR_10_TARGZ_FILEPATH),
file=sys.stderr)
# Unpack the dataset.
if not os.path.isdir(CIFAR_10_DIR):
print("Unpacking CIFAR 10 to: `{}`...".format(CIFAR_10_DIR),
file=sys.stderr)
shutil.unpack_archive(CIFAR_10_TARGZ_FILEPATH, CIFAR_10_UNPACKING_DIR)
else:
print("CIFAR 10 already unpacked to: `{}`.".format(CIFAR_10_DIR),
file=sys.stderr)
# meta_path = os.path.join(CIFAR_10_DIR, 'batches.meta')
# batch1_path = os.path.join(CIFAR_10_DIR, 'data_batch_1')
# Mess with the test images.
if not os.path.isdir(CIFAR_10_DISTORTED_DIR):
print("Creating CIFAR-10-DISTORTED at: `{}`.".format(
CIFAR_10_DISTORTED_DIR),
file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(CIFAR_10_DIR, 'test_batch'))
Xz, params = cifar_utils.distort_batch(X,
horizontal_flip=False,
return_parameters=True)
cifar_utils.save_batch(
os.path.join(CIFAR_10_DISTORTED_DIR, 'test_batch'), Xz, y)
print("CIFAR-10-DISTORTED created.", file=sys.stderr)
if USE_PANDAS:
params_filepath = os.path.join(CIFAR_10_DISTORTED_DIR,
'test_batch_params.csv')
print("Saving distortions parameters to `{}`...".format(
params_filepath),
file=sys.stderr)
pd.DataFrame(params).to_csv(params_filepath, index=False)
else:
print("CIFAR-10-DISTORTED already present at: `{}`.".format(
CIFAR_10_DISTORTED_DIR),
file=sys.stderr)
def train(args):
print('We will train for {}.'.format(args.cifar10), file=sys.stderr)
print('Loading dataset from: {}...'.format(args.cifar10), file=sys.stderr)
if args.cheap:
print('Loading just a few images...', file=sys.stderr)
X, y = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_1'))
X = X[:args.cheap]
y = y[:args.cheap]
else:
X_b1, y_b1 = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_1'))
X_b2, y_b2 = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_2'))
X_b3, y_b3 = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_3'))
X_b4, y_b4 = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_4'))
X_b5, y_b5 = cifar_utils.load_batch(os.path.join(args.cifar10, 'data_batch_5'))
X = np.concatenate([X_b1, X_b2, X_b3, X_b4, X_b5], axis=0)
y = np.concatenate([y_b1, y_b2, y_b3, y_b4, y_b5], axis=0)
del X_b1, X_b2, X_b3, X_b4, X_b5
del y_b1, y_b2, y_b3, y_b4, y_b5
X_train, X_valid, y_train, y_valid = train_test_split(X, y,
test_size=0.1, random_state=7)
del X, y
if args.dataset == 'CIFAR-10':
batch_generator = cifar_utils.generate_batches(X_train, y_train, distort=False, batch_size=args.batch_size)
elif args.dataset == 'CIFAR-10-DISTORTED':
X_valid = cifar_utils.distort_batch(X_valid)
batch_generator = cifar_utils.generate_batches(X_train, y_train, distort=True, batch_size=args.batch_size)
validation_data = cifar_utils.batch_preprocessing(X_valid, y_valid)
training_start = create_timestamp()
for model_name, create_fn in MODELS.items():
if model_name in args.allowed_models:
model_def_path = os.path.join(args.trained_dir, '{}_{}_{}.json'.format(args.dataset, model_name, training_start))
model_weights_path = os.path.join(args.trained_dir, '{}_{}_{}.hd5'.format(args.dataset, model_name, training_start))
tb_logdir = os.path.join(args.tensorboard_log_dir, '{}_{}_{}'.format(args.dataset, model_name, training_start))
checkpoint_filepath = os.path.join(args.checkpoints_dir, '{}_{}_{}_EP{}.hd5'.format(args.dataset, model_name, training_start, '{epoch:02d}'))
tb_callback = TensorBoard(log_dir=tb_logdir, histogram_freq=0)
checkpoint_cb = ModelCheckpoint(checkpoint_filepath, monitor='val_loss',
save_best_only=False, save_weights_only=True, period=1)
print('Creating {} model...'.format(model_name))
model = create_fn(input_shape=args.input_shape, output_dim=10)
print('Training {} model on {}...'.format(model_name, args.dataset))
begin = time.time()
model.fit_generator(
generator=batch_generator, steps_per_epoch=len(X_train)/args.batch_size,
validation_data=validation_data,
epochs=args.epochs, callbacks=[tb_callback, checkpoint_cb])
end = time.time()
duration = datetime.timedelta(seconds=end-begin)
print('Training of {} lasted {}.'.format(model_name, duration))
save_model(model, model_def_path, model_weights_path)
def main(args):
test_batch_path = os.path.join(args.cifar10_dir, 'test_batch')
X_test, y_test = load_batch(test_batch_path)
# bv = BatchVisualizer(X_test, y_test, 5, 5)
# bv.show()
from keras.backend import set_image_data_format
set_image_data_format('channels_last')
from keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(rotation_range=60)
datagen.fit(X_test)
for X, y in datagen.flow(X_test, y_test, batch_size=36):
bv = BatchVisualizer(X.astype(np.uint8), y.astype(np.uint8), 6, 6)
bv.show()
break
def inspect(args):
X, y = cifar_utils.load_batch(args.batch_path)
bv = cifar_utils.BatchVisualizer(X, y, args.rows, args.columns)
bv.show()