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, 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') for fn in range(len(TEST_FILES)): log_string('----'+str(fn)+'----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:,0:NUM_POINT,:] current_label = np.squeeze(current_label) print(current_data.shape) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE print(file_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['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 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('%d, %d\n' % (pred_val[i-start_idx], 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) error_cnt += 1 if pred_val[i-start_idx] == l and FLAGS.visu: # ERROR CASE, DUMP! img_filename = '%d_label_%s_pred_%s.jpg' % (total_correct, SHAPE_NAMES[l], SHAPE_NAMES[pred_val[i-start_idx]]) img_filename = os.path.join(SUCC_DIR, img_filename) output_img = pc_util.point_cloud_three_views(np.squeeze(current_data[i, :, :])) scipy.misc.imsave(img_filename, output_img) 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') for fn in range(len(TEST_FILES)): log_string('----' + str(fn) + '----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:, 0:NUM_POINT, :] # print(current_data) current_label = np.squeeze(current_label) print(current_data.shape) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE print(file_size) for batch_idx in range(num_batches): point_cloud_transformed_val = None TNet1 = None 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['is_training_pl']: is_training } loss_val, pred_val, point_cloud_transformed_val, TNet1 = sess.run( [ ops['loss'], ops['pred'], ops['point_cloud_transformed'], ops['TNet1'] ], feed_dict=feed_dict) for i in range(start_idx, end_idx): l = current_label[i] img_filename = os.path.join( DUMP_DIR, "{label}.{fn}.{batch_idx}.{i}.{vote_idx}.rotated_data.jpg" .format(fn=fn, batch_idx=batch_idx, i=i, label=SHAPE_NAMES[l], vote_idx=vote_idx)) # input: test point cloud output_img = pc_util.point_cloud_three_views( np.squeeze(rotated_data[i - start_idx, :, :])) # using utilities include in this repo # to draw point cloud into jpg scipy.misc.imsave(img_filename, output_img) img_filename = os.path.join( DUMP_DIR, "{label}.{fn}.{batch_idx}.{i}.{vote_idx}.point_cloud_transformed.jpg" .format(fn=fn, batch_idx=batch_idx, i=i, label=SHAPE_NAMES[l], vote_idx=vote_idx)) # output: transformed point cloud output_img = pc_util.point_cloud_three_views( np.squeeze( point_cloud_transformed_val[i - start_idx, :, :])) # using utilities include in this repo # to draw point cloud into jpg scipy.misc.imsave(img_filename, output_img) # j = i - start_idx # f = open( # "dump/{label}.{fn}.{batch_idx}.{i}.{vote_idx}.txt". # format( # fn=fn, # batch_idx=batch_idx, # i=i, # label=SHAPE_NAMES[l], # vote_idx=vote_idx), "w") # f.write(str(TNet1[j])) # T-Net1: 3X3 martix # f.write("\r\n") # # ||1-AA'|| # det = np.linalg.det( # np.eye(3) - np.dot(TNet1[j], TNet1[j].T)) # f.write(str(det)) # f.write("\r\n") # z, y, x = mat2euler(TNet1[j]) # print(z, y, x) # theta, vec = euler2angle_axis(z, y, x) # print(theta, vec) # f.write(str(theta*180/np.pi) + "\r\n" + str(vec)) # f.close() # print(point_cloud_transformed_val.shape) # (4, 1024, 3) # print(rotated_data.shape) # (4, 1024, 3) # print(current_data[0, :, :].shape) # (1024, 3) # print(np.squeeze(current_data[0, :, :]).shape) # (1024, 3) 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('%d, %d\n' % (pred_val[i - start_idx], 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) error_cnt += 1 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') for fn in range(len(TEST_FILES)): log_string('----' + str(fn) + '----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:, 0:NUM_POINT, :] current_label = np.squeeze(current_label) print(current_data.shape) #输出是(420,1024,3) # print(current_data)#输出是一堆数字 print(current_label) #输出是正确的标签 file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE print(file_size) #是420 print(BATCH_SIZE) #是4 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 print(start_idx) #输出开始位置 print(end_idx) #输出结束位置 print(cur_batch_size) #输出4 # 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 ########预测后分类的正确与否(0或1) # print(batch_loss_sum) print(batch_pred_sum) #输出40个0 print(batch_pred_classes) #输出40个0 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) ####### 预测值 # print(loss_val) print(pred_val) #将数据输入网络,得到每个类别的分数 print(batch_pred_sum) # print(batch_pred_val) #根据每个类别的分数来得到预测的类别和下面的pred_val是一样的 for el_idx in range(cur_batch_size): batch_pred_classes[el_idx, batch_pred_val[el_idx]] += 1 print(batch_pred_classes) #根据得到的类别, 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) print(pred_val) ###打印出2468个数据的类别是哪一类 # Aggregating END correct = np.sum(pred_val == current_label[start_idx:end_idx]) print(correct) # correct = np.sum(pred_val_topk[:,0:topk] == label_val) total_correct += correct total_seen += cur_batch_size loss_sum += batch_loss_sum print(total_correct) #总共正确的个数 print(total_seen) #总共的个数 for i in range(start_idx, end_idx): l = current_label[i] print(l) #输出是正确的标签 total_seen_class[l] += 1 # print(total_seen_class[l]) #输出没明白 total_correct_class[l] += (pred_val[i - start_idx] == l) # print(total_correct_class[l] )#输出没明白 fout.write('%d, %d\n' % (pred_val[i - start_idx], l)) #是将正确的标签和预测的标签都写入到里面 print(pred_val[i - start_idx]) #输出是预测的标签 # fout.write('%d\n'%(pred_val[i - start_idx])) #仅仅将预测的标签写入到日志文件中 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) error_cnt += 1 # print(output_img) 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, run_metadata=None): 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)] total_time = 0. total_batches = 0. fout = open(os.path.join(DUMP_DIR, 'pred_label.txt'), 'w') for fn in range(len(TEST_FILES)): log_string('----' + str(fn) + '----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:, 0:NUM_POINT, :] current_label = np.squeeze(current_label) print(current_data.shape) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE print(file_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['is_training_pl']: is_training } # Time measurement start = timer() loss_val, pred_val = sess.run( [ops['loss'], ops['pred']], feed_dict=feed_dict ) #, options=tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE), run_metadata=run_metadata) end = timer() if batch_idx != 0: total_time += (end - start) total_batches += 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('%d, %d\n' % (pred_val[i - start_idx], 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) error_cnt += 1 if VERBOSE: flops = tf.profiler.profile( sess.graph, options=tf.profiler.ProfileOptionBuilder.float_operation(), run_meta=run_metadata) log_string('flops: %f' % (flops.total_float_ops)) 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('mean evaluation time of one batch: %f' % (total_time / total_batches)) parameter_num = np.sum( [np.prod(v.shape.as_list()) for v in tf.trainable_variables()]) log_string('number of trainable parameters: %f' % (parameter_num)) 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]))
else: x_original, target, x_adv, faces = res for eps_idx in range(len(args.eps)): class_idx = np.random.choice(len(class_names), size=len(class_names), replace=False) for i in class_idx: idx = np.random.choice(len(x_original[eps_idx][i]), size=min(3, len(x_original[eps_idx][i])), replace=False) for j in idx: img_file = "%d_%s_original.jpg" % ( j, class_names[target[eps_idx][i][j]]) img_file = os.path.join(args.output, img_file) img = pc_util.point_cloud_three_views( x_original[eps_idx][i][j]) scipy.misc.imsave(img_file, img) eps_str = str(args.eps[eps_idx]).replace(".", "_") img_file = "%d_%s_adv_target_%s_eps_%s.jpg" % (j, class_names[ target[eps_idx][i][j]], class_names[i], eps_str) img_file = os.path.join(args.output, img_file) img = pc_util.point_cloud_three_views(x_adv[eps_idx][i][j]) scipy.misc.imsave(img_file, img) else: res = adversarial_utils.untargeted_attack( args.checkpoint, args.output, x_pl, t_pl, model_loss_fn,
def eval_one_epoch(sess, ops, num_votes=1, topk=1): error_cnt = 0 want_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') for fn in range(len(TEST_FILES)): log_string('----'+str(fn)+'----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:,0:NUM_POINT,:] current_label = np.squeeze(current_label) log_string(current_data.shape.__str__()) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE log_string(file_size.__str__()) 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): nnnnn = 1 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} # if (fn==0 and batch_idx == nnnnn): loss_val, pred_val, point_cloud_transformed,PC_after_transformed1,PC_after_transformed2,after_maxpool,rotateTransform \ = sess.run([ops['loss'], ops['pred'], ops['point_cloud_transformed'],ops['PC_after_transformed1'],ops['PC_after_transformed2'],ops['after_maxpool'],ops['rotateTransform']], feed_dict=feed_dict) # else: # loss_val, pred_val = sess.run([ops['loss'], ops['pred']], feed_dict=feed_dict) if (fn==0 and batch_idx == nnnnn): log_string ("---point_cloud_transformed---") log_string (point_cloud_transformed.shape.__str__()) log_string(point_cloud_transformed[0, :, :][0].__str__()) log_string ("---PC_after_transformed1---") log_string (PC_after_transformed1.shape.__str__()) log_string ("---PC_after_transformed2---") log_string (PC_after_transformed2.shape.__str__()) log_string ("---after_maxpool---") log_string (after_maxpool.shape.__str__()) log_string("---rotateTransform---") log_string(rotateTransform.shape.__str__()) log_string(rotateTransform[0].__str__()) log_string ("---pred_val---") log_string (pred_val.shape.__str__()) 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('%d, %d\n' % (pred_val[i-start_idx], l))\ THS_DIR = os.path.join(FIN_DIR, SHAPE_NAMES[l]) if not os.path.exists(THS_DIR): os.mkdir(THS_DIR) ##log rotate THS_FOUT = open(os.path.join(ROTMAT_DIR, '%s_evaluate.txt'%(SHAPE_NAMES[l])), 'a') THS_FOUT.write('%d_TnetR_label_%s_pred_%s\n' % (want_cnt, SHAPE_NAMES[l],SHAPE_NAMES[pred_val[i-start_idx]])) THS_FOUT.write(rotateTransform[i-start_idx].__str__()+'\n\n') THS_FOUT.flush() Nx3Tnet[l]['%d'%(want_cnt)] = rotateTransform if FLAGS.visu: # if(fn==0 and batch_idx== nnnnn): RAimg_filename = '%d_beforeR_label_%s_pred_%s.jpg' % (want_cnt, SHAPE_NAMES[l],SHAPE_NAMES[pred_val[i-start_idx]]) RAimg_filename = os.path.join(THS_DIR, RAimg_filename) RAoutput_img = pc_util.point_cloud_three_views(np.squeeze(rotated_data[i-start_idx, :, :])) # RAoutput_img = pc_util.draw_point_cloud(np.squeeze(rotated_data[0, :, :])) # print(rotated_data[0, :, :][0]) scipy.misc.imsave(RAimg_filename, RAoutput_img) # print("---") # print(point_cloud_transformed[0, :, :][0]) Nimg_filename = '%d_TnetR_label_%s_pred_%s.jpg' % (want_cnt, SHAPE_NAMES[l],SHAPE_NAMES[pred_val[i-start_idx]]) Nimg_filename = os.path.join(THS_DIR, Nimg_filename) Noutput_img = pc_util.point_cloud_three_views(np.squeeze(point_cloud_transformed[i-start_idx, :, :])) # Noutput_img = pc_util.draw_point_cloud(np.squeeze(point_cloud_transformed[0, :, :])) scipy.misc.imsave(Nimg_filename, Noutput_img) if pred_val[i-start_idx] != l: # 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) error_cnt += 1 # else: # img_filename = '%d_label_%s_pred_%s.jpg' % (want_cnt, SHAPE_NAMES[l], # SHAPE_NAMES[pred_val[i-start_idx]]) # img_filename = os.path.join(WANT_DIR, img_filename) # output_img = pc_util.point_cloud_three_views(np.squeeze(current_data[i, :, :])) # scipy.misc.imsave(img_filename, output_img) # want_cnt += want_cnt += 1 #save to npz print (len(SHAPE_NAMES)) for i in range(0, len(SHAPE_NAMES)): npzFile = os.path.join(ROTMAT_DIR, '%s.npz'%(SHAPE_NAMES[i])) np.savez(npzFile, **(Nx3Tnet[i])) 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') for fn in range(len(TEST_FILES)): log_string('----' + str(fn) + '----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:, 0:NUM_POINT, :] current_label = np.squeeze(current_label) file_size = current_data.shape[0] print(file_size) # set by wind: # my code is based on batch_size = 1 # set batch_size = 1 for this file for batch_idx in range(file_size): start_idx = batch_idx end_idx = batch_idx + 1 cur_batch_size = 1 #------------------------------------------------------------------- # get critical points #------------------------------------------------------------------- no_influence_position = current_data[start_idx, 0, :].copy() global_feature_list = [] orgin_data = current_data[start_idx, :, :].copy() for change_point in range(NUM_POINT): current_data[start_idx, change_point, :] = no_influence_position.copy() for change_point in range(NUM_POINT): current_data[start_idx, change_point, :] = orgin_data[ change_point, :].copy() # Aggregating BEG 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 } global_feature_val = sess.run(ops['global_feature'], feed_dict=feed_dict) global_feature_list.append(global_feature_val) critical_points = [] max_feature = np.zeros(global_feature_list[0].size) - 10 feature_points = np.zeros(global_feature_list[0].size) for index in range(len(global_feature_list)): #distance = math.sqrt(((global_feature_list[index] - global_feature_list[-1]) ** 2).sum()) #distance_list.append(distance) top = global_feature_list[index] feature_points = np.where(top > max_feature, index, feature_points) max_feature = np.where(top > max_feature, top, max_feature) for index in feature_points[0]: critical_points.append(orgin_data[int(index), :]) critical_points = list(set([tuple(t) for t in critical_points])) print(len(critical_points)) img_filename = './test/%d_critical_points.jpg' % (start_idx) output_img = pc_util.point_cloud_three_views( np.squeeze(critical_points)) scipy.misc.imsave(img_filename, output_img) img_filename = './test/%d_orgin_points.jpg' % (start_idx) output_img = pc_util.point_cloud_three_views( np.squeeze(orgin_data)) scipy.misc.imsave(img_filename, output_img) #------------------------------------------------------------------- # get upper-bound points #------------------------------------------------------------------- upper_bound_points = np.empty_like(orgin_data.shape) upper_bound_points = orgin_data.copy() current_data[start_idx, :, :] = orgin_data.copy() search_step = 0.02 stand_feature = np.empty_like(global_feature_list[-1].shape) max_position = [-1, -1, -1] min_position = [1, 1, 1] for point_index in range(NUM_POINT): max_position = np.maximum( max_position, current_data[start_idx, point_index, :]) min_position = np.minimum( min_position, current_data[start_idx, point_index, :]) print(max_position) print(min_position) 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 } global_feature_val = sess.run(ops['global_feature'], feed_dict=feed_dict) stand_feature = global_feature_val.copy() change_point = 0 current_data[start_idx, :, :] = orgin_data.copy() for point_index in range(NUM_POINT): if not (point_index in feature_points[0]): change_point = point_index break for x in np.linspace( min_position[0], max_position[0], (max_position[0] - min_position[0]) // search_step + 1): for y in np.linspace( min_position[1], max_position[1], (max_position[1] - min_position[1]) // search_step + 1): for z in np.linspace( min_position[2], max_position[2], (max_position[2] - min_position[2]) // search_step + 1): current_data[start_idx, change_point, :] = (x, y, z ) #+ orgin_position # Aggregating BEG 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 } global_feature_val = sess.run( ops['global_feature'], feed_dict=feed_dict) if (global_feature_val <= stand_feature).all(): upper_bound_points = np.append( upper_bound_points, np.array([[x, y, z]]), axis=0) print(x) img_filename = './test/%d_upper_bound_points.jpg' % (start_idx) output_img = pc_util.point_cloud_three_views( np.squeeze(upper_bound_points)) scipy.misc.imsave(img_filename, output_img) current_data[start_idx, :, :] = orgin_data.copy()
for fn in range(len(TEST_FILES)): print('----' + str(fn) + '----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:, 0:NUM_POINT, :] current_label = np.squeeze(current_label) file_size = current_data.shape[0] for file_idx in range(0, file_size, BATCH_SIZE): if file_idx + BATCH_SIZE > file_size: break data = current_data[file_idx:file_idx + BATCH_SIZE, :, :] for idx in range(BATCH_SIZE): img_filename = f"images/test_{count}_idx_{idx}_front.jpg" output_img = pc_util.point_cloud_three_views(np.squeeze(data[idx])) skimage.io.imsave(img_filename, output_img) if ROTATE_POINT_CLOUD: for k in range(6): rotated_data = provider.rotate_point_by_label( data, [k] * BATCH_SIZE) for idx in range(BATCH_SIZE): img_filename = f"images/test_{count}_idx_{idx}_rot_{k}.jpg" output_img = pc_util.point_cloud_three_views( np.squeeze(rotated_data[idx])) skimage.io.imsave(img_filename, output_img) if ROTATE_TENSOR: w = tf.constant(data) for k in range(6):
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') total_correct_seg = 0 # 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) current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5(TEST_DATA, TEST_LABELS, TEST_MASKS, NUM_POINT, shuffle=False) current_label = np.squeeze(current_label) current_mask = np.squeeze(current_mask) 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_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) feed_dict = {ops['pointclouds_pl']: rotated_data, ops['masks_pl']: current_mask[start_idx:end_idx], ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training} loss_val, pred_val, seg_val = sess.run([ops['loss'], ops['pred'],ops['seg_pred']], feed_dict=feed_dict) 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 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 == 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) current_pred.append(pred_val[i-start_idx]) 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 (FLAGS.visu_mask and pred_val[i-start_idx] == l): fname = str(start_idx)+'_gt' fname = os.path.join(DUMP_DIR, fname) save_binfiles(current_data[start_idx,:,:], gt_mask,fname) fname = str(start_idx)+'_pred' fname = os.path.join(DUMP_DIR, fname) save_binfiles(current_data[start_idx,:,:], pred_mask,fname) fname = str(start_idx)+'_pred.obj' fname = os.path.join(DUMP_DIR, fname) output_color_point_cloud(current_data[start_idx,:,:], pred_mask,fname) fname = str(start_idx)+'_gt.obj' fname = os.path.join(DUMP_DIR, fname) output_color_point_cloud(current_data[start_idx,:,:], gt_mask,fname) ###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]]) # 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)))) 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]))
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') for fn in range(len(TEST_FILES)): log_string('----'+str(fn)+'----') current_data, current_label = provider.loadDataFile(TEST_FILES[fn]) current_data = current_data[:,0:NUM_POINT,:] current_label = np.squeeze(current_label) print(current_data.shape) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE print(file_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['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 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('%d, %d\n' % (pred_val[i-start_idx], 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) error_cnt += 1 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]))