def main(flags):
nn_utils.set_gpu(GPU)
# define network
model = unet.UNet(flags.num_classes, flags.patch_size, suffix=flags.model_suffix, learn_rate=flags.learning_rate,
decay_step=flags.decay_step, decay_rate=flags.decay_rate, epochs=flags.epochs,
batch_size=flags.batch_size)
overlap = model.get_overlap()
cm = collectionMaker.read_collection(raw_data_path=flags.data_dir,
field_name='austin,chicago,kitsap,tyrol-w,vienna',
field_id=','.join(str(i) for i in range(37)),
rgb_ext='RGB',
gt_ext='GT',
file_ext='tif',
force_run=False,
clc_name=flags.ds_name)
gt_d255 = collectionEditor.SingleChanMult(cm.clc_dir, 1 / 255, ['GT', 'gt_d255']). \
run(force_run=False, file_ext='png', d_type=np.uint8, )
cm.replace_channel(gt_d255.files, True, ['GT', 'gt_d255'])
cm.print_meta_data()
file_list_train = cm.load_files(field_id=','.join(str(i) for i in range(6, 37)), field_ext='RGB,gt_d255')
file_list_valid = cm.load_files(field_id=','.join(str(i) for i in range(6)), field_ext='RGB,gt_d255')
chan_mean = cm.meta_data['chan_mean'][:3]
patch_list_train = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size, flags.ds_name + '_train',
overlap, overlap // 2). \
run(file_list=file_list_train, file_exts=['jpg', 'png'], force_run=False).get_filelist()
patch_list_valid = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size, flags.ds_name + '_valid',
overlap, overlap // 2). \
run(file_list=file_list_valid, file_exts=['jpg', 'png'], force_run=False).get_filelist()
train_init_op, valid_init_op, reader_op = \
dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.patch_size, patch_list_train, patch_list_valid, batch_size=flags.batch_size, chan_mean=chan_mean,
aug_func=[reader_utils.image_flipping, reader_utils.image_rotating],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult).read_op()
feature, label = reader_op
model.create_graph(feature)
model.compile(feature, label, flags.n_train, flags.n_valid, flags.patch_size, ersaPath.PATH['model'],
par_dir=flags.model_par_dir, val_mult=flags.val_mult, loss_type='xent')
train_hook = hook.ValueSummaryHook(flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'], print_val=[0])
model_save_hook = hook.ModelSaveHook(model.get_epoch_step()*flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHook(model.get_epoch_step(), [model.loss, model.loss_iou],
value_names=['valid_loss', 'valid_mIoU'], log_time=True,
run_time=model.n_valid, iou_pos=1)
image_hook = hook.ImageValidSummaryHook(model.input_size, model.get_epoch_step(), feature, label, model.output,
nn_utils.image_summary, img_mean=cm.meta_data['chan_mean'])
start_time = time.time()
model.train(train_hooks=[train_hook, model_save_hook], valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op, valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time)/3600))
def main(flags):
nn_utils.set_gpu(GPU)
# define network
model = pspnet.PSPNet(flags.num_classes, flags.tile_size, suffix=flags.model_suffix, learn_rate=flags.learning_rate,
decay_step=flags.decay_step, decay_rate=flags.decay_rate, epochs=flags.epochs,
batch_size=flags.batch_size, weight_decay=flags.weight_decay, momentum=flags.momentum)
cm_train = cityscapes_reader.CollectionMakerCityscapes(flags.data_dir, flags.rgb_type, flags.gt_type, 'train',
flags.rgb_ext, flags.gt_ext, ['png', 'png'],
clc_name='{}_train'.format(flags.ds_name),
force_run=flags.force_run)
cm_valid = cityscapes_reader.CollectionMakerCityscapes(flags.data_dir, flags.rgb_type, flags.gt_type, 'val',
flags.rgb_ext, flags.gt_ext, ['png', 'png'],
clc_name='{}_valid'.format(flags.ds_name),
force_run=flags.force_run)
cm_train.print_meta_data()
cm_valid.print_meta_data()
resize_func = lambda img: resize_image(img, flags.tile_size)
train_init_op, valid_init_op, reader_op = dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.tile_size, cm_train.meta_data['file_list'], cm_valid.meta_data['file_list'],
flags.batch_size, cm_train.meta_data['chan_mean'], aug_func=[reader_utils.image_flipping_hori,
reader_utils.image_scaling_with_label],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult, global_func=resize_func)\
.read_op()
feature, label = reader_op
model.create_graph(feature)
model.load_resnet(flags.res_dir)
model.compile(feature, label, flags.n_train, flags.n_valid, flags.tile_size, ersaPath.PATH['model'],
par_dir=flags.model_par_dir, val_mult=flags.val_mult, loss_type='xent')
train_hook = hook.ValueSummaryHook(flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'], print_val=[0])
model_save_hook = hook.ModelSaveHook(model.get_epoch_step()*flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHook(model.get_epoch_step(), [model.loss, model.loss_iou],
value_names=['valid_loss', 'valid_mIoU'], log_time=True,
run_time=model.n_valid, iou_pos=1)
image_hook = hook.ImageValidSummaryHook(model.input_size, model.get_epoch_step(), feature, label, model.output,
cityscapes_labels.image_summary, img_mean=cm_train.meta_data['chan_mean'])
start_time = time.time()
model.train(train_hooks=[train_hook, model_save_hook], valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op, valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time)/3600))
suffix = 'aemo_hist_rgb'
ds_name = 'aemo'
lr = 1e-3
ds = 60
dr = 0.1
epochs = 130
bs = 5
valid_mult = 5
gpu = 0
n_train = 785
n_valid = 500
verb_step = 50
save_epoch = 5
model_dir = r'/hdd6/Models/spca/psp101/pspnet_spca_PS(384, 384)_BS5_EP100_LR0.001_DS40_DR0.1'
nn_utils.set_gpu(gpu)
# define network
unet = pspnet.PSPNet(class_num, patch_size, suffix=suffix, learn_rate=lr, decay_step=ds, decay_rate=dr,
epochs=epochs, batch_size=bs, weight_decay=1e-3)
overlap = unet.get_overlap()
cm = collectionMaker.read_collection(raw_data_path=r'/home/lab/Documents/bohao/data/aemo',
field_name='aus10,aus30,aus50',
field_id='',
rgb_ext='.*rgb',
gt_ext='.*gt',
file_ext='tif',
force_run=False,
clc_name='aemo')
gt_d255 = collectionEditor.SingleChanMult(cm.clc_dir, 1/255, ['.*gt', 'gt_d255']).\
def main(flags):
nn_utils.set_gpu(GPU)
# define network
model = pspnet.PSPNet(flags.num_classes,
flags.patch_size,
suffix=flags.model_suffix,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
batch_size=flags.batch_size,
weight_decay=flags.weight_decay,
momentum=flags.momentum)
overlap = model.get_overlap()
cm = collectionMaker.read_collection(raw_data_path=flags.data_dir,
field_name='Fresno,Modesto,Stockton',
field_id=','.join(
str(i) for i in range(663)),
rgb_ext='RGB',
gt_ext='GT',
file_ext='jpg,png',
force_run=False,
clc_name=flags.ds_name)
cm.print_meta_data()
file_list_train = cm.load_files(field_id=','.join(
str(i) for i in range(0, 250)),
field_ext='RGB,GT')
file_list_valid = cm.load_files(field_id=','.join(
str(i) for i in range(250, 500)),
field_ext='RGB,GT')
chan_mean = cm.meta_data['chan_mean'][:3]
patch_list_train = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size, flags.ds_name + '_train',
overlap, overlap // 2). \
run(file_list=file_list_train, file_exts=['jpg', 'png'], force_run=False).get_filelist()
patch_list_valid = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size, flags.ds_name + '_valid',
overlap, overlap // 2). \
run(file_list=file_list_valid, file_exts=['jpg', 'png'], force_run=False).get_filelist()
train_init_op, valid_init_op, reader_op = \
dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.patch_size, patch_list_train, patch_list_valid, batch_size=flags.batch_size, chan_mean=chan_mean,
aug_func=[reader_utils.image_flipping, reader_utils.image_rotating],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult).read_op()
feature, label = reader_op
model.create_graph(feature)
model.load_resnet(flags.res_dir, keep_last=False)
model.compile(feature,
label,
flags.n_train,
flags.n_valid,
flags.patch_size,
ersaPath.PATH['model'],
par_dir=flags.model_par_dir,
val_mult=flags.val_mult,
loss_type='xent')
train_hook = hook.ValueSummaryHook(
flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'],
print_val=[0])
model_save_hook = hook.ModelSaveHook(
model.get_epoch_step() * flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHookIters(
model.get_epoch_step(), [model.loss_xent, model.loss_iou],
value_names=['valid_loss', 'valid_mIoU'],
log_time=True,
run_time=model.n_valid)
image_hook = hook.ImageValidSummaryHook(model.input_size,
model.get_epoch_step(),
feature,
label,
model.output,
nn_utils.image_summary,
img_mean=cm.meta_data['chan_mean'])
start_time = time.time()
model.train(train_hooks=[train_hook, model_save_hook],
valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op,
valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time) / 3600))
def process(self):
"""
Evaluate the network
:return:
"""
nn_utils.set_gpu(self.gpu)
if self.score_results:
with open(os.path.join(self.score_save_dir, 'result.txt'), 'w'):
pass
iou_record = []
# prepare the reader
if self.score_results:
init_op, reader_op = dataReaderSegmentation.DataReaderSegmentationTesting(
self.input_size,
self.tile_size,
self.file_list,
overlap=self.model.get_overlap(),
pad=self.model.get_overlap() // 2,
batch_size=self.batch_size,
chan_mean=self.img_mean,
is_train=False,
has_gt=True,
random=False,
gt_dim=1,
include_gt=True).read_op()
feature, label = reader_op
self.model.create_graph(feature, **self.kwargs)
else:
init_op, reader_op = dataReaderSegmentation.DataReaderSegmentationTesting(
self.input_size,
self.tile_size,
self.file_list,
overlap=self.model.get_overlap(),
pad=self.model.get_overlap() // 2,
batch_size=self.batch_size,
chan_mean=self.img_mean,
is_train=False,
has_gt=False,
random=False,
gt_dim=0,
include_gt=False).read_op()
feature = reader_op
self.model.create_graph(feature[0], **self.kwargs)
pad = self.model.get_overlap()
for file_cnt, (file_name_list) in enumerate(self.file_list):
file_name_truth = None
if self.score_results:
file_name, file_name_truth = file_name_list
tile_name = os.path.basename(file_name_truth).split(
self.split_char)[0]
else:
file_name = file_name_list[0]
tile_name = os.path.basename(file_name).split(
self.split_char)[0]
if self.verb:
print('Evaluating {} ... '.format(tile_name))
# read tile size if no tile size is given
if self.tile_size is None or self.compute_shape_flag:
self.compute_shape_flag = True
tile = ersa_utils.load_file(file_name)
self.tile_size = tile.shape[:2]
start_time = time.time()
# run the model
if self.model.config is None:
self.model.config = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=self.model.config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
self.model.load(self.model_dir,
sess,
epoch=self.load_epoch_num,
best_model=self.best_model)
result = self.model.test_sample(sess, init_op[file_cnt])
image_pred = patchExtractor.unpatch_block(
result,
tile_dim=[self.tile_size[0] + pad, self.tile_size[1] + pad],
patch_size=self.input_size,
tile_dim_output=self.tile_size,
patch_size_output=[
self.input_size[0] - pad, self.input_size[1] - pad
],
overlap=pad)
if self.compute_shape_flag:
self.tile_size = None
pred = nn_utils.get_pred_labels(image_pred) * self.truth_val
if self.score_results:
truth_label_img = ersa_utils.load_file(file_name_truth)
iou = nn_utils.iou_metric(truth_label_img,
pred,
divide_flag=True)
iou_record.append(iou)
duration = time.time() - start_time
if self.verb:
print('{} mean IoU={:.3f}, duration: {:.3f}'.format(
tile_name, iou[0] / iou[1], duration))
# save results
pred_save_dir = os.path.join(self.score_save_dir, 'pred')
ersa_utils.make_dir_if_not_exist(pred_save_dir)
ersa_utils.save_file(
os.path.join(pred_save_dir, '{}.png'.format(tile_name)),
pred.astype(np.uint8))
if self.score_results:
with open(os.path.join(self.score_save_dir, 'result.txt'),
'a+') as file:
file.write('{} {}\n'.format(tile_name, iou))
if self.score_results:
iou_record = np.array(iou_record)
mean_iou = np.sum(iou_record[:, 0]) / np.sum(iou_record[:, 1])
print('Overall mean IoU={:.3f}'.format(mean_iou))
with open(os.path.join(self.score_save_dir, 'result.txt'),
'a+') as file:
file.write('{}'.format(mean_iou))
def process(self):
"""
Evaluate the network
:return:
"""
nn_utils.set_gpu(self.gpu)
if self.score_results:
with open(os.path.join(self.score_save_dir, 'result.txt'), 'w'):
pass
iou_record = []
# prepare the reader
if self.score_results:
feature, label = self.reader_op
self.model.create_graph(feature, **self.kwargs)
else:
feature = self.reader_op
self.model.create_graph(feature[0], **self.kwargs)
# run the model
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run([init, self.init_op])
self.model.load(self.model_dir,
sess,
epoch=self.load_epoch_num,
best_model=self.best_model)
for file_cnt, (file_name_list) in enumerate(self.file_list):
file_name_truth = None
if self.score_results:
file_name, file_name_truth = file_name_list
tile_name = os.path.basename(file_name_truth).split(
self.split_char)[0]
else:
file_name = file_name_list[0]
tile_name = os.path.basename(file_name).split(
self.split_char)[0]
if self.verb:
print('Evaluating {} ... '.format(tile_name))
start_time = time.time()
result = sess.run(self.model.output)
pred = np.argmax(np.squeeze(result, axis=0), axis=-1)
if self.post_func is not None:
pred = self.post_func(pred)
if self.save_func is not None:
save_img = self.save_func(pred)
else:
save_img = pred
if self.score_results:
truth_label_img = ersa_utils.load_file(file_name_truth)
iou = nn_evals.mean_IU(pred, truth_label_img,
self.ignore_label)
iou_record.append(iou)
duration = time.time() - start_time
if self.verb:
print('{} mean IoU={:.3f}, duration: {:.3f}'.format(
tile_name, iou, duration))
# save results
pred_save_dir = os.path.join(self.score_save_dir, 'pred')
ersa_utils.make_dir_if_not_exist(pred_save_dir)
ersa_utils.save_file(
os.path.join(pred_save_dir,
'{}.png'.format(tile_name)),
save_img.astype(np.uint8))
if self.score_results:
with open(
os.path.join(self.score_save_dir,
'result.txt'), 'a+') as file:
file.write('{} {}\n'.format(tile_name, iou))
if self.score_results:
iou_record = np.array(iou_record)
mean_iou = np.mean(iou_record)
print('Overall mean IoU={:.3f}'.format(mean_iou))
with open(os.path.join(self.score_save_dir, 'result.txt'),
'a+') as file:
file.write('{}'.format(mean_iou))
def main(flags):
nn_utils.set_gpu(flags.GPU)
np.random.seed(flags.run_id)
tf.set_random_seed(flags.run_id)
# define network
model = unet.UNet(flags.num_classes,
flags.patch_size,
suffix=flags.suffix,
learn_rate=flags.learn_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
batch_size=flags.batch_size)
overlap = model.get_overlap()
cm = collectionMaker.read_collection(
raw_data_path=flags.data_dir,
field_name='Tucson,Colwich,Clyde,Wilmington',
field_id=','.join(str(i) for i in range(1, 16)),
rgb_ext='RGB',
gt_ext='GT',
file_ext='tif,png',
force_run=False,
clc_name=flags.ds_name)
gt_d255 = collectionEditor.SingleChanSwitch(cm.clc_dir, {
2: 0,
3: 1,
4: 0,
5: 0,
6: 0,
7: 0
}, ['GT', 'GT_switch'], 'tower_only').run(
force_run=False,
file_ext='png',
d_type=np.uint8,
)
cm.replace_channel(gt_d255.files, True, ['GT', 'GT_switch'])
cm.print_meta_data()
file_list_train = cm.load_files(
field_name='Tucson,Colwich,Clyde,Wilmington',
field_id=','.join(str(i) for i in range(4, 16)),
field_ext='RGB,GT_switch')
file_list_valid = cm.load_files(
field_name='Tucson,Colwich,Clyde,Wilmington',
field_id='1,2,3',
field_ext='RGB,GT_switch')
patch_list_train = patchExtractor.PatchExtractor(flags.patch_size,
ds_name=flags.ds_name + '_tower_only',
overlap=overlap, pad=overlap // 2). \
run(file_list=file_list_train, file_exts=['jpg', 'png'], force_run=False).get_filelist()
patch_list_valid = patchExtractor.PatchExtractor(flags.patch_size,
ds_name=flags.ds_name + '_tower_only',
overlap=overlap, pad=overlap // 2). \
run(file_list=file_list_valid, file_exts=['jpg', 'png'], force_run=False).get_filelist()
chan_mean = cm.meta_data['chan_mean']
train_init_op, valid_init_op, reader_op = \
dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.patch_size, patch_list_train, patch_list_valid, batch_size=flags.batch_size,
chan_mean=chan_mean,
aug_func=[reader_utils.image_flipping, reader_utils.image_rotating],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult).read_op()
feature, label = reader_op
model.create_graph(feature)
model.compile(feature,
label,
flags.n_train,
flags.n_valid,
flags.patch_size,
ersaPath.PATH['model'],
par_dir=flags.par_dir,
loss_type='xent',
pos_weight=flags.pos_weight)
train_hook = hook.ValueSummaryHook(
flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'],
print_val=[0])
model_save_hook = hook.ModelSaveHook(
model.get_epoch_step() * flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHookIters(
model.get_epoch_step(), [model.loss_iou, model.loss_xent],
value_names=['IoU', 'valid_loss'],
log_time=True,
run_time=model.n_valid)
image_hook = hook.ImageValidSummaryHook(model.input_size,
model.get_epoch_step(),
feature,
label,
model.pred,
partial(
nn_utils.image_summary,
label_num=flags.num_classes),
img_mean=chan_mean)
start_time = time.time()
model.train(train_hooks=[train_hook, model_save_hook],
valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op,
valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time) / 3600))
def main(flags):
nn_utils.set_gpu(GPU)
# define network
model = stn.STN(flags.num_classes,
flags.tile_size,
suffix=flags.model_suffix,
learn_rate=flags.learning_rate,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
batch_size=flags.batch_size)
cm_train = cityscapes_reader.CollectionMakerCityscapes(
flags.data_dir,
flags.rgb_type,
flags.gt_type,
'train',
flags.rgb_ext,
flags.gt_ext, ['png', 'png'],
clc_name='{}_train'.format(flags.ds_name),
force_run=flags.force_run)
cm_valid = cityscapes_reader.CollectionMakerCityscapes(
flags.data_dir,
flags.rgb_type,
flags.gt_type,
'val',
flags.rgb_ext,
flags.gt_ext, ['png', 'png'],
clc_name='{}_valid'.format(flags.ds_name),
force_run=flags.force_run)
cm_train.print_meta_data()
cm_valid.print_meta_data()
train_pred_dir = r'/home/lab/Documents/bohao/data/deeplab_model/vis_train/raw_segmentation_results'
valid_pred_dir = r'/home/lab/Documents/bohao/data/deeplab_model/vis/raw_segmentation_results'
file_list_train = get_image_list(flags.data_dir, train_pred_dir, 'train')
file_list_valid = get_image_list(flags.data_dir, valid_pred_dir, 'val')
resize_func = lambda img: resize_image(img, flags.tile_size)
train_init_op, valid_init_op, reader_op = DataReaderSegmentationTrainValid(
flags.tile_size, file_list_train, file_list_valid,
flags.batch_size, cm_train.meta_data['chan_mean'], aug_func=[reader_utils.image_flipping_hori],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult, global_func=resize_func)\
.read_op()
feature, label, pred = reader_op
train_init_op_valid, _, reader_op = DataReaderSegmentationTrainValid(
flags.tile_size, file_list_valid, file_list_train,
flags.batch_size, cm_valid.meta_data['chan_mean'], aug_func=[reader_utils.image_flipping_hori],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult, global_func=resize_func) \
.read_op()
_, _, pred_valid = reader_op
model.create_graph(pred, feature_valid=pred_valid, rgb=feature)
model.compile(pred,
label,
flags.n_train,
flags.n_valid,
flags.tile_size,
ersaPath.PATH['model'],
par_dir=flags.model_par_dir,
val_mult=flags.val_mult,
loss_type='xent')
train_hook = hook.ValueSummaryHook(
flags.verb_step, [
model.loss, model.g_loss, model.d_loss, model.lr_op[0],
model.lr_op[1], model.lr_op[2]
],
value_names=['seg_loss', 'g_loss', 'd_loss', 'lr_seg', 'lr_g', 'lr_d'],
print_val=[0, 1, 2])
model_save_hook = hook.ModelSaveHook(
model.get_epoch_step() * flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHookIters(
model.get_epoch_step(), [model.loss_xent, model.loss_iou],
value_names=['valid_loss', 'valid_mIoU'],
log_time=True,
run_time=model.n_valid)
image_hook = hook.ImageValidSummaryHook(
model.input_size,
model.get_epoch_step(),
feature,
label,
model.refine,
cityscapes_labels.image_summary,
img_mean=cm_train.meta_data['chan_mean'])
start_time = time.time()
model.train(train_hooks=[train_hook, model_save_hook],
valid_hooks=[valid_loss_hook, image_hook],
train_init=[train_init_op, train_init_op_valid],
valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time) / 3600))
def main(flags):
nn_utils.set_gpu(GPU)
# define network
model = deeplab.DeepLab(flags.num_classes,
flags.tile_size,
batch_size=flags.batch_size)
cm_train = cityscapes_reader.CollectionMakerCityscapes(
flags.data_dir,
flags.rgb_type,
flags.gt_type,
'train',
flags.rgb_ext,
flags.gt_ext, ['png', 'png'],
clc_name='{}_train'.format(flags.ds_name),
force_run=False)
cm_test = cityscapes_reader.CollectionMakerCityscapes(
flags.data_dir,
flags.rgb_type,
flags.gt_type,
'val',
flags.rgb_ext,
flags.gt_ext, ['png', 'png'],
clc_name='{}_valid'.format(flags.ds_name),
force_run=False)
cm_test.print_meta_data()
resize_func_train = lambda img: skimage.transform.resize(
img, flags.tile_size, mode='reflect')
resize_func_test = lambda img: skimage.transform.resize(
img,
cm_test.meta_data['tile_dim'],
order=0,
preserve_range=True,
mode='reflect')
init_op, reader_op = dataReaderSegmentation.DataReaderSegmentation(
flags.tile_size,
cm_test.meta_data['file_list'],
batch_size=flags.batch_size,
random=False,
chan_mean=cm_train.meta_data['chan_mean'],
is_train=False,
has_gt=True,
gt_dim=1,
include_gt=True,
global_func=resize_func_train).read_op()
estimator = nn_processor.NNEstimatorSegmentScene(
model,
cm_test.meta_data['file_list'],
flags.res_dir,
init_op,
reader_op,
ds_name='city_scapes',
save_result_parent_dir='Cityscapes',
gpu=flags.GPU,
score_result=True,
split_char='.',
post_func=resize_func_test,
save_func=make_general_id_map,
ignore_label=(-1, 255))
estimator.run(force_run=flags.force_run)
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from glob import glob
import ersa_utils
from nn import nn_utils, deeplab
from preprocess import patchExtractor
from collection import collectionMaker
from visualize import visualize_utils
patch_size = (321, 321)
overlap = 184
class_num = 2
bs = 1
suffix = 'aemo_pad'
nn_utils.set_gpu(1)
cm = collectionMaker.read_collection('aemo_pad')
chan_mean = cm.meta_data['chan_mean'][-3:]
file_list_valid = cm.load_files(field_name='aus50', field_id='', field_ext='.*rgb_hist,.*gt_d255')
pred_dir = r'/hdd/Results/aemo/deeplab_aemo_spca_hist_PS(321, 321)_BS5_EP2_LR0.001_DS50_DR0.1/default/pred'
pred_files = sorted(glob(os.path.join(pred_dir, '*.png')))
unet = deeplab.DeepLab(class_num, patch_size, suffix=suffix, batch_size=bs)
model_dir = r'/hdd6/Models/aemo/new2/deeplab_aemo_spca_hist_PS(321, 321)_BS5_EP2_LR0.001_DS50_DR0.1'
feature = tf.placeholder(tf.float32, shape=(None, patch_size[0], patch_size[1], 3))
unet.create_graph(feature)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
unet.load(model_dir, sess)
def main(flags):
nn_utils.set_gpu(flags.GPU)
for start_layer in flags.start_layer:
if start_layer >= 10:
suffix_base = 'aemo_newloss'
else:
suffix_base = 'aemo_newloss_up{}'.format(start_layer)
if flags.from_scratch:
suffix_base += '_scratch'
for lr in flags.learn_rate:
for run_id in range(4):
suffix = '{}_{}'.format(suffix_base, run_id)
tf.reset_default_graph()
np.random.seed(run_id)
tf.set_random_seed(run_id)
# define network
model = unet.UNet(flags.num_classes, flags.patch_size, suffix=suffix, learn_rate=lr,
decay_step=flags.decay_step, decay_rate=flags.decay_rate,
epochs=flags.epochs, batch_size=flags.batch_size)
overlap = model.get_overlap()
cm = collectionMaker.read_collection(raw_data_path=flags.data_dir,
field_name='aus10,aus30,aus50',
field_id='',
rgb_ext='.*rgb',
gt_ext='.*gt',
file_ext='tif',
force_run=False,
clc_name=flags.ds_name)
cm.print_meta_data()
file_list_train = cm.load_files(field_name='aus10,aus30', field_id='', field_ext='.*rgb,.*gt')
file_list_valid = cm.load_files(field_name='aus50', field_id='', field_ext='.*rgb,.*gt')
patch_list_train = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size,
flags.ds_name + '_train_hist',
overlap, overlap // 2). \
run(file_list=file_list_train, file_exts=['jpg', 'png'], force_run=False).get_filelist()
patch_list_valid = patchExtractor.PatchExtractor(flags.patch_size, flags.tile_size,
flags.ds_name + '_valid_hist',
overlap, overlap // 2). \
run(file_list=file_list_valid, file_exts=['jpg', 'png'], force_run=False).get_filelist()
chan_mean = cm.meta_data['chan_mean']
train_init_op, valid_init_op, reader_op = \
dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.patch_size, patch_list_train, patch_list_valid, batch_size=flags.batch_size,
chan_mean=chan_mean,
aug_func=[reader_utils.image_flipping, reader_utils.image_rotating],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult).read_op()
feature, label = reader_op
model.create_graph(feature)
if start_layer >= 10:
model.compile(feature, label, flags.n_train, flags.n_valid, flags.patch_size, ersaPath.PATH['model'],
par_dir=flags.par_dir, loss_type='xent')
else:
model.compile(feature, label, flags.n_train, flags.n_valid, flags.patch_size, ersaPath.PATH['model'],
par_dir=flags.par_dir, loss_type='xent',
train_var_filter=['layerup{}'.format(i) for i in range(start_layer, 10)])
train_hook = hook.ValueSummaryHook(flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'],
print_val=[0])
model_save_hook = hook.ModelSaveHook(model.get_epoch_step() * flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHookIters(model.get_epoch_step(), [model.loss_xent, model.loss_iou],
value_names=['valid_loss', 'IoU'], log_time=True,
run_time=model.n_valid)
image_hook = hook.ImageValidSummaryHook(model.input_size, model.get_epoch_step(), feature, label,
model.pred,
nn_utils.image_summary, img_mean=chan_mean)
start_time = time.time()
if not flags.from_scratch:
model.load(flags.model_dir)
model.train(train_hooks=[train_hook, model_save_hook], valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op, valid_init=valid_init_op)
print('Duration: {:.3f}'.format((time.time() - start_time) / 3600))
patch_img = img[y_slide - patch_size:y_slide,
x_slide - patch_size:x_slide, :]
patch_gt = gt[y_slide - patch_size:y_slide,
x_slide - patch_size:x_slide]
assert np.all([
patch_img[patch_size - 88 - block_size - cnt_y:patch_size -
88 - cnt_y, patch_size - 88 - block_size -
cnt_x:patch_size - 88 - cnt_x, :] == ref_val
])
yield patch_img, patch_gt, cnt_y, cnt_x
if __name__ == '__main__':
force_run = False
nn_utils.set_gpu(0)
pretrained_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 field_name in ['austin', 'chicago', 'kitsap', 'tyrol-w', 'vienna']:
for field_id in ['1', '2', '3', '4', '5']:
y = 800
x = 800
patch_size = 321
stride = 1
block_size = 33
output_size = 121
tf.reset_default_graph()
record_matrix = []
img_dir, task_dir = sis_utils.get_task_img_folder()
save_file_name = os.path.join(
import tensorflow as tf
import matplotlib.pyplot as plt
import ersa_utils, sis_utils
import uab_collectionFunctions
from nn import nn_utils
from bohaoCustom import uabMakeNetwork_UNet
model_dir = r'/hdd6/Models/Inria_decay/UnetCrop_inria_decay_0_PS(572, 572)_BS5_EP100_LR0.0001_DS60.0_DR0.1_SFN32'
rgb_dir = r'/media/ei-edl01/data/uab_datasets/inria/data/Original_Tiles/austin1_RGB.tif'
rgb = ersa_utils.load_file(rgb_dir)
rgb = rgb[1200:2200, 900:2300, :]
height = 2200 - 1200
width = 2300 - 900
rgb_temp = np.copy(rgb)
nn_utils.set_gpu(-1)
img_dir, task_dir = sis_utils.get_task_img_folder()
blCol = uab_collectionFunctions.uabCollection('inria')
img_mean = blCol.getChannelMeans([0, 1, 2])
X = tf.placeholder(tf.float32, shape=[None, 572, 572, 3], name='X')
y = tf.placeholder(tf.int32, shape=[None, 572, 572, 1], name='y')
mode = tf.placeholder(tf.bool, name='mode')
model = uabMakeNetwork_UNet.UnetModelCrop({
'X': X,
'Y': y
},
trainable=mode,
input_size=(572, 572),
batch_size=1,
def main(flags):
nn_utils.set_gpu(flags.GPU)
for start_layer in flags.start_layer:
if start_layer >= 10:
suffix_base = 'aemo'
else:
suffix_base = 'aemo_up{}'.format(start_layer)
if flags.from_scratch:
suffix_base += '_scratch'
for lr in flags.learn_rate:
for run_id in range(1):
suffix = '{}_{}'.format(suffix_base, run_id)
tf.reset_default_graph()
np.random.seed(run_id)
tf.set_random_seed(run_id)
# define network
model = unet.UNet(flags.num_classes,
flags.patch_size,
suffix=suffix,
learn_rate=lr,
decay_step=flags.decay_step,
decay_rate=flags.decay_rate,
epochs=flags.epochs,
batch_size=flags.batch_size)
file_list = os.path.join(flags.data_dir, 'file_list.txt')
lines = ersa_utils.load_file(file_list)
patch_list_train = []
patch_list_valid = []
train_tile_names = ['aus10', 'aus30']
valid_tile_names = ['aus50']
for line in lines:
tile_name = os.path.basename(
line.split(' ')[0]).split('_')[0].strip()
if tile_name in train_tile_names:
patch_list_train.append(line.strip().split(' '))
elif tile_name in valid_tile_names:
patch_list_valid.append(line.strip().split(' '))
else:
raise ValueError
cm = collectionMaker.read_collection('aemo_align')
chan_mean = cm.meta_data['chan_mean']
train_init_op, valid_init_op, reader_op = \
dataReaderSegmentation.DataReaderSegmentationTrainValid(
flags.patch_size, patch_list_train, patch_list_valid, batch_size=flags.batch_size,
chan_mean=chan_mean,
aug_func=[reader_utils.image_flipping, reader_utils.image_rotating],
random=True, has_gt=True, gt_dim=1, include_gt=True, valid_mult=flags.val_mult).read_op()
feature, label = reader_op
model.create_graph(feature)
if start_layer >= 10:
model.compile(feature,
label,
flags.n_train,
flags.n_valid,
flags.patch_size,
ersaPath.PATH['model'],
par_dir=flags.par_dir,
loss_type='xent')
else:
model.compile(feature,
label,
flags.n_train,
flags.n_valid,
flags.patch_size,
ersaPath.PATH['model'],
par_dir=flags.par_dir,
loss_type='xent',
train_var_filter=[
'layerup{}'.format(i)
for i in range(start_layer, 10)
])
train_hook = hook.ValueSummaryHook(
flags.verb_step, [model.loss, model.lr_op],
value_names=['train_loss', 'learning_rate'],
print_val=[0])
model_save_hook = hook.ModelSaveHook(
model.get_epoch_step() * flags.save_epoch, model.ckdir)
valid_loss_hook = hook.ValueSummaryHookIters(
model.get_epoch_step(), [model.loss_xent, model.loss_iou],
value_names=['valid_loss', 'IoU'],
log_time=True,
run_time=model.n_valid)
image_hook = hook.ImageValidSummaryHook(model.input_size,
model.get_epoch_step(),
feature,
label,
model.pred,
nn_utils.image_summary,
img_mean=chan_mean)
start_time = time.time()
if not flags.from_scratch:
model.load(flags.model_dir)
model.train(train_hooks=[train_hook, model_save_hook],
valid_hooks=[valid_loss_hook, image_hook],
train_init=train_init_op,
valid_init=valid_init_op)
print('Duration: {:.3f}'.format(
(time.time() - start_time) / 3600))
