def train_one_epoch(sess, ops, train_writer):
""" ops: dict mapping from string to tf ops """
is_training = True
current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(
TRAIN_DATA, TRAIN_LABELS, TRAIN_MASKS, NUM_POINT)
current_label = np.squeeze(current_label)
current_mask = np.squeeze(current_mask)
num_batches = current_data.shape[0] // BATCH_SIZE
total_correct = 0
total_seen = 0
loss_sum = 0
total_correct_seg = 0
classify_loss_sum = 0
seg_loss_sum = 0
for batch_idx in range(num_batches):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx + 1) * BATCH_SIZE
# Augment batched point clouds by rotation and jittering
rotated_data = provider.rotate_point_cloud(
current_data[start_idx:end_idx, :, :])
jittered_data = provider.jitter_point_cloud(rotated_data)
feed_dict = {
ops['pointclouds_pl']: jittered_data,
ops['labels_pl']: current_label[start_idx:end_idx],
ops['masks_pl']: current_mask[start_idx:end_idx],
ops['is_training_pl']: is_training,
}
summary, step, _, loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run(
[
ops['merged'], ops['step'], ops['train_op'], ops['loss'],
ops['pred'], ops['seg_pred'], ops['classify_loss'],
ops['seg_loss']
],
feed_dict=feed_dict)
train_writer.add_summary(summary, step)
pred_val = np.argmax(pred_val, 1)
correct = np.sum(pred_val == current_label[start_idx:end_idx])
seg_val = np.argmax(seg_val, 2)
seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx])
total_correct_seg += seg_correct
total_correct += correct
total_seen += BATCH_SIZE
loss_sum += loss_val
classify_loss_sum += classify_loss
seg_loss_sum += seg_loss
log_string('mean loss: %f' % (loss_sum / float(num_batches)))
log_string('classify mean loss: %f' %
(classify_loss_sum / float(num_batches)))
log_string('seg mean loss: %f' % (seg_loss_sum / float(num_batches)))
log_string('accuracy: %f' % (total_correct / float(total_seen)))
log_string('seg accuracy: %f' % (total_correct_seg /
(float(total_seen) * NUM_POINT)))
def eval_one_epoch(sess, ops, test_writer):
""" ops: dict mapping from string to tf ops """
is_training = False
total_correct = 0
total_seen = 0
loss_sum = 0
classify_loss_sum = 0
seg_loss_sum = 0
total_correct_seg = 0
total_seen_class = [0 for _ in range(NUM_CLASSES)]
total_correct_class = [0 for _ in range(NUM_CLASSES)]
current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(
TEST_DATA, TEST_LABELS, TEST_MASKS, NUM_POINT)
current_label = np.squeeze(current_label)
current_mask = np.squeeze(current_mask)
num_batches = current_data.shape[0] // BATCH_SIZE
for batch_idx in range(num_batches):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx + 1) * BATCH_SIZE
feed_dict = {
ops['pointclouds_pl']: current_data[start_idx:end_idx, :, :],
ops['labels_pl']: current_label[start_idx:end_idx],
ops['masks_pl']: current_mask[start_idx:end_idx],
ops['is_training_pl']: is_training
}
summary, step, loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run(
[
ops['merged'], ops['step'], ops['loss'], ops['pred'],
ops['seg_pred'], ops['classify_loss'], ops['seg_loss']
],
feed_dict=feed_dict)
test_writer.add_summary(summary, step)
pred_val = np.argmax(pred_val, 1)
correct = np.sum(pred_val == current_label[start_idx:end_idx])
seg_val = np.argmax(seg_val, 2)
seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx])
total_correct_seg += seg_correct
total_correct += correct
total_seen += BATCH_SIZE
loss_sum += (loss_val * BATCH_SIZE)
classify_loss_sum += classify_loss * BATCH_SIZE
seg_loss_sum += seg_loss * BATCH_SIZE
for i in range(start_idx, end_idx):
l = current_label[i]
total_seen_class[l] += 1
total_correct_class[l] += (pred_val[i - start_idx] == l)
log_string('eval mean loss: %f' % (loss_sum / float(total_seen)))
log_string('eval accuracy: %f' % (total_correct / float(total_seen)))
log_string('eval avg class acc: %f' % (np.mean(
np.array(total_correct_class) /
np.array(total_seen_class, dtype=np.float))))
log_string('eval seg accuracy: %f' % (total_correct_seg /
(float(total_seen) * NUM_POINT)))
def eval_one_epoch(sess, ops, test_writer):
is_training = False
total_correct = 0
total_seen = 0
loss_sum = 0
classify_loss_sum = 0
seg_loss_sum = 0
total_correct_seg = 0
total_seen_class = [0 for _ in range(NUM_CLASSES)]
total_correct_class = [0 for _ in range(NUM_CLASSES)]
current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(
TEST_DATA, TEST_LABELS, TEST_MASKS, sample_num)
current_label = np.squeeze(current_label)
current_mask = np.squeeze(current_mask)
num_batches = current_data.shape[0] // batch_size
for batch_idx in range(num_batches):
start_idx = batch_idx * batch_size
end_idx = (batch_idx + 1) * batch_size
xforms_np, rotations_np = pf.get_xforms(
batch_size,
rotation_range=rotation_range_val,
scaling_range=scaling_range_val,
order=setting.rotation_order)
# Augment batched point clouds by rotation and jittering
feed_dict = {
ops['pointclouds_pl']: current_data[start_idx:end_idx, :, :],
ops['labels_pl']: current_label[start_idx:end_idx],
ops['masks_pl']: current_mask[start_idx:end_idx],
ops['is_training_pl']: is_training,
ops['xforms']: xforms_np,
ops['rotations']: rotations_np,
ops['jitter_range']: np.array([jitter_val])
}
summary, step, loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run(
[
ops['merged'], ops['step'], ops['loss'], ops['pred'],
ops['seg_pred'], ops['classify_loss'], ops['seg_loss']
],
feed_dict=feed_dict)
pred_val = np.sum(pred_val, axis=1)
pred_val = np.argmax(pred_val, 1)
correct = np.sum(pred_val == current_label[start_idx:end_idx])
seg_val = np.argmax(seg_val, 2)
seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx])
total_correct_seg += seg_correct
total_correct += correct
total_seen += batch_size
loss_sum += (loss_val * batch_size)
for i in range(start_idx, end_idx):
l = current_label[i]
total_seen_class[l] += 1
total_correct_class[l] += (pred_val[i - start_idx] == l)
log_string('eval mean loss: %f' % (loss_sum / float(total_seen)))
log_string('eval accuracy: %f' % (total_correct / float(total_seen)))
log_string('eval avg class acc: %f' % (np.mean(
np.array(total_correct_class) /
np.array(total_seen_class, dtype=np.float))))
log_string('eval accuracy: %f' % (total_correct / float(total_seen)))
log_string('eval avg class acc: %f' % (np.mean(
np.array(total_correct_class) /
np.array(total_seen_class, dtype=np.float))))
log_string('eval seg accuracy: %f' % (total_correct_seg /
(float(total_seen) * sample_num)))
def train_one_epoch(sess, ops, train_writer):
is_training = True
current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(
TRAIN_DATA, TRAIN_LABELS, TRAIN_MASKS, sample_num)
current_label = np.squeeze(current_label)
current_mask = np.squeeze(current_mask)
num_batches = current_data.shape[0] // batch_size
total_correct = 0
total_seen = 0
loss_sum = 0
total_correct_seg = 0
classify_loss_sum = 0
seg_loss_sum = 0
for batch_idx in range(num_batches):
start_idx = batch_idx * batch_size
end_idx = (batch_idx + 1) * batch_size
xforms_np, rotations_np = pf.get_xforms(batch_size,
rotation_range=rotation_range,
scaling_range=scaling_range,
order=setting.rotation_order)
# Augment batched point clouds by rotation and jittering
feed_dict = {
ops['pointclouds_pl']: current_data[start_idx:end_idx, :, :],
ops['labels_pl']: current_label[start_idx:end_idx],
ops['masks_pl']: current_mask[start_idx:end_idx],
ops['is_training_pl']: is_training,
ops['xforms']: xforms_np,
ops['rotations']: rotations_np,
ops['jitter_range']: np.array([jitter])
}
summary, step, _, loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run(
[
ops['merged'], ops['step'], ops['train_op'], ops['loss'],
ops['pred'], ops['seg_pred'], ops['classify_loss'],
ops['seg_loss']
],
feed_dict=feed_dict)
train_writer.add_summary(summary, step)
pred_val = np.sum(pred_val, axis=1)
pred_val = np.argmax(pred_val, 1)
# print(pred_val)
# print(current_label[start_idx:end_idx])
correct = np.sum(pred_val == current_label[start_idx:end_idx])
seg_val = np.argmax(seg_val, 2)
seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx])
total_correct_seg += seg_correct
total_correct += correct
total_seen += batch_size
loss_sum += loss_val
classify_loss_sum += classify_loss
seg_loss_sum += seg_loss
log_string('mean loss: %f' % (loss_sum / float(num_batches)))
log_string('classify mean loss: %f' %
(classify_loss_sum / float(num_batches)))
log_string('seg mean loss: %f' % (seg_loss_sum / float(num_batches)))
log_string('accuracy: %f' % (total_correct / float(total_seen)))
log_string('seg accuracy: %f' % (total_correct_seg /
(float(total_seen) * sample_num)))
def eval_one_epoch(sess, ops, num_votes=1, topk=1):
error_cnt = 0
is_training = False
total_correct = 0
total_seen = 0
loss_sum = 0
total_correct_seg = 0
classify_loss_sum = 0
seg_loss_sum = 0
total_seen_class = [0 for _ in range(NUM_CLASSES)]
total_correct_class = [0 for _ in range(NUM_CLASSES)]
fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w')
current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(
TEST_DATA, TEST_LABELS, TEST_MASKS, NUM_POINT)
current_label = np.squeeze(current_label)
current_mask = np.squeeze(current_mask)
num_batches = current_data.shape[0] // BATCH_SIZE
for batch_idx in range(num_batches):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx + 1) * BATCH_SIZE
cur_batch_size = end_idx - start_idx
# Aggregating BEG
batch_loss_sum = 0 # sum of losses for the batch
batch_pred_sum = np.zeros(
(cur_batch_size, NUM_CLASSES)) # score for classes
batch_seg_sum = np.zeros(
(cur_batch_size, NUM_POINT, 2)) # score for classes
batch_pred_classes = np.zeros(
(cur_batch_size, NUM_CLASSES)) # 0/1 for classes
for vote_idx in range(num_votes):
rotated_data = provider.rotate_point_cloud_by_angle(
current_data[start_idx:end_idx, :, :],
vote_idx / float(num_votes) * np.pi * 2)
xforms_np, rotations_np = pf.get_xforms(
BATCH_SIZE,
rotation_range=rotation_range_val,
scaling_range=scaling_range_val,
order=setting.rotation_order)
# Augment batched point clouds by rotation and jittering
feed_dict = {
ops['pointclouds_pl']: rotated_data,
ops['labels_pl']: current_label[start_idx:end_idx],
ops['masks_pl']: current_mask[start_idx:end_idx],
ops['is_training_pl']: is_training,
ops['xforms']: xforms_np,
ops['rotations']: rotations_np,
ops['jitter_range']: np.array([jitter_val])
}
loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run(
[
ops['loss'], ops['pred'], ops['seg_pred'],
ops['classify_loss'], ops['seg_loss']
],
feed_dict=feed_dict)
pred_val = np.sum(pred_val, axis=1)
# pred_val = np.argmax(pred_val, 1)
batch_pred_sum += pred_val
batch_seg_sum += seg_val
batch_pred_val = np.argmax(pred_val, 1)
for el_idx in range(cur_batch_size):
batch_pred_classes[el_idx, batch_pred_val[el_idx]] += 1
batch_loss_sum += (loss_val * cur_batch_size / float(num_votes))
# pred_val_topk = np.argsort(batch_pred_sum, axis=-1)[:,-1*np.array(range(topk))-1]
# pred_val = np.argmax(batch_pred_classes, 1)
pred_val = np.argmax(batch_pred_sum, 1)
# Aggregating END
correct = np.sum(pred_val == current_label[start_idx:end_idx])
seg_val = np.argmax(batch_seg_sum, 2)
seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx])
total_correct_seg += seg_correct
# correct = np.sum(pred_val_topk[:,0:topk] == label_val)
total_correct += correct
total_seen += cur_batch_size
loss_sum += batch_loss_sum
for i in range(start_idx, end_idx):
l = current_label[i]
total_seen_class[l] += 1
total_correct_class[l] += (pred_val[i - start_idx] == l)
fout.write('%s, %s\n' %
(SHAPE_NAMES[pred_val[i - start_idx]], SHAPE_NAMES[l]))
gt_mask = current_mask[i]
pred_mask = seg_val[i - start_idx]
pred_mask_idx = np.where(pred_mask == 1)[0]
gt_mask_idx = np.where(gt_mask == 1)[0]
correct_obj_mask = np.where((pred_mask == gt_mask)
& (pred_mask == 1))[0]
if (len(correct_obj_mask) == 1):
continue
if (i % 20 == 0 and FLAGS.visu_mask):
###1)
img_filename = '%d_label_%s_pred_%s_gtmask.jpg' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
img_filename = os.path.join(DUMP_DIR, img_filename)
output_img = pc_util.point_cloud_three_views(
np.squeeze(current_data[i, gt_mask_idx, :]))
scipy.misc.imsave(img_filename, output_img)
#save ply
ply_filename = '%d_label_%s_pred_%s_gtmask.ply' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
ply_filename = os.path.join(DUMP_DIR, ply_filename)
data_utils.save_ply(
np.squeeze(current_data[i, gt_mask_idx, :]), ply_filename)
###2)
img_filename = '%d_label_%s_pred_%s_predmask.jpg' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
img_filename = os.path.join(DUMP_DIR, img_filename)
output_img = pc_util.point_cloud_three_views(
np.squeeze(current_data[i, pred_mask_idx, :]))
scipy.misc.imsave(img_filename, output_img)
#save ply
ply_filename = '%d_label_%s_pred_%s_predmask.ply' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
ply_filename = os.path.join(DUMP_DIR, ply_filename)
data_utils.save_ply(
np.squeeze(current_data[i, pred_mask_idx, :]),
ply_filename)
###3)
img_filename = '%d_label_%s_pred_%s_correctpredmask.jpg' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
img_filename = os.path.join(DUMP_DIR, img_filename)
output_img = pc_util.point_cloud_three_views(
np.squeeze(current_data[i, correct_obj_mask, :]))
scipy.misc.imsave(img_filename, output_img)
#save ply
ply_filename = '%d_label_%s_pred_%s_correctpredmask.ply' % (
i, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i - start_idx]])
ply_filename = os.path.join(DUMP_DIR, ply_filename)
data_utils.save_ply(
np.squeeze(current_data[i, correct_obj_mask, :]),
ply_filename)
if pred_val[i -
start_idx] != l and FLAGS.visu: # ERROR CASE, DUMP!
img_filename = '%d_label_%s_pred_%s.jpg' % (
error_cnt, SHAPE_NAMES[l],
SHAPE_NAMES[pred_val[i - start_idx]])
img_filename = os.path.join(DUMP_DIR, img_filename)
output_img = pc_util.point_cloud_three_views(
np.squeeze(current_data[i, :, :]))
scipy.misc.imsave(img_filename, output_img)
#save ply
ply_filename = '%d_label_%s_pred_%s.ply' % (
error_cnt, SHAPE_NAMES[l],
SHAPE_NAMES[pred_val[i - start_idx]])
data_utils.save_ply(np.squeeze(current_data[i, :, :]),
ply_filename)
error_cnt += 1
log_string('total seen: %d' % (total_seen))
log_string('eval mean loss: %f' % (loss_sum / float(total_seen)))
log_string('eval accuracy: %f' % (total_correct / float(total_seen)))
log_string('eval avg class acc: %f' % (np.mean(
np.array(total_correct_class) /
np.array(total_seen_class, dtype=np.float))))
log_string('seg accuracy: %f' % (total_correct_seg /
(float(total_seen) * NUM_POINT)))
class_accuracies = np.array(total_correct_class) / np.array(
total_seen_class, dtype=np.float)
for i, name in enumerate(SHAPE_NAMES):
log_string('%10s:\t%0.3f' % (name, class_accuracies[i]))