def make_preds(model, model_dir, file_list, save_path):
for file_name in file_list:
tile_name = os.path.basename(file_name)[:-4]
print('Evaluating {} ...'.format(tile_name))
start_time = time.time()
try:
tile_size = imageio.imread(file_name).shape[:2]
except OSError:
continue
#prepare the reader
pad = model.get_overlap()
reader = uabDataReader.ImageLabelReader(gtInds=[0], dataInds=[0], nChannels=3,
parentDir=os.path.dirname(file_name),
chipFiles=[[os.path.basename(file_name)]],
chip_size=input_size, tile_size=tile_size,
batchSize=batch_size, block_mean=img_mean,
overlap=pad, padding=np.array([pad/2, pad/2]),
isTrain=False)
rManager = reader.readManager
# run the model
pred = model.run(pretrained_model_dir=model_dir, test_reader=rManager, tile_size=tile_size,
patch_size=input_size, gpu=gpu, load_epoch_num=None, best_model=False)
print(np.unique(pred), pred.shape)
# save results
save_name = os.path.join(save_path, '{}_pred.png'.format(tile_name))
imageio.imsave(save_name, pred.astype(np.uint8))
duration = time.time() - start_time
print('duration: {:.2f}'.format(duration))
def save_activations(self, rgb_list, gt_list, rgb_dir, img_mean, gpu,
pretrained_model_dir, path_to_save, input_size,
batch_size, load_epoch_num):
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
activation_dict = dict()
for file_name, file_name_truth in zip(rgb_list, gt_list):
tile_name = file_name_truth.split('_')[0]
print('Evaluating {} ... '.format(tile_name))
# get tile size
sample_img = imageio.imread(os.path.join(rgb_dir[0], file_name[0]))
tile_size = sample_img.shape[:2]
# prepare the reader
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=rgb_dir,
chipFiles=[file_name],
chip_size=input_size,
tile_size=tile_size,
batchSize=batch_size,
block_mean=img_mean,
overlap=self.get_overlap(),
padding=np.array(
(self.get_overlap() / 2, self.get_overlap() / 2)),
isTrain=False)
rManager = reader.readManager
total_len = np.ceil((tile_size[0] + self.get_overlap()) / (input_size[0] - self.get_overlap())) * \
np.ceil((tile_size[1] + self.get_overlap()) / (input_size[1] - self.get_overlap()))
if self.config is None:
self.config = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=self.config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
self.load(pretrained_model_dir,
sess,
epoch=load_epoch_num,
best_model=False)
for X_batch in tqdm(rManager, total=total_len):
for layer_id in range(len(self.activations)):
layer_val = sess.run(self.activations[layer_id],
feed_dict={
self.inputs['X']: X_batch,
self.trainable: False
})
for chan_id in range(layer_val.shape[-1]):
f_i_t = layer_val[:, :, :, chan_id].flatten()
act_name = 'f_{}_{}'.format(layer_id, chan_id)
if act_name not in activation_dict:
activation_dict[act_name] = bayes_update()
activation_dict[act_name].update(f_i_t)
save_name = os.path.join(path_to_save, 'activation_list.pkl')
ersa_utils.save_file(save_name, activation_dict)
def make_preds(model, model_dir, file_list):
for file_name in file_list:
tile_name = os.path.basename(file_name)[:-4]
print('Evaluating {} ... '.format(tile_name))
start_time = time.time()
tile_size = imageio.imread(file_name).shape[:2]
print(img_mean)
# prepare the reader
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=os.path.dirname(file_name),
chipFiles=[[os.path.basename(file_name)]],
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 = model.run(pretrained_model_dir=model_dir,
test_reader=rManager,
tile_size=tile_size,
patch_size=input_size,
gpu=gpu,
load_epoch_num=None,
best_model=False)
print(np.unique(pred))
#from visualize import visualize_utils
#visualize_utils.compare_figures([imageio.imread(file_name), pred], (1, 2), fig_size=(12, 5))
duration = time.time() - start_time
print('duration: {:.3f}'.format(duration))
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))
# 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 = uabMakeNetwork_UNet.UnetModelCrop({'X': X, 'Y': y},
trainable=mode,
input_size=input_size,
batch_size=5, start_filter_num=32)
# create graph
model.create_graph('X', class_num=2)
reader = uabDataReader.ImageLabelReader(gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=adjust_save_dir,
chipFiles=[['{}.tif'.format(img_id)]],
chip_size=input_size,
tile_size=tile_size,
batchSize=5,
block_mean=img_mean,
overlap=model.get_overlap(),
padding=np.array((model.get_overlap() / 2, model.get_overlap() / 2)),
isTrain=False)
test_reader = reader.readManager
# run algo
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model.load(sp_model_dir, sess)
result = model.test('X', sess, test_reader)
image_pred = uabUtilreader.un_patchify_shrink(result,
start_filter_num=32)
# create graph
model.create_graph('X', class_num=2)
# sp detector
file_name = 'sp_' + test_file[0]
if os.path.exists(os.path.join(my_dir, file_name)):
continue
else:
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=os.path.join(data_dir, 'hist_match_ct'),
chipFiles=[test_file],
chip_size=patch_size,
tile_size=tile_size,
batchSize=bs,
block_mean=img_mean,
overlap=model.get_overlap(),
padding=np.array(
(model.get_overlap() / 2, model.get_overlap() / 2)),
isTrain=False)
test_reader = reader.readManager
# run algo
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model.load(model_dir, sess)
result = model.test('X', sess, test_reader)
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 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):
# city_dict
city_dict = {
'austin': 0,
'chicago': 1,
'kitsap': 2,
'tyrol-w': 3,
'vienna': 4
}
train_city_list = [city_dict[a] for a in flags.train_city.split(',')]
# 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('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 in train_city_list and j > 5:
filter_train.append(j * 10 + i)
elif j <= 5:
filter_valid.append(j * 10 + i)
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,
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',
'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, # 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 evaluate(self,
rgb_list,
gt_list,
rgb_dir,
gt_dir,
input_size,
tile_size,
batch_size,
img_mean,
model_dir,
gpu=None,
save_result=True,
save_result_parent_dir=None,
show_figure=False,
verb=True,
ds_name='default',
load_epoch_num=None,
best_model=True):
if show_figure:
import matplotlib.pyplot as plt
if save_result:
self.model_name = model_dir.split('/')[-1]
if save_result_parent_dir is None:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
self.model_name, ds_name)
else:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
save_result_parent_dir,
self.model_name, ds_name)
if not os.path.exists(score_save_dir):
os.makedirs(score_save_dir)
with open(os.path.join(score_save_dir, 'result.txt'), 'w'):
pass
iou_record = []
iou_return = {}
for file_name, file_name_truth in zip(rgb_list, gt_list):
tile_size = ersa_utils.load_file(
os.path.join(rgb_dir[0], file_name[0])).shape[:2]
tile_name = file_name_truth.split('_')[0]
if verb:
print('Evaluating {} ... '.format(tile_name))
start_time = time.time()
# prepare the reader
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=rgb_dir,
chipFiles=[file_name],
chip_size=input_size,
tile_size=tile_size,
batchSize=batch_size,
block_mean=img_mean,
overlap=self.get_overlap(),
padding=np.array(
(self.get_overlap() / 2, self.get_overlap() / 2)),
isTrain=False)
rManager = reader.readManager
# run the model
pred = self.run(pretrained_model_dir=model_dir,
test_reader=rManager,
tile_size=tile_size,
patch_size=input_size,
gpu=gpu,
load_epoch_num=load_epoch_num,
best_model=best_model,
tile_name=tile_name)
truth_label_img = imageio.imread(
os.path.join(gt_dir, file_name_truth))
iou = util_functions.iou_metric(truth_label_img,
pred,
divide_flag=True)
iou_record.append(iou)
iou_return[tile_name] = iou
duration = time.time() - start_time
if verb:
print('{} mean IoU={:.3f}, duration: {:.3f}'.format(
tile_name, iou[0] / iou[1], duration))
# save results
if save_result:
pred_save_dir = os.path.join(score_save_dir, 'pred')
if not os.path.exists(pred_save_dir):
os.makedirs(pred_save_dir)
imageio.imsave(os.path.join(pred_save_dir, tile_name + '.png'),
pred.astype(np.uint8))
with open(os.path.join(score_save_dir, 'result.txt'),
'a+') as file:
file.write('{} {}\n'.format(tile_name, iou))
if show_figure:
plt.figure(figsize=(12, 4))
ax1 = plt.subplot(121)
ax1.imshow(truth_label_img)
plt.title('Truth')
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
ax2.imshow(pred)
plt.title('pred')
plt.suptitle('{} Results on {} IoU={:3f}'.format(
self.model_name,
file_name_truth.split('_')[0], iou[0] / iou[1]))
plt.show()
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))
if save_result:
if save_result_parent_dir is None:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
self.model_name, ds_name)
else:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
save_result_parent_dir,
self.model_name, ds_name)
with open(os.path.join(score_save_dir, 'result.txt'),
'a+') as file:
file.write('{}'.format(mean_iou))
return iou_return
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))
'bellingham', 'bloomington', 'sfo', 'tyrol-e', 'innsbruck', 'vienna_s'
])
file_list_valid = uabCrossValMaker.make_file_list_by_key(
idx,
file_list, [i for i in range(6, 11)],
filter_list=[
'bellingham', 'bloomington', 'sfo', 'tyrol-e', 'innsbruck', 'vienna_s'
])
with tf.name_scope('image_loader'):
# GT has no mean to subtract, append a 0 for block mean
dataReader_train1 = uabDataReader.ImageLabelReader([3], [0, 1, 2],
patchDir,
file_list_train,
chip_size,
tile_size,
source_control[0],
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,
chip_size,
tile_size,
batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean))
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))
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)
# create graph
model.create_graph('X', class_num=2)
# load data
large_tile = ['{}_RGB.jpg'.format(tile_ids[tile_cnt])]
ct_tile = [
os.path.join(gt_dir,
'{}_RGB.jpg'.format(tile_ids[tile_cnt].replace('_', '-')))
]
reader = uabDataReader.ImageLabelReader(gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=data_path,
chipFiles=[large_tile],
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)
test_reader = reader.readManager
reader2 = uabDataReader.ImageLabelReader(gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=data_path,
chipFiles=[ct_tile],
chip_size=input_size,
tile_size=tile_size,
batchSize=batch_size,
for YEAR in [15, 16, 17]:
data_dir = r'/hdd/lbnl/SDall{}/data/Original_Tiles'.format(YEAR)
file_list = natsorted(glob(os.path.join(data_dir, '*.tif')))
for img_file in file_list:
file_name = os.path.splitext(os.path.basename(img_file))[0]
print('Evaluating {} at year 20{}...'.format(file_name, YEAR))
# prepare the reader
reader = uabDataReader.ImageLabelReader(
gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=data_dir,
chipFiles=[[os.path.basename(img_file)]],
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 = model.run(pretrained_model_dir=model_dir,
test_reader=rManager,
tile_size=tile_size,
patch_size=input_size,
gpu=gpu,
load_epoch_num=EPOCH_NUM,
# 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,
chip_size,
tile_size,
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_train,
chip_size,
tile_size,
batch_size,
dataAug=' ',
block_mean=np.append(
[0], img_mean))
},
trainable=mode,
input_size=input_size,
batch_size=5,
start_filter_num=32)
# create graph
model.create_graph('X', class_num=2)
pad = np.array((model.get_overlap() / 2, model.get_overlap() / 2))
# prepare the reader
reader = uabDataReader.ImageLabelReader(gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=parent_dir,
chipFiles=[file_name],
chip_size=input_size,
tile_size=tile_size,
batchSize=batch_size,
block_mean=img_mean,
overlap=model.get_overlap(),
padding=pad,
isTrain=False)
rManager = reader.readManager
# run the model
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model.load(model_dir, sess)
model.model_name = model_dir.split('/')[-1]
result = model.test('X', sess, rManager)
image_pred = uabUtilreader.un_patchify_shrink(
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))
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))
