input_image = cv2.flip(input_image, 0)
output_image = cv2.flip(output_image, 0)
if args.brightness:
factor = 1.0 + abs(
random.gauss(mu=0.0, sigma=self.brightness))
if random.randint(0, 1):
factor = 1.0 / factor
table = np.array([
((i / 255.0)**factor) * 255 for i in np.arange(0, 256)
]).astype(np.uint8)
image = cv2.LUT(image, table)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(
helpers.one_hot_it(label=output_image,
num_classes=num_classes))
input_image_batch.append(np.expand_dims(input_image, axis=0))
output_image_batch.append(np.expand_dims(output_image, axis=0))
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# memory()
if args.batch_size == 1:
input_image_batch = input_image_batch[0]
# Collect a batch of images
for j in range(args.batch_size):
index = i * args.batch_size + j
id = id_list[index]
input_image = load_image(train_input_names[id])
output_image = load_image(train_output_names[id])
with tf.device('/cpu:0'):
input_image, output_image = data_augmentation(
input_image, output_image)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(
helpers.one_hot_it(label=output_image,
label_values=label_values))
input_image_batch.append(
np.expand_dims(input_image, axis=0))
output_image_batch.append(
np.expand_dims(output_image, axis=0))
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# memory()
file_name = utils_seg.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
gt_map = helpers.reverse_one_hot(helpers.one_hot_it(gt_map))
gt_map = helpers.colour_code_segmentation(gt_map)
file_name = os.path.basename(val_input_names[ind])
file_name = os.path.splitext(file_name)[0]
cv2.imwrite(model_dir + "/%s_pred.png" % (ind),
np.uint8(out_vis_image))
cv2.imwrite(model_dir + "/%s_gt.png" % (ind), np.uint8(gt_map))
avg_score = np.mean(scores_list)
avg_precision = np.mean(precision_list)
avg_recall = np.mean(recall_list)
avg_f1 = np.mean(f1_list)
avg_iou = np.mean(iou_list)
print("\nAverage validation accuracy for iteration # %06d = %f" %
(step, avg_score))
file_name = utils.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
gt = helpers.reverse_one_hot(helpers.one_hot_it(gt))
gt = helpers.colour_code_segmentation(gt)
file_name = os.path.basename(val_input_names[ind])
file_name = os.path.splitext(file_name)[0]
cv2.imwrite(
"%s/%04d/%s_pred.png" % ("checkpoints2", epoch, file_name),
np.uint8(out_vis_image))
cv2.imwrite(
"%s/%04d/%s_gt.png" % ("checkpoints2", epoch, file_name),
np.uint8(gt))
target.close()
avg_score = np.mean(scores_list)
class_avg_scores = np.mean(class_scores_list, axis=0)
def create_record(dataset_dir=args.dataset):
train_input_names = []
train_output_names = []
train_output_weight_names = []
val_input_names = []
val_output_names = []
test_input_names = []
test_output_names = []
for file in os.listdir(dataset_dir + "/train"):
cwd = os.getcwd()
train_input_names.append(cwd + "/" + dataset_dir + "/train/" + file)
for file in os.listdir(dataset_dir + "/train_labels"):
cwd = os.getcwd()
train_output_names.append(cwd + "/" + dataset_dir + "/train_labels/" +
file)
for file in os.listdir(dataset_dir + "/val"):
cwd = os.getcwd()
val_input_names.append(cwd + "/" + dataset_dir + "/val/" + file)
for file in os.listdir(dataset_dir + "/val_labels"):
cwd = os.getcwd()
val_output_names.append(cwd + "/" + dataset_dir + "/val_labels/" +
file)
for file in os.listdir(dataset_dir + "/test"):
cwd = os.getcwd()
test_input_names.append(cwd + "/" + dataset_dir + "/test/" + file)
for file in os.listdir(dataset_dir + "/test_labels"):
cwd = os.getcwd()
test_output_names.append(cwd + "/" + dataset_dir + "/test_labels/" +
file)
writer = tf.python_io.TFRecordWriter("train.tfrecords")
for t_ind in range(len(train_input_names)):
img = cv2.imread(train_input_names[t_ind], -1)
label = cv2.imread(train_output_names[t_ind], -1)
label = helpers.one_hot_it(label=label, num_classes=2).astype('uint8')
# print(img.shape,img.dtype,label.shape,label.dtype)
img_raw = img.tobytes() #将图片转化为原生bytes
label_raw = label.tobytes()
example = tf.train.Example(features=tf.train.Features(
feature={
"label_raw":
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[label_raw])),
'img_raw':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[img_raw]))
}))
writer.write(example.SerializeToString())
writer.close()
writer = tf.python_io.TFRecordWriter("valid.tfrecords")
for t_ind in range(len(val_input_names)):
img = cv2.imread(val_input_names[t_ind], -1)
label = cv2.imread(val_output_names[t_ind], -1)
label = helpers.one_hot_it(label=label, num_classes=2).astype('uint8')
# print(img.shape,img.dtype,label.shape,label.dtype)
img_raw = img.tobytes() #将图片转化为原生bytes
label_raw = label.tobytes()
example = tf.train.Example(features=tf.train.Features(
feature={
"label_raw":
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[label_raw])),
'img_raw':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[img_raw]))
}))
writer.write(example.SerializeToString())
writer.close()
# Collect a batch of images
for j in range(args.batch_size):
index = i * args.batch_size + j
id = id_list[index]
input_image = load_image(train_input_names[id])
output_image = load_image(train_output_names[id])
with tf.device('/cpu:0'):
input_image, output_image = data_augmentation(
input_image, output_image)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(
helpers.one_hot_it(label=output_image,
class_dict=class_dict))
input_image_batch.append(
np.expand_dims(input_image, axis=0))
output_image_batch.append(
np.expand_dims(output_image, axis=0))
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# memory()
def main():
args = get_arguments()
# load parameters
param = cityscapes_param
crop_size = param['crop_size']
num_classes = param['num_classes']
ignore_label = param['ignore_label']
num_steps = param['num_steps']
PSPNet = param['model']
PSPNet_2 = param['model2']
data_dir = param['data_dir']
image_h = 1024
image_w = 2048
overlap_size = 256
# Set up tf session and initialize variables.
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
g1 = tf.Graph()
g2 = tf.Graph()
g3 = tf.Graph()
sess = tf.Session(config=config, graph=g1)
sess2 = tf.Session(config=config, graph=g2)
sess3 = tf.Session(config=config, graph=g3)
# Create network.1
with g1.as_default():
sess.run(tf.global_variables_initializer())
x = tf.placeholder(dtype=tf.float32, shape=[None, None, 3])
img = preprocess(x, image_h, image_w)
img = tf.image.crop_to_bounding_box(img, 0, 0, overlap_size, overlap_size)
net = PSPNet({'data': img}, is_training=False, num_classes=num_classes)
raw_output = net.layers['conv6']
# Predictions.
raw_output_up = tf.image.resize_bilinear(raw_output, size=[overlap_size, overlap_size], align_corners=True)
raw_output_up = tf.image.pad_to_bounding_box(raw_output_up, 0, 0, image_h, image_w)
restore_var = tf.global_variables()
ckpt = tf.train.get_checkpoint_state("./logdir_fine/")
if ckpt and ckpt.model_checkpoint_path:
loader = tf.train.Saver(var_list=restore_var)
load_step = int(os.path.basename(ckpt.model_checkpoint_path).split('-')[1])
load(loader, sess, ckpt.model_checkpoint_path)
else:
print('No checkpoint file found.')
# Create network.2
with g2.as_default():
sess2.run(tf.global_variables_initializer())
x2 = tf.placeholder(dtype=tf.float32, shape=[None, None, 3])
img2 = preprocess(x2, image_h, image_w)
net2 = PSPNet_2({'data': img2}, is_training=False, num_classes=num_classes)
raw_output2 = net2.layers['conv6_v2']
# Predictions.
raw_output_up2 = tf.image.resize_bilinear(raw_output2, size=[image_h, image_w], align_corners=True)
raw_output_up2 = tf.image.pad_to_bounding_box(raw_output_up2, 0, 0, image_h, image_w)
restore_var2 = tf.global_variables()
ckpt2 = tf.train.get_checkpoint_state('./logdir_coarse/')
if ckpt2 and ckpt2.model_checkpoint_path:
loader2 = tf.train.Saver(var_list=restore_var2)
load(loader2, sess2, ckpt2.model_checkpoint_path)
else:
print('No checkpoint file found.')
# combine
with g3.as_default():
model1 = tf.placeholder(dtype=tf.float32, shape=[None, None, None, 19])
model2 = tf.placeholder(dtype=tf.float32, shape=[None, None, None, 19])
Weights1 = tf.Variable(initial_value=[0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5])
Weights2 = tf.Variable(initial_value=[0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5])
combine_output = tf.add(tf.multiply(model1,Weights1),tf.multiply(model2,Weights2))
sess3.run(tf.global_variables_initializer())
ckpt3 = tf.train.get_checkpoint_state('./combine_variables/')
if ckpt3 and ckpt3.model_checkpoint_path:
loader3 = tf.train.Saver()
load(loader3, sess3, ckpt3.model_checkpoint_path)
else:
print('No checkpoint file found.')
anno_filename = tf.placeholder(dtype=tf.string)
# Read & Decode image
anno = tf.image.decode_image(tf.read_file(anno_filename), channels=1)
anno.set_shape([None, None, 1])
pred_placeholder = tf.placeholder(dtype=tf.int64)
pred_expand = tf.expand_dims(pred_placeholder, dim=3)
pred_flatten = tf.reshape(pred_expand, [-1, ])
raw_gt = tf.reshape(anno, [-1, ])
indices = tf.squeeze(tf.where(tf.not_equal(raw_gt, ignore_label)), 1)
gt = tf.cast(tf.gather(raw_gt, indices), tf.int32)
pred = tf.gather(pred_flatten, indices)
mIoU, update_op = tf.contrib.metrics.streaming_mean_iou(pred, gt, num_classes=num_classes)
eval_sess = tf.Session(config=config)
eval_sess.run(tf.local_variables_initializer())
class_scores_list = []
class_names_list, label_values = helpers.get_label_info("class_dict.csv")
file = open(param['val_list'], 'r')
file_RGB = open("./list/cityscapes_val_list_RGB.txt", 'r')
for step in trange(num_steps, desc='evaluation', leave=True):
f1, f2 = file.readline().split('\n')[0].split(' ')
f1 = os.path.join(data_dir, f1)
f2 = os.path.join(data_dir, f2)
img_out, _ = load_img(f1)
# model 1
preds1 = np.zeros((1, 1024, 2048, 19))
for over_h in range(0, image_h, 256):
for over_w in range(0, image_w, 256):
if over_h <= image_h - overlap_size and over_w <= image_w - overlap_size:
pred_imgs=img_out[over_h:over_h+overlap_size, over_w:over_w+overlap_size]
tmp = sess.run(raw_output_up, feed_dict={x: pred_imgs})
tmp2=np.zeros((1,1024,2048,19))
for i in range(overlap_size):
for j in range(overlap_size):
tmp2[0][i+over_h][j+over_w]=tmp[0][i][j]
preds1 += tmp2
preds2 = sess2.run(raw_output_up2, feed_dict={x2: img_out})
combine_out = sess3.run([combine_output], feed_dict={model1: preds1, model2: preds2})
img_out = np.argmax(combine_out[0], axis=3)
preds = helpers.colour_code_segmentation(img_out, label_values)
# misc.imsave("./1106test/" + str(step) + ".png", preds[0])
# Average per class test accuracies
RGB_label = file_RGB.readline().split('\n')[0].split(' ')[1]
RGB_label = os.path.join(data_dir, RGB_label)
img_label, _ = load_img(RGB_label)
img_label = helpers.reverse_one_hot(helpers.one_hot_it(img_label, label_values))
class_accuracies = util.evaluate_segmentation(pred=img_out, label=img_label, num_classes=num_classes)
class_scores_list.append(class_accuracies)
_ = eval_sess.run(update_op, feed_dict={pred_placeholder: img_out, anno_filename: f2})
print('mIoU: {:04f}'.format(eval_sess.run(mIoU)))
class_avg_scores = np.mean(class_scores_list, axis=0)
print("Average per class test accuracies = \n")
for index, item in enumerate(class_avg_scores):
print("%s = %f" % (class_names_list[index], item))
print('mIoU: {:04f}'.format(eval_sess.run(mIoU)))
# st=time.time()
input_image_batch = []
output_image_batch = []
# Collect a batch of images
for j in range(batch_size):
index = i * batch_size + j
id = id_list[index]
input_image = load_image(train_input_names[id])
output_image = load_image(train_output_names[id])
# input_image, output_image = data_augmentation(input_image, output_image)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(
helpers.one_hot_it(output_image, depth=classes_num, on_value=1))
input_image_batch.append(np.expand_dims(input_image, axis=0))
output_image_batch.append(np.expand_dims(output_image, axis=0))
# 一个batch的图片（label）需要堆叠成 NWHC 形式
if batch_size == 1:
input_image_batch = input_image_batch[0]
output_image_batch = output_image_batch[0]
else:
input_image_batch = np.squeeze(np.stack(input_image_batch, axis=1))
output_image_batch = np.squeeze(np.stack(output_image_batch, axis=1))
# Do the training
_, cur_loss = sess.run([opt, loss], feed_dict={
input: input_image_batch,
ind = random.randint(0, len(val_input_names) - 1)
val_indices.append(ind)
id_list = np.random.permutation(len(train_input_names))
##############
# 8 start training
##############
prev_measure = 1
measure_history = deque([0]*lr_update_step, lr_update_step)
for step in trange(start_step, max_step):
id = id_list[step%len(train_input_names)]
input_image = np.expand_dims(cv2.cvtColor(cv2.imread(train_input_names[id],-1), cv2.COLOR_BGR2RGB),0) / 255.0
# gt_map = np.expand_dims(np.expand_dims(cv2.imread(train_output_names[id],-1),0),3)
gt_map = cv2.imread(train_output_names[id],-1)
print('gt_map.shape:',gt_map.shape, np.unique(gt_map))
gt_map = np.expand_dims(helpers.one_hot_it(gt_map,num_classes=6),0)
#gt_map /= np.max(gt_map)
input_image = np.transpose(input_image, [0, 3, 1, 2])
gt_map = np.transpose(gt_map, [0, 3, 1, 2])
fetch_dict = {
"k_update": k_update,
"measure": measure,
}
if step % log_step == 0:
fetch_dict.update({
"summary": summary_op,
"g_loss": g_loss,
"d_loss": d_loss,
"k_t": k_t,
})
iou_list = []
run_times_list = []
# Run testing on ALL test images
for ind in range(len(test_input_names)):
sys.stdout.write("\rRunning test image %d / %d" %
(ind + 1, len(test_input_names)))
sys.stdout.flush()
input_image = np.expand_dims(np.float32(
utils.load_image(
test_input_names[ind])[:args.crop_height, :args.crop_width]),
axis=0) / 255.0
gt = utils.load_image(
test_output_names[ind])[:args.crop_height, :args.crop_width]
gt = helpers.reverse_one_hot(helpers.one_hot_it(gt, label_values))
st = time.time()
output_image = sess.run(network, feed_dict={net_input: input_image})
run_times_list.append(time.time() - st)
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
out_vis_image = helpers.colour_code_segmentation(output_image,
label_values)
accuracy, class_accuracies, prec, rec, f1, iou = utils.evaluate_segmentation(
pred=output_image, label=gt, num_classes=num_classes)
file_name = utils.filepath_to_name(test_input_names[ind])
val_labels = []
for img_name in train_input_names:
input_image = util.load_image(img_name)
with tf.device('/cpu:0'):
input_image = np.float32(input_image) / 255.0
#input_data.append(np.expand_dims(input_image, axis=0))
input_data.append(input_image)
print(img_name)
for labels_name in train_output_names:
output_image = util.load_image(labels_name, is_data=False)
with tf.device('/cpu:0'):
output_image = np.float32(
helpers.one_hot_it(label=output_image, label_values=label_values))
#output_labels.append(np.expand_dims(output_image, axis=0))
output_labels.append(output_image)
print(labels_name)
for img_name in val_input_names:
input_image = util.load_image(img_name)
with tf.device('/cpu:0'):
input_image = np.float32(input_image) / 255.0
#input_data.append(np.expand_dims(input_image, axis=0))
val_data.append(input_image)
print(img_name)
for labels_name in val_output_names:
output_image_batch = []
# Collect a batch of images
for j in range(args.batch_size):
index = i*args.batch_size + j
id = id_list[index]
input_image = load_image(train_input_names[id])
output_image = load_image(train_output_names[id])
with tf.device('/cpu:0'):
input_image, output_image = data_augmentation(input_image, output_image)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(helpers.one_hot_it(label=output_image, label_values=label_values))
input_image_batch.append(np.expand_dims(input_image, axis=0))
output_image_batch.append(np.expand_dims(output_image, axis=0))
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# memory()
if args.batch_size == 1:
input_image_batch = input_image_batch[0]
def val():
# Create directories if needed
if not os.path.isdir(cfg.base_dir + "%s/%s" % ("result", "Val")):
os.makedirs(cfg.base_dir + "%s/%s" % ("result", "Val"))
target = open(cfg.base_dir + "%s/%s/val_scores.csv" % ("result", "Val"),
'w')
target.write(
"val_name, avg_accuracy, precision, recall, f1 score, mean iou, %s\n" %
(class_names_string))
scores_list = []
class_scores_list = []
precision_list = []
recall_list = []
f1_list = []
iou_list = []
run_times_list = []
# Run testing on ALL test images
for ind in range(len(val_input_names)):
sys.stdout.write("\rRunning test image %d / %d" %
(ind + 1, len(val_input_names)))
sys.stdout.flush()
input_image = np.expand_dims(np.float32(
dataset.load_image(val_input_names[ind])[:cfg.height, :cfg.width]),
axis=0) / 255.0
gt = dataset.load_image(val_output_names[ind])[:cfg.height, :cfg.width]
gt = helpers.reverse_one_hot(helpers.one_hot_it(gt, label_values))
st = time.time()
output_image = sess.run(network, feed_dict={net_input: input_image})
run_times_list.append(time.time() - st)
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
out_vis_image = helpers.colour_code_segmentation(
output_image, label_values)
accuracy, class_accuracies, prec, rec, f1, iou = utils.evaluate_segmentation(
pred=output_image, label=gt, num_classes=num_classes)
file_name = utils.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
gt = helpers.colour_code_segmentation(gt, label_values)
cv2.imwrite(
cfg.base_dir + "%s/%s/%s_pred.png" % ("result", "Val", file_name),
cv2.cvtColor(np.uint8(out_vis_image), cv2.COLOR_RGB2BGR))
cv2.imwrite(
cfg.base_dir + "%s/%s/%s_gt.png" % ("result", "Val", file_name),
cv2.cvtColor(np.uint8(gt), cv2.COLOR_RGB2BGR))
target.close()
avg_score = np.mean(scores_list)
class_avg_scores = np.mean(class_scores_list, axis=0)
avg_precision = np.mean(precision_list)
avg_recall = np.mean(recall_list)
avg_f1 = np.mean(f1_list)
avg_iou = np.mean(iou_list)
avg_time = np.mean(run_times_list)
print("Average test accuracy = ", avg_score)
print("Average per class test accuracies = \n")
for index, item in enumerate(class_avg_scores):
print("%s = %f" % (class_names_list[index], item))
print("Average precision = ", avg_precision)
print("Average recall = ", avg_recall)
print("Average F1 score = ", avg_f1)
print("Average mean IoU score = ", avg_iou)
print("Average run time = ", avg_time)
def train():
if cfg.class_balancing:
print("Computing class weights for trainlabel ...")
class_weights = utils.compute_class_weights(
labels_dir=train_output_names, label_values=label_values)
weights = tf.reduce_sum(class_weights * net_output, axis=-1)
unweighted_loss = None
unweighted_loss = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=network, labels=net_output)
losses = unweighted_loss * class_weights
else:
losses = tf.nn.softmax_cross_entropy_with_logits_v2(logits=network,
labels=net_output)
loss = tf.reduce_mean(losses)
opt = tf.train.AdamOptimizer(cfg.lr).minimize(
loss, var_list=[var for var in tf.trainable_variables()])
sess.run(tf.global_variables_initializer())
utils.count_params()
# If a pre-trained ResNet is required, load the weights.
# This must be done AFTER the variables are initialized with sess.run(tf.global_variables_initializer())
if init_fn is not None:
init_fn(sess)
avg_scores_per_epoch = []
avg_loss_per_epoch = []
# Which validation images do we want
val_indices = []
num_vals = min(cfg.num_val_images, len(val_input_names))
# Set random seed to make sure models are validated on the same validation images.
# So you can compare the results of different models more intuitively.
random.seed(16)
val_indices = random.sample(range(0, len(val_input_names)), num_vals)
# Do the training here
for epoch in range(0, cfg.num_epochs):
current_losses = []
cnt = 0
# Equivalent to shuffling
id_list = np.random.permutation(len(train_input_names))
num_iters = int(np.floor(len(id_list) / cfg.batch_size))
st = time.time()
epoch_st = time.time()
for i in range(num_iters):
# st=time.time()
input_image_batch = []
output_image_batch = []
# Collect a batch of images
for j in range(cfg.batch_size):
index = i * cfg.batch_size + j
id = id_list[index]
input_image = dataset.load_image(train_input_names[id])
output_image = dataset.load_image(train_output_names[id])
h, w, _ = input_image.shape
new_h, new_w = dataset.getTrainSize(h, w)
with tf.device('/cpu:0'):
input_image, output_image = dataset.data_augmentation(
input_image, output_image, new_h, new_w)
# Prep the data. Make sure the labels are in one-hot format
input_image = np.float32(input_image) / 255.0
output_image = np.float32(
helpers.one_hot_it(label=output_image,
label_values=label_values))
input_image_batch.append(
np.expand_dims(input_image, axis=0))
output_image_batch.append(
np.expand_dims(output_image, axis=0))
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# input_image = tf.image.crop_to_bounding_box(input_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# output_image = tf.image.crop_to_bounding_box(output_image, offset_height=0, offset_width=0,
# target_height=args.crop_height, target_width=args.crop_width).eval(session=sess)
# ***** THIS CAUSES A MEMORY LEAK AS NEW TENSORS KEEP GETTING CREATED *****
# memory()
# print(cfg.batch_size)
if cfg.batch_size == 1:
input_image_batch = input_image_batch[0]
output_image_batch = output_image_batch[0]
else:
input_image_batch = np.squeeze(
np.stack(input_image_batch, axis=1))
output_image_batch = np.squeeze(
np.stack(output_image_batch, axis=1))
# print(input_image_batch.shape)
# Do the training
_, current = sess.run([opt, loss],
feed_dict={
net_input: input_image_batch,
net_output: output_image_batch
})
current_losses.append(current)
cnt = cnt + cfg.batch_size
if cnt % 20 == 0:
string_print = "Epoch = %d Count = %d Current_Loss = %.4f Time = %.2f" % (
epoch, cnt, current, time.time() - st)
utils.LOG(string_print)
st = time.time()
mean_loss = np.mean(current_losses)
avg_loss_per_epoch.append(mean_loss)
# Create directories if needed
if not os.path.isdir(cfg.base_dir + "%s/%s/%04d" %
("checkpoints", cfg.model, epoch)):
os.makedirs(cfg.base_dir + "%s/%s/%04d" %
("checkpoints", cfg.model, epoch))
# Save latest checkpoint to same file name
print("Saving latest checkpoint")
saver.save(sess, model_checkpoint_name)
if val_indices != 0 and epoch % cfg.checkpoint_step == 0:
print("Saving checkpoint for this epoch")
saver.save(
sess, cfg.base_dir + "%s/%s/%04d/model.ckpt" %
("checkpoints", cfg.model, epoch))
if epoch % cfg.validation_step == 0:
print("Performing validation")
target = open(
cfg.base_dir + "%s/%s/%04d/val_scores.csv" %
("checkpoints", cfg.model, epoch), 'w')
target.write(
"val_name, avg_accuracy, precision, recall, f1 score, mean iou, %s\n"
% (class_names_string))
scores_list = []
class_scores_list = []
precision_list = []
recall_list = []
f1_list = []
iou_list = []
# Do the validation on a small set of validation images
for ind in val_indices:
input_image = dataset.load_image(val_input_names[ind])
output_image = dataset.load_image(val_output_names[ind])
h, w, _ = input_image.shape
new_h, new_w = dataset.getTrainSize(h, w)
input_image, output_image = utils.random_crop(
input_image, output_image, new_h, new_w)
input_image = np.expand_dims(np.float32(input_image),
axis=0) / 255.0
gt = helpers.reverse_one_hot(
helpers.one_hot_it(output_image, label_values))
# st = time.time()
output_image = sess.run(network,
feed_dict={net_input: input_image})
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
out_vis_image = helpers.colour_code_segmentation(
output_image, label_values)
accuracy, class_accuracies, prec, rec, f1, iou = utils.evaluate_segmentation(
pred=output_image, label=gt, num_classes=num_classes)
file_name = utils.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
gt = helpers.colour_code_segmentation(gt, label_values)
file_name = os.path.basename(val_input_names[ind])
file_name = os.path.splitext(file_name)[0]
cv2.imwrite(
cfg.base_dir + "%s/%s/%04d/%s_pred.png" %
("checkpoints", cfg.model, epoch, file_name),
cv2.cvtColor(np.uint8(out_vis_image), cv2.COLOR_RGB2BGR))
cv2.imwrite(
cfg.base_dir + "%s/%s/%04d/%s_gt.png" %
("checkpoints", cfg.model, epoch, file_name),
cv2.cvtColor(np.uint8(gt), cv2.COLOR_RGB2BGR))
target.close()
avg_score = np.mean(scores_list)
class_avg_scores = np.mean(class_scores_list, axis=0)
avg_scores_per_epoch.append(avg_score)
avg_precision = np.mean(precision_list)
avg_recall = np.mean(recall_list)
avg_f1 = np.mean(f1_list)
avg_iou = np.mean(iou_list)
print("\nAverage validation accuracy for epoch # %04d = %f" %
(epoch, avg_score))
print("Average per class validation accuracies for epoch # %04d:" %
(epoch))
for index, item in enumerate(class_avg_scores):
print("%s = %f" % (class_names_list[index], item))
print("Validation precision = ", avg_precision)
print("Validation recall = ", avg_recall)
print("Validation F1 score = ", avg_f1)
print("Validation IoU score = ", avg_iou)
epoch_time = time.time() - epoch_st
remain_time = epoch_time * (cfg.num_epochs - 1 - epoch)
m, s = divmod(remain_time, 60)
h, m = divmod(m, 60)
if s != 0:
train_time = "Remaining training time = %d hours %d minutes %d seconds\n" % (
h, m, s)
else:
train_time = "Remaining training time : Training completed.\n"
utils.LOG(train_time)
scores_list = []
utils.drawLine(range(cfg.num_epochs),
avg_scores_per_epoch,
cfg.base_dir + 'checkpoints/' + cfg.model +
'/accuracy_vs_epochs.png',
title='Average validation accuracy vs epochs',
xlabel='Epoch',
ylabel='Avg. val. accuracy')
utils.drawLine(range(cfg.num_epochs),
avg_loss_per_epoch,
cfg.base_dir + 'checkpoints/' + cfg.model +
'/loss_vs_epochs.png',
title='Average loss vs epochs',
xlabel='Epoch',
ylabel='Current loss')
############ DeepLab v3 ##########################
class_names_list, label_values = helpers.get_label_info(os.path.join("SRF_PED", "class_dict.csv"))
DeepLab_DIR = "deeplab_test_Val"
dice = []
iou = []
images = sorted(os.listdir(DeepLab_DIR))
for i in range(0, len(images)-1,2):
gt_image = threshold(cv2.imread(os.path.join(DeepLab_DIR, images[i])))
pred_image = threshold(cv2.imread(os.path.join(DeepLab_DIR, images[i+1])))
# print(helpers.one_hot_it(pred_image, label_values).shape)
gt = helpers.reverse_one_hot(helpers.one_hot_it(gt_image, label_values))
pred = helpers.reverse_one_hot(helpers.one_hot_it(pred_image, label_values))
# print np.unique(pred)
#_, d = compute_dice_coeff(pred, gt)
#_, i = compute_mean_iou(pred, gt)
_, i = mean_IU(pred, gt)
_, d = mean_Dice(pred, gt)
dice.append(d)
iou.append(i)
dice = np.array(dice)
iou = np.array(iou)
