def train_one_epoch(sess, ops, gmm, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True if (".h5" in TRAIN_FILE): current_data, current_label = data_utils.get_current_data_h5(TRAIN_DATA, TRAIN_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data(TRAIN_DATA, TRAIN_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0]//BATCH_SIZE total_correct = 0 total_seen = 0 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 augmented_data = current_data[start_idx:end_idx, :, :] if augment_scale: augmented_data = provider.scale_point_cloud(augmented_data, smin=0.66, smax=1.5) if augment_rotation: augmented_data = provider.rotate_point_cloud(augmented_data) if augment_translation: augmented_data = provider.translate_point_cloud(augmented_data, tval = 0.2) if augment_jitter: augmented_data = provider.jitter_point_cloud(augmented_data, sigma=0.01, clip=0.05) # default sigma=0.01, clip=0.05 if augment_outlier: augmented_data = provider.insert_outliers_to_point_cloud(augmented_data, outlier_ratio=0.02) feed_dict = {ops['points_pl']: augmented_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], 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]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def eval_one_epoch(sess, ops, test_writer): is_training = False total_correct = 0 total_seen = 0 loss_sum = 0 total_seen_class = [0 for _ in range(NUM_CLASSES)] total_correct_class = [0 for _ in range(NUM_CLASSES)] # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, sample_num) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, sample_num) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, sample_num) else: current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, sample_num) current_label = np.squeeze(current_label) 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['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 = sess.run([ops['merged'], ops['step'], ops['loss'], ops['pred']], 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]) 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))))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True log_string(str(datetime.now())) #Shuffle data # data_utils.shuffle_points(TRAIN_DATA) #get current data, shuffle and set to numpy array with desired num_point # current_data, current_label = data_utils.get_current_data(TRAIN_DATA, TRAIN_LABELS, NUM_POINT) if (".h5" in TRAIN_FILE): current_data, current_label = data_utils.get_current_data_h5( TRAIN_DATA, TRAIN_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TRAIN_DATA, TRAIN_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0] // BATCH_SIZE total_correct = 0 total_seen = 0 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['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run([ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], 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]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): is_training = True #get current data, shuffle and set to numpy array with desired num_points # current_data, current_label = data_utils.get_current_data(TRAIN_DATA, TRAIN_LABELS, sample_num) # current_data, current_label = data_utils.get_current_data_h5(TRAIN_DATA, TRAIN_LABELS, sample_num) if (".h5" in TRAIN_FILE): current_data, current_label = data_utils.get_current_data_h5(TRAIN_DATA, TRAIN_LABELS, sample_num) else: current_data, current_label = data_utils.get_current_data(TRAIN_DATA, TRAIN_LABELS, sample_num) current_label = np.squeeze(current_label) num_batches = current_data.shape[0]//batch_size total_correct = 0 total_seen = 0 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['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 = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], 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]) total_correct += correct total_seen += batch_size loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
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 total_seen_class = [0 for _ in range(NUM_CLASSES)] total_correct_class = [0 for _ in range(NUM_CLASSES)] # data_utils.shuffle_points(TEST_DATA) # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, NUM_POINT) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, NUM_POINT) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) 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['is_training_pl']: is_training } summary, step, loss_val, pred_val = sess.run( [ops['merged'], ops['step'], ops['loss'], ops['pred']], feed_dict=feed_dict) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) 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))))
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_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') # data_utils.shuffle_points(TEST_DATA) # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, NUM_POINT) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, NUM_POINT) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) 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_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['is_training_pl']: is_training, ops['xforms']: xforms_np, ops['rotations']: rotations_np, ops['jitter_range']: np.array([jitter_val]) } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], 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_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]) # 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])) 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]]) ply_filename = os.path.join(DUMP_DIR, ply_filename) 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)))) 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]))
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_seen_class = [0 for _ in range(NUM_C)] total_correct_class = [0 for _ in range(NUM_C)] fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') # data_utils.shuffle_points(TEST_DATA) # current_data, current_label = data_utils.get_current_data(TEST_DATA, TEST_LABELS, NUM_POINT) # current_data, current_label = data_utils.get_current_data_h5(TEST_DATA, TEST_LABELS, NUM_POINT) if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) #################################################### print(current_data.shape) print(current_label.shape) filtered_data = [] filtered_label = [] for i in range(current_label.shape[0]): if (current_label[i] in OBJECTDATASET_TO_MODELNET.keys()): filtered_label.append(current_label[i]) filtered_data.append(current_data[i, :]) filtered_data = np.array(filtered_data) filtered_label = np.array(filtered_label) print(filtered_data.shape) print(filtered_label.shape) current_data = filtered_data current_label = filtered_label ################################################### 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, 40)) # score for classes batch_pred_classes = np.zeros((cur_batch_size, 40)) # 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) feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) batch_pred_sum += pred_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 for i in range(start_idx, end_idx): total_seen += 1 if (pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET.keys()): continue pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] # if (pred_val[i-start_idx] == current_label[i]): if (pred == current_label[i]): total_correct += 1 for i in range(start_idx, end_idx): l = current_label[i] total_seen_class[l] += 1 if pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET: pred_label = "NA" else: pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] total_correct_class[l] += (pred == l) pred_label = SHAPE_NAMES[pred] # groundtruth_label = SHAPE_NAMES[MODELNET_TO_OBJECTDATASET[l]] groundtruth_label = SHAPE_NAMES[l] fout.write('%s, %s\n' % (pred_label, groundtruth_label)) if pred_val[i - start_idx] != l and FLAGS.visu: # ERROR CASE, DUMP! img_filename = '%d_label_%s_pred_%s.jpg' % ( error_cnt, groundtruth_label, pred_label) 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, groundtruth_label, pred_label) 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))) seen_class_accuracies = [] seen_correct_class = [] for i in range(len(total_seen_class)): if total_seen_class[i] != 0: seen_class_accuracies.append(total_seen_class[i]) seen_correct_class.append(total_correct_class[i]) log_string('eval avg class acc: %f' % (np.mean( np.array(seen_correct_class) / np.array(seen_class_accuracies, dtype=np.float)))) for i, name in enumerate(SHAPE_NAMES): if (total_seen_class[i] == 0): accuracy = -1 else: accuracy = total_correct_class[i] / float(total_seen_class[i]) log_string('%10s:\t%0.3f' % (name, accuracy))
def eval_one_epoch(sess, ops, gmm, num_votes): """ ops: dict mapping from string to tf ops """ error_cnt = 0 is_training = False total_correct = 0 total_seen = 0 loss_sum = 0 total_seen_class = [0 for _ in range(15)] total_correct_class = [0 for _ in range(15)] fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) #################################################### print(current_data.shape) print(current_label.shape) filtered_data = [] filtered_label = [] for i in range(current_label.shape[0]): if (current_label[i] in OBJECTDATASET_TO_MODELNET.keys()): filtered_label.append(current_label[i]) filtered_data.append(current_data[i, :]) filtered_data = np.array(filtered_data) filtered_label = np.array(filtered_label) print(filtered_data.shape) print(filtered_label.shape) current_data = filtered_data current_label = filtered_label ################################################### num_batches = current_data.shape[0] // BATCH_SIZE current_pred = [] 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, 40)) # score for classes batch_pred_classes = np.zeros((cur_batch_size, 40)) # 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) feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) batch_pred_sum += pred_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 = np.argmax(batch_pred_sum, 1) # Aggregating END for i in range(start_idx, end_idx): total_seen += 1 if (pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET.keys()): continue pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] # if (pred_val[i-start_idx] == current_label[i]): if (pred == current_label[i]): total_correct += 1 for i in range(start_idx, end_idx): l = current_label[i] total_seen_class[l] += 1 if pred_val[i - start_idx] not in MODELNET_TO_OBJECTDATASET: pred_label = "NA" else: pred = MODELNET_TO_OBJECTDATASET[pred_val[i - start_idx]] total_correct_class[l] += (pred == l) pred_label = SHAPE_NAMES[pred] # groundtruth_label = SHAPE_NAMES[MODELNET_TO_OBJECTDATASET[l]] groundtruth_label = SHAPE_NAMES[l] fout.write('%s, %s\n' % (pred_label, groundtruth_label)) 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))) seen_class_accuracies = [] seen_correct_class = [] for i in range(len(total_seen_class)): if total_seen_class[i] != 0: seen_class_accuracies.append(total_seen_class[i]) seen_correct_class.append(total_correct_class[i]) log_string('eval avg class acc: %f' % (np.mean( np.array(seen_correct_class) / np.array(seen_class_accuracies, dtype=np.float)))) for i, name in enumerate(SHAPE_NAMES): if (total_seen_class[i] == 0): accuracy = -1 else: accuracy = total_correct_class[i] / float(total_seen_class[i]) log_string('%10s:\t%0.3f' % (name, accuracy))
def eval_one_epoch(sess, ops, gmm, num_votes): """ ops: dict mapping from string to tf ops """ error_cnt = 0 is_training = False total_correct = 0 total_seen = 0 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') if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) 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_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) feed_dict = { ops['pointclouds_pl']: rotated_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) batch_pred_sum += pred_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 = np.argmax(batch_pred_sum, 1) # Aggregating END correct = np.sum(pred_val == current_label[start_idx:end_idx]) # 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])) 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)))) 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]))
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_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') if (".h5" in TEST_FILE): current_data, current_label = data_utils.get_current_data_h5( TEST_DATA, TEST_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data( TEST_DATA, TEST_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0] // BATCH_SIZE current_pred = [] 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_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['is_training_pl']: is_training, ops['xforms']: xforms_np, ops['rotations']: rotations_np, ops['jitter_range']: np.array([jitter_val]) } loss_val, pred_val = sess.run([ops['loss'], ops['pred']], 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_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]) # 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])) current_pred.append(pred_val[i - start_idx]) 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)))) 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])) #Plot confusion matrix current_pred = np.array(current_pred) groundtruth = current_label.flatten() predictions = current_pred.flatten() mat = confusion_matrix(groundtruth, predictions) plt.style.use('seaborn-paper') plt.rcParams["figure.figsize"] = (10, 10) ax = plt.subplot(111) cmap = plt.cm.Reds mat = mat.astype('float') / mat.sum(axis=1)[:, np.newaxis] mat = np.nan_to_num(mat, copy=True) plt.imshow(mat, interpolation='nearest', cmap=cmap) # cbar = plt.colorbar(fraction=0.03, pad=0.05, aspect=30) # cbar.ax.tick_params(labelsize=10) tick_marks = np.arange(len(SHAPE_NAMES)) plt.xticks(tick_marks, SHAPE_NAMES, rotation=90) plt.yticks(tick_marks, SHAPE_NAMES) plt.ylabel('Ground truth') plt.xlabel('Prediction') for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()): item.set_fontsize(36) plt.tight_layout() plt.savefig(os.path.join(DUMP_DIR, 'matrix.pdf')) plt.show()