is_training, bn_decay, end_points)
stage1_center = center_delta + mask_xyz_mean # Bx3
end_points['stage1_center'] = stage1_center
# Get object point cloud in object coordinate
object_point_cloud_xyz_new = \
object_point_cloud_xyz - tf.expand_dims(center_delta, 1)
# Amodel Box Estimation PointNet
output, end_points = get_3d_box_estimation_v1_net(\
object_point_cloud_xyz_new, one_hot_vec,
is_training, bn_decay, end_points)
# Parse output to 3D box parameters
end_points = parse_output_to_tensors(output, end_points)
end_points['center'] = end_points['center_boxnet'] + stage1_center # Bx3
return end_points
if __name__ == '__main__':
with tf.Graph().as_default():
inputs = tf.zeros((32, 1024, 4))
outputs = get_model(inputs, tf.ones((32, 3)), tf.constant(True))
for key in outputs:
print((key, outputs[key]))
loss = get_loss(tf.zeros((32, 1024), dtype=tf.int32),
tf.zeros((32, 3)), tf.zeros((32, ), dtype=tf.int32),
tf.zeros((32, )), tf.zeros((32, ), dtype=tf.int32),
tf.zeros((32, 3)), outputs)
print(loss)
''' Loss functions for 3D object detection.
Input:
mask_label: int32 tensor in shape (B,N)
center_label: tensor in shape (B,3)
heading_class_label: int32 tensor in shape (B,)
heading_residual_label: tensor in shape (B,)
size_class_label: tensor int32 in shape (B,)
size_residual_label: tensor tensor in shape (B,)
end_points: dict, outputs from our model
corner_loss_weight: float scalar
box_loss_weight: float scalar
Output:
total_loss: scalar tensor
the total_loss is also added to the losses collection
'''
mask_label = torch.randint(0, 2, (batch_size, N))
center_label = torch.rand((batch_size, 3))
heading_class_label = torch.randint(0, NUM_HEADING_BIN, (batch_size, ))
heading_residual_label = torch.rand((batch_size, ))
size_class_label = torch.randint(0, NUM_SIZE_CLUSTER, (batch_size, ))
size_residual_label = torch.rand((batch_size, 3))
corner_loss_weight = 0.5
box_loss_weight = 0.5
for value in end_points.values():
print(value.dtype)
total_loss = get_loss(mask_label, center_label, heading_class_label,
heading_residual_label, size_class_label,
size_residual_label, end_points, corner_loss_weight,
box_loss_weight)
print(total_loss)
# loss = get_loss(tf.random.uniform((25,1024),minval=0,maxval=2, dtype=tf.int32),
# tf.random.uniform((25,3),minval=0,maxval=2,), tf.random.uniform((25,),minval=0,maxval=2,dtype=tf.int32),
# tf.random.uniform((25,),minval=0,maxval=2,), tf.random.uniform((25,),minval=0,maxval=2,dtype=tf.int32),
# tf.random.uniform((25,3),minval=0,maxval=2,), outputs)
# print(loss)
if __name__ == '__main__':
with tf.Graph().as_default():
inputs = tf.zeros((25, 1024, 4))
outputs = get_model(inputs, tf.ones((25, 1)), tf.constant(True))
for key in outputs:
print((key, outputs[key]))
loss = get_loss(
tf.random.uniform((25, 1024), minval=0, maxval=2, dtype=tf.int32),
tf.random.uniform(
(25, 3),
minval=0,
maxval=2,
), tf.random.uniform((25, ), minval=0, maxval=2, dtype=tf.int32),
tf.random.uniform(
(25, ),
minval=0,
maxval=2,
), tf.random.uniform((25, ), minval=0, maxval=2, dtype=tf.int32),
tf.random.uniform(
(25, 3),
minval=0,
maxval=2,
), outputs)
print(loss)
object_point_cloud_xyz, one_hot_vec,
is_training, bn_decay, end_points)
stage1_center = center_delta + mask_xyz_mean # Bx3
end_points['stage1_center'] = stage1_center
# Get object point cloud in object coordinate
object_point_cloud_xyz_new = \
object_point_cloud_xyz - tf.expand_dims(center_delta, 1)
# Amodel Box Estimation PointNet
output, end_points = get_3d_box_estimation_v1_net(\
object_point_cloud_xyz_new, one_hot_vec,
is_training, bn_decay, end_points)
# Parse output to 3D box parameters
end_points = parse_output_to_tensors(output, end_points)
end_points['center'] = end_points['center_boxnet'] + stage1_center # Bx3
return end_points
if __name__=='__main__':
with tf.Graph().as_default():
inputs = tf.zeros((32,1024,4))
outputs = get_model(inputs, tf.ones((32,3)), tf.constant(True))
for key in outputs:
print((key, outputs[key]))
loss = get_loss(tf.zeros((32,1024),dtype=tf.int32),
tf.zeros((32,3)), tf.zeros((32,),dtype=tf.int32),
tf.zeros((32,)), tf.zeros((32,),dtype=tf.int32),
tf.zeros((32,3)), outputs)
print(loss)
def eval_one_epoch(fpointnet,device):
'''
@author chonepieceyb
:param fpointnet: 网络对象
:param device: 设备
:return:
'''
# get data
global EPOCH_CNT
log_string(str(datetime.now()))
log_string('---- EPOCH %03d EVALUATION ----' % (EPOCH_CNT))
test_idxs = np.arange(0, len(TEST_DATASET))
num_batches = len(TEST_DATASET) // BATCH_SIZE
# To collect statistics
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)]
iou2ds_sum = 0
iou3ds_sum = 0
iou3d_correct_cnt = 0
fpointnet.eval() # 训练模式
for batch_idx in range(int(num_batches)):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx+1)* BATCH_SIZE
batch_data, batch_label, batch_center, \
batch_hclass, batch_hres, \
batch_sclass, batch_sres, \
batch_rot_angle, batch_one_hot_vec = \
get_batch(TEST_DATASET, test_idxs, start_idx, end_idx,
NUM_POINT, NUM_CHANNEL)
# convert to torch tensor and change data format
batch_data_gpu = torch.from_numpy(batch_data).permute(0,2,1).to(device,dtype=torch.float32) #
batch_label_gpu= torch.from_numpy(batch_label).to(device,dtype=torch.int64)
batch_center_gpu = torch.from_numpy(batch_center).to(device,dtype=torch.float32)
batch_hclass_gpu = torch.from_numpy(batch_hclass).to(device,dtype=torch.int64)
batch_hres_gpu = torch.from_numpy(batch_hres).to(device,dtype=torch.float32)
batch_sclass_gpu = torch.from_numpy(batch_sclass).to(device,dtype=torch.int64)
batch_sres_gpu = torch.from_numpy(batch_sres).to(device,dtype=torch.float32)
batch_one_hot_vec_gpu = torch.from_numpy(batch_one_hot_vec).to(device ,dtype=torch.float32)
# eval
with torch.no_grad():
end_points = fpointnet.forward(batch_data_gpu,batch_one_hot_vec_gpu)
loss, losses = get_loss(batch_label_gpu,batch_center_gpu,batch_hclass_gpu,batch_hres_gpu,batch_sclass_gpu,batch_sres_gpu,end_points)
#get data and transform dataformat from torch style to tensorflow style
loss_val = loss.cpu().data.numpy()
logits_val = end_points['mask_logits'].data.cpu().numpy()
iou2ds,iou3ds,accuracy = compute_summary(end_points,batch_label_gpu,batch_center,batch_hclass,batch_hres,batch_sclass,batch_sres)
preds_val = np.argmax(logits_val, 1)
correct = np.sum(preds_val == batch_label)
total_correct += correct
total_seen += (BATCH_SIZE * NUM_POINT)
loss_sum += loss_val
for l in range(NUM_CLASSES):
total_seen_class[l] += np.sum(batch_label == l)
total_correct_class[l] += (np.sum((preds_val == l) & (batch_label == l)))
iou2ds_sum += np.sum(iou2ds)
iou3ds_sum += np.sum(iou3ds)
iou3d_correct_cnt += np.sum(iou3ds >= 0.7)
for i in range(BATCH_SIZE):
segp = preds_val[i,:]
segl = batch_label[i,:]
part_ious = [0.0 for _ in range(NUM_CLASSES)]
for l in range(NUM_CLASSES):
if (np.sum(segl==l) == 0) and (np.sum(segp==l) == 0):
part_ious[l] = 1.0 # class not present
else:
part_ious[l] = np.sum((segl==l) & (segp==l)) / \
float(np.sum((segl==l) | (segp==l)))
log_string('eval mean loss: %f' % (loss_sum / float(num_batches)))
log_string('eval segmentation accuracy: %f' % \
(total_correct / float(total_seen)))
log_string('eval segmentation avg class acc: %f' % \
(np.mean(np.array(total_correct_class) / \
np.array(total_seen_class, dtype=np.float))))
log_string('eval box IoU (ground/3D): %f / %f' % \
(iou2ds_sum / float(num_batches * BATCH_SIZE), iou3ds_sum / \
float(num_batches * BATCH_SIZE)))
log_string('eval box estimation accuracy (IoU=0.7): %f' % \
(float(iou3d_correct_cnt) / float(num_batches * BATCH_SIZE)))
EPOCH_CNT += 1
def train_one_epoch(fpointnet,device,optimizer):
'''
@author Qiao
:param fpointnet: 网络
:param device: 设备
:return:
'''
global EPOCH_CNT
log_string(str(datetime.now()))
log_string('---- EPOCH %03d TRAINING ----' % (EPOCH_CNT))
# 按照原始数据集大小进行取值
if FLAGS.train_batch_num == None:
train_idxs = np.arange(0, len(TRAIN_DATASET))
np.random.shuffle(train_idxs) #随机
num_batches = len(TRAIN_DATASET)//BATCH_SIZE
else:
num_batches = int(FLAGS.train_batch_num)
num_batches = min(num_batches,len(TRAIN_DATASET)//BATCH_SIZE)
train_idxs = np.arange(0, BATCH_SIZE*num_batches)
np.random.shuffle(train_idxs)
# To collect statistics
total_correct = 0
total_seen = 0
loss_sum = 0
iou2ds_sum = 0
iou3ds_sum = 0
iou3d_correct_cnt = 0
# Training with batches
for batch_idx in range(num_batches):
start_idx = batch_idx * BATCH_SIZE
end_idx = (batch_idx+1) * BATCH_SIZE
batch_data, batch_label, batch_center, \
batch_hclass, batch_hres, \
batch_sclass, batch_sres, \
batch_rot_angle, batch_one_hot_vec = \
get_batch(TRAIN_DATASET, train_idxs, start_idx, end_idx,
NUM_POINT, NUM_CHANNEL)
pointclouds_pl = torch.from_numpy(batch_data)
pointclouds_pl = pointclouds_pl.permute(0, 2, 1)
pointclouds_pl = pointclouds_pl.to(device,dtype=torch.float32)
one_hot_vec_pl = torch.from_numpy(batch_one_hot_vec)
one_hot_vec_pl = one_hot_vec_pl.to(device,dtype=torch.float32)
labels_pl = torch.from_numpy(batch_label).to(device,dtype=torch.int64)
centers_pl = torch.from_numpy(batch_center).to(device,dtype=torch.float32)
heading_class_label_pl = torch.from_numpy(batch_hclass).to(device,dtype=torch.int64)
heading_residual_label_pl = torch.from_numpy(batch_hres).to(device,dtype=torch.float32)
size_class_label_pl = torch.from_numpy(batch_sclass).to(device,dtype=torch.int64)
size_residual_label_pl = torch.from_numpy(batch_sres).to(device,dtype=torch.float32)
fpointnet.train()
end_points = fpointnet.forward(pointclouds_pl, one_hot_vec_pl)
loss, losses = get_loss(labels_pl, centers_pl,\
heading_class_label_pl, heading_residual_label_pl,\
size_class_label_pl, size_residual_label_pl, end_points)
optimizer.zero_grad()
loss.backward()
optimizer.step()
loss_val = loss.cpu().detach().numpy()
logits_val = end_points['mask_logits'].cpu().detach().numpy()
iou2ds,iou3ds,accuracy = compute_summary(end_points,labels_pl ,batch_center,\
batch_hclass,batch_hres,batch_sclass,batch_sres)
preds_val = np.argmax(logits_val, 1)
correct = np.sum(preds_val == batch_label)
total_correct += correct
total_seen += (BATCH_SIZE*NUM_POINT)
loss_sum += loss_val
iou2ds_sum += np.sum(iou2ds)
iou3ds_sum += np.sum(iou3ds)
iou3d_correct_cnt += np.sum(iou3ds>=0.7)
iou2d_t = np.sum(iou2ds)/float(BATCH_SIZE)
iou3d_t = np.sum(iou3ds)/float(BATCH_SIZE)
writer.add_scalar('iou2ds', iou2d_t, global_step=EPOCH_CNT*batch_idx)
writer.add_scalar('iou3ds', iou3d_t, global_step=EPOCH_CNT*batch_idx)
for key,value in losses.items():
writer.add_scalar(key, losses[key].cpu().data.numpy(), global_step=EPOCH_CNT*batch_idx)
# writer.add_scalar('total_loss', loss, global_step=EPOCH_CNT*batch_idx)
for param_group in optimizer.param_groups:
learning_rate = param_group['lr']
writer.add_scalar('learning_rate', learning_rate, global_step=EPOCH_CNT*batch_idx)
writer.add_scalar('segmentation accuracy', accuracy, global_step=EPOCH_CNT*batch_idx)
if (batch_idx+1)%10 == 0:
log_string(' -- %03d / %03d --' % (batch_idx+1, num_batches))
log_string('mean loss: %f' % (loss_sum / 10))
log_string('segmentation accuracy: %f' % \
(total_correct / float(total_seen)))
log_string('box IoU (ground/3D): %f / %f' % \
(iou2ds_sum / float(BATCH_SIZE*10), iou3ds_sum / float(BATCH_SIZE*10)))
log_string('box estimation accuracy (IoU=0.7): %f' % \
(float(iou3d_correct_cnt)/float(BATCH_SIZE*10)))
total_correct = 0
total_seen = 0
loss_sum = 0
iou2ds_sum = 0
iou3ds_sum = 0
iou3d_correct_cnt = 0
