def onnx_model_predict(config_path=None, model_dir=None):
import onnxruntime
from second.pytorch.models.pointpillars import PillarFeatureNet, PointPillarsScatter
# check the pfe onnx model IR input paramters as follows
# pillar_x = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# pillar_y = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# pillar_z = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# pillar_i = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# num_points_per_pillar = torch.ones([1, 12000], dtype=torch.float32, device="cuda:0")
# x_sub_shaped = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# y_sub_shaped = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# mask = torch.ones([1, 1, 12000, 100], dtype=torch.float32, device="cuda:0")
# check the rpn onnx model IR input paramters as follows
pillar_x = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
pillar_y = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
pillar_z = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
pillar_i = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
num_points_per_pillar = torch.ones([1, 9918],
dtype=torch.float32,
device="cuda:0")
x_sub_shaped = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
y_sub_shaped = torch.ones([1, 1, 9918, 100],
dtype=torch.float32,
device="cuda:0")
mask = torch.ones([1, 1, 9918, 100], dtype=torch.float32, device="cuda:0")
pfe_session = onnxruntime.InferenceSession("pfe.onnx")
# Compute ONNX Runtime output prediction
pfe_inputs = {
pfe_session.get_inputs()[0].name: (pillar_x.data.cpu().numpy()),
pfe_session.get_inputs()[1].name: (pillar_y.data.cpu().numpy()),
pfe_session.get_inputs()[2].name: (pillar_z.data.cpu().numpy()),
pfe_session.get_inputs()[3].name: (pillar_i.data.cpu().numpy()),
pfe_session.get_inputs()[4].name:
(num_points_per_pillar.data.cpu().numpy()),
pfe_session.get_inputs()[5].name: (x_sub_shaped.data.cpu().numpy()),
pfe_session.get_inputs()[6].name: (y_sub_shaped.data.cpu().numpy()),
pfe_session.get_inputs()[7].name: (mask.data.cpu().numpy())
}
pfe_outs = pfe_session.run(None, pfe_inputs)
print(
'-------------------------- PFE ONNX Outputs ----------------------------'
)
print(pfe_outs) # also you could save it to file for comparing
print(
'-------------------------- PFE ONNX Ending ----------------------------'
)
##########################Middle-Features-Extractor#########################
# numpy --> tensor
pfe_outs = np.array(pfe_outs)
voxel_features_tensor = torch.from_numpy(pfe_outs)
voxel_features = voxel_features_tensor.squeeze()
# voxel_features = np.array(pfe_outs).squeeze()
voxel_features = voxel_features.permute(1, 0)
if isinstance(config_path, str):
config = pipeline_pb2.TrainEvalPipelineConfig()
with open(config_path, "r") as f:
proto_str = f.read()
text_format.Merge(proto_str, config)
else:
config = config_path
model_cfg = config.model.second
vfe_num_filters = list(model_cfg.voxel_feature_extractor.num_filters)
voxel_generator = voxel_builder.build(model_cfg.voxel_generator)
grid_size = voxel_generator.grid_size
output_shape = [1] + grid_size[::-1].tolist() + [vfe_num_filters[-1]]
num_input_features = vfe_num_filters[-1]
batch_size = 2
mid_feature_extractor = PointPillarsScatter(output_shape,
num_input_features, batch_size)
device = torch.device("cuda:0")
coors_numpy = np.loadtxt('./onnx_predict_outputs/coors.txt',
dtype=np.int32)
coors = torch.from_numpy(coors_numpy)
coors = coors.to(device).cuda() # CPU Tensor --> GPU Tensor
voxel_features = voxel_features.to(device).cuda()
rpn_input_features = mid_feature_extractor(voxel_features, coors)
#################################RPN-Feature-Extractor########################################
# rpn_input_features = torch.ones([1, 64, 496, 432], dtype=torch.float32, device='cuda:0')
rpn_session = onnxruntime.InferenceSession("rpn.onnx")
# compute RPN ONNX Runtime output prediction
rpn_inputs = {
rpn_session.get_inputs()[0].name:
(rpn_input_features.data.cpu().numpy())
}
rpn_outs = rpn_session.run(None, rpn_inputs)
print('---------------------- RPN ONNX Outputs ----------------------')
print(rpn_outs)
print('---------------------- RPN ONNX Ending ----------------------')
def __init__(self,
output_shape,
num_class=2,
num_input_features=4,
vfe_class_name="VoxelFeatureExtractor",
vfe_num_filters=[32, 128],
with_distance=False,
middle_class_name="MiddleExtractor",
middle_num_filters_d1=[64],
middle_num_filters_d2=[64, 64],
rpn_class_name="RPN",
rpn_layer_nums=[3, 5, 5],
rpn_layer_strides=[2, 2, 2],
rpn_num_filters=[128, 128, 256],
rpn_upsample_strides=[1, 2, 4],
rpn_num_upsample_filters=[256, 256, 256],
use_norm=True,
use_groupnorm=False,
num_groups=32,
use_sparse_rpn=False,
use_direction_classifier=True,
use_sigmoid_score=False,
encode_background_as_zeros=True,
use_rotate_nms=True,
multiclass_nms=False,
nms_score_threshold=0.5,
nms_pre_max_size=1000,
nms_post_max_size=20,
nms_iou_threshold=0.1,
target_assigner=None,
use_bev=False,
lidar_only=False,
cls_loss_weight=1.0,
loc_loss_weight=1.0,
pos_cls_weight=1.0,
neg_cls_weight=1.0,
direction_loss_weight=1.0,
loss_norm_type=LossNormType.NormByNumPositives,
encode_rad_error_by_sin=False,
loc_loss_ftor=None,
cls_loss_ftor=None,
voxel_size=(0.2, 0.2, 4),
pc_range=(0, -40, -3, 70.4, 40, 1),
name='voxelnet',
K=100,
hm_weight=1,
dim_weight=1,
rot_weight=1,
off_weight=1,
centernet_layers=50):
super().__init__()
self.name = name
self._num_class = num_class
self._use_rotate_nms = use_rotate_nms
self._multiclass_nms = multiclass_nms
self._nms_score_threshold = nms_score_threshold
self._nms_pre_max_size = nms_pre_max_size
self._nms_post_max_size = nms_post_max_size
self._nms_iou_threshold = nms_iou_threshold
self._use_sigmoid_score = use_sigmoid_score
self._encode_background_as_zeros = encode_background_as_zeros
self._use_sparse_rpn = use_sparse_rpn
self._use_direction_classifier = use_direction_classifier
self._use_bev = use_bev
self._total_forward_time = 0.0
self._total_postprocess_time = 0.0
self._total_inference_count = 0
self._num_input_features = num_input_features
self._box_coder = target_assigner.box_coder
self._lidar_only = lidar_only
self.K = K
self.hm_weight = hm_weight
self.dim_weight = dim_weight
self.rot_weight = rot_weight
self.off_weight = off_weight
self.centernet_layers = centernet_layers
self.pc_range = pc_range
vfe_class_dict = {
"VoxelFeatureExtractor": VoxelFeatureExtractor,
"VoxelFeatureExtractorV2": VoxelFeatureExtractorV2,
"PillarFeatureNet": PillarFeatureNet
}
vfe_class = vfe_class_dict[vfe_class_name]
if vfe_class_name == "PillarFeatureNet":
self.voxel_feature_extractor = vfe_class(
num_input_features,
use_norm,
num_filters=vfe_num_filters,
with_distance=with_distance,
voxel_size=voxel_size,
pc_range=pc_range)
else:
self.voxel_feature_extractor = vfe_class(
num_input_features,
use_norm,
num_filters=vfe_num_filters,
with_distance=with_distance)
print("middle_class_name", middle_class_name)
if middle_class_name == "PointPillarsScatter":
self.middle_feature_extractor = PointPillarsScatter(
output_shape=output_shape,
num_input_features=vfe_num_filters[-1])
else:
mid_class_dict = {
"MiddleExtractor": MiddleExtractor
# "SparseMiddleExtractor": SparseMiddleExtractor,
}
mid_class = mid_class_dict[middle_class_name]
self.middle_feature_extractor = mid_class(
output_shape,
use_norm,
num_input_features=vfe_num_filters[-1],
num_filters_down1=middle_num_filters_d1,
num_filters_down2=middle_num_filters_d2)
#======================= New detection heads ==========================
heads = {'hm': self._num_class, 'rot': 8, 'dim': 3, 'reg': 2}
self.centernet = get_pose_net(num_layers=self.centernet_layers,
heads=heads)
#=======================================================================
self.rpn_acc = metrics.Accuracy(
dim=-1, encode_background_as_zeros=encode_background_as_zeros)
self.rpn_precision = metrics.Precision(dim=-1)
self.rpn_recall = metrics.Recall(dim=-1)
self.rpn_metrics = metrics.PrecisionRecall(
dim=-1,
thresholds=[0.1, 0.3, 0.5, 0.7, 0.8, 0.9, 0.95],
use_sigmoid_score=use_sigmoid_score,
encode_background_as_zeros=encode_background_as_zeros)
self.hm_loss = metrics.Scalar()
self.dim_loss = metrics.Scalar()
self.rot_loss = metrics.Scalar()
self.total_loss = metrics.Scalar()
self.register_buffer("global_step", torch.LongTensor(1).zero_())
def __init__(self,
output_shape,
num_class=2,
num_input_features=4,
vfe_class_name="VoxelFeatureExtractor",
vfe_num_filters=[32, 128],
with_distance=False,
middle_class_name="SparseMiddleExtractor",
middle_num_filters_d1=[64],
middle_num_filters_d2=[64, 64],
rpn_class_name="RPN",
rpn_layer_nums=[3, 5, 5],
rpn_layer_strides=[2, 2, 2],
rpn_num_filters=[128, 128, 256],
rpn_upsample_strides=[1, 2, 4],
rpn_num_upsample_filters=[256, 256, 256],
use_norm=True,
use_groupnorm=False,
num_groups=32,
use_sparse_rpn=False,
use_direction_classifier=True,
use_sigmoid_score=False,
encode_background_as_zeros=True,
use_rotate_nms=True,
multiclass_nms=False,
nms_score_threshold=0.5,
nms_pre_max_size=1000,
nms_post_max_size=20,
nms_iou_threshold=0.1,
target_assigner=None,
use_bev=False,
lidar_only=False,
cls_loss_weight=1.0,
loc_loss_weight=1.0,
pos_cls_weight=1.0,
neg_cls_weight=1.0,
direction_loss_weight=1.0,
loss_norm_type=LossNormType.NormByNumPositives,
encode_rad_error_by_sin=False,
loc_loss_ftor=None,
cls_loss_ftor=None,
voxel_size=(0.2, 0.2, 4),
pc_range=(0, -40, -3, 70.4, 40, 1),
name='voxelnet'):
super().__init__()
self.name = name
self._num_class = num_class
self._use_rotate_nms = use_rotate_nms
self._multiclass_nms = multiclass_nms
self._nms_score_threshold = nms_score_threshold
self._nms_pre_max_size = nms_pre_max_size
self._nms_post_max_size = nms_post_max_size
self._nms_iou_threshold = nms_iou_threshold
self._use_sigmoid_score = use_sigmoid_score
self._encode_background_as_zeros = encode_background_as_zeros
self._use_sparse_rpn = use_sparse_rpn
self._use_direction_classifier = use_direction_classifier
self._use_bev = use_bev
self._total_forward_time = 0.0
self._total_postprocess_time = 0.0
self._total_inference_count = 0
self._num_input_features = num_input_features
self._box_coder = target_assigner.box_coder
self._lidar_only = lidar_only
self.target_assigner = target_assigner
self._pos_cls_weight = pos_cls_weight
self._neg_cls_weight = neg_cls_weight
self._encode_rad_error_by_sin = encode_rad_error_by_sin
self._loss_norm_type = loss_norm_type
self._dir_loss_ftor = WeightedSoftmaxClassificationLoss()
self._loc_loss_ftor = loc_loss_ftor
self._cls_loss_ftor = cls_loss_ftor
self._direction_loss_weight = direction_loss_weight
self._cls_loss_weight = cls_loss_weight
self._loc_loss_weight = loc_loss_weight
vfe_class_dict = {
"VoxelFeatureExtractor": VoxelFeatureExtractor,
"VoxelFeatureExtractorV2": VoxelFeatureExtractorV2,
"PillarFeatureNet": PillarFeatureNet
}
vfe_class = vfe_class_dict[vfe_class_name]
if vfe_class_name == "PillarFeatureNet":
self.voxel_feature_extractor = vfe_class(
num_input_features,
use_norm,
num_filters=vfe_num_filters,
with_distance=with_distance,
voxel_size=voxel_size,
pc_range=pc_range)
else:
self.voxel_feature_extractor = vfe_class(
num_input_features,
use_norm,
num_filters=vfe_num_filters,
with_distance=with_distance)
print("middle_class_name", middle_class_name)
if middle_class_name == "PointPillarsScatter":
self.middle_feature_extractor = PointPillarsScatter(
output_shape=output_shape,
num_input_features=vfe_num_filters[-1])
num_rpn_input_filters = self.middle_feature_extractor.nchannels
else:
mid_class_dict = {
"MiddleExtractor": MiddleExtractor,
# "SparseMiddleExtractor": SparseMiddleExtractor,
}
mid_class = mid_class_dict[middle_class_name]
self.middle_feature_extractor = mid_class(
output_shape,
use_norm,
num_input_features=vfe_num_filters[-1],
num_filters_down1=middle_num_filters_d1,
num_filters_down2=middle_num_filters_d2)
if len(middle_num_filters_d2) == 0:
if len(middle_num_filters_d1) == 0:
num_rpn_input_filters = int(vfe_num_filters[-1] * 2)
else:
num_rpn_input_filters = int(middle_num_filters_d1[-1] * 2)
else:
num_rpn_input_filters = int(middle_num_filters_d2[-1] * 2)
rpn_class_dict = {
"RPN": RPN,
}
rpn_class = rpn_class_dict[rpn_class_name]
self.rpn = rpn_class(
use_norm=True,
num_class=num_class,
layer_nums=rpn_layer_nums,
layer_strides=rpn_layer_strides,
num_filters=rpn_num_filters,
upsample_strides=rpn_upsample_strides,
num_upsample_filters=rpn_num_upsample_filters,
num_input_filters=num_rpn_input_filters,
num_anchor_per_loc=target_assigner.num_anchors_per_location,
encode_background_as_zeros=encode_background_as_zeros,
use_direction_classifier=use_direction_classifier,
use_bev=use_bev,
use_groupnorm=use_groupnorm,
num_groups=num_groups,
box_code_size=target_assigner.box_coder.code_size)
self.rpn_acc = metrics.Accuracy(
dim=-1, encode_background_as_zeros=encode_background_as_zeros)
self.rpn_precision = metrics.Precision(dim=-1)
self.rpn_recall = metrics.Recall(dim=-1)
self.rpn_metrics = metrics.PrecisionRecall(
dim=-1,
thresholds=[0.1, 0.3, 0.5, 0.7, 0.8, 0.9, 0.95],
use_sigmoid_score=use_sigmoid_score,
encode_background_as_zeros=encode_background_as_zeros)
self.rpn_cls_loss = metrics.Scalar()
self.rpn_loc_loss = metrics.Scalar()
self.rpn_total_loss = metrics.Scalar()
self.register_buffer("global_step", torch.LongTensor(1).zero_())
def tensorrt_backend_pointpillars_onnx(config_path=None):
import torch
from second.protos import pipeline_pb2
from google.protobuf import text_format
from second.builder import voxel_builder
from second.pytorch.models.pointpillars import PointPillarsScatter
############################# PFE-Layer TensorRT ################################
pillar_x = np.ones([1, 1, 12000, 100], dtype=np.float32)
pillar_y = np.ones([1, 1, 12000, 100], dtype=np.float32)
pillar_z = np.ones([1, 1, 12000, 100], dtype=np.float32)
pillar_i = np.ones([1, 1, 12000, 100], dtype=np.float32)
num_points_per_pillar = np.ones([1, 12000], dtype=np.float32)
x_sub_shaped = np.ones([1, 1, 12000, 100], dtype=np.float32)
y_sub_shaped = np.ones([1, 1, 12000, 100], dtype=np.float32)
mask = np.ones([1, 1, 12000, 100], dtype=np.float32)
pfe_inputs = [
pillar_x, pillar_y, pillar_z, pillar_i, num_points_per_pillar,
x_sub_shaped, y_sub_shaped, mask
]
pfe_model = onnx.load("pfe.onnx")
engine = backend.prepare(pfe_model, device="CUDA:0", max_batch_size=1)
pfe_start_time = time.time()
pfe_outputs = engine.run(pfe_inputs)
pfe_end_time = time.time()
print('inference time is : ', (pfe_end_time - pfe_start_time))
###################### PillarScatter Python Coder Transfer #########################
# numpy --> tensor
pfe_outs = np.array(pfe_outputs)
voxel_features_tensor = torch.from_numpy(pfe_outs)
voxel_features = voxel_features_tensor.squeeze()
voxel_features = voxel_features.permute(1, 0)
if isinstance(config_path, str):
config = pipeline_pb2.TrainEvalPipelineConfig()
with open(config_path, "r") as f:
proto_str = f.read()
text_format.Merge(proto_str, config)
else:
config = config_path
model_cfg = config.model.second
vfe_num_filters = list(model_cfg.voxel_feature_extractor.num_filters)
voxel_generator = voxel_builder.build(model_cfg.voxel_generator)
grid_size = voxel_generator.grid_size
output_shape = [1] + grid_size[::-1].tolist() + [vfe_num_filters[-1]]
num_input_features = vfe_num_filters[-1]
batch_size = 1
mid_feature_extractor = PointPillarsScatter(output_shape,
num_input_features, batch_size)
device = torch.device("cuda:0")
coors_numpy = np.loadtxt('coors.txt', dtype=np.int32)
coors = torch.from_numpy(coors_numpy)
coors = coors.to(device).cuda() #CPU Tensor --> GPU Tensor
voxel_features = voxel_features.to(device).cuda()
rpn_input_features = mid_feature_extractor(voxel_features, coors)
########################### RPN Network TensorRT #################################
rpn_input_features = rpn_input_features.data.cpu().numpy()
rpn_model = onnx.load("rpn.onnx")
engine_rpn = backend.prepare(rpn_model, device="CUDA:0", max_batch_size=1)
rpn_start_time = time.time()
rpn_outputs = engine_rpn.run(rpn_input_features)
rpn_end_time = time.time()
print('rpn inference time is : ', (rpn_end_time - rpn_start_time))
print(rpn_outputs)