def check_res50_features(model_name, GPU=0):
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '{}'.format(GPU)
import keras
input_size_fit = (224, 224)
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(255)
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2])
if model_name == 'deeplab':
input_size = (321, 321)
overlap = 0
else:
input_size = (572, 572)
overlap = 184
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4],
cSize=input_size,
numPixOverlap=overlap,
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=overlap // 2)
patchDir = extrObj.run(blCol)
file_name = os.path.join(patchDir, 'fileList.txt')
with open(file_name, 'r') as f:
files = f.readlines()
res50 = keras.applications.resnet50.ResNet50(include_top=True,
weights='imagenet')
pred_list = np.zeros(len(files))
for file_cnt, file_line in enumerate(tqdm(files)):
img = np.zeros((input_size[0], input_size[1], 3), dtype=np.uint8)
for cnt, file in enumerate(file_line.strip().split(' ')[:3]):
img[:, :, cnt] = imageio.imread(os.path.join(patchDir,
file)) - img_mean[cnt]
img = np.expand_dims(crop_center(img, input_size_fit[0],
input_size_fit[1]),
axis=0)
fc1000 = res50.predict(img).reshape((-1, )).tolist()
pred_list[file_cnt] = np.argmax(fc1000)
return pred_list
def make_res50_features(model_name, task_dir, GPU=0, force_run=False):
tf.reset_default_graph()
feature_file_name = os.path.join(task_dir, 'res50_atlanta_{}.csv'.format(model_name))
patch_file_name = os.path.join(task_dir, 'res50_atlanta_{}.txt'.format(model_name))
if model_name == 'deeplab':
input_size = (321, 321)
overlap = 0
else:
input_size = (572, 572)
overlap = 184
blCol = uab_collectionFunctions.uabCollection('atlanta')
img_mean = blCol.getChannelMeans([0, 1, 2])
extrObj = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 3],
cSize=input_size,
numPixOverlap=overlap,
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=overlap // 2)
patchDir = extrObj.run(blCol)
if not os.path.exists(feature_file_name) or not os.path.exists(patch_file_name) or force_run:
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '{}'.format(GPU)
import keras
input_size_fit = (224, 224)
file_name = os.path.join(patchDir, 'fileList.txt')
with open(file_name, 'r') as f:
files = f.readlines()
res50 = keras.applications.resnet50.ResNet50(include_top=True, weights='imagenet')
fc2048 = keras.models.Model(inputs=res50.input, outputs=res50.get_layer('flatten_1').output)
with open(feature_file_name, 'w+') as f:
with open(patch_file_name, 'w+') as f2:
for file_line in tqdm(files):
patch_name = file_line.split('.')[0][:-5]
img = np.zeros((input_size[0], input_size[1], 3), dtype=np.uint8)
for cnt, file in enumerate(file_line.strip().split(' ')[:3]):
img[:, :, cnt] = imageio.imread(os.path.join(patchDir, file)) - img_mean[cnt]
img = np.expand_dims(crop_center(img, input_size_fit[0], input_size_fit[1]), axis=0)
fc1000 = fc2048.predict(img).reshape((-1,)).tolist()
writer = csv.writer(f, lineterminator='\n')
writer.writerow(['{}'.format(x) for x in fc1000])
f2.write('{}\n'.format(patch_name))
return feature_file_name, patch_file_name, input_size[0], patchDir
def main(flags):
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
z = tf.placeholder(tf.float32, shape=[None, flags.z_dim], name='z')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UGAN.UGAN({
'X': X,
'Z': z
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4], # extract all 4 channels
cSize=flags.input_size, # patch size as 572*572
numPixOverlap=int(model.get_overlap() / 2), # overlap as 92
extSave=['jpg', 'jpg', 'jpg',
'png'], # save rgb files as jpg and gt as png
isTrain=True,
gtInd=3,
pad=model.get_overlap()) # pad around the tiles
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'force_tile')
# use first 5 tiles for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(6, 37)])
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(0, 6)])
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train = uabDataReader.ImageLabelReader(
[3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
flags.tile_size,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
flags.tile_size,
flags.batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean))
# train
start_time = time.time()
model.train_config('X', 'Z', flags.n_train, flags.n_valid,
flags.input_size, uabRepoPaths.modelPath)
model.run(
train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=None,
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
best_model=best_model)
self.model_name = pretrained_model_dir.split('/')[-1]
result = self.test('X', sess, test_reader)
image_pred = uabUtilreader.un_patchify_shrink(
result, [tile_size[0] + pad, tile_size[1] + pad],
tile_size,
patch_size, [patch_size[0] - pad, patch_size[1] - pad],
overlap=pad)
ersa_utils.save_file(
os.path.join(SAVE_DIR, '{}.png'.format(tile_name)),
(image_pred[:, :, 1] * 255).astype(np.uint8))
return util_functions.get_pred_labels(image_pred) * truth_val
# settings
blCol = uab_collectionFunctions.uabCollection(ds_name)
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([1, 2, 3, 4])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(0)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list,
'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [1, 2, 3])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth, file_list_truth, [1, 2, 3])
img_mean = blCol.getChannelMeans([2, 3, 4])
img_mean = np.concatenate([np.array([0]), img_mean])
def main(flags):
city_list = ['austin', 'chicago', 'kitsap', 'tyrol-w', 'vienna']
flags.llh_file_dir = flags.llh_file_dir.format(flags.finetune_city)
weight = np.load(flags.llh_file_dir)
# make network
# define place holder
X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X')
y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UNet.UnetModelCrop({'X': X, 'Y': y},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif', 'Map GT to (0, 1)', [3], opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 4], # extract all 4 channels
cSize=flags.input_size, # patch size as 572*572
numPixOverlap=int(model.get_overlap()/2), # overlap as 92
extSave=['jpg', 'jpg', 'jpg', 'png'], # save rgb files as jpg and gt as png
isTrain=True,
gtInd=3,
pad=model.get_overlap()) # pad around the tiles
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx_city, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt', 'city')
idx_tile, _ = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt', 'force_tile')
idx = [j * 10 + i for i, j in zip(idx_city, idx_tile)]
# use first city for validation
filter_train = []
filter_valid = []
for i in range(5):
for j in range(1, 37):
if i != flags.finetune_city and j > 5:
filter_train.append(j * 10 + i)
elif i == flags.finetune_city and j <= 5:
filter_valid.append(j * 10 + i)
# use first city for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(idx, file_list, filter_train)
file_list_valid = uabCrossValMaker.make_file_list_by_key(idx, file_list, filter_valid)
dataReader_train = uabDataReader.ImageLabelReaderPatchSampleControl(
[3], [0, 1, 2], patchDir, file_list_train, flags.input_size, flags.batch_size,
weight, dataAug='flip,rotate', block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir, file_list_valid, flags.input_size,
flags.batch_size, dataAug=' ',
block_mean=np.append([0], img_mean), batch_code=0)
# train
start_time = time.time()
model.train_config('X', 'Y', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent', par_dir='Inria_Domain_Selection')
model.run(train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=flags.pred_model_dir.format(flags.finetune_city),
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size
)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration/60/60))
def main(flags):
# make network
# define place holder
X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X')
y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_DeepLabV2.DeeplabV3({'X':X, 'Y':y},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('spca')
blCol.readMetadata()
img_mean = blCol.getChannelMeans([1, 2, 3]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtrRand([0, 1, 2, 3], # extract all 4 channels
cSize=flags.input_size, # patch size as 572*572
numPerTile=256, # overlap as 92
extSave=['png', 'jpg', 'jpg', 'jpg'],
# save rgb files as jpg and gt as png
isTrain=True,
gtInd=0,
pad=model.get_overlap(),
name='Rand{}'.format(flags.run_id)) # pad around the tiles
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt', 'force_tile')
# use first 5 tiles for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(idx, file_list, [i for i in range(0, 250)])
file_list_valid = uabCrossValMaker.make_file_list_by_key(idx, file_list, [i for i in range(250, 500)])
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train = uabDataReader.ImageLabelReader([0], [1, 2, 3], patchDir, file_list_train, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([0], [1, 2, 3], patchDir, file_list_valid, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug=' ', block_mean=np.append([0], img_mean))
# train
start_time = time.time()
model.train_config('X', 'Y', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent')
model.run(train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=flags.res_dir,
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration/60/60))
def main(flags):
np.random.seed(int(flags.run_id))
tf.set_random_seed(int(flags.run_id))
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
y = tf.placeholder(
tf.int32,
shape=[None, flags.input_size[0], flags.input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = myUnetModelCrop({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection(flags.ds_name)
blCol.readMetadata()
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
print(img_mean)
img_dir, task_dir = sis_utils.get_task_img_folder()
save_dir = os.path.join(task_dir, 'bihar_patches')
ersa_utils.make_dir_if_not_exist(save_dir)
files, par_dir = blCol.getAllTileByDirAndExt([0, 1, 2, 3])
resize_patches(files, par_dir, flags.input_size, save_dir)
patchDir = save_dir
# make data reader
# use first 5 tiles for validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'tile')
# use first city for validation
#assert len(file_list) == flags.n_train + flags.n_valid
file_list_train = [a for a in file_list[:45]]
file_list_valid = [a for a in file_list[-5:]]
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train = uabDataReader.ImageLabelReader(
[3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
None,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
None,
flags.batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean))
# train
start_time = time.time()
model.train_config('X',
'Y',
flags.n_train,
flags.n_valid,
flags.input_size,
uabRepoPaths.modelPath,
loss_type='xent',
par_dir='{}'.format(flags.ds_name))
model.run(
train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=
None, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=200, # save the model every 5 epochs
gpu=GPU,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
def train(self,
x_name,
y_name,
y_name_2,
n_train,
sess,
summary_writer,
n_valid=1000,
train_reader=None,
train_reader_building=None,
valid_reader=None,
image_summary=None,
verb_step=100,
save_epoch=5,
img_mean=np.array((0, 0, 0), dtype=np.float32),
continue_dir=None,
valid_iou=False):
# define summary operations
valid_cross_entropy_summary_op = tf.summary.scalar(
'xent_validation', self.valid_cross_entropy)
valid_iou_summary_op = tf.summary.scalar('iou_validation',
self.valid_iou)
valid_image_summary_op = tf.summary.image('Validation_images_summary',
self.valid_images,
max_outputs=10)
if continue_dir is not None and os.path.exists(continue_dir):
self.load(continue_dir, sess)
gs = sess.run(self.global_step)
start_epoch = int(np.ceil(gs / n_train * self.bs))
start_step = gs - int(start_epoch * n_train / self.bs)
else:
start_epoch = 0
start_step = 0
cross_entropy_valid_min = np.inf
iou_valid_max = 0
for epoch in range(start_epoch, self.epochs):
start_time = time.time()
for step in range(start_step, n_train, self.bs):
X_batch, y_batch = train_reader.readerAction(sess)
_, self.global_step_value = sess.run(
[self.optimizer[0], self.global_step],
feed_dict={
self.inputs[x_name]: X_batch,
self.inputs[y_name]: y_batch,
self.trainable: True
})
X_batch, _, building_truth = train_reader_building.readerAction(
sess)
_, self.global_step_value = sess.run(
[self.optimizer[1], self.global_step],
feed_dict={
self.inputs[x_name]: X_batch,
self.inputs[y_name_2]: building_truth,
self.trainable: True
})
if self.global_step_value % verb_step == 0:
pred_train, step_cross_entropy, step_summary = sess.run(
[self.pred, self.loss, self.summary],
feed_dict={
self.inputs[x_name]: X_batch,
self.inputs[y_name]: y_batch,
self.inputs[y_name_2]: building_truth,
self.trainable: False
})
summary_writer.add_summary(step_summary,
self.global_step_value)
print(
'Epoch {:d} step {:d}\tcross entropy = {:.3f}'.format(
epoch, self.global_step_value, step_cross_entropy))
# validation
cross_entropy_valid_mean = []
iou_valid_mean = np.zeros(2)
for step in range(0, n_valid, self.bs):
X_batch_val, y_batch_val = valid_reader.readerAction(sess)
pred_valid, cross_entropy_valid, iou_valid = sess.run(
[self.pred, self.loss, self.loss_iou],
feed_dict={
self.inputs[x_name]: X_batch_val,
self.inputs[y_name]: y_batch_val,
self.trainable: False
})
cross_entropy_valid_mean.append(cross_entropy_valid)
iou_valid_mean += iou_valid
cross_entropy_valid_mean = np.mean(cross_entropy_valid_mean)
iou_valid_mean = iou_valid_mean[0] / iou_valid_mean[1]
duration = time.time() - start_time
if valid_iou:
print('Validation IoU: {:.3f}, duration: {:.3f}'.format(
iou_valid_mean, duration))
else:
print('Validation cross entropy: {:.3f}, duration: {:.3f}'.
format(cross_entropy_valid_mean, duration))
valid_cross_entropy_summary = sess.run(
valid_cross_entropy_summary_op,
feed_dict={self.valid_cross_entropy: cross_entropy_valid_mean})
valid_iou_summary = sess.run(
valid_iou_summary_op,
feed_dict={self.valid_iou: iou_valid_mean})
summary_writer.add_summary(valid_cross_entropy_summary,
self.global_step_value)
summary_writer.add_summary(valid_iou_summary,
self.global_step_value)
if valid_iou:
if iou_valid_mean > iou_valid_max:
iou_valid_max = iou_valid_mean
saver = tf.train.Saver(var_list=tf.global_variables(),
max_to_keep=1)
saver.save(sess, '{}/best_model.ckpt'.format(self.ckdir))
else:
if cross_entropy_valid_mean < cross_entropy_valid_min:
cross_entropy_valid_min = cross_entropy_valid_mean
saver = tf.train.Saver(var_list=tf.global_variables(),
max_to_keep=1)
saver.save(sess, '{}/best_model.ckpt'.format(self.ckdir))
if image_summary is not None:
valid_image_summary = sess.run(
valid_image_summary_op,
feed_dict={
self.valid_images:
image_summary(X_batch_val[:, :, :, :3], y_batch_val,
pred_valid, img_mean)
})
summary_writer.add_summary(valid_image_summary,
self.global_step_value)
if epoch % save_epoch == 0:
saver = tf.train.Saver(var_list=tf.global_variables(),
max_to_keep=1)
saver.save(sess,
'{}/model_{}.ckpt'.format(self.ckdir, epoch),
global_step=self.global_step)
# remake gts
blCol = uab_collectionFunctions.uabCollection('inria')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(
4)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(
None, file_list, 'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
city_list = [
'austin', 'chicago', 'kitsap', 'tyrol-w', 'vienna'
]
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx,
file_list, [i for i in range(0, 6)],
filter_list=[
'bellingham', 'bloomington', 'sfo', 'tyrol-e',
'innsbruck'
] +
[a for a in city_list if a != city_list[flags.leave_city]])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth,
file_list_truth, [i for i in range(0, 6)],
filter_list=[
'bellingham', 'bloomington', 'sfo', 'tyrol-e',
'innsbruck'
] +
[a for a in city_list if a != city_list[flags.leave_city]])
img_mean = blCol.getChannelMeans([0, 1, 2])
self.evaluate(file_list_valid,
file_list_valid_truth,
parent_dir,
parent_dir_truth, (572, 572), (5000, 5000),
50,
img_mean,
self.ckdir,
flags.GPU,
save_result_parent_dir='domain_selection',
ds_name='inria_{}'.format(epoch),
best_model=False)
result_dir = os.path.join(uabRepoPaths.evalPath,
self.model_name)
make_gt(result_dir, flags.pred_file_dir, 'iter')
def main(flags):
np.random.seed(int(flags.run_id))
tf.set_random_seed(int(flags.run_id))
if flags.start_layer >= 10:
pass
else:
flags.model_name += '_up{}'.format(flags.start_layer)
# make network
# define place holder
X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X')
y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UNet.UnetModelCrop({'X': X, 'Y': y},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection(flags.ds_name)
blCol.readMetadata()
img_mean = blCol.getChannelMeans([1, 2, 3]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 3],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['png', 'jpg', 'jpg', 'jpg'],
isTrain=True,
gtInd=0,
pad=int(model.get_overlap()//2))
patchDir = extrObj.run(blCol)
# make data reader
# use first 5 tiles for validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt', 'tile')
file_list_train = uabCrossValMaker.make_file_list_by_key(idx, file_list, [0, 1, 2, 3])
file_list_valid = uabCrossValMaker.make_file_list_by_key(idx, file_list, [4, 5])
file_list_train = file_list_train[-int(len(file_list_train)*flags.portion):]
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train = uabDataReader.ImageLabelReader([0], [1, 2, 3], patchDir, file_list_train, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([0], [1, 2, 3], patchDir, file_list_valid, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug=' ', block_mean=np.append([0], img_mean))
# train
start_time = time.time()
if flags.start_layer >= 10:
model.train_config('X', 'Y', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent', par_dir='aemo/{}'.format(flags.ds_name))
else:
model.train_config('X', 'Y', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent', par_dir='aemo/{}'.format(flags.ds_name),
train_var_filter=['layerup{}'.format(i) for i in range(flags.start_layer, 10)])
model.run(train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=flags.model_dir, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration/60/60))
def compute_missing_percentage(rgb):
stack = np.sum(rgb, axis=2)
def white_pixel(a):
if a == 255 * 3:
return 1
else:
return 0
map_func = np.vectorize(white_pixel)
mpixel_map = map_func(stack)
return np.sum(mpixel_map) / (mpixel_map.shape[0]**2), 1 - mpixel_map
blCol = uab_collectionFunctions.uabCollection('road')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [0] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [0],
opDetObj)
rescObj.run(blCol)
blCol.readMetadata()
img_mean = blCol.getChannelMeans([1, 2, 3]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[1, 2, 3, 4], # extract all 4 channels
cSize=(572, 572), # patch size as 572*572
numPixOverlap=46, # half overlap for this
def main(flags):
# ------------------------------------------Network---------------------------------------------#
# make network
# define place holder
X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X')
y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UnetMTL.UnetModelMTL({'X':X, 'Y':y},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn,
source_num=flags.s_num,
source_name=flags.s_name,
source_control=flags.s_control)
model.create_graph('X', class_num=flags.num_classes, start_filter_num=flags.sfn)
# ------------------------------------------Dataset Inria---------------------------------------------#
# create collection for inria
blCol_inria = uab_collectionFunctions.uabCollection('inria')
opDetObj_inria = bPreproc.uabOperTileDivide(255)
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif', 'Map GT to (0, 1)', [3], opDetObj_inria)
rescObj.run(blCol_inria)
img_mean_inria = blCol_inria.getChannelMeans([0, 1, 2])
# extract patches
extrObj_inria = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 4],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=int(model.get_overlap() / 2))
patchDir_inria = extrObj_inria.run(blCol_inria)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx_inria, file_list_inria = uabCrossValMaker.uabUtilGetFolds(patchDir_inria, 'fileList.txt', 'force_tile')
# use first 5 tiles for validation
file_list_train_inria = uabCrossValMaker.make_file_list_by_key(idx_inria, file_list_inria,
[i for i in range(20, 136)])
file_list_valid_inria = uabCrossValMaker.make_file_list_by_key(idx_inria, file_list_inria,
[i for i in range(0, 20)])
with tf.name_scope('image_loader_inria'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train_inria = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir_inria, file_list_train_inria,
flags.input_size, flags.tile_size, flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean_inria))
# no augmentation needed for validation
dataReader_valid_inria = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir_inria, file_list_valid_inria,
flags.input_size, flags.tile_size,
flags.batch_size, dataAug=' ',
block_mean=np.append([0], img_mean_inria))
# ------------------------------------------Dataset Road---------------------------------------------#
# create collection for road
blCol_road = uab_collectionFunctions.uabCollection('road_5000')
opDetObj_road = bPreproc.uabOperTileDivide(255)
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif', 'Map GT to (0, 1)', [3], opDetObj_road)
rescObj.run(blCol_road)
img_mean_road = blCol_road.getChannelMeans([0, 1, 2])
# extract patches
extrObj_road = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 4],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=int(model.get_overlap() / 2))
patchDir_road = extrObj_road.run(blCol_road)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx_road, file_list_road = uabCrossValMaker.uabUtilGetFolds(patchDir_road, 'fileList.txt', 'city')
# use first 5 tiles for validation
file_list_train_road = uabCrossValMaker.make_file_list_by_key(idx_road, file_list_road, [1])
file_list_valid_road = uabCrossValMaker.make_file_list_by_key(idx_road, file_list_road, [0, 2])
with tf.name_scope('image_loader_road'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train_road = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir_road, file_list_train_road,
flags.input_size, flags.tile_size, flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean_road))
# no augmentation needed for validation
dataReader_valid_road = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir_road, file_list_valid_road,
flags.input_size, flags.tile_size,
flags.batch_size, dataAug=' ',
block_mean=np.append([0], img_mean_road))
# ------------------------------------------Train---------------------------------------------#
start_time = time.time()
model.train_config('X', 'Y', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent')
model.run(train_reader=[dataReader_train_inria, dataReader_train_road],
valid_reader=[dataReader_valid_inria, dataReader_valid_road],
pretrained_model_dir=None, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=[img_mean_inria, img_mean_road],
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration/60/60))
import os
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = '1'
import keras
import numpy as np
import sis_utils
import uabRepoPaths
import uabCrossValMaker
import uab_collectionFunctions
import uab_DataHandlerFunctions
import building_data_reader
if __name__ == '__main__':
# train on um
blCol_um = uab_collectionFunctions.uabCollection('um')
img_mean_um = blCol_um.getChannelMeans([0, 1, 2])
blCol_um.readMetadata()
# valid on inria
blCol_inria = uab_collectionFunctions.uabCollection('inria')
img_mean_inria = blCol_inria.getChannelMeans([0, 1, 2])
blCol_inria.readMetadata()
model_name = 'res50'
batch_size = 25
class_num = 2
n_train = 300
n_valid = 100
epoch = 150
learn_rate = 1e-5
prescr_name = 'res50'
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_DeepLabV2.DeeplabV3({
'X': X,
'Y': y
},
trainable=mode,
input_size=input_size,
batch_size=batch_size)
# create graph, same as training
model.create_graph('X', class_num=2)
print('-' * 10 + 'Begin to predict testing set' + '-' * 10)
# ------------------------------------------Dataset Inria Training Set---------------------------------------------#
# make collections
# same as what to do in training
blCol = uab_collectionFunctions.uabCollection('fullInriaTest')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(4)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list,
'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx,
file_list, [i for i in range(0, 5000)],
filter_list=['bellingham', 'bloomington', 'sfo', 'tyrol-e', 'innsbruck'])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth,
file_list_truth, [i for i in range(0, 5000)],
batch_size=batch_size, # mini-batch size
learn_rate=learn_rate, # learning rate
decay_step=decay_step, # learn rate decay after 60 epochs
decay_rate=decay_rate, # learn rate decay to 0.1*before
epochs=epochs,
source_num=source_num,
start_filter_num=start_filter_num) # number of filters at the first layer
model.create_graph('X',
class_num=class_num) # TensorFlow will now draw the graph
####Inira 1 ########
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inriaNew2')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
print(blCol.readMetadata()
) # now inria collection has 4 channels, the last one is GT with (0,1)
# extract patches
extrObj = uab_DataHandlerFunctions.\
uabPatchExtr([0, 1, 2, 4], # extract all 4 channels
cSize=chip_size, # patch size as 572*572
def eval_tiles():
blCol = uab_collectionFunctions.uabCollection(ds_name)
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([1, 2, 3])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(0)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list, 'tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [0, 1, 2, 3, 4, 5])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth, file_list_truth, [0, 1, 2, 3, 4, 5])
img_mean = blCol.getChannelMeans([1, 2, 3])
# make the model
# define place holder
X = tf.placeholder(tf.float32,
shape=[None, input_size[0], input_size[1], 3],
name='X')
y = tf.placeholder(tf.int32,
shape=[None, input_size[0], input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = UnetModelCrop({
'X': X,
'Y': y
},
trainable=mode,
input_size=input_size,
batch_size=batch_size,
start_filter_num=32)
# create graph
model.create_graph('X', class_num=2)
# evaluate on each sub folder
root_dir = r'/home/lab/Documents/bohao/data/aemo_all/align/0584270470{}0_01'
for fl, p_dir in get_file_list(root_dir):
for f in fl:
print('Evaluating {} in {}'.format(f, p_dir))
pred_save_dir = os.path.join(task_dir, 'aemo_all',
'/'.join(p_dir.split('/')[7:]))
ersa_utils.make_dir_if_not_exist(pred_save_dir)
# prepare the reader
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=p_dir,
chipFiles=[[f]],
chip_size=input_size,
tile_size=tile_size,
batchSize=batch_size,
block_mean=img_mean,
overlap=model.get_overlap(),
padding=np.array(
(model.get_overlap() / 2, model.get_overlap() / 2)),
isTrain=False)
rManager = reader.readManager
# run the model
pred, conf_map = model.run(pretrained_model_dir=model_dir,
test_reader=rManager,
tile_size=tile_size,
patch_size=input_size,
gpu=gpu,
load_epoch_num=75,
best_model=False)
pred_name = 'pred_{}.png'.format(f.split('.')[0])
conf_name = 'conf_{}.npy'.format(f.split('.')[0])
ersa_utils.save_file(os.path.join(pred_save_dir, pred_name),
pred.astype(np.uint8))
ersa_utils.save_file(os.path.join(pred_save_dir, conf_name),
conf_map)
def main(flags):
np.random.seed(int(flags.run_id))
tf.set_random_seed(int(flags.run_id))
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
y = tf.placeholder(
tf.int32,
shape=[None, flags.input_size[0], flags.input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = UnetModelCrop({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection(flags.ds_name)
blCol.readMetadata()
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 3],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=int(model.get_overlap() // 2))
patchDir = extrObj.run(blCol)
# make data reader
# use first 5 tiles for validation
idx_city, file_list = uabCrossValMaker.uabUtilGetFolds(
patchDir, 'fileList.txt', 'city')
idx_tile, _ = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'force_tile')
idx = [j * 10 + i for i, j in zip(idx_city, idx_tile)]
# use first city for validation
filter_train = []
filter_valid = []
for i in range(4):
for j in range(1, 20):
if i == flags.leave_city and j < 4:
filter_valid.append(j * 10 + i)
elif i == flags.leave_city and j >= 4:
filter_train.append(j * 10 + i)
# use first city for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(
idx, file_list, filter_train)
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, filter_valid)
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train = uabDataReader.ImageLabelReader(
[3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
None,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
None,
flags.batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean))
# train
start_time = time.time()
model.train_config('X',
'Y',
flags.n_train,
flags.n_valid,
flags.input_size,
uabRepoPaths.modelPath,
loss_type='xent',
par_dir='{}'.format(flags.ds_name),
pos_weight=flags.pos_weight)
model.run(
train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=
None, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean[1:],
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
def main(flags):
copyfile(
os.path.join(
flags.pred_file_dir,
'1iter_pred_building_binary_{}.npy'.format(flags.leave_city)),
os.path.join(
flags.pred_file_dir,
'iter_pred_building_binary_{}.npy'.format(flags.leave_city)))
flags.pred_file_dir = os.path.join(
flags.pred_file_dir,
'iter_pred_building_binary_{}.npy'.format(flags.leave_city))
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
y = tf.placeholder(
tf.int32,
shape=[None, flags.input_size[0], flags.input_size[1], 1],
name='y')
y2 = tf.placeholder(tf.float32, shape=[None, 1], name='y2')
mode = tf.placeholder(tf.bool, name='mode')
model = UnetModelCrop_Iter({
'X': X,
'Y': y,
'Y2': y2
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4], # extract all 4 channels
cSize=flags.input_size, # patch size as 572*572
numPixOverlap=int(model.get_overlap() / 2), # overlap as 92
extSave=['jpg', 'jpg', 'jpg',
'png'], # save rgb files as jpg and gt as png
isTrain=True,
gtInd=3,
pad=model.get_overlap()) # pad around the tiles
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'city')
# use first city for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(5) if i != flags.leave_city])
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [flags.leave_city])
dataReader_train = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append(
[0], img_mean),
batch_code=0)
dataReader_train_building = uabDataReader.ImageLabelReaderBuildingCustom(
[3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
flags.batch_size,
dataAug='flip,rotate',
percent_file=flags.pred_file_dir,
block_mean=np.append([0], img_mean),
patch_prob=0.1,
binary=True)
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
flags.batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean),
batch_code=0)
# train
start_time = time.time()
model.train_config('X',
'Y',
'Y2',
flags.n_train,
flags.n_valid,
flags.input_size,
uabRepoPaths.modelPath,
loss_type='xent',
par_dir='Inria_Domain_LOO')
model.run(
train_reader=dataReader_train,
train_reader_building=dataReader_train_building,
valid_reader=dataReader_valid,
pretrained_model_dir=flags.
finetune_dir, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
model = uabMakeNetwork_UnetMTL.UnetModelMTL({
'X': X,
'Y': y
},
trainable=mode,
input_size=input_size,
batch_size=5,
source_num=2,
source_name=['INRIA', 'ROAD'])
# create graph, same as training
model.create_graph('X', class_num=[2, 2])
# ------------------------------------------Dataset Inria---------------------------------------------#
# make collections
# same as what to do in training
blCol = uab_collectionFunctions.uabCollection('inria')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(4)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list,
'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx,
file_list, [i for i in range(0, 6)],
filter_list=['bellingham', 'bloomington', 'sfo', 'tyrol-e', 'innsbruck'])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth,
file_list_truth, [i for i in range(0, 6)],
import ersa_utils
import uab_collectionFunctions
from visualize import visualize_utils
from bohaoCustom import uabMakeNetwork_DeepLabV2
# settings
data_dir = r'/media/ei-edl01/data/uab_datasets/bihar_building/data/Original_Tiles'
input_size = (300, 300)
batch_size = 1
# set gpu to use
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISISBLE_DEVICES'] = '0'
# settings
blCol = uab_collectionFunctions.uabCollection('bihar_building')
blCol.readMetadata()
img_mean = blCol.getChannelMeans([0, 1, 2])
# make the model
# define place holder
model_dir = r'/media/ei-edl01/user/bh163/models/bihar_building2'
X = tf.placeholder(tf.float32,
shape=[None, input_size[0], input_size[1], 3],
name='X')
y = tf.placeholder(tf.int32,
shape=[None, input_size[0], input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_DeepLabV2.DeeplabV3({
'X': X,
'Y': y
},
trainable=mode,
model_name=model_name,
input_size=chip_size,
batch_size=batch_size,
learn_rate=learn_rate,
decay_step=decay_step,
decay_rate=decay_rate,
epochs=epochs,
start_filter_num=start_filter_num)
model.create_graph('X', class_num=2)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('um')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
print(blCol.readMetadata()
) # now inria collection has 4 channels, the last one is GT with (0, 1)
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4], # extract all 4 channels
cSize=chip_size, # patch size as 572*572
tile_size = [5000, 5000]
util_functions.tf_warn_level(3)
city_list = ['austin', 'chicago', 'kitsap', 'tyrol-w', 'vienna']
model_type = 'deeplab'
if model_type == 'unet':
patch_size = [572, 828, 1084, 1340, 1596, 1852, 2092, 2332, 2636]
model_dir = r'/hdd6/Models/UNET_rand_gird/UnetCrop_spca_aug_grid_0_PS(572, 572)_BS5_EP100_LR0.0001_DS60_DR0.1_SFN32'
else:
patch_size = [520, 736, 832, 1088, 1344, 1600, 1856, 2096, 2640]
model_dir = r'/hdd6/Models/DeepLab_rand_grid/DeeplabV3_spca_aug_grid_0_PS(321, 321)_BS5_EP100_LR1e-05_DS40_DR0.1_SFN32'
for ps in patch_size:
input_size = [ps, ps]
tf.reset_default_graph()
blCol = uab_collectionFunctions.uabCollection('spca')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([1, 2, 3])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(0)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list,
'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(250, 500)])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth, file_list_truth, [i for i in range(250, 500)])
img_mean = blCol.getChannelMeans([1, 2, 3])
# make the model
util_functions.tf_warn_level(3)
model_type = 'deeplab'
if model_type == 'unet':
model_dir = r'/hdd6/Models/Inria_decay/UnetCrop_inria_decay_0_PS(572, 572)_BS5_' \
r'EP100_LR0.0001_DS60.0_DR0.1_SFN32'
patch_size = [572, 828, 1084, 1340, 1596, 1852, 2092, 2332, 2636]
else:
patch_size = [520, 736, 832, 1088, 1344, 1600, 1856, 2096, 2640]
model_dir = r'/hdd6/Models/Inria_decay/DeeplabV3_inria_decay_0_PS(321, 321)_BS5_' \
r'EP100_LR1e-05_DS40.0_DR0.1_SFN32'
for ps in patch_size:
input_size = [ps, ps]
tf.reset_default_graph()
blCol = uab_collectionFunctions.uabCollection('aioi')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(3)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(None, file_list,
'force_tile')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'force_tile')
# use first 5 tiles for validation
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(0, 6)])
file_list_valid_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth, file_list_truth, [i for i in range(0, 6)])
img_mean = blCol.getChannelMeans([0, 1, 2])
# make the model
def main(flags):
city_dict = {
'austin': 0,
'chicago': 1,
'kitsap': 2,
'tyrol-w': 3,
'vienna': 4
}
city_alpha = [0.2, 0.5, 0.1, 0.1, 0.1]
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
y = tf.placeholder(
tf.int32,
shape=[None, flags.input_size[0], flags.input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UNet.UnetModelCrop({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=model.get_overlap() / 2)
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'force_tile')
# use first 5 tiles for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(6, 37)])
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [i for i in range(0, 6)])
dataReader_train = uabDataReader.ImageLabelReaderCitySampleControl(
[3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
flags.batch_size,
city_dict,
city_alpha,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReaderCitySampleControl(
[3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
flags.batch_size,
city_dict,
city_alpha,
dataAug=' ',
block_mean=np.append([0], img_mean))
# train
start_time = time.time()
model.train_config('X',
'Y',
flags.n_train,
flags.n_valid,
flags.input_size,
uabRepoPaths.modelPath,
loss_type='xent',
par_dir='Inria_Domain')
model.run(
train_reader=dataReader_train,
valid_reader=dataReader_valid,
pretrained_model_dir=PRED_DIR,
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size,
)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
# settings
gpu = 1
batch_size = 5
input_size = [572, 572]
tile_size = [1500, 1500]
util_functions.tf_warn_level(3)
model_list = [
r'UnetGAN_V3ShrinkRGB_road_gan_0_PS(572, 572)_BS20_EP60_LR0.0001_1e-06_1e-06_DS60.0_60.0_60.0_DR0.1_0.1_0.1',
]
for model_dir in model_list:
for load_epoch in range(0, 60, 10):
model_dir = os.path.join(r'/hdd6/Models/Inria_GAN/Road/', model_dir)
tf.reset_default_graph()
blCol = uab_collectionFunctions.uabCollection('Mass_road')
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(4)
img_mean = blCol.getChannelMeans([0, 1, 2])
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(
None, file_list, 'city')
idx_truth, file_list_truth = uabCrossValMaker.uabUtilGetFolds(
None, file_list_truth, 'city')
file_list_test = uabCrossValMaker.make_file_list_by_key(
idx, file_list, [0])
file_list_test_truth = uabCrossValMaker.make_file_list_by_key(
idx_truth, file_list_truth, [0])
trainable=mode,
input_size=chip_size,
batch_size=batch_size,
learn_rate=learn_rate,
decay_step=decay_step,
decay_rate=decay_rate,
epochs=epochs,
start_filter_num=start_filter_num)
model.create_graph('X', class_num=2)
# If you only want to load a specific number of layers, you have to do load_weight() here
# don't give pretrained_model_dir and layers2keep when calling model.run(), that will cause problem
model.load_weights(pre_trained_model_dir, layers2keep)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
print(blCol.readMetadata()
) # now inria collection has 4 channels, the last one is GT with (0, 1)
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4], # extract all 4 channels
cSize=chip_size, # patch size as 572*572
trainable=mode, # control if you're training or not
input_size=chip_size, # input size to NN, same as extracted
model_name=model_name, # patch size
batch_size=batch_size, # mini-batch size
learn_rate=learn_rate, # learning rate
decay_step=decay_step, # learn rate decay after 60 epochs
decay_rate=decay_rate, # learn rate decay to 0.1*before
epochs=epochs,
backbone_name=backbone, # total number of epochs to run
start_filter_num=start_filter_num) # number of filters at the first layer
model.create_graph('X',
class_num=class_num) # TensorFlow will now draw the graph
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('deepglobe')
opDetObj = bPreproc.uabOperTileDivide(
255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
print(blCol.readMetadata()
) # now inria collection has 4 channels, the last one is GT with (0,1)
# extract patches
extrObj = uab_DataHandlerFunctions.\
uabPatchExtr([0, 1, 2, 4], # extract all 4 channels
cSize=chip_size, # patch size as 572*572
def main(flags):
# make network
# define place holder
X = tf.placeholder(
tf.float32,
shape=[None, flags.input_size[0], flags.input_size[1], 3],
name='X')
y = tf.placeholder(
tf.int32,
shape=[None, flags.input_size[0], flags.input_size[1], 1],
name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_ASSN.SSAN_UNet({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn,
lada=flags.lada,
slow_iter=flags.slow_iter)
model.create_graph(['X', 'Y'], class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(255)
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif',
'Map GT to (0, 1)', [3],
opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2])
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr(
[0, 1, 2, 4],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=model.get_overlap() // 2)
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx_city, file_list = uabCrossValMaker.uabUtilGetFolds(
patchDir, 'fileList.txt', 'city')
idx_tile, _ = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt',
'force_tile')
idx = [j * 10 + i for i, j in zip(idx_city, idx_tile)]
# use first city for validation
filter_train = []
filter_train_target = []
filter_valid = []
for i in range(5):
for j in range(1, 37):
if i != flags.finetune_city and j > 5:
filter_train.append(j * 10 + i)
elif i == flags.finetune_city and j > 5:
filter_train_target.append(j * 10 + i)
elif i == flags.finetune_city and j <= 5:
filter_valid.append(j * 10 + i)
# use first city for validation
file_list_train = uabCrossValMaker.make_file_list_by_key(
idx, file_list, filter_train)
filter_list_train_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, filter_train_target)
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx, file_list, filter_valid)
dataReader_train = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_train,
flags.input_size,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append(
[0], img_mean),
batch_code=0)
dataReader_train_target = uabDataReader.ImageLabelReader(
[3], [0, 1, 2],
patchDir,
filter_list_train_valid,
flags.input_size,
flags.batch_size,
dataAug='flip,rotate',
block_mean=np.append([0], img_mean),
batch_code=0)
# no augmentation needed for validation
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_valid,
flags.input_size,
flags.batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean),
batch_code=0)
# train
start_time = time.time()
model.load_weights(flags.pred_model_dir.format(flags.finetune_city),
layers2load='1,2,3,4,5,6,7,8,9',
load_final_layer=True)
model.train_config('X',
'Y',
flags.n_train,
flags.n_valid,
flags.input_size,
uabRepoPaths.modelPath,
loss_type='xent',
par_dir='Inria_GAN/SSAN')
model.run(
train_reader=dataReader_train,
train_reader_source=dataReader_train,
train_reader_target=dataReader_train_target,
valid_reader=dataReader_valid,
pretrained_model_dir=
None, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=flags.save_epoch, # save the model every 5 epochs
gpu=GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
try:
gt_orig = imageio.imread(gt_file)
gt_dest = imageio.imread(os.path.join(dest_dir, file_id.replace('_', '-')+'_GT.png'))
rgb_orig = imageio.imread(os.path.join(orig_rgb_dir, rgb_orig_fname))
rgb_dest = imageio.imread(os.path.join(dest_dir, file_id.replace('_', '-')+'_RGB.tif'))
plt.figure(figsize=(12, 9))
ax1 = plt.subplot(221)
plt.imshow(gt_orig)
plt.title('gt orig')
plt.axis('off')
ax2 = plt.subplot(222, sharex=ax1, sharey=ax1)
plt.imshow(rgb_orig)
plt.title('rgb orig')
plt.axis('off')
ax3 = plt.subplot(223, sharex=ax1, sharey=ax1)
plt.imshow(gt_dest)
plt.title('gt dest')
plt.axis('off')
ax4 = plt.subplot(224, sharex=ax1, sharey=ax1)
plt.imshow(rgb_dest)
plt.title('rgb dest')
plt.axis('off')
plt.tight_layout()
plt.show()
except OSError:
continue'''
blCol = uab_collectionFunctions.uabCollection('gbdx2')
blCol.readMetadata()
from nn import nn_utils
from bohaoCustom import uabMakeNetwork_UNet
if __name__ == '__main__':
# settings
nn_utils.tf_warn_level(3)
model_dir = r'/hdd6/Models/UNET_rand_gird/UnetCrop_inria_aug_grid_0_PS(572, 572)_BS5_' \
r'EP100_LR0.0001_DS60_DR0.1_SFN32'
gpu = 0
batch_size = 1
input_size = [572, 572]
#for city_name in ['Arlington', 'Atlanta', 'Austin', 'DC', 'NewHaven', 'NewYork', 'SanFrancisco', 'Seekonk']:
for city_name in ['Norfolk']:
tf.reset_default_graph()
blCol = uab_collectionFunctions.uabCollection(city_name)
blCol.readMetadata()
file_list, parent_dir = blCol.getAllTileByDirAndExt([0, 1, 2])
file_list_truth, parent_dir_truth = blCol.getAllTileByDirAndExt(3)
img_mean = blCol.getChannelMeans([0, 1, 2])
# make the model
# define place holder
X = tf.placeholder(tf.float32,
shape=[None, input_size[0], input_size[1], 3],
name='X')
Z = tf.placeholder(tf.float32,
shape=[None, input_size[0], input_size[1], 3],
name='Z')
y = tf.placeholder(tf.int32,
shape=[None, input_size[0], input_size[1], 1],
def main(flags, weight_dict):
path_to_save = os.path.join(flags.weight_dir, 'shift_dict.pkl')
shift_dict = ersa_utils.load_file(path_to_save)
# make network
# define place holder
X = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='X')
Z = tf.placeholder(tf.float32, shape=[None, flags.input_size[0], flags.input_size[1], 3], name='Z')
y = tf.placeholder(tf.int32, shape=[None, flags.input_size[0], flags.input_size[1], 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UNet.UnetModelDTDA({'X': X, 'Z': Z, 'Y': y},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size,
batch_size=flags.batch_size,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
start_filter_num=flags.sfn)
model.create_graph('X', 'Z', class_num=flags.num_classes)
# create collection
# the original file is in /ei-edl01/data/uab_datasets/inria
blCol = uab_collectionFunctions.uabCollection('inria')
opDetObj = bPreproc.uabOperTileDivide(255) # inria GT has value 0 and 255, we map it back to 0 and 1
# [3] is the channel id of GT
rescObj = uabPreprocClasses.uabPreprocMultChanOp([], 'GT_Divide.tif', 'Map GT to (0, 1)', [3], opDetObj)
rescObj.run(blCol)
img_mean = blCol.getChannelMeans([0, 1, 2]) # get mean of rgb info
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 4],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=model.get_overlap() // 2)
patchDir = extrObj.run(blCol)
# make data reader
# use uabCrossValMaker to get fileLists for training and validation
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir, 'fileList.txt', 'force_tile')
# use first 5 tiles for validation
file_list_source = uabCrossValMaker.make_file_list_by_key(idx, file_list, [i for i in range(6, 37)])
file_list_valid = uabCrossValMaker.make_file_list_by_key(idx, file_list, [i for i in range(0, 6)])
# AIOI dataset
blCol = uab_collectionFunctions.uabCollection(CITY_LIST[flags.leave_city])
# extract patches
extrObj = uab_DataHandlerFunctions.uabPatchExtr([0, 1, 2, 3],
cSize=flags.input_size,
numPixOverlap=int(model.get_overlap()),
extSave=['jpg', 'jpg', 'jpg', 'png'],
isTrain=True,
gtInd=3,
pad=model.get_overlap() // 2)
patchDir_target = extrObj.run(blCol)
idx, file_list = uabCrossValMaker.uabUtilGetFolds(patchDir_target, 'fileList.txt', 'force_tile')
file_list_target = uabCrossValMaker.make_file_list_by_key(idx, file_list, [i for i in range(5)])
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_source = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir, file_list_source, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# no augmentation needed for validation
dataReader_target = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir_target, file_list_target, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
dataReader_valid = uabDataReader.ImageLabelReader([3], [0, 1, 2], patchDir, file_list_valid, flags.input_size,
flags.tile_size,
flags.batch_size, dataAug='flip,rotate',
block_mean=np.append([0], img_mean))
# train
start_time = time.time()
model.train_config('X', 'Y', 'Z', flags.n_train, flags.n_valid, flags.input_size, uabRepoPaths.modelPath,
loss_type='xent', par_dir='domain_baseline/contorl_valid', lam=flags.lam)
model.load_source_weights(flags.model_dir, shift_dict, gpu=flags.GPU)
model.run(train_reader_source=dataReader_source,
train_reader_target=dataReader_target,
valid_reader=dataReader_valid,
pretrained_model_dir=None, # train from scratch, no need to load pre-trained model
isTrain=True,
img_mean=img_mean,
verb_step=100, # print a message every 100 step(sample)
save_epoch=5, # save the model every 5 epochs
gpu=flags.GPU,
tile_size=flags.tile_size,
patch_size=flags.input_size)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration/60/60))
