def main(flags):
# set gpu
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU
# environment settings
np.random.seed(flags.random_seed)
tf.set_random_seed(flags.random_seed)
# data prepare step
Data = rsrClassData(flags.rsr_data_dir)
(collect_files_test, meta_test) = Data.getCollectionByName(flags.test_data_dir)
# image reader
coord = tf.train.Coordinator()
# 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')
# initialize model
model = unet.UnetModel({'X':X, 'Y':y}, trainable=mode, model_name=flags.model_name, input_size=flags.input_size)
model.create_graph('X', flags.num_classes)
model.make_update_ops('X', 'Y')
# set ckdir
model.make_ckdir(flags.ckdir)
# set up graph and initialize
config = tf.ConfigProto()
# run training
start_time = time.time()
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state(model.ckdir):
latest_check_point = tf.train.latest_checkpoint(model.ckdir)
saver.restore(sess, latest_check_point)
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
try:
for (image_name, label_name) in collect_files_test:
if flags.city_name in image_name:
city_name = re.findall('[a-z\-]*(?=[0-9]+\.)', image_name)[0]
tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0]
# load reader
iterator_test = image_reader.image_label_iterator(
os.path.join(flags.rsr_data_dir, image_name),
batch_size=flags.batch_size,
tile_dim=meta_test['dim_image'][:2],
patch_size=flags.input_size,
overlap=0)
# run
result = model.test('X', sess, iterator_test)
pred_label_img = sis_utils.get_output_label(result, meta_test['dim_image'],
flags.input_size, meta_test['colormap'])
# evaluate
truth_label_img = scipy.misc.imread(os.path.join(flags.rsr_data_dir, label_name))
iou = sis_utils.iou_metric(truth_label_img, pred_label_img)
print('{}_{}: iou={:.2f}'.format(city_name, tile_id, iou*100))
finally:
coord.request_stop()
coord.join(threads)
duration = time.time() - start_time
print('duration {:.2f} minutes'.format(duration/60))
def test_unet(rsr_data_dir,
test_data_dir,
input_size,
model_name,
num_classes,
ckdir,
city,
batch_size,
ds_name='inria',
GPU='0',
random_seed=1234):
import re
import scipy.misc
import tensorflow as tf
from network import unet
from dataReader import image_reader
from rsrClassData import rsrClassData
def name_has_city(city_list, name):
for city in city_list:
if city in name:
return True
return False
city = city.split(',')
# set gpu
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = GPU
tf.reset_default_graph()
# environment settings
np.random.seed(random_seed)
tf.set_random_seed(random_seed)
# data prepare step
Data = rsrClassData(rsr_data_dir)
(collect_files_test, meta_test) = Data.getCollectionByName(test_data_dir)
# image reader
coord = tf.train.Coordinator()
# 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')
# initialize model
model = unet.UnetModel({
'X': X,
'Y': y
},
trainable=mode,
model_name=model_name,
input_size=input_size)
model.create_graph('X', num_classes)
model.make_update_ops('X', 'Y')
# set ckdir
model.make_ckdir(ckdir)
# set up graph and initialize
config = tf.ConfigProto()
result_dict = {}
# run training
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state(
model.ckdir):
latest_check_point = tf.train.latest_checkpoint(model.ckdir)
saver.restore(sess, latest_check_point)
print('loaded model from {}'.format(latest_check_point))
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
for (image_name, label_name) in collect_files_test:
#if city in image_name:
if name_has_city(city, image_name):
if ds_name == 'inria':
city_name = re.findall('[a-z\-]*(?=[0-9]+\.)',
image_name)[0]
tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0]
else:
city_name = os.path.basename(image_name)[:3]
tile_id = os.path.basename(image_name)[9:12]
# load reader
iterator_test = image_reader.image_label_iterator(
os.path.join(rsr_data_dir, image_name),
batch_size=batch_size,
tile_dim=meta_test['dim_image'][:2],
patch_size=input_size,
overlap=0)
# run
result = model.test('X', sess, iterator_test)
pred_label_img = get_output_label(result,
meta_test['dim_image'],
input_size,
meta_test['colormap'])
# evaluate
truth_label_img = scipy.misc.imread(
os.path.join(rsr_data_dir, label_name))
iou = iou_metric(truth_label_img, pred_label_img)
result_dict['{}{}'.format(city_name, tile_id)] = iou
coord.request_stop()
coord.join(threads)
return result_dict
def main(flags):
# set gpu
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU
# environment settings
np.random.seed(flags.random_seed)
tf.set_random_seed(flags.random_seed)
# data prepare step
Data = rsrClassData(flags.rsr_data_dir)
(collect_files_train,
meta_train) = Data.getCollectionByName(flags.train_data_dir)
pe_train = patch_extractor.PatchExtractorInria(
flags.rsr_data_dir,
collect_files_train,
patch_size=flags.input_size,
tile_dim=meta_train['dim_image'][:2],
appendix=flags.train_patch_appendix)
train_data_dir = pe_train.extract(flags.patch_dir)
(collect_files_valid,
meta_valid) = Data.getCollectionByName(flags.valid_data_dir)
pe_valid = patch_extractor.PatchExtractorInria(
flags.rsr_data_dir,
collect_files_valid,
patch_size=flags.input_size,
tile_dim=meta_train['dim_image'][:2],
appendix=flags.valid_patch_appendix)
valid_data_dir = pe_valid.extract(flags.patch_dir)
# image reader
coord = tf.train.Coordinator()
# load reader
with tf.name_scope('image_loader'):
reader_train = image_reader.ImageLabelReader(
train_data_dir,
flags.input_size,
coord,
city_list=flags.city_name,
tile_list=flags.train_tile_names)
reader_valid = image_reader.ImageLabelReader(
valid_data_dir,
flags.input_size,
coord,
city_list=flags.city_name,
tile_list=flags.valid_tile_names)
X_batch_op, y_batch_op = reader_train.dequeue(flags.batch_size)
X_batch_op_valid, y_batch_op_valid = reader_valid.dequeue(
flags.batch_size * 2)
reader_train_op = [X_batch_op, y_batch_op]
reader_valid_op = [X_batch_op_valid, y_batch_op_valid]
# 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')
# initialize model
model = unet.UnetModel({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size)
model.create_graph('X', flags.num_classes)
model.make_loss('Y')
model.make_learning_rate(
flags.learning_rate,
tf.cast(flags.n_train / flags.batch_size * flags.decay_step, tf.int32),
flags.decay_rate)
model.make_update_ops('X', 'Y')
model.make_optimizer(model.learning_rate)
# set ckdir
model.make_ckdir(flags.ckdir)
# make summary
model.make_summary()
# set up graph and initialize
config = tf.ConfigProto()
# run training
start_time = time.time()
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state(
model.ckdir):
latest_check_point = tf.train.latest_checkpoint(model.ckdir)
saver.restore(sess, latest_check_point)
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
try:
train_summary_writer = tf.summary.FileWriter(
model.ckdir, sess.graph)
model.train('X',
'Y',
flags.epochs,
flags.n_train,
flags.batch_size,
sess,
train_summary_writer,
train_reader=reader_train_op,
valid_reader=reader_valid_op,
image_summary=sis_utils.image_summary)
finally:
coord.request_stop()
coord.join(threads)
saver.save(sess,
'{}/model.ckpt'.format(model.ckdir),
global_step=model.global_step)
duration = time.time() - start_time
print('duration {:.2f} hours'.format(duration / 60 / 60))
def main(flags):
# set gpu
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU
# environment settings
np.random.seed(flags.random_seed)
tf.set_random_seed(flags.random_seed)
# data prepare step
Data = rsrClassData(flags.rsr_data_dir)
(collect_files_test,
meta_test) = Data.getCollectionByName(flags.test_data_dir)
# image reader
coord = tf.train.Coordinator()
# 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')
# initialize model
model = unet.UnetModel({
'X': X,
'Y': y
},
trainable=mode,
model_name=flags.model_name,
input_size=flags.input_size)
model.create_graph('X', flags.num_classes)
model.make_update_ops('X', 'Y')
# set ckdir
model.make_ckdir(flags.ckdir)
# set up graph and initialize
config = tf.ConfigProto()
# run training
start_time = time.time()
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
if os.path.exists(model.ckdir) and tf.train.get_checkpoint_state(
model.ckdir):
print('loading model from {}'.format(model.ckdir))
latest_check_point = tf.train.latest_checkpoint(model.ckdir)
saver.restore(sess, latest_check_point)
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
tile_cnt = 0
error_map = np.zeros(flags.input_size)
fig = plt.figure(figsize=(20.0, 12.0))
try:
for (image_name, label_name) in collect_files_test:
if flags.city_name in image_name:
tile_cnt += 1
city_name = re.findall('[a-z\-]*(?=[0-9]+\.)',
image_name)[0]
tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0]
print('Evaluating {}_{}.tif'.format(city_name, tile_id))
# load reader
iterator_test = image_reader.image_label_iterator(
os.path.join(flags.rsr_data_dir, image_name),
batch_size=flags.batch_size,
tile_dim=meta_test['dim_image'][:2],
patch_size=flags.input_size,
overlap=0)
# run
result = model.test('X', sess, iterator_test)
# evaluate
label_img = scipy.misc.imread(
os.path.join(flags.rsr_data_dir, label_name))
error_map += evaluate_on_patch(result, label_img,
meta_test['dim_image'][:2],
flags.input_size)
plt.subplot(230 + tile_cnt)
plt.imshow(error_map / np.max(error_map), cmap='hot')
plt.colorbar()
plt.title('Error Map {}_{}'.format(city_name, tile_id))
plt.suptitle('Patch Size = {}'.format(flags.input_size))
dist, error = error_vs_dist(error_map)
plt.subplot(236)
plt.plot(dist, error, 'r.')
plt.title('Error VS Dist ({})'.format(city_name))
plt.xlabel('Dist to center of patch')
plt.ylabel('#Errors')
save_dir = sis_utils.make_task_img_folder(IMG_SAVE_DIR)
plt.savefig(os.path.join(
save_dir, 'M-{}_PS-{}'.format(flags.model_name,
flags.input_size[0])),
bbox_inches='tight')
plt.show()
finally:
coord.request_stop()
coord.join(threads)
duration = time.time() - start_time
print('duration {:.2f} minutes'.format(duration / 60))
def main(flags):
# set gpu
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = flags.GPU
# environment settings
np.random.seed(flags.random_seed)
tf.set_random_seed(flags.random_seed)
for city in ['bellingham', 'bloomington', 'innsbruck', 'sfo', 'tyrol-e']:
if not os.path.exists('./temp'):
os.makedirs('./temp')
flags.city_name = city
for m_name in MODEL_NAME:
tf.reset_default_graph()
# data prepare step
Data = rsrClassData(flags.rsr_data_dir)
(collect_files_test,
meta_test) = Data.getCollectionByName(flags.test_data_dir)
# image reader
coord = tf.train.Coordinator()
# 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')
# initialize model
model = unet.UnetModel({
'X': X,
'Y': y
},
trainable=mode,
model_name=m_name,
input_size=flags.input_size)
model.create_graph('X', flags.num_classes)
model.make_update_ops('X', 'Y')
# set ckdir
model.make_ckdir(flags.ckdir)
# set up graph and initialize
config = tf.ConfigProto()
# run training
start_time = time.time()
with tf.Session(config=config) as sess:
init = tf.global_variables_initializer()
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(),
max_to_keep=1)
if os.path.exists(
model.ckdir) and tf.train.get_checkpoint_state(
model.ckdir):
print('loading model from {}'.format(model.ckdir))
latest_check_point = tf.train.latest_checkpoint(
model.ckdir)
saver.restore(sess, latest_check_point)
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
for (image_name, ) in collect_files_test:
if flags.city_name in image_name:
city_name = re.findall('[a-z\-]*(?=[0-9]+\.)',
image_name)[0]
tile_id = re.findall('[0-9]+(?=\.tif)', image_name)[0]
print('Evaluating {}_{} at patch size: {}'.format(
city_name, tile_id, flags.input_size))
# load reader
iterator_test = image_reader.image_label_iterator(
os.path.join(flags.rsr_data_dir, image_name),
batch_size=flags.batch_size,
tile_dim=meta_test['dim_image'][:2],
patch_size=flags.input_size,
overlap=0)
# run
result = model.test('X', sess, iterator_test)
raw_pred = patch_extractor.un_patchify(
result, meta_test['dim_image'], flags.input_size)
file_name = '{}_{}_{}.npy'.format(
m_name, city_name, tile_id)
np.save(os.path.join('./temp', file_name), raw_pred)
coord.request_stop()
coord.join(threads)
duration = time.time() - start_time
print('duration {:.2f} minutes'.format(duration / 60))
for tile_num in range(36):
output = np.zeros((5000, 5000, 2))
for m_name in MODEL_NAME:
raw_pred = np.load(
os.path.join(
'./temp',
'{}_{}_{}.npy'.format(m_name, flags.city_name,
tile_num + 1)))
output += raw_pred
# combine results
labels_pred = sis_utils.get_pred_labels(output)
output_pred = sis_utils.make_output_file(labels_pred,
meta_test['colormap'])
scipy.misc.imsave(
os.path.join(FIG_SAVE_DIR,
'{}{}.tif'.format(flags.city_name, tile_num + 1)),
output_pred)
shutil.rmtree('./temp')