def epoch(n, i, mode):
# mode (str): train or test
batch_ind = np.arange(i, i + batch_size)
batch = np.float32(images[:, :, :, batch_ind]) / 255
#batch_mask = np.copy(masks[:, :, :, batch_ind])
thisNames = building_names[batch_ind[0]]
this_bb = np.copy(bounding_boxes[batch_ind[0]])
base_name = thisNames.split('_')[0] + '_' + thisNames.split('_')[1]
#thisGT = np.copy(GT[:, :, batch_ind[0]])
thisDWT = np.copy(DWT[:, :, batch_ind[0]])
# prediction_np = sess.run(prediction,feed_dict={x:batch})
[mapE, mapA, mapB, mapK,
l2] = sess.run([predE, predA, predB, predK, l2loss], feed_dict={x: batch})
mapA = np.maximum(mapA, 0)
mapB = np.maximum(mapB, 0)
mapK = np.maximum(mapK, 0)
for j in range(batch_size):
init_snake = thisDWT
snake, snake_hist = snake_process(mapE, mapA, mapB, mapK, init_snake)
# Get last layer gradients
M = mapE.shape[0]
N = mapE.shape[1]
der1, der2 = derivatives_poly(snake)
#der1_GT, der2_GT = derivatives_poly(thisGT)
#grads_arrayE = mapE * 0.001
#grads_arrayA = mapA * 0.001
#grads_arrayB = mapB * 0.001
#grads_arrayK = mapK * 0.001
#grads_arrayE[:, :, 0, 0] -= draw_poly(snake, 1, [M, N],12) - draw_poly(thisGT, 1, [M, N],12)
#grads_arrayA[:, :, 0, 0] -= (np.mean(der1) - np.mean(der1_GT))
#grads_arrayB[:, :, 0, 0] -= (draw_poly(snake, der2, [M, N],12) - draw_poly(thisGT, der2_GT, [M, N],12))
#mask_gt = draw_poly_fill(thisGT, [M, N])
#mask_snake = draw_poly_fill(snake, [M, N])
#grads_arrayK[:, :, 0, 0] -= mask_gt - mask_snake
#intersection = (mask_gt+mask_snake) == 2
#union = (mask_gt + mask_snake) >= 1
#iou = np.sum(intersection) / np.sum(union)
if do_plot:
plot_snakes(snake, snake_hist, None, mapE, mapA, mapB, mapK, \
None, None, None, None, batch, None)
if do_write_results:
if all_snakes.__contains__(base_name):
all_snakes[base_name]['snakes'].append(
np.copy(snake) * im_size / out_size)
all_snakes[base_name]['init'].append(thisDWT * im_size / out_size)
all_snakes[base_name]['bb'].append(this_bb)
else:
all_snakes[base_name] = {}
all_snakes[base_name]['snakes'] = [
np.copy(snake) * im_size / out_size
]
all_snakes[base_name]['init'] = [thisDWT * im_size / out_size]
all_snakes[base_name]['bb'] = [this_bb]
return
def epoch(n, i, mode):
# mode (str): train or test
batch_ind = np.arange(i, i + batch_size)
batch = np.float32(images[:, :, :, batch_ind]) / 255
batch_mask = np.copy(masks[:, :, :, batch_ind])
thisGT = np.copy(GT[:, :, batch_ind[0]])
thisDWT = np.copy(DWT[:, :, batch_ind[0]])
if mode is 'train':
ang = np.random.rand() * 360
for j in range(len(batch_ind)):
for b in range(batch.shape[2]):
batch[:, :, b, j] = imrotate(batch[:, :, b, j], ang)
batch_mask[:, :, 0, j] = imrotate(batch_mask[:, :, 0, j],
ang,
resample='nearest')
R = [[np.cos(ang * np.pi / 180),
np.sin(ang * np.pi / 180)],
[-np.sin(ang * np.pi / 180),
np.cos(ang * np.pi / 180)]]
thisGT -= out_size / 2
thisGT = np.matmul(thisGT, R)
thisGT += out_size / 2
thisDWT -= out_size / 2
thisDWT = np.matmul(thisDWT, R)
thisDWT += out_size / 2
thisGT = np.minimum(thisGT, out_size - 1)
thisGT = np.maximum(thisGT, 0)
thisDWT = np.minimum(thisDWT, out_size - 1)
thisDWT = np.maximum(thisDWT, 0)
# prediction_np = sess.run(prediction,feed_dict={x:batch})
[mapE, mapA, mapB, mapK,
l2] = sess.run([predE, predA, predB, predK, l2loss], feed_dict={x: batch})
if mode is 'train':
for j in range(mapK.shape[3]):
mapK[:, :, 0, j] -= batch_mask[:, :, 0, j] * 0.5 - 0.5 / 2
mapA = np.maximum(mapA, 0)
mapB = np.maximum(mapB, 0)
mapK = np.maximum(mapK, 0)
# Do snake inference
for j in range(batch_size):
init_snake = thisDWT
snake, snake_hist = snake_process(mapE, mapA, mapB, mapK, init_snake)
# Get last layer gradients
M = mapE.shape[0]
N = mapE.shape[1]
der1, der2 = derivatives_poly(snake)
der1_GT, der2_GT = derivatives_poly(thisGT)
grads_arrayE = mapE * 0.001
grads_arrayA = mapA * 0.001
grads_arrayB = mapB * 0.001
grads_arrayK = mapK * 0.001
grads_arrayE[:, :, 0,
0] -= draw_poly(snake, 1, [M, N], 12) - draw_poly(
thisGT, 1, [M, N], 12)
grads_arrayA[:, :, 0, 0] -= (np.mean(der1) - np.mean(der1_GT))
grads_arrayB[:, :, 0, 0] -= (draw_poly(snake, der2, [M, N], 12) -
draw_poly(thisGT, der2_GT, [M, N], 12))
mask_gt = draw_poly_fill(thisGT, [M, N])
mask_snake = draw_poly_fill(snake, [M, N])
grads_arrayK[:, :, 0, 0] -= mask_gt - mask_snake
intersection = (mask_gt + mask_snake) == 2
union = (mask_gt + mask_snake) >= 1
iou = np.sum(intersection) / np.sum(union)
if mode is 'train':
tic = time.time()
apply_gradients.run(
feed_dict={
x: batch,
grad_predE: grads_arrayE,
grad_predA: grads_arrayA,
grad_predB: grads_arrayB,
grad_predK: grads_arrayK,
grad_l2loss: 1
})
#print('%.2f' % (time.time() - tic) + ' s apply gradients')
#print('IoU = %.2f' % (iou))
#if mode is 'test':
#print('IoU = %.2f' % (iou))
if do_plot and n >= 1:
plot_snakes(snake, snake_hist, thisGT, mapE, np.maximum(mapA, 0), np.maximum(mapB, 0), mapK, \
grads_arrayE, grads_arrayA, grads_arrayB, grads_arrayK, batch, batch_mask)
#plt.show()
return iou
