def data():
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
NEURONS = [1024]
[x_train,y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[x_test,y_test] = pickle.load(open(VAL_DATA, 'rb'))
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array([item[0] for item in y_train])
y_test = np.array([item[0] for item in y_test])
x_train, y_train, x_test, y_test = augment(x_train,
y_train, x_test, y_test, ['all', 'colour'],
RANDOM_CROP_NUMBER, RESIZE_DIM, RANDOM_CROP_DIM)
# Normalise input
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = y_train.astype('float32')
# Normalise output
y_test = y_test.astype('float32')
y_train /= 255
y_test /= 255
return x_train, y_train, x_test, y_test
def supervised_train_loop(model, optimizer, train_dataset, avg_loss, mIoU,
iters):
i = 0
b = 0
for images, labels in train_dataset:
# with tf.device('/GPU:0'):
images, labels = augment(images, labels)
with tf.GradientTape() as tape:
logits = model(images)
preds = tf.argmax(tf.nn.softmax(logits), axis=-1)
valid_labels, valid_logits = valid_mask_preds(labels, logits)
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(
labels=valid_labels, logits=valid_logits)
loss = tf.reduce_mean(loss)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(
grads_and_vars=zip(gradients, model.trainable_variables))
avg_loss.update_state(loss)
valid_lbls, valid_preds = valid_mask_preds(labels, preds)
mIoU.update_state(valid_lbls, valid_preds)
if 0 < FLAGS.debug_freq <= b:
debug_plot(images, labels, preds, i, b)
b = 0
else:
b += 1
i += 1
def semisupervised_train_loop(model, optimizer, train_dataset, avg_loss, mIoU,
iters):
i = 0
b = 0
beta_distribution = Beta(FLAGS.alpha, FLAGS.alpha)
for X, U in train_dataset:
images, labels = X
unlabeled_images = U
# with tf.device('/GPU:0'):
images, labels = augment(images, labels)
unlabeled_images, boxes, flip_mask = augment_image(
unlabeled_images, FLAGS.K)
U_final = predict_labels(FLAGS.K, boxes, flip_mask, model,
unlabeled_images)
i_c = tf.concat([images, unlabeled_images], axis=0)
label_num = U_final.shape[-1]
one_hot_labels = tf.one_hot(labels, depth=label_num)
l_c = tf.concat([one_hot_labels, U_final], axis=0)
if FLAGS.do_mixup:
i_mix, l_mix, i_shuffled, l_shuffled = mixup(
beta_distribution, i_c, l_c)
else:
i_mix, l_mix = i_c, l_c
l_labeled = tf.stack(l_mix[:images.shape[0]])
l_unlabeled = tf.stack(l_mix[images.shape[0]:])
with tf.GradientTape() as tape:
loss = combined_loss(i_mix, l_labeled, l_unlabeled, model)
# loss = loss_s
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(
grads_and_vars=zip(gradients, model.trainable_variables))
avg_loss.update_state(loss)
preds = tf.argmax(model(images), axis=-1)
valid_lbls, valid_preds = valid_mask_preds(labels, preds)
mIoU.update_state(valid_lbls, valid_preds)
# for k in range(FLAGS.batch_size + FLAGS.unlabeled_batch_size * FLAGS.K):
# plot(i_mix[k], "out/{}/i{}_{}.png".format(FLAGS.run, k, i))
#
# for k in range(FLAGS.batch_size + FLAGS.unlabeled_batch_size * FLAGS.K):
# plot(l_c[k], "out/{}/l0{}_{}.png".format(FLAGS.run, k, i))
# # plot(l_shuffled[k], "out/{}/l1{}_{}.png".format(FLAGS.run, k, i))
# if 0 < FLAGS.debug_freq <= b:
# debug_plot(images, labels, preds, i, b)
# b = 0
# else:
# b += 1
i += 1
def build_ensemble(X, y):
augs = augment(X)
ids = np.arange(len(augs))
clfs = [new_classifier().fit(X, y)]
# for r in range(1, len(augs)+1):
for r in [1, len(augs)]:
combos = [list(e) for e in combinations(ids, r=r)]
for combi in combos:
Xi, yi = concat(augs[combi]), concat([y for _ in combi])
Xi, yi = concat([Xi, X]), concat([yi, y])
clf = new_classifier().fit(Xi, yi)
clfs.append(clf)
return clfs
def __getitem__(self, index):
"""Generate one batch of data
:param index: index of the batch
:return: X and y when fitting. X only when predicting
"""
# Generate indexes of the batch
current_indexes = list(
range(index * self.batch_size, (index + 1) * self.batch_size))
img_paths_temp = self.img_paths[current_indexes]
# Generate data
X = []
y = []
for path in img_paths_temp:
_X = cv2.cvtColor(cv2.imread(self.base_path + f"/images/{path}"),
cv2.COLOR_BGR2RGB)
_y = rgb_to_depth(cv2.imread(self.base_path + f"/depth/{path}"))
_y = 1000.0 * _y
if (np.random.random() < self.augmentation_rate):
_X = augment(_X)
if (np.random.random() < 0.5) and self.augmentation_rate:
_X, _y = flip(_X, _y)
_y = np.clip(_y, self.min_depth, self.max_depth)
_y = DepthNorm(_y, maxDepth=self.max_depth)
_y = resize(_y, (_X.shape[0] // 2, _X.shape[1] // 2),
preserve_range=True,
mode='reflect',
anti_aliasing=True)
_y = _y.reshape(_y.shape[0], _y.shape[1], 1)
#_y = np.log(_y)
X.append(_X)
y.append(_y)
if self.to_fit:
return (np.array(X) /
255).astype('float32'), np.array(y).astype('float32')
else:
return np.array(X).astype('float32')
def _data_generation (self, images_to_load, corresponding_masks, shape):
X = list(map(lambda path: cv2.imread(path), images_to_load))
'''
X = []
for path in images_to_load:
X.append(img_to_array(load_img(path, target_size=(256, 256), grayscale=True)) / 255)
'''
y = list(map(lambda path: cv2.imread(path), corresponding_masks))
'''
y = []
for path in corresponding_masks:
y.append(img_to_array(load_img(path, target_size=(256, 256), grayscale=True )) / 255)
'''
for i, img in enumerate(y):
if img is None:
print(' [EROOR INFO] None image Loaded: ', corresponding_masks[i])
exit(1)
X,y = augment(X, y)
X = list(map(lambda img: cv2.resize(img, shape) if img.shape!=shape else img, X))
y = list(map(lambda img: cv2.resize(img, shape) if img.shape!=shape else img, y))
X = list(map(lambda img: cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), X))
y = list(map(lambda img: cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), y))
# normalize input images and mask images
X = list(map(lambda x: exposure.equalize_adapthist(x), X))
#X = list(map(lambda x: x/255, X))
y = list(map(lambda x: x/255, y))
# expand dims to fit the network architecture
X = list(map(lambda x: np.expand_dims(x,3), X))
y = list(map(lambda x: np.expand_dims(x,3), y))
return X,y
def data():
TRAIN_DATA = '/vol/bitbucket/qn14/train_raw_data.p'
VAL_DATA = '/vol/bitbucket/qn14/validate_raw_data.p'
RANDOM_CROP_NUMBER = 2
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
NO_FILTERS = [16, 32, 64]
[x_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[x_test, y_test] = pickle.load(open(VAL_DATA, 'rb'))
x_train = np.array(
[cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in x_train])
x_test = np.array(
[cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in x_test])
x_train = x_train.reshape(x_train.shape + (1, ))
x_test = x_test.reshape(x_test.shape + (1, ))
y_train = np.array([item[0] for item in y_train])
y_test = np.array([item[0] for item in y_test])
x_train, y_train, x_test, y_test = augment(x_train, y_train, x_test,
y_test, ['all'],
RANDOM_CROP_NUMBER, RESIZE_DIM,
RANDOM_CROP_DIM)
# Normalise input
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = y_train.astype('float32')
# Normalise output
y_test = y_test.astype('float32')
y_train /= 255
y_test /= 255
return x_train, y_train, x_test, y_test
def main(args):
# Hyper-parameters
BATCH_SIZE = 128
EPOCHS = 25
SAVE_DIR = 'results'
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
MODEL_NAME = args[0]
RANDOM_CROP_NUMBER = 2
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
# Set up network training instance
model = Sequential()
if 'translate' in args or 'all' in args:
model.add(Conv2D(32, (5, 5), padding='same',
input_shape=(RANDOM_CROP_DIM,RANDOM_CROP_DIM,1)))
else:
model.add(Conv2D(32, (5, 5), padding='same',
input_shape=(RESIZE_DIM,RESIZE_DIM,1)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (5, 5), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(500))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2, kernel_initializer='normal'))
model.add(Activation('linear'))
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss='mean_squared_error', optimizer=opt)
# Prepare data for training
[X_train,y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[X_val,y_val] = pickle.load(open(VAL_DATA, 'rb'))
X_train = np.array([cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in X_train])
X_val = np.array([cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in X_val])
X_train = X_train.reshape(X_train.shape + (1,))
X_val = X_val.reshape(X_val.shape + (1,))
y_train = np.array([item[0] for item in y_train])
y_val = np.array([item[0] for item in y_val])
X_train, y_train, X_val, y_val = augment(X_train,
y_train, X_val, y_val, args,
RANDOM_CROP_NUMBER, RESIZE_DIM, RANDOM_CROP_DIM)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape)
# Normalise input
X_train = X_train.astype('float32')
X_val = X_val.astype('float32')
X_train /= 255
X_val /= 255
# Normalise output
y_train = y_train.astype('float32')
y_val = y_val.astype('float32')
y_train /= 255
y_val /= 255
# Train the CNN
history = customValidationCallback()
model.fit(X_train, y_train,
epochs=EPOCHS, batch_size=BATCH_SIZE,
validation_data = (X_val, y_val),
callbacks = [history]
)
history_data = {
'loss_history': history.losses,
'val_error_means': history.val_error_means,
'val_error_stds': history.val_error_stds,
}
model.save(MODEL_NAME + '.h5')
pickle.dump(history_data, open(SAVE_DIR + '/' + MODEL_NAME + '.p', 'wb'))
history = None
def training(train_ds, val_ds, test_ds, model, EPOCHS):
@tf.function
def train_step(images, labels):
with tf.GradientTape() as tape:
# training=True is only needed if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions, feature_map = model(images, training=True)
loss = loss_object(labels, predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_accuracy(labels, predictions)
pred_label = tf.math.argmax(predictions, axis=1)
_ = train_AUC.update_state(labels, pred_label)
# pred_axis0, pred_axis1 = tf.unstack(predictions, axis=1)
# _ = train_ROC.update_state(labels, pred_axis0, pred_axis1)
@tf.function
def val_step(images, labels):
# training=False is only needed if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions = model(images, training=False)
v_loss = loss_object(labels, predictions)
val_loss(v_loss)
val_accuracy(labels, predictions)
@tf.function
def test_step(images, labels):
# training=False is only needed if there are layers with different
# behavior during training versus inference (e.g. Dropout).
predictions = model(images, training=False)
t_loss = loss_object(labels, predictions)
test_loss(t_loss)
test_accuracy(labels, predictions)
pred_label = tf.math.argmax(predictions, axis=1)
_ = test_AUC.update_state(labels, pred_label)
# _ = test_ROC.update_state(labels, predictions)
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
optimizer = tf.keras.optimizers.Adam()
ckpt = tf.train.Checkpoint(step=tf.Variable(1), optimizer=optimizer, model=model)
manager = tf.train.CheckpointManager(ckpt, './tf_ckpts', max_to_keep=3)
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
train_AUC = tf.keras.metrics.AUC(
num_thresholds=200, curve='ROC', summation_method='interpolation')
train_ROC = ROC()
num_class = 2
# train_CM = C_M(num_class)
val_loss = tf.keras.metrics.Mean(name='val_loss')
val_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='val_accuracy')
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')
test_AUC = tf.keras.metrics.AUC(
num_thresholds=200, curve='ROC', summation_method='interpolation')
test_ROC = ROC()
# test_CM = C_M(num_class)
# EPOCHS = 10
current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + current_time + '/test'
val_log_dir = 'logs/gradient_tape/' + current_time + '/val'
ROC_log_dir = 'logs/gradient_tape/' + current_time + '/ROC'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)
validation_summary_writer = tf.summary.create_file_writer(val_log_dir)
ROC_summary_writer = tf.summary.create_file_writer(ROC_log_dir)
ckpt.restore(manager.latest_checkpoint)
if manager.latest_checkpoint:
print("Restored from {}".format(manager.latest_checkpoint))
else:
print("Initializing from scratch.")
for epoch in range(EPOCHS):
train_loss.reset_states()
train_accuracy.reset_states()
train_AUC.reset_states()
# train_CM.reset_states()
train_ROC.reset_states()
test_loss.reset_states()
test_accuracy.reset_states()
test_AUC.reset_states()
test_ROC.reset_states()
# test_CM.reset_states()
val_loss.reset_states()
val_accuracy.reset_states()
for sample in train_ds:
size_shape = tf.random.uniform([], minval=200, maxval=256)
train_img = sample[0]
train_label = sample[2]
train_img, train_label = augment(train_img, train_label, size_shape)
train_step(train_img, train_label)
predictions = model(train_img, training=True)
label_pred = tf.math.argmax(predictions, axis=1)
_ = train_ROC.update_state(train_label, predictions)
# _ = train_CM.update_state(train_label,label_pred)
ckpt.step.assign_add(1)
if int(ckpt.step) % 2 == 0:
save_path = manager.save()
print("Saved checkpoint for step {}: {}".format(int(ckpt.step), save_path))
print(manager.checkpoints)
# 画ROC的图并保存
fp, tp = train_ROC.result()
plot_roc('ROC_train', fp, tp) # create figure & 1 axis
plt.savefig('ROC_train_img.png') # save the figure to file
plt.show()
fig = mpimg.imread('ROC_train_img.png')
fig = tf.expand_dims(fig, 0)
with train_summary_writer.as_default():
tf.summary.scalar('train_loss', train_loss.result(), step=epoch)
tf.summary.scalar('train_accuracy', train_accuracy.result(), step=epoch)
tf.summary.scalar('AUC_train', train_AUC.result(), step=epoch)
tf.summary.image("ROC_train", fig, step=epoch)
# tf.summary.image('Confusion Matrix train', fig_CM, step=epoch)
for sample in val_ds:
val_img = sample[0]
val_label = sample[2]
val_step(val_img, val_label)
with validation_summary_writer.as_default():
tf.summary.scalar('val_loss', val_loss.result(), step=epoch)
tf.summary.scalar('val_accuracy', val_accuracy.result(), step=epoch)
template = 'Epoch {}, Loss: {}, Accuracy: {}, Val Loss: {}, Val Accuracy: {}'
print(template.format(epoch + 1,
train_loss.result(),
train_accuracy.result() * 100,
val_loss.result(),
val_accuracy.result() * 100))
def main(args):
# Hyper-parameters
BATCH_SIZE = 32
EPOCHS = 25
SAVE_DIR = 'results'
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
MODEL_NAME = args[0]
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
# Set up network training instance
base_model = DenseNet201(include_top=False,
input_shape=(224, 224, 3),
weights='imagenet')
# x = AveragePooling2D((7, 7), name='avg_pool')(base_model.output)
x = GlobalAveragePooling2D()(base_model.output)
# x = Flatten()(x)
x = Dense(1000, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(2, activation='linear')(x)
model = Model(inputs=base_model.input, outputs=x)
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss='mean_squared_error', optimizer=opt)
# Prepare data for training
[X_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[X_val, y_val] = pickle.load(open(VAL_DATA, 'rb'))
X_train = np.array(X_train)
X_val = np.array(X_val)
y_train = np.array([item[0] for item in y_train])
y_val = np.array([item[0] for item in y_val])
X_train, y_train, X_val, y_val = augment(X_train, y_train, X_val, y_val,
args, RANDOM_CROP_NUMBER,
RESIZE_DIM, RANDOM_CROP_DIM)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape)
# Normalise input
n = X_train.shape[0]
d1 = X_train[:n // 2, :].astype('float32')
print(d1.shape)
d2 = X_train[n // 2:, :].astype('float32')
print(d2.shape)
X_train = np.vstack((d1, d2))
# X_train = X_train.astype('float32')
X_val = X_val.astype('float32')
X_train /= 255
X_val /= 255
# Normalise output
y_train = y_train.astype('float32')
y_val = y_val.astype('float32')
y_train /= 255
y_val /= 255
# Train the CNN
history = customValidationCallback()
model.fit(X_train,
y_train,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
validation_data=(X_val, y_val),
callbacks=[history])
history_data = {
'loss_history': history.losses,
'val_error_means': history.val_error_means,
'val_error_stds': history.val_error_stds,
}
model.save(MODEL_NAME + '.h5')
pickle.dump(history_data, open(SAVE_DIR + '/' + MODEL_NAME + '.p', 'wb'))
history = None
def preprocess(dir, fn):
"""
Data preprocessing function. Given input directory, image and mask data is
copied into a new temporary working directory called "data_copy". Data from
the input directory is copied to "data_copy" and processed.
Parameters
----------
dir : str
String for the directory to perform training with.
n : int
The factor of augmented images to generate with Augmentor.
Returns
-------
None : All processed images are saved into the data_copy directory.
"""
# Insert condition to check whether the augmentation generates NaN data
# If so, repeat the entire process again...
nandetected = False
while not nandetected:
data_copy_dir = dir.strip('/')+'_WORKINGCOPY'
training_data_dir = os.path.join(data_copy_dir, 'training_data')
test_data_dir = os.path.join(data_copy_dir, 'test_data')
# Clean up any old directories and create new directories
cleanup.clean()
os.makedirs(os.path.join(training_data_dir, 'images'))
os.makedirs(os.path.join(training_data_dir, 'masks'))
os.makedirs(os.path.join(test_data_dir, 'images'))
os.makedirs(os.path.join(test_data_dir, 'masks'))
# Make a working directory copy of data so we don't lose anything
os.makedirs(os.path.join(data_copy_dir, 'images'))
os.makedirs(os.path.join(data_copy_dir, 'masks'))
copy_tree(os.path.join(dir, 'images'), os.path.join(data_copy_dir, 'images'))
copy_tree(os.path.join(dir, 'masks'), os.path.join(data_copy_dir, 'masks'))
print ('Performing basic rotation and flipping augmentation on data copy...')
augmentation.basicaugment(data_copy_dir)
print ('Done!')
print ('Performing augmentation on data copy...')
if fn>0:
images_data = os.listdir(data_copy_dir+'/images/')
n=fn*len(images_data)
augmentation.augment(data_copy_dir,n)
aug_images = glob.glob(data_copy_dir+'/images/images_original*')
aug_masks = glob.glob(data_copy_dir+'/images/_groundtruth*')
aug_images.sort(key=lambda x:x[-40:])
aug_masks.sort(key=lambda x:x[-40:])
for i, (image_file, mask_file) in enumerate(zip(aug_images, aug_masks)):
shutil.move(image_file, image_file.replace('images_original_', ''))
shutil.move(mask_file, mask_file.replace('_groundtruth_(1)_images_', '').replace('/images/', '/masks/'))
print ('Augmented and saved with n='+str(n)+' samples!')
print ('Randomly selecting/moving 70% training and 30% test data...')
images_data = natsorted(os.listdir(data_copy_dir+'/images/'))
masks_data = natsorted(os.listdir(data_copy_dir+'/masks/'))
# Changed the sampling so they sample approximately the same distribution
# Now sampling is 75:25
test_images_data = images_data[::4]
test_masks_data = [f.replace('/images/', '/masks/') for f in test_images_data]
training_images_data = [x for x in images_data if x not in test_images_data]
training_masks_data = [f.replace('/images/', '/masks/') for f in training_images_data]
# Old random sampling method for 70:30 data split
# random.shuffle(images_data)
# training_images_data = images_data[:int(0.7*len(images_data))]
# training_masks_data = [f.replace('/images/', '/masks/') for f in training_images_data]
# test_images_data = images_data[int(0.7*len(images_data)):]
# test_masks_data = [f.replace('/images/', '/masks/') for f in test_images_data]
for f in training_images_data:
shutil.copy(os.path.join(data_copy_dir,'images',f), os.path.join(training_data_dir,'images',f))
for f in training_masks_data:
shutil.copy(os.path.join(data_copy_dir,'masks',f), os.path.join(training_data_dir,'masks',f))
for f in test_images_data:
shutil.copy(os.path.join(data_copy_dir,'images',f), os.path.join(test_data_dir,'images',f))
for f in test_masks_data:
shutil.copy(os.path.join(data_copy_dir,'masks',f), os.path.join(test_data_dir,'masks',f))
print ('Done!')
training_data_images = []
training_data_masks = []
test_data_images = []
test_data_masks = []
print ('Loading data...')
for imagepath, maskpath in zip(natsorted(glob.glob(training_data_dir+'/images/*')), natsorted(glob.glob(training_data_dir+'/masks/*'))):
image = Image.open(imagepath).resize((512, 512), resample=Image.BILINEAR)
mask = Image.open(maskpath).resize((512, 512), resample=Image.NEAREST)
training_data_images.append(np.array(image))
training_data_masks.append(np.array(mask))
for imagepath, maskpath in zip(natsorted(glob.glob(test_data_dir+'/images/*')), natsorted(glob.glob(test_data_dir+'/masks/*'))):
image = Image.open(imagepath).resize((512, 512), resample=Image.BILINEAR)
mask = Image.open(maskpath).resize((512, 512), resample=Image.NEAREST)
test_data_images.append(np.array(image))
test_data_masks.append(np.array(mask))
training_data_images = np.array(training_data_images).astype(np.float32)
training_data_masks = np.array(training_data_masks).astype(np.float32)
test_data_images = np.array(test_data_images).astype(np.float32)
test_data_masks = np.array(test_data_masks).astype(np.float32)
print ('Done!')
print ('Running normalisation...')
for idx, img in enumerate(training_data_images):
training_data_images[idx] = (img-np.min(img))/(np.max(img)-np.min(img))
for idx, img in enumerate(training_data_masks):
if np.sum(img) > 0:
img[img < (np.min(img)+np.max(img))/2] = 0.
img[img >= (np.min(img)+np.max(img))/2] = 1.
training_data_masks[idx] = img
for idx, img in enumerate(test_data_images):
test_data_images[idx] = (img-np.min(img))/(np.max(img)-np.min(img))
for idx, img in enumerate(test_data_masks):
if np.sum(img) > 0:
img[img < (np.min(img)+np.max(img))/2] = 0.
img[img >= (np.min(img)+np.max(img))/2] = 1.
test_data_masks[idx] = img
print ('Done!')
print ('Checking nan...')
if np.isnan(training_data_images).any() or np.isnan(training_data_masks).any() or np.isnan(test_data_images).any() or np.isnan(test_data_masks).any():
print ('NaN value detected. Repeating the augmentation process again...')
else:
nandetected = True
print ('Done!')
training_data_images = training_data_images[..., np.newaxis]
training_data_masks = training_data_masks[..., np.newaxis]
test_data_images = test_data_images[..., np.newaxis]
test_data_masks = test_data_masks[..., np.newaxis]
return (training_data_images, training_data_masks, test_data_images, test_data_masks)
def generator(self):
while True:
batches = _make_batches(size=self.total_images,
batch_size=self.batch_size)
for start, end in batches:
arr = []
labels = []
cur_batch = self.image_paths[start:end]
for image_path in cur_batch:
# print image_path
img = imread(
fname=os.path.join(self.data_path, image_path))
# if channels are not 3
ndim = len(img.shape)
if ndim == 2:
img = img[..., np.newaxis]
img = np.tile(A=img, reps=(1, 1, 3))
if ndim == 4:
img = img[..., :3]
# resizing image maintaining aspect ratio
img = resize_image(img=img, size=self.input_size)
if self.training:
# random cropping while training
img = random_crop_image(img=img, size=self.input_size)
img = augment(img=img,
horizontal_flip=True,
vertical_flip=True,
brightness=True,
contrast=True,
rotation=True,
translation=True,
blur=True,
noise=True)
else:
# center cropping
h, w, c = img.shape
center_h = h / 2
center_w = w / 2
center_new_img = self.input_size / 2
new_x1 = center_w - center_new_img
new_y1 = center_h - center_new_img
new_x2 = center_w + center_new_img
new_y2 = center_h + center_new_img
if self.input_size % 2 == 1:
new_x2 += 1
new_y2 += 1
img = img[new_y1:new_y2, new_x1:new_x2]
arr.append(img)
cls = image_path.split('/')[0]
id_for_cls = self.cls2id[cls]
labels.append(id_for_cls)
arr = np.array(arr)
arr.astype('float32')
# making mean of data 0 with standard deviation 1
arr /= 255.
arr -= 0.5
arr *= 2.
# one hot encoding
labels = to_categorical(y=labels,
num_classes=self.total_classes)
yield (arr, labels)
def test_imgaug_on_multichannel_different():
sample = np.ones((240, 180, 5)) * 0.5
result = augment(sample, mode=DATA_AUGMENTATION_DIFFERENT_EACH_CHANNEL)
assert not np.all(result[0] == result[1])
assert result.shape == (240, 180, 5)
def main(args):
# Hyper-parameters
BATCH_SIZE = 128
EPOCHS = 25
# SAVE_DIR = '/vol/bitbucket/qn14/'
# TRAIN_DATA = '/vol/bitbucket/qn14/train_raw_data.p'
# VAL_DATA = '/vol/bitbucket/qn14/validate_raw_data.p'
SAVE_DIR = 'results/'
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
MODEL_NAME = args[0]
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
# Set up network training instance
model = Sequential()
model.add(
Conv2D(64, (10, 10),
strides=(3, 3),
padding='valid',
input_shape=(RANDOM_CROP_DIM, RANDOM_CROP_DIM, 1)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Conv2D(256, (5, 5), padding='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Conv2D(288, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1)))
model.add(Conv2D(272, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(256, (3, 3), padding='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(3584))
model.add(Activation('relu'))
# model.add(Dropout(0.5))
model.add(Dense(2048))
model.add(Activation('relu'))
model.add(Dense(7))
model.add(Activation('softmax'))
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss='categorical_crossentropy', optimizer=opt)
# Prepare data for training
[X_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[X_val, y_val] = pickle.load(open(VAL_DATA, 'rb'))
X_train = np.array(X_train)
X_val = np.array(X_val)
X_train = np.array(
[cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in X_train])
X_val = np.array(
[cv2.cvtColor(item, cv2.COLOR_BGR2GRAY) for item in X_val])
X_train = X_train.reshape(X_train.shape + (1, ))
X_val = X_val.reshape(X_val.shape + (1, ))
y_train = np.array([cyclone_classification(item[1]) for item in y_train])
y_val = np.array([cyclone_classification(item[1]) for item in y_val])
X_train, y_train, X_val, y_val = augment(X_train, y_train, X_val, y_val,
['classification'],
RANDOM_CROP_NUMBER, RESIZE_DIM,
RANDOM_CROP_DIM)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape)
# Normalise input
n = X_train.shape[0]
d1 = X_train[:n // 2, :].astype('float32')
print(d1.shape)
d2 = X_train[n // 2:, :].astype('float32')
print(d2.shape)
X_train = np.vstack((d1, d2))
X_val = X_val.astype('float32')
X_train /= 255
X_val /= 255
y_train = np_utils.to_categorical(y_train)
y_val = np_utils.to_categorical(y_val)
# Train the CNN
history = customValidationCallback()
model.fit(X_train,
y_train,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
validation_data=(X_val, y_val),
callbacks=[history])
history_data = {
'f1': history.val_f1s,
'recall': history.val_recalls,
'precision': history.val_precisions,
'accuracy': history.val_accuracy,
'best_model': history.best_model
}
pickle.dump(history_data, open(SAVE_DIR + MODEL_NAME + '.p', 'wb'))
history = None
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
[x_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[x_test, y_test] = pickle.load(open(VAL_DATA, 'rb'))
x_train = np.array(x_train)
x_test = np.array(x_test)
y_train = np.array([item[0] for item in y_train])
y_test = np.array([item[0] for item in y_test])
x_train, y_train, x_test, y_test = augment(x_train, y_train, x_test, y_test,
['all', 'colour'],
RANDOM_CROP_NUMBER, RESIZE_DIM,
RANDOM_CROP_DIM)
# Normalise input
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = y_train.astype('float32')
# Normalise output
y_test = y_test.astype('float32')
y_train /= 255
y_test /= 255
# Train the CNN
import pickle
import numpy as np
from augmentation import augment
TRAIN_DATA = 'train_raw_data.p'
VAL_DATA = 'validate_raw_data.p'
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
# Prepare data for training
[X_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[X_val, y_val] = pickle.load(open(VAL_DATA, 'rb'))
X_train = np.array(X_train)
X_val = np.array(X_val)
y_train = np.array([item[0] for item in y_train])
y_val = np.array([item[0] for item in y_val])
X_train, y_train, X_val, y_val = augment(X_train, y_train, X_val, y_val,
['all', 'colour'], RANDOM_CROP_NUMBER,
RESIZE_DIM, RANDOM_CROP_DIM)
result = np.abs(np.ones(y_val.shape) * 255 / 2 - y_val)
result = np.sqrt(np.dot(result**2, np.array([1, 1])))
print(np.mean(result))
print(np.std(result))
def __init__(self, root_dir, preprocess_type, dimension):
self.root_dir = root_dir
self.preprocess_type = preprocess_type
self.dimension = dimension
self.aug_det = augmentation.augment().to_deterministic()
def test_imgaug_on_multichannel_same():
sample = np.ones((240, 180, 5)) * 0.5
result = augment(sample, mode=DATA_AUGMENTATION_SAME_PER_CHANNEL)
# assert np.all(result[0] == result[1]) # cannot be ensured currently
assert result.shape == (240, 180, 5)
def main(args):
# Hyper-parameters
BATCH_SIZE = 16
EPOCHS = 25
SAVE_DIR = '/vol/bitbucket/qn14/'
TRAIN_DATA = '/vol/bitbucket/qn14/train_raw_data.p'
VAL_DATA = '/vol/bitbucket/qn14/validate_raw_data.p'
MODEL_NAME = args[0]
RANDOM_CROP_NUMBER = 1
RESIZE_DIM = 256
RANDOM_CROP_DIM = 224
# Set up network training instance
base_model = DenseNet201(include_top=False,
input_shape=(224, 224, 3),
weights='imagenet')
# x = AveragePooling2D((7, 7), name='avg_pool')(base_model.output)
x = GlobalAveragePooling2D()(base_model.output)
# x = Flatten()(x)
x = Dense(512)(x)
x = Activation('relu')(x)
x = Dropout(0.38)(x)
x = Dense(7, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=x)
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(loss='categorical_crossentropy', optimizer=opt)
# Prepare data for training
[X_train, y_train] = pickle.load(open(TRAIN_DATA, 'rb'))
[X_val, y_val] = pickle.load(open(VAL_DATA, 'rb'))
X_train = np.array(X_train)
X_val = np.array(X_val)
y_train = np.array([cyclone_classification(item[1]) for item in y_train])
y_val = np.array([cyclone_classification(item[1]) for item in y_val])
X_train, y_train, X_val, y_val = augment(X_train, y_train, X_val, y_val,
['classification', 'colour'],
RANDOM_CROP_NUMBER, RESIZE_DIM,
RANDOM_CROP_DIM)
print(X_train.shape)
print(y_train.shape)
print(X_val.shape)
print(y_val.shape)
# Normalise input
n = X_train.shape[0]
d1 = X_train[:n // 2, :].astype('float32')
print(d1.shape)
d2 = X_train[n // 2:, :].astype('float32')
print(d2.shape)
X_train = np.vstack((d1, d2))
X_val = X_val.astype('float32')
X_train /= 255
X_val /= 255
y_train = np_utils.to_categorical(y_train)
y_val = np_utils.to_categorical(y_val)
# Train the CNN
history = customValidationCallback()
model.fit(X_train,
y_train,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
validation_data=(X_val, y_val),
callbacks=[history])
history_data = {
'f1': history.val_f1s,
'recall': history.val_recalls,
'precision': history.val_precisions,
'accuracy': history.val_accuracy,
'best_model': history.best_model
}
pickle.dump(history_data, open(SAVE_DIR + MODEL_NAME + '.p', 'wb'))
history = None
def test_imgaug_on_multichannel_no():
sample = np.random.rand(240, 180, 5)
result = augment(sample, mode=DATA_AUGMENTATION_NO)
assert result.shape == (240, 180, 5)
def train(d_model,
g_model,
gan_model,
dataset_train,
n_epochs=100,
n_batch=4,
n_aug=20):
"""
Train the generator and discriminator models
"""
# Extract current time for model/plot save files
now = datetime.now()
current_time = now.strftime("%Y-%m-%d_%H-%M-%S")
modelsDir = os.path.join("models", f"run_{current_time}")
os.mkdir(modelsDir)
logsDir = os.path.join("logs", f"run_{current_time}")
os.mkdir(logsDir)
# determine the output square shape of the discriminator
n_patch = d_model.output_shape[1]
# Split training set in train and validation sets
dataset_train, dataset_val = split_train_val(dataset_train)
trainA_ori, trainB_ori = dataset_train
valA, valB = dataset_val
# Fix train- and test-dataset dimensionality issues
trainA = np.expand_dims(trainA_ori, axis=3)
trainB = np.expand_dims(trainB_ori, axis=3)
valA = np.expand_dims(valA, axis=3)
valB = np.expand_dims(valB, axis=3)
dataset_train = [trainA, trainB]
dataset_val = [valA, valB]
# calculate the number of batches per training epoch
bat_per_epo = int(len(trainA_ori) * n_aug / n_batch) # for us: 22*n_aug
# Define loggers for losses, images and similarity metrics
logger_g = Logger(os.path.join(logsDir, "gen"))
logger_d1 = Logger(os.path.join(logsDir, "dis1"))
logger_d2 = Logger(os.path.join(logsDir, "dis2"))
logger_im = Logger(os.path.join(logsDir, "im"))
logger_train = Logger(os.path.join(logsDir, "ssim_train"))
logger_val = Logger(os.path.join(logsDir, "ssim_val"))
# manually enumerate epochs
i = 0
for epoch in range(n_epochs):
print("\n" + print_style.BOLD + f"Epoch {epoch+1}/{n_epochs}:" +
print_style.END)
# Create list of available indices --> Images can't be used twice in the same epoch.
available_idx = np.array(range(np.shape(dataset_train)[1]))
# For each epoch, create a new augmented dataset
print("Performing data augmentation... ", end="", flush=True)
# initialize augmented dataset
A = np.zeros((len(trainA_ori) * n_aug, 256, 256, 1))
B = np.zeros((len(trainA_ori) * n_aug, 256, 256, 1))
# for shuffling of all slices
rand_i = list(range(len(trainA_ori) * n_aug))
random.shuffle(rand_i) # unique list of random indices
k = 0
for n in range(n_aug):
for j in range(len(trainA_ori)):
# Augment every image randomely per epoch
trainA_aug, trainB_aug = augment(trainA_ori[j], trainB_ori[j])
A[rand_i[k]] = trainA_aug
B[rand_i[k]] = trainB_aug
k += 1
dataset_aug = [A, B] # all trainingdata (day4 and day1)
print("Completed")
time.sleep(1)
for batch in tqdm(range(bat_per_epo), ascii=True):
# select a batch of real samples
[X_realA, X_realB], y_real, used_idx = generate_real_samples(
dataset_aug, n_batch, n_patch, available_idx)
np.delete(available_idx, used_idx)
# generate a batch of fake samples
X_fakeB, y_fake = generate_fake_samples(g_model, X_realA, n_patch)
# Perform actual training
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# update discriminator for real samples
d_loss1 = d_model.train_on_batch([X_realA, X_realB], y_real)
# update discriminator for generated samples
d_loss2 = d_model.train_on_batch([X_realA, X_fakeB], y_fake)
# update the generator
g_loss, _, _, _ = gan_model.train_on_batch(
X_realA, [y_real, X_realB, X_realB])
# Store losses (tensorboard)
if (i + 1) % (bat_per_epo // 50) == 0:
logger_g.log_scalar('run_{}'.format(current_time), g_loss, i)
logger_d1.log_scalar('run_{}'.format(current_time), d_loss1, i)
logger_d2.log_scalar('run_{}'.format(current_time), d_loss2, i)
# Store similarities (tensorboard)
if (i + 1) % (bat_per_epo // 20) == 0:
similarity_train = check_ssim(g_model, dataset_train, 1)
similarity_val = check_ssim(g_model, dataset_val, 1)
logger_train.log_scalar('run_{}'.format(current_time),
similarity_train, i)
logger_val.log_scalar('run_{}'.format(current_time),
similarity_val, i)
i += 1
print('>Losses: d1[%.3f] d2[%.3f] g[%.3f]' %
(d_loss1, d_loss2, g_loss))
summarize_performance(i, g_model, dataset_train, dataset_val,
modelsDir, logger_im, current_time)
# output current_time so a model can be selected from the correct directory
return current_time
