def load_and_enqueue(sess, enqueue_op, pointgrid_ph, cat_label_ph, seg_label_ph): for epoch in range(1000 * TRAINING_EPOCHES): train_file_idx = np.arange(0, len(TRAINING_FILE_LIST)) np.random.shuffle(train_file_idx) for loop in range(0, len(TRAINING_FILE_LIST)): # mat_content = scipy.io.loadmat('../data/ShapeNet/train/' + TRAINING_FILE_LIST[train_file_idx[loop]] + '.mat') # pc = mat_content['points'] # labels = np.squeeze(mat_content['labels']) # category = mat_content['category'][0][0] cur_train_filename = os.path.join( hdf5_data_dir, TRAINING_FILE_LIST[train_file_idx[loop]]) print('Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data( cur_data, np.squeeze(cur_labels)) cur_seg = cur_seg[order, ...] for pc_idx in range(0, len(cur_data)): pc = cur_data[pc_idx] category = cur_labels[pc_idx] labels = cur_seg[pc_idx] pc = model.rotate_pc(pc) cat_label = model.integer_label_to_one_hot_label(category) seg_label = model.integer_label_to_one_hot_label(labels) pointgrid, pointgrid_label, _ = model.pc2voxel(pc, seg_label) sess.run(enqueue_op, feed_dict={ pointgrid_ph: pointgrid, cat_label_ph: cat_label, seg_label_ph: pointgrid_label })
def find_all_needto_aug(): ''' 提取出源文件中符合条件的数据 ''' #初始化一个跟数据格式一样的数据原本 object_data = np.zeros((1, 2048, 3)) object_labels = np.zeros((1), np.int32) object_seg = np.zeros((1, 2048), np.int32) count = 0 #统计所有数据个数 #提取出所有符合标签的数据 for i in range(num_train_file): print('load the num ' + str(i) + ' train file') cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) for nlabel in range(cur_data.shape[0]): if cur_labels[nlabel] == 10 or cur_labels[nlabel] == 13: count += 1 object_data = np.vstack( (object_data, cur_data[nlabel, :, :].reshape(1, 2048, 3))) object_labels = np.vstack((object_labels, cur_labels[nlabel])) object_seg = np.vstack((object_seg, cur_seg[nlabel, :])) #上述object_data、object_lables、object_seg即包含了所有符合条件的数据 idx = np.random.randint(count, size=1) #随机将第一个初始化的数据赋成数据中的一个 object_data[0, :, :] = cur_data[idx, :, :] #将数据第一个0项初始化为任意一项 object_labels[0] = cur_labels[idx] object_seg[0, :] = cur_seg[idx, :] return object_data, object_labels, object_seg
def object_aug(object_data, object_labels, object_seg): object_data1 = provider.jitter_point_cloud(object_data, sigma=0.001, clip=0.005) #给数据加噪一次 object_data2 = provider.jitter_point_cloud(object_data, sigma=0.001, clip=0.005) #给数据加噪两次 object_data = np.vstack((object_data1, object_data2)) object_labels = np.vstack((object_labels, object_labels)) object_seg = np.vstack((object_seg, object_seg)) #合并所有数据 for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) object_data = np.vstack((object_data, cur_data)) object_labels = np.vstack((object_labels, cur_labels)) object_seg = np.vstack((object_seg, cur_seg)) object_data, object_labels, object_seg = provider.shuffle_data_with_seg( object_data, object_labels, object_seg) #将数据分成几个文件 n_object = object_data.shape[0] num_every_file = n_object // 8 for i in range(8): f = h5py.File(hdf5_data_dir + '/object_aug' + str(i) + '.h5', 'w') f['data'] = object_data[i * (num_every_file):(i + 1) * num_every_file, :, :] f['label'] = object_labels[i * (num_every_file):(i + 1) * num_every_file] f['pid'] = object_seg[i * (num_every_file):(i + 1) * num_every_file, :] f.close()
def object_aug(object_data, object_labels, object_seg): #合并所有数据 #渲染一个数据观察 render_file = os.path.join(BASE_DIR, 'render_aug_part.obj') output_point_cloud(object_data[3, :, :], render_file) for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) object_data = np.vstack((object_data, cur_data)) object_labels = np.vstack((object_labels, cur_labels)) object_seg = np.vstack((object_seg, cur_seg)) object_data, object_labels, object_seg = provider.shuffle_data_with_seg( object_data, object_labels, object_seg) #将数据分成几个文件 n_object = object_data.shape[0] num_every_file = n_object // 8 for i in range(8): f = h5py.File(hdf5_data_dir + '/object_part_aug' + str(i) + '.h5', 'w') f['data'] = object_data[i * (num_every_file):(i + 1) * num_every_file, :, :] f['label'] = object_labels[i * (num_every_file):(i + 1) * num_every_file] f['pid'] = object_seg[i * (num_every_file):(i + 1) * num_every_file, :] f.close()
def find_all_needto_aug_part(): ''' 提取出源文件中符合条件的数据 ''' #初始化一个跟数据格式一样的数据原本 object_data = np.zeros((1, 2048, 3)) object_labels = np.zeros((1), np.int32) object_seg = np.zeros((1, 2048), np.int32) #提取出所有符合标签的数据 sigma = 0.001 clip = 0.005 for i in range(num_train_file): print('load the num ' + str(i) + ' train file') cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) for nlabel in range(cur_data.shape[0]): jittered_data = np.clip( sigma * np.random.randn(cur_data.shape[0], cur_data.shape[1], cur_data.shape[2]), -clip, clip) for npoint in range(cur_data.shape[1]): #寻找满足条件的点云 if cur_seg[nlabel][npoint]!=4 or cur_seg[nlabel][npoint]!=8 or cur_seg[nlabel][npoint]!=27 or cur_seg[nlabel][npoint]!=30 or \ cur_seg[nlabel][npoint]!=31 or cur_seg[nlabel][npoint]!=34 or cur_seg[nlabel][npoint]!=40 or cur_seg[nlabel][npoint]!=42 or \ cur_seg[nlabel][npoint]!=46 or cur_seg[nlabel][npoint]!=49: jittered_data[nlabel][npoint][:] = 0 cur_data = cur_data + jittered_data object_data = np.vstack((object_data, cur_data)) object_labels = np.vstack((object_labels, cur_labels)) object_seg = np.vstack((object_seg, cur_seg)) print('train_file ' + str(i) + ' success') #上述object_data、object_lables、object_seg即包含了所有符合条件的数据 num = object_data.shape[0] idx = np.random.randint(1, num, size=1) #随机将第一个初始化的数据赋成数据中的一个 object_data[0, :, :] = object_data[idx, :, :] #数据第一个0项初始化为任意一项 object_labels[0] = object_labels[idx] object_seg[0, :] = object_seg[idx, :] return object_data, object_labels, object_seg
def eval_one_epoch(epoch_num): is_training = False total_loss = 0.0 total_seg_loss = 0.0 total_seg_acc = 0.0 total_seen = 0 test_filename = os.path.join(hdf5_data_dir, "data_testing.h5") printout(flog, 'Loading test file ' + test_filename) cur_data, cur_seg = provider.loadDataFile_with_seg(test_filename) num_data = len(cur_data) num_batch = num_data // batch_size for i in range(num_batch): begidx = i * batch_size endidx = (i + 1) * batch_size feed_dict = { pointclouds_ph: cur_data[begidx:endidx, ...], seg_ph: cur_seg[begidx:endidx, ...], is_training_ph: is_training, } loss_val, seg_loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([loss, seg_loss, per_instance_seg_loss, seg_pred, \ per_instance_seg_pred_res], feed_dict=feed_dict) ''' seg_pred_res = sess.run([seg_pred], feed_dict={ pointclouds_ph: cur_data[begidx: endidx, ...], is_training_ph: is_training, }) seg_pred_res = np.array(seg_pred_res)[0, ...][0, ...] seg_pred_val = np.argmax(seg_pred_res, axis=1)[:batch_size*point_num] print seg_pred_val ''' per_instance_part_acc = np.mean( pred_seg_res == cur_seg[begidx:endidx, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_seen += 1 total_loss += loss_val total_seg_loss += seg_loss_val total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / total_seen total_seg_loss = total_seg_loss * 1.0 / total_seen total_seg_acc = total_seg_acc * 1.0 / total_seen test_loss_sum, test_seg_loss_sum, test_seg_acc_sum \ = sess.run([total_test_loss_sum_op, seg_test_loss_sum_op, seg_test_acc_sum_op], \ feed_dict={total_testing_loss_ph: total_loss, seg_testing_loss_ph: total_seg_loss, seg_testing_acc_ph: total_seg_acc}) test_writer.add_summary(test_loss_sum, epoch_num + 1) test_writer.add_summary(test_seg_loss_sum, epoch_num + 1) test_writer.add_summary(test_seg_acc_sum, epoch_num + 1) printout(flog, '\tTesting Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTesting Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTesting Seg Accuracy: %f' % total_seg_acc)
def train_one_epoch(epoch_num): is_training = True train_filename = os.path.join(hdf5_data_dir, "data_training.h5") printout(flog, 'Loading train file ' + train_filename) cur_data, cur_seg = provider.loadDataFile_with_seg(train_filename) num_data = len(cur_data) num_batch = num_data // batch_size total_loss = 0.0 total_seg_loss = 0.0 total_seg_acc = 0.0 for i in range(num_batch): begidx = i * batch_size endidx = (i + 1) * batch_size feed_dict = { pointclouds_ph: cur_data[begidx:endidx, ...], seg_ph: cur_seg[begidx:endidx, ...], is_training_ph: is_training, } _, loss_val, seg_loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([train_op, loss, seg_loss, per_instance_seg_loss, seg_pred, \ per_instance_seg_pred_res], feed_dict=feed_dict) ''' seg_pred_res = sess.run([seg_pred], feed_dict={ pointclouds_ph: cur_data[begidx: endidx, ...], is_training_ph: is_training, }) seg_pred_res = np.array(seg_pred_res)[0, ...][0, ...] seg_pred_val = np.argmax(seg_pred_res, axis=1)[:batch_size*point_num] print seg_pred_val ''' per_instance_part_acc = np.mean( pred_seg_res == cur_seg[begidx:endidx, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_loss += loss_val total_seg_loss += seg_loss_val total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / num_batch total_seg_loss = total_seg_loss * 1.0 / num_batch total_seg_acc = total_seg_acc * 1.0 / num_batch lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_seg_loss_sum, train_seg_acc_sum \ = sess.run([lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, \ seg_train_loss_sum_op, seg_train_acc_sum_op], feed_dict={total_training_loss_ph: total_loss, \ seg_training_loss_ph: total_seg_loss, seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, epoch_num) train_writer.add_summary(train_seg_loss_sum, epoch_num) train_writer.add_summary(lr_sum, epoch_num) train_writer.add_summary(bn_decay_sum, epoch_num) train_writer.add_summary(train_seg_acc_sum, epoch_num) train_writer.add_summary(batch_sum, epoch_num) printout(flog, '\tTraining Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTraining Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTraining Seg Accuracy: %f' % total_seg_acc) training_loss_value.append(total_loss)
def eval_one_epoch(epoch_num): is_training = False total_loss = 0.0 total_label_loss = 0.0 total_seg_loss = 0.0 total_label_acc = 0.0 total_seg_acc = 0.0 total_seen = 0 total_label_acc_per_cat = np.zeros( (NUM_CATEGORIES)).astype(np.float32) total_seg_acc_per_cat = np.zeros( (NUM_CATEGORIES)).astype(np.float32) total_seen_per_cat = np.zeros((NUM_CATEGORIES)).astype(np.int32) for i in range(num_test_file): cur_test_filename = os.path.join(hdf5_data_dir, test_file_list[i]) printout(flog, 'Loading test file ' + cur_test_filename) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_test_filename) cur_labels = np.squeeze(cur_labels) cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // batch_size for j in range(num_batch): begidx = j * batch_size endidx = (j + 1) * batch_size feed_dict = { pointclouds_ph: cur_data[begidx:endidx, ...], labels_ph: cur_labels[begidx:endidx, ...], input_label_ph: cur_labels_one_hot[begidx:endidx, ...], seg_ph: cur_seg[begidx:endidx, ...], is_training_ph: is_training, } loss_val, label_loss_val, seg_loss_val, per_instance_label_loss_val, \ per_instance_seg_loss_val, label_pred_val, seg_pred_val, pred_seg_res \ = sess.run([loss, label_loss, seg_loss, per_instance_label_loss, \ per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict) per_instance_part_acc = np.mean( pred_seg_res == cur_seg[begidx:endidx, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_seen += 1 total_loss += loss_val total_label_loss += label_loss_val total_seg_loss += seg_loss_val per_instance_label_pred = np.argmax(label_pred_val, axis=1) total_label_acc += np.mean( np.float32(per_instance_label_pred == cur_labels[ begidx:endidx, ...])) total_seg_acc += average_part_acc for shape_idx in range(begidx, endidx): total_seen_per_cat[cur_labels[shape_idx]] += 1 total_label_acc_per_cat[ cur_labels[shape_idx]] += np.int32( per_instance_label_pred[shape_idx - begidx] == cur_labels[shape_idx]) total_seg_acc_per_cat[ cur_labels[shape_idx]] += per_instance_part_acc[ shape_idx - begidx] total_loss = total_loss * 1.0 / total_seen total_label_loss = total_label_loss * 1.0 / total_seen total_seg_loss = total_seg_loss * 1.0 / total_seen total_label_acc = total_label_acc * 1.0 / total_seen total_seg_acc = total_seg_acc * 1.0 / total_seen test_loss_sum, test_label_acc_sum, test_label_loss_sum, test_seg_loss_sum, test_seg_acc_sum = sess.run( [ total_test_loss_sum_op, label_test_acc_sum_op, label_test_loss_sum_op, seg_test_loss_sum_op, seg_test_acc_sum_op ], feed_dict={ total_testing_loss_ph: total_loss, label_testing_loss_ph: total_label_loss, seg_testing_loss_ph: total_seg_loss, label_testing_acc_ph: total_label_acc, seg_testing_acc_ph: total_seg_acc }) test_writer.add_summary(test_loss_sum, (epoch_num + 1) * num_train_file - 1) test_writer.add_summary(test_label_loss_sum, (epoch_num + 1) * num_train_file - 1) test_writer.add_summary(test_seg_loss_sum, (epoch_num + 1) * num_train_file - 1) test_writer.add_summary(test_label_acc_sum, (epoch_num + 1) * num_train_file - 1) test_writer.add_summary(test_seg_acc_sum, (epoch_num + 1) * num_train_file - 1) printout(flog, '\tTesting Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTesting Label Mean_loss: %f' % total_label_loss) printout(flog, '\t\tTesting Label Accuracy: %f' % total_label_acc) printout(flog, '\t\tTesting Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTesting Seg Accuracy: %f' % total_seg_acc) for cat_idx in range(NUM_CATEGORIES): if total_seen_per_cat[cat_idx] > 0: printout( flog, '\n\t\tCategory %s Object Number: %d' % (all_obj_cats[cat_idx][0], total_seen_per_cat[cat_idx])) printout( flog, '\t\tCategory %s Label Accuracy: %f' % (all_obj_cats[cat_idx][0], total_label_acc_per_cat[cat_idx] / total_seen_per_cat[cat_idx])) printout( flog, '\t\tCategory %s Seg Accuracy: %f' % (all_obj_cats[cat_idx][0], total_seg_acc_per_cat[cat_idx] / total_seen_per_cat[cat_idx]))
def train_one_epoch(train_file_idx, epoch_num): is_training = True for i in range(num_train_file): cur_train_filename = os.path.join( hdf5_data_dir, train_file_list[train_file_idx[i]]) printout(flog, 'Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data( cur_data, np.squeeze(cur_labels)) cur_seg = cur_seg[order, ...] cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // batch_size total_loss = 0.0 total_label_loss = 0.0 total_seg_loss = 0.0 total_label_acc = 0.0 total_seg_acc = 0.0 for j in range(num_batch): begidx = j * batch_size endidx = (j + 1) * batch_size feed_dict = { pointclouds_ph: cur_data[begidx:endidx, ...], labels_ph: cur_labels[begidx:endidx, ...], input_label_ph: cur_labels_one_hot[begidx:endidx, ...], seg_ph: cur_seg[begidx:endidx, ...], is_training_ph: is_training, } _, loss_val, label_loss_val, seg_loss_val, per_instance_label_loss_val, \ per_instance_seg_loss_val, label_pred_val, seg_pred_val, pred_seg_res \ = sess.run([train_op, loss, label_loss, seg_loss, per_instance_label_loss, per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res], feed_dict=feed_dict) per_instance_part_acc = np.mean( pred_seg_res == cur_seg[begidx:endidx, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_loss += loss_val total_label_loss += label_loss_val total_seg_loss += seg_loss_val per_instance_label_pred = np.argmax(label_pred_val, axis=1) total_label_acc += np.mean( np.float32(per_instance_label_pred == cur_labels[ begidx:endidx, ...])) total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / num_batch total_label_loss = total_label_loss * 1.0 / num_batch total_seg_loss = total_seg_loss * 1.0 / num_batch total_label_acc = total_label_acc * 1.0 / num_batch total_seg_acc = total_seg_acc * 1.0 / num_batch lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_label_acc_sum, \ train_label_loss_sum, train_seg_loss_sum, train_seg_acc_sum = sess.run( [lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, label_train_acc_sum_op, label_train_loss_sum_op, seg_train_loss_sum_op, seg_train_acc_sum_op], feed_dict={total_training_loss_ph: total_loss, label_training_loss_ph: total_label_loss, seg_training_loss_ph: total_seg_loss, label_training_acc_ph: total_label_acc, seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(lr_sum, i + epoch_num * num_train_file) train_writer.add_summary(bn_decay_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(batch_sum, i + epoch_num * num_train_file) printout(flog, '\tTraining Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTraining Label Mean_loss: %f' % total_label_loss) printout(flog, '\t\tTraining Label Accuracy: %f' % total_label_acc) printout(flog, '\t\tTraining Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTraining Seg Accuracy: %f' % total_seg_acc)
os.mkdir(STATISTIC_FOLDER) #--------------输出数据并且保存-------------------------- def printout(flog, data): print(data) flog.write(data + '\n') #-----------------------定义数据的统计量--------------------------- total_part_statistic = np.zeros((NUM_PART_CATS)).astype(np.int32) count_part = 0 for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) #读取一个文件 num_object = cur_seg.shape[0] #当前文件包含的物体数目 print num_object for object_idx in range(num_object): seg_de_repeat = set(cur_seg[object_idx]) #去除当前列表的重复项 count_part = count_part + len(seg_de_repeat) #统计所有物体的所有part的个数 for item in seg_de_repeat: total_part_statistic[item] += 1 #单独对part计数 #-------------------------结果展示-------------------------------------------- flog = open(os.path.join(STATISTIC_FOLDER, 'part_statistic.txt'), 'w') PART2OBJECT_NAME = [] for i in range(NUM_PART_CATS): printout( flog, 'num %d percents:%f' % (i, total_part_statistic[i] * 100.0 / count_part))
def parepare_dataset(sess, NUM_REPEATS, file_name): data_files =provider.getDataFiles( \ os.path.join(hdf5_data_dir, sess+'_hdf5_file_list.txt')) data_file_size = 0 for fn in range(len(data_files)): cur_train_filename = os.path.join(hdf5_data_dir, data_files[fn]) current_data, current_label, current_seg = provider.loadDataFile_with_seg( cur_train_filename) file_size = current_data.shape[0] data_file_size += file_size x_set = f.create_dataset("x_" + sess, (data_file_size * NUM_REPEATS, SIZE_SUB * SIZE_TOP, SIZE_SUB * SIZE_TOP, 3), dtype='f') y_set = f.create_dataset("y_" + sess, (data_file_size * NUM_REPEATS, 16), dtype='i') s_set = f.create_dataset("s_" + sess, (data_file_size * NUM_REPEATS, SIZE_SUB * SIZE_TOP, SIZE_SUB * SIZE_TOP, 51), dtype='i') p_set = f.create_dataset("p_" + sess, (data_file_size * NUM_REPEATS, NUM_POINTS, 2), dtype='i') l_set = f.create_dataset("l_" + sess, (data_file_size * NUM_REPEATS, NUM_POINTS), dtype='i') d_set = f.create_dataset("d_" + sess, (data_file_size * NUM_REPEATS, NUM_POINTS, 3), dtype='f') sample_list = np.arange(data_file_size * NUM_REPEATS) if (sess == 'train'): np.random.shuffle(sample_list) idx_sample = 0 node_loss_rate_list = [] time_begin = time.time() for fn in range(len(data_files)): cur_train_filename = os.path.join(hdf5_data_dir, data_files[fn]) file_data, file_label, file_seg = provider.loadDataFile_with_seg( cur_train_filename) current_data = file_data[:, 0:NUM_POINTS, :] current_seg = file_seg[:, 0:NUM_POINTS] for current_sample_data, current_sample_label, current_sample_seg in zip( current_data, file_label, current_seg): for i_repeat in range(NUM_REPEATS): final_data = current_sample_data[np.newaxis, :, :] if (FLAG_ROTATION): final_data = provider.rotate_point_cloud(final_data) if (FLAG_JITTER): final_data = provider.jitter_point_cloud(final_data) mat, seg, pos, node_loss_rate = GPGL2_seg( final_data[0], current_sample_seg) x_set[sample_list[idx_sample]] = mat y_set[sample_list[idx_sample], current_sample_label] = 1 s_set[sample_list[idx_sample]] = seg p_set[sample_list[idx_sample]] = pos l_set[sample_list[idx_sample]] = current_sample_seg d_set[sample_list[idx_sample]] = current_sample_data print( file_name + ":" + sess + ": idx=" + str(idx_sample) + "/" + str(x_set.shape[0]), "node_loss_rate=" + str(node_loss_rate)) idx_sample += 1 node_loss_rate_list.append(node_loss_rate) time_end = time.time() node_loss_rate_final = np.array(node_loss_rate_list).mean() x_set.attrs['NUM_REPEATS'] = NUM_REPEATS x_set.attrs['node loss ratio'] = node_loss_rate_final return idx_sample, node_loss_rate_final, time_end - time_begin
def train_one_epoch(train_file_idx, epoch_num): is_training = True for i in range(num_train_file): #cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[train_file_idx[i]]) cur_train_filename = os.path.join(point_cloud_file_path_, training_data_file_name) printout(flog, 'Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data( cur_data, np.squeeze(cur_labels, axis=0)) cur_seg = cur_seg[order, ...] cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // batch_size total_loss = 0.0 total_label_loss = 0.0 total_seg_loss = 0.0 total_label_acc = 0.0 total_seg_acc = 0.0 for j in range(num_batch): begidx = j * batch_size endidx = (j + 1) * batch_size calc_pairwise_distance = calculatePairWiseDistanceEnergies( cur_data[begidx:endidx, ...]) feed_dict = { pointclouds_ph: cur_data[begidx:endidx, ...], labels_ph: cur_labels[begidx:endidx, ...], input_label_ph: cur_labels_one_hot[begidx:endidx, ...], seg_ph: cur_seg[begidx:endidx, ...], is_training_ph: is_training, pairwise_distances_ph: calc_pairwise_distance } _, loss_val, label_loss_val, seg_loss_val, per_instance_label_loss_val, \ per_instance_seg_loss_val, label_pred_val, seg_pred_val, pred_seg_res, feature_output_val\ = sess.run([train_op, loss, label_loss, seg_loss, per_instance_label_loss, \ per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res, feature_output], \ feed_dict=feed_dict) if epoch_num == TRAINING_EPOCHES - 1: text_file = open(point_cloud_file_path, "r") input = text_file.read().split('\n') l = [] for i in range(len(input)): x = list(input[i].split()) l.append(x) l = l[:-1] points = np.array(l, dtype=np.float) point_data = points[:, 0:3] seg_pred_output = np.argmax(np.squeeze(seg_pred_val), axis=-1) colors = [ label_color_dict[x + 1] for x in seg_pred_output ] output = np.column_stack( (np.squeeze(point_data), colors)) np.savetxt(labelled_cloud_file_name, output) # There is a bug here and I fully don't understand why it is crashing here per_instance_part_acc = np.mean( pred_seg_res == cur_seg[begidx:endidx, ...]) average_part_acc = np.mean(per_instance_part_acc) total_loss += loss_val total_label_loss += label_loss_val total_seg_loss += seg_loss_val per_instance_label_pred = np.argmax(label_pred_val, axis=1) total_label_acc += np.mean( np.float32(per_instance_label_pred == cur_labels[ begidx:endidx, ...])) total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / num_batch total_label_loss = total_label_loss * 1.0 / num_batch total_seg_loss = total_seg_loss * 1.0 / num_batch total_label_acc = total_label_acc * 1.0 / num_batch total_seg_acc = total_seg_acc * 1.0 / num_batch lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_label_acc_sum, \ train_label_loss_sum, train_seg_loss_sum, train_seg_acc_sum = sess.run(\ [lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, label_train_acc_sum_op, \ label_train_loss_sum_op, seg_train_loss_sum_op, seg_train_acc_sum_op], \ feed_dict={total_training_loss_ph: total_loss, label_training_loss_ph: total_label_loss, \ seg_training_loss_ph: total_seg_loss, label_training_acc_ph: total_label_acc, \ seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(lr_sum, i + epoch_num * num_train_file) train_writer.add_summary(bn_decay_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(batch_sum, i + epoch_num * num_train_file) printout(flog, '\tTraining Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTraining Label Mean_loss: %f' % total_label_loss) printout(flog, '\t\tTraining Label Accuracy: %f' % total_label_acc) printout(flog, '\t\tTraining Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTraining Seg Accuracy: %f' % total_seg_acc)
def train_one_epoch(train_file_idx, epoch_num): is_training = True for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[train_file_idx[i]]) printout(flog, 'Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg(cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data(cur_data, np.squeeze(cur_labels)) cur_seg = cur_seg[order, ...] # cur_labels_one_hot = convert_label_to_one_hot(cur_labels) ###Mix up### mixed_cur_data, cur_labels_a, cur_labels_b, cur_seg_a, cur_seg_b, lam= mixup_data(cur_data, cur_labels, cur_seg, 0.4) cur_labels_a_onehot = convert_label_to_one_hot(cur_labels_a) cur_labels_b_onehot = convert_label_to_one_hot(cur_labels_b) mixed_cur_labels_onehot = lam * cur_labels_a_onehot + (1 - lam) * cur_labels_b_onehot num_data = len(cur_labels) num_batch = num_data // batch_size total_loss = 0.0 total_label_loss = 0.0 total_seg_loss = 0.0 total_label_acc = 0.0 total_seg_acc = 0.0 for j in range(num_batch): begidx = j * batch_size endidx = (j + 1) * batch_size # feed_dict = { # pointclouds_ph: cur_data[begidx: endidx, ...], # labels_ph: cur_labels[begidx: endidx, ...], # input_label_ph: cur_labels_one_hot[begidx: endidx, ...], # seg_ph: cur_seg[begidx: endidx, ...], # is_training_ph: is_training, # } feed_dict_a = { pointclouds_ph: mixed_cur_data[begidx: endidx, ...], labels_ph: cur_labels_a[begidx: endidx, ...], input_label_ph: mixed_cur_labels_onehot[begidx: endidx, ...], seg_ph: cur_seg_a[begidx: endidx, ...], is_training_ph: is_training, } feed_dict_b = { pointclouds_ph: mixed_cur_data[begidx: endidx, ...], labels_ph: cur_labels_b[begidx: endidx, ...], input_label_ph: mixed_cur_labels_onehot[begidx: endidx, ...], seg_ph: cur_seg_b[begidx: endidx, ...], is_training_ph: is_training, } # _, loss_val, label_loss_val, seg_loss_val, per_instance_label_loss_val, \ # per_instance_seg_loss_val, label_pred_val, seg_pred_val, pred_seg_res \ # = sess.run([train_op, loss, label_loss, seg_loss, per_instance_label_loss, \ # per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res], \ # feed_dict=feed_dict) _, loss_val_a, label_loss_val_a, seg_loss_val_a, per_instance_label_loss_val_a, \ per_instance_seg_loss_val_a, label_pred_val_a, seg_pred_val_a, pred_seg_res_a \ = sess.run([train_op, loss, label_loss, seg_loss, per_instance_label_loss, \ per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict_a) _, loss_val_b, label_loss_val_b, seg_loss_val_b, per_instance_label_loss_val_b, \ per_instance_seg_loss_val_b, label_pred_val_b, seg_pred_val_b, pred_seg_res_b \ = sess.run([train_op, loss, label_loss, seg_loss, per_instance_label_loss, \ per_instance_seg_loss, labels_pred, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict_b) loss_val = lam * loss_val_a + (1-lam)*loss_val_b label_loss_val = lam * label_loss_val_a + (1-lam) * label_loss_val_b seg_loss_val = lam * seg_loss_val_a + (1-lam) * seg_loss_val_b per_instance_part_acc_a = np.mean(pred_seg_res_a == cur_seg[begidx: endidx, ...], axis=1) per_instance_part_acc_b = np.mean(pred_seg_res_b == cur_seg[begidx: endidx, ...], axis=1) per_instance_part_acc = lam * per_instance_part_acc_a + (1-lam) * per_instance_part_acc_b average_part_acc = np.mean(per_instance_part_acc) total_loss += loss_val total_label_loss += label_loss_val total_seg_loss += seg_loss_val per_instance_label_pred_a = np.argmax(label_pred_val_a, axis=1) per_instance_label_pred_b = np.argmax(label_pred_val_b, axis=1) label_acc_a = np.mean(np.float32(per_instance_label_pred_a == cur_labels_a[begidx: endidx, ...])) label_acc_b = np.mean(np.float32(per_instance_label_pred_b == cur_labels_b[begidx: endidx, ...])) label_acc = lam*label_acc_a + (1-lam)*label_acc_b total_label_acc += label_acc total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / num_batch total_label_loss = total_label_loss * 1.0 / num_batch total_seg_loss = total_seg_loss * 1.0 / num_batch total_label_acc = total_label_acc * 1.0 / num_batch total_seg_acc = total_seg_acc * 1.0 / num_batch lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_label_acc_sum, \ train_label_loss_sum, train_seg_loss_sum, train_seg_acc_sum = sess.run(\ [lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, label_train_acc_sum_op, \ label_train_loss_sum_op, seg_train_loss_sum_op, seg_train_acc_sum_op], \ feed_dict={total_training_loss_ph: total_loss, label_training_loss_ph: total_label_loss, \ seg_training_loss_ph: total_seg_loss, label_training_acc_ph: total_label_acc, \ seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(lr_sum, i + epoch_num * num_train_file) train_writer.add_summary(bn_decay_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_label_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(batch_sum, i + epoch_num * num_train_file) printout(flog, '\tTraining Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTraining Label Mean_loss: %f' % total_label_loss) printout(flog, '\t\tTraining Label Accuracy: %f' % total_label_acc) printout(flog, '\t\tTraining Seg Mean_loss: %f' % total_seg_loss) printout(flog, '\t\tTraining Seg Accuracy: %f' % total_seg_acc)