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)
