sampleSSD inference on jetson Nano in C++ error

god_ra · June 8, 2020, 10:39am

Description

Hi,

I am trying to execute sampleSSD from /usr/src/tensorrt/sample/sampleSSD folder.
I have made the changes specified inthe README file as:
replaced type: Flatten → Reshape
replaced flatten_param { … } → reshape_param{…}

also replaced detect_out top: with keep_count.

But I am getting this error.

Can someone throw some suggestion to it to make it work.

&&&& RUNNING TensorRT.sample_ssd # ./sample_ssd
[05/08/2020-11:45:45] [I] Building and running a GPU inference engine for SSD

Plugin layer output count is not equal to caffe output count
Segmentation fault (core dumped)

If i do not chnage anything in deploy.prototxt, I am gettin this error.

&&&& RUNNING TensorRT.sample_ssd # ./sample_ssd
[05/08/2020-12:36:04] [I] Building and running a GPU inference engine for SSD
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
Warning: Flatten layer ignored. TensorRT implicitly flattens input to FullyConnected layers, but in other circumstances this will result in undefined behavior.
[05/08/2020-12:36:05] [E] [TRT] mbox_loc: all concat input tensors must have the same dimensions except on the concatenation axis (0), but dimensions mismatched at input 1 at index 1. Input 0 shape: [38,38,16], Input 1 shape: [19,19,24]
[05/08/2020-12:36:05] [E] [TRT] mbox_conf: all concat input tensors must have the same dimensions except on the concatenation axis (0), but dimensions mismatched at input 1 at index 1. Input 0 shape: [38,38,84], Input 1 shape: [19,19,126]
Caffe Parser: Invalid axis in softmax layer - TensorRT expects NCHW input. Negative axis is not supported in TensorRT, please use positive axis indexing
error parsing layer type Softmax index 98
Segmentation fault (core dumped)

Thank you

Environment

TensorRT Version:
GPU Type:
Nvidia Driver Version:
CUDA Version:
CUDNN Version:
Operating System + Version:
Python Version (if applicable):
TensorFlow Version (if applicable):
PyTorch Version (if applicable):
Baremetal or Container (if container which image + tag):

Relevant Files

Here is the file:
ssd.prototxt

Steps To Reproduce

Please include:

Exact steps/commands to build your repro
Exact steps/commands to run your repro
Full traceback of errors encountered

SunilJB · June 8, 2020, 10:48am

Could you please refer to below topic in case it helps:

Also, it seems share model has restricted access due to which i am not able to download it.

Thanks

god_ra · June 8, 2020, 11:01am

no help from that link.

here is the ssd.prototxt contents.

name: “VGG_VOC0712_SSD_300x300_deploy”
input: “data”
input_shape {
dim: 1
dim: 3
dim: 300
dim: 300
}
layer {
name: “conv1_1”
type: “Convolution”
bottom: “data”
top: “conv1_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 64
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu1_1”
type: “ReLU”
bottom: “conv1_1”
top: “conv1_1”
}
layer {
name: “conv1_2”
type: “Convolution”
bottom: “conv1_1”
top: “conv1_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 64
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu1_2”
type: “ReLU”
bottom: “conv1_2”
top: “conv1_2”
}
layer {
name: “pool1”
type: “Pooling”
bottom: “conv1_2”
top: “pool1”
pooling_param {
pool: MAX
kernel_size: 2
stride: 2
}
}
layer {
name: “conv2_1”
type: “Convolution”
bottom: “pool1”
top: “conv2_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 128
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu2_1”
type: “ReLU”
bottom: “conv2_1”
top: “conv2_1”
}
layer {
name: “conv2_2”
type: “Convolution”
bottom: “conv2_1”
top: “conv2_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 128
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu2_2”
type: “ReLU”
bottom: “conv2_2”
top: “conv2_2”
}
layer {
name: “pool2”
type: “Pooling”
bottom: “conv2_2”
top: “pool2”
pooling_param {
pool: MAX
kernel_size: 2
stride: 2
}
}
layer {
name: “conv3_1”
type: “Convolution”
bottom: “pool2”
top: “conv3_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu3_1”
type: “ReLU”
bottom: “conv3_1”
top: “conv3_1”
}
layer {
name: “conv3_2”
type: “Convolution”
bottom: “conv3_1”
top: “conv3_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu3_2”
type: “ReLU”
bottom: “conv3_2”
top: “conv3_2”
}
layer {
name: “conv3_3”
type: “Convolution”
bottom: “conv3_2”
top: “conv3_3”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu3_3”
type: “ReLU”
bottom: “conv3_3”
top: “conv3_3”
}
layer {
name: “pool3”
type: “Pooling”
bottom: “conv3_3”
top: “pool3”
pooling_param {
pool: MAX
kernel_size: 2
stride: 2
}
}
layer {
name: “conv4_1”
type: “Convolution”
bottom: “pool3”
top: “conv4_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu4_1”
type: “ReLU”
bottom: “conv4_1”
top: “conv4_1”
}
layer {
name: “conv4_2”
type: “Convolution”
bottom: “conv4_1”
top: “conv4_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu4_2”
type: “ReLU”
bottom: “conv4_2”
top: “conv4_2”
}
layer {
name: “conv4_3”
type: “Convolution”
bottom: “conv4_2”
top: “conv4_3”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu4_3”
type: “ReLU”
bottom: “conv4_3”
top: “conv4_3”
}
layer {
name: “pool4”
type: “Pooling”
bottom: “conv4_3”
top: “pool4”
pooling_param {
pool: MAX
kernel_size: 2
stride: 2
}
}
layer {
name: “conv5_1”
type: “Convolution”
bottom: “pool4”
top: “conv5_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
dilation: 1
}
}
layer {
name: “relu5_1”
type: “ReLU”
bottom: “conv5_1”
top: “conv5_1”
}
layer {
name: “conv5_2”
type: “Convolution”
bottom: “conv5_1”
top: “conv5_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
dilation: 1
}
}
layer {
name: “relu5_2”
type: “ReLU”
bottom: “conv5_2”
top: “conv5_2”
}
layer {
name: “conv5_3”
type: “Convolution”
bottom: “conv5_2”
top: “conv5_3”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
dilation: 1
}
}
layer {
name: “relu5_3”
type: “ReLU”
bottom: “conv5_3”
top: “conv5_3”
}
layer {
name: “pool5”
type: “Pooling”
bottom: “conv5_3”
top: “pool5”
pooling_param {
pool: MAX
kernel_size: 3
stride: 1
pad: 1
}
}
layer {
name: “fc6”
type: “Convolution”
bottom: “pool5”
top: “fc6”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 1024
pad: 6
kernel_size: 3
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
dilation: 6
}
}
layer {
name: “relu6”
type: “ReLU”
bottom: “fc6”
top: “fc6”
}
layer {
name: “fc7”
type: “Convolution”
bottom: “fc6”
top: “fc7”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 1024
kernel_size: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “relu7”
type: “ReLU”
bottom: “fc7”
top: “fc7”
}
layer {
name: “conv6_1”
type: “Convolution”
bottom: “fc7”
top: “conv6_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 0
kernel_size: 1
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv6_1_relu”
type: “ReLU”
bottom: “conv6_1”
top: “conv6_1”
}
layer {
name: “conv6_2”
type: “Convolution”
bottom: “conv6_1”
top: “conv6_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 512
pad: 1
kernel_size: 3
stride: 2
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv6_2_relu”
type: “ReLU”
bottom: “conv6_2”
top: “conv6_2”
}
layer {
name: “conv7_1”
type: “Convolution”
bottom: “conv6_2”
top: “conv7_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 128
pad: 0
kernel_size: 1
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv7_1_relu”
type: “ReLU”
bottom: “conv7_1”
top: “conv7_1”
}
layer {
name: “conv7_2”
type: “Convolution”
bottom: “conv7_1”
top: “conv7_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 1
kernel_size: 3
stride: 2
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv7_2_relu”
type: “ReLU”
bottom: “conv7_2”
top: “conv7_2”
}
layer {
name: “conv8_1”
type: “Convolution”
bottom: “conv7_2”
top: “conv8_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 128
pad: 0
kernel_size: 1
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv8_1_relu”
type: “ReLU”
bottom: “conv8_1”
top: “conv8_1”
}
layer {
name: “conv8_2”
type: “Convolution”
bottom: “conv8_1”
top: “conv8_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 0
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv8_2_relu”
type: “ReLU”
bottom: “conv8_2”
top: “conv8_2”
}
layer {
name: “conv9_1”
type: “Convolution”
bottom: “conv8_2”
top: “conv9_1”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 128
pad: 0
kernel_size: 1
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv9_1_relu”
type: “ReLU”
bottom: “conv9_1”
top: “conv9_1”
}
layer {
name: “conv9_2”
type: “Convolution”
bottom: “conv9_1”
top: “conv9_2”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 256
pad: 0
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv9_2_relu”
type: “ReLU”
bottom: “conv9_2”
top: “conv9_2”
}
layer {
name: “conv4_3_norm”
type: “Normalize”
bottom: “conv4_3”
top: “conv4_3_norm”
norm_param {
across_spatial: false
scale_filler {
type: “constant”
value: 20
}
channel_shared: false
}
}
layer {
name: “conv4_3_norm_mbox_loc”
type: “Convolution”
bottom: “conv4_3_norm”
top: “conv4_3_norm_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 16
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv4_3_norm_mbox_loc_perm”
type: “Permute”
bottom: “conv4_3_norm_mbox_loc”
top: “conv4_3_norm_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv4_3_norm_mbox_loc_flat”
type: “Reshape”
bottom: “conv4_3_norm_mbox_loc_perm”
top: “conv4_3_norm_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv4_3_norm_mbox_conf”
type: “Convolution”
bottom: “conv4_3_norm”
top: “conv4_3_norm_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 84
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv4_3_norm_mbox_conf_perm”
type: “Permute”
bottom: “conv4_3_norm_mbox_conf”
top: “conv4_3_norm_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv4_3_norm_mbox_conf_flat”
type: “Reshape”
bottom: “conv4_3_norm_mbox_conf_perm”
top: “conv4_3_norm_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv4_3_norm_mbox_priorbox”
type: “PriorBox”
bottom: “conv4_3_norm”
bottom: “data”
top: “conv4_3_norm_mbox_priorbox”
prior_box_param {
min_size: 30.0
max_size: 60.0
aspect_ratio: 2
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 8
offset: 0.5
}
}
layer {
name: “fc7_mbox_loc”
type: “Convolution”
bottom: “fc7”
top: “fc7_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 24
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “fc7_mbox_loc_perm”
type: “Permute”
bottom: “fc7_mbox_loc”
top: “fc7_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “fc7_mbox_loc_flat”
type: “Reshape”
bottom: “fc7_mbox_loc_perm”
top: “fc7_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “fc7_mbox_conf”
type: “Convolution”
bottom: “fc7”
top: “fc7_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 126
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “fc7_mbox_conf_perm”
type: “Permute”
bottom: “fc7_mbox_conf”
top: “fc7_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “fc7_mbox_conf_flat”
type: “Reshape”
bottom: “fc7_mbox_conf_perm”
top: “fc7_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “fc7_mbox_priorbox”
type: “PriorBox”
bottom: “fc7”
bottom: “data”
top: “fc7_mbox_priorbox”
prior_box_param {
min_size: 60.0
max_size: 111.0
aspect_ratio: 2
aspect_ratio: 3
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 16
offset: 0.5
}
}
layer {
name: “conv6_2_mbox_loc”
type: “Convolution”
bottom: “conv6_2”
top: “conv6_2_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 24
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv6_2_mbox_loc_perm”
type: “Permute”
bottom: “conv6_2_mbox_loc”
top: “conv6_2_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv6_2_mbox_loc_flat”
type: “Reshape”
bottom: “conv6_2_mbox_loc_perm”
top: “conv6_2_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv6_2_mbox_conf”
type: “Convolution”
bottom: “conv6_2”
top: “conv6_2_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 126
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv6_2_mbox_conf_perm”
type: “Permute”
bottom: “conv6_2_mbox_conf”
top: “conv6_2_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv6_2_mbox_conf_flat”
type: “Reshape”
bottom: “conv6_2_mbox_conf_perm”
top: “conv6_2_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv6_2_mbox_priorbox”
type: “PriorBox”
bottom: “conv6_2”
bottom: “data”
top: “conv6_2_mbox_priorbox”
prior_box_param {
min_size: 111.0
max_size: 162.0
aspect_ratio: 2
aspect_ratio: 3
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 32
offset: 0.5
}
}
layer {
name: “conv7_2_mbox_loc”
type: “Convolution”
bottom: “conv7_2”
top: “conv7_2_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 24
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv7_2_mbox_loc_perm”
type: “Permute”
bottom: “conv7_2_mbox_loc”
top: “conv7_2_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv7_2_mbox_loc_flat”
type: “Reshape”
bottom: “conv7_2_mbox_loc_perm”
top: “conv7_2_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv7_2_mbox_conf”
type: “Convolution”
bottom: “conv7_2”
top: “conv7_2_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 126
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv7_2_mbox_conf_perm”
type: “Permute”
bottom: “conv7_2_mbox_conf”
top: “conv7_2_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv7_2_mbox_conf_flat”
type: “Reshape”
bottom: “conv7_2_mbox_conf_perm”
top: “conv7_2_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv7_2_mbox_priorbox”
type: “PriorBox”
bottom: “conv7_2”
bottom: “data”
top: “conv7_2_mbox_priorbox”
prior_box_param {
min_size: 162.0
max_size: 213.0
aspect_ratio: 2
aspect_ratio: 3
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 64
offset: 0.5
}
}
layer {
name: “conv8_2_mbox_loc”
type: “Convolution”
bottom: “conv8_2”
top: “conv8_2_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 16
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv8_2_mbox_loc_perm”
type: “Permute”
bottom: “conv8_2_mbox_loc”
top: “conv8_2_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv8_2_mbox_loc_flat”
type: “Reshape”
bottom: “conv8_2_mbox_loc_perm”
top: “conv8_2_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv8_2_mbox_conf”
type: “Convolution”
bottom: “conv8_2”
top: “conv8_2_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 84
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv8_2_mbox_conf_perm”
type: “Permute”
bottom: “conv8_2_mbox_conf”
top: “conv8_2_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv8_2_mbox_conf_flat”
type: “Reshape”
bottom: “conv8_2_mbox_conf_perm”
top: “conv8_2_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv8_2_mbox_priorbox”
type: “PriorBox”
bottom: “conv8_2”
bottom: “data”
top: “conv8_2_mbox_priorbox”
prior_box_param {
min_size: 213.0
max_size: 264.0
aspect_ratio: 2
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 100
offset: 0.5
}
}
layer {
name: “conv9_2_mbox_loc”
type: “Convolution”
bottom: “conv9_2”
top: “conv9_2_mbox_loc”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 16
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv9_2_mbox_loc_perm”
type: “Permute”
bottom: “conv9_2_mbox_loc”
top: “conv9_2_mbox_loc_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv9_2_mbox_loc_flat”
type: “Reshape”
bottom: “conv9_2_mbox_loc_perm”
top: “conv9_2_mbox_loc_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv9_2_mbox_conf”
type: “Convolution”
bottom: “conv9_2”
top: “conv9_2_mbox_conf”
param {
lr_mult: 1
decay_mult: 1
}
param {
lr_mult: 2
decay_mult: 0
}
convolution_param {
num_output: 84
pad: 1
kernel_size: 3
stride: 1
weight_filler {
type: “xavier”
}
bias_filler {
type: “constant”
value: 0
}
}
}
layer {
name: “conv9_2_mbox_conf_perm”
type: “Permute”
bottom: “conv9_2_mbox_conf”
top: “conv9_2_mbox_conf_perm”
permute_param {
order: 0
order: 2
order: 3
order: 1
}
}
layer {
name: “conv9_2_mbox_conf_flat”
type: “Reshape”
bottom: “conv9_2_mbox_conf_perm”
top: “conv9_2_mbox_conf_flat”
reshape_param {
shape {
dim: 0
dim: -1
dim: 1
dim: 1
}
}
}
layer {
name: “conv9_2_mbox_priorbox”
type: “PriorBox”
bottom: “conv9_2”
bottom: “data”
top: “conv9_2_mbox_priorbox”
prior_box_param {
min_size: 264.0
max_size: 315.0
aspect_ratio: 2
flip: true
clip: false
variance: 0.1
variance: 0.1
variance: 0.2
variance: 0.2
step: 300
offset: 0.5
}
}
layer {
name: “mbox_loc”
type: “Concat”
bottom: “conv4_3_norm_mbox_loc_flat”
bottom: “fc7_mbox_loc_flat”
bottom: “conv6_2_mbox_loc_flat”
bottom: “conv7_2_mbox_loc_flat”
bottom: “conv8_2_mbox_loc_flat”
bottom: “conv9_2_mbox_loc_flat”
top: “mbox_loc”
concat_param {
axis: 1
}
}
layer {
name: “mbox_conf”
type: “Concat”
bottom: “conv4_3_norm_mbox_conf_flat”
bottom: “fc7_mbox_conf_flat”
bottom: “conv6_2_mbox_conf_flat”
bottom: “conv7_2_mbox_conf_flat”
bottom: “conv8_2_mbox_conf_flat”
bottom: “conv9_2_mbox_conf_flat”
top: “mbox_conf”
concat_param {
axis: 1
}
}
layer {
name: “mbox_priorbox”
type: “Concat”
bottom: “conv4_3_norm_mbox_priorbox”
bottom: “fc7_mbox_priorbox”
bottom: “conv6_2_mbox_priorbox”
bottom: “conv7_2_mbox_priorbox”
bottom: “conv8_2_mbox_priorbox”
bottom: “conv9_2_mbox_priorbox”
top: “mbox_priorbox”
concat_param {
axis: 2
}
}
layer {
name: “mbox_conf_reshape”
type: “Reshape”
bottom: “mbox_conf”
top: “mbox_conf_reshape”
reshape_param {
shape {
dim: 0
dim: -1
dim: 21
}
}
}
layer {
name: “mbox_conf_softmax”
type: “Softmax”
bottom: “mbox_conf_reshape”
top: “mbox_conf_softmax”
softmax_param {
axis: 2
}
}
layer {
name: “mbox_conf_flatten”
type: “Flatten”
bottom: “mbox_conf_softmax”
top: “mbox_conf_flatten”
flatten_param {
axis: 1
}
}
layer {
name: “detection_out”
type: “DetectionOutput”
bottom: “mbox_loc”
bottom: “mbox_conf_flatten”
bottom: “mbox_priorbox”
top: “detection_out”
top: “keep_count”
include {
phase: TEST
}
detection_output_param {
num_classes: 21
share_location: true
background_label_id: 0
nms_param {
nms_threshold: 0.45
top_k: 400
}
save_output_param {
label_map_file: “data/VOC0712/labelmap_voc.prototxt”
}
code_type: CENTER_SIZE
keep_top_k: 200
confidence_threshold: 0.01
}
}

god_ra · June 8, 2020, 11:08am

I think now the prototxt is edited properly. I missed to add detection_out layer with top: keep_count. No errors with flatten layers.

But I am getting a different error like this.
When i run ./sample_ssd :

[05/08/2020-12:59:20] [I] [TRT] Some tactics do not have sufficient workspace memory to run. Increasing workspace size may increase performance, please check verbose output.
[05/08/2020-13:02:02] [I] [TRT] Detected 1 inputs and 2 output network tensors.
sample_ssd: nmsPlugin.cpp:131: virtual void nvinfer1::plugin::DetectionOutput::configureWithFormat(const nvinfer1::Dims*, int, const nvinfer1::Dims*, int, nvinfer1::DataType, nvinfer1::PluginFormat, int): Assertion `inputDims[1].nbDims == 3’ failed.
Aborted (core dumped)

What could be the reason??
how to avoid it??

SunilJB · June 9, 2020, 3:28pm

I think it might be due to this flatten layer.
Ca you try on latest TRT version after replacing flatten layer with reshape.

Thanks

god_ra · June 9, 2020, 6:33pm

Yes, I rectified it. Got it worked.

How to use same sampleSSD code to store the TRT engine and use it later without having to build it again for new images.??
Could you help me with that…

SunilJB · June 10, 2020, 5:07am

Please refer to below link and sample:

github.com

NVIDIA/TensorRT/blob/572d54f91791448c015e74a4f1d6923b77b79795/samples/opensource/sampleUffFasterRCNN/sampleUffFasterRCNN.cpp#L292


      
              builder->setInt8Calibrator(calibrator.get());
          }
          
          
mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(builder->buildCudaEngine(*network), samplesCommon::InferDeleter());
          
          
if (!mEngine)
          {
              return false;
          }
          
          
if (mParams.saveEngine.size() > 0)
          {
              std::ofstream p(mParams.saveEngine, std::ios::binary);
              if (!p)
              {
                  return false;
              }
              nvinfer1::IHostMemory* ptr = mEngine->serialize();
              assert(ptr);
              p.write(reinterpret_cast<const char*>(ptr->data()), ptr->size());
              ptr->destroy();

Thanks

god_ra · June 10, 2020, 8:09am

I am getting this error :

‘SampleSSDParams initializeSampleParams(const samplesCommon::Args&)’:
/home/ram/ALPR/OCR/sampleSSD/src/main.cpp:95:30: error: ‘const struct samplesCommon::Args’ has no member named ‘saveEngine’
params.saveEngine = args.saveEngine;
^~~~~~~~~~

What to do???

SunilJB · June 10, 2020, 8:15am

This is just a saveEngine file path argument that present the sample that i shared as reference:

github.com

NVIDIA/TensorRT/blob/572d54f91791448c015e74a4f1d6923b77b79795/samples/opensource/sampleUffFasterRCNN/sampleUffFasterRCNN.cpp#L511


      
              std::cout << "--fp16[-f]              Specify to run in fp16 mode." << std::endl;
              std::cout << "--int8[-i]              Specify to run in int8 mode." << std::endl;
              std::cout << "--inputWidth[-W]        Specify the input width of the model." << std::endl;
              std::cout << "--inputHeight[-H]       Specify the input height of the model." << std::endl;
              std::cout << "--batchSize[-B]         Specify the batch size for inference." << std::endl;
              std::cout << "--profile[-p]           Whether to do per-layer profiling." << std::endl;
              std::cout << "--repeat[-r]            Specify the repeat number to execute the TRT context,"
                           " used to smooth the profiling time."
                        << std::endl;
              std::cout << "--inputImages[-I]       Specify the input images for inference." << std::endl;
              std::cout << "--saveEngine[-s]        Path to save engine." << std::endl;
              std::cout << "--loadEngine[-l]        Path to load engine." << std::endl;
          }
          
          
//! \brief Define the function to apply delta to ROIs
          //!
          void SampleUffFasterRcnn::batch_inverse_transform_classifier(const float* roi_after_nms, int roi_num_per_img,
              const float* classifier_cls, const float* classifier_regr, std::vector<float>& pred_boxes,
              std::vector<int>& pred_cls_ids, std::vector<float>& pred_probs, std::vector<int>& box_num_per_img, int N)
          {
              auto max_index = [](const float* start, const float* end) -> int {

You can either add that argument support in sampleSSD or replace it with filepath for trt engine.

Thanks

god_ra · June 10, 2020, 8:30am

This is the code i am trying to execute. Could you please execute it with the changes??
i am getting like this when I run it.

[05/10/2020-10:28:34] [I] Building and running a GPU inference engine for SSD
[05/10/2020-10:28:35] [E] [TRT] Parameter check failed at: runtime.cpp::deserializeCudaEngine::30, condition: (blob) != nullptr
[05/10/2020-10:28:35] [I] TRT Engine loaded from: output/
&&&& FAILED TensorRT.sample_ssd # ./ssd_anpr

god_ra · June 10, 2020, 9:03am

This is the entire code of the sampleSSD:

sampleSSD.cpp (18.3 KB)

god_ra · June 10, 2020, 2:36pm

Hi, I am not able to get the desired output. It is not saving the model.
Could you please sort it out…
Thank you

god_ra · June 11, 2020, 12:30pm

Hello,

I have tried serializing the engine and deserializing the engine.
Please check the script attached.

I am gettingsampleSSD.cpp (13.9 KB) bus error when I run for the first time.

It stores and deserialize the engine. but after that i get buss error. it does not go to infer part.

In second run with the stored engine.
I get segmentation error

this particular line executes several times and then segmentation error comes up.

Could you let me know what is the problem is all about??

SunilJB · June 12, 2020, 8:03am

I am getting compilation error while using the shared code. Could you please share the complete code along with Makefile that you are using in this case?

Also, could you please share complete error log?

Thanks

god_ra · June 12, 2020, 11:44am

you can run it usign sample make files also.

I have chnaged only the Build method inside the class.

here is the code modifications to build method.

initLibNvInferPlugins(&gLogger.getTRTLogger(), "");


std::string engineName = std::string("ssd_Caffe_TRT_Engine") + ".buf";
bool engineExist = std::ifstream(engineName).good();

IRuntime* runtime = createInferRuntime(gLogger.getTRTLogger());
assert(runtime != nullptr);


if (engineExist)
{

	assert(mEngine != nullptr);
	
	gLogInfo << "*** deserializing" << std::endl;
  // Deserialize the engine
	std::string buffer = readBuffer(engineName);
	
	mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(
			runtime->deserializeCudaEngine(buffer.data(), buffer.size(), nullptr), samplesCommon::InferDeleter());
	gLogInfo << "*** deserializing now:" << std::endl;
	runtime->destroy();
	gLogInfo << "*** executed" << std::endl;
	assert(mEngine != nullptr && "loaded afterwards");
   
	gLogInfo << "*** deserializing is done next -> infer" << std::endl;
    gLogInfo << "*** Final success deserializing from disk" << std::endl;
	return true;
	
}
else
{

	auto builder = SampleUniquePtr<nvinfer1::IBuilder>(nvinfer1::createInferBuilder(gLogger.getTRTLogger()));
	if (!builder)
	{
		return false;
	}

	auto network = SampleUniquePtr<nvinfer1::INetworkDefinition>(builder->createNetwork());
	if (!network)
	{
		return false;
	}

	auto config = SampleUniquePtr<nvinfer1::IBuilderConfig>(builder->createBuilderConfig());
	if (!config)
	{
		return false;
	}

	auto parser = SampleUniquePtr<nvcaffeparser1::ICaffeParser>(nvcaffeparser1::createCaffeParser());
	if (!parser)
	{
		return false;
	}
	
	auto constructed = constructNetwork(builder, network, config, parser);
	if (!constructed)
	{
		return false;
	}
	
	assert(network->getNbInputs() == 1);

	mInputDims = network->getInput(0)->getDimensions();
	assert(mInputDims.nbDims == 3);
	
	assert(trtModelStream != nullptr);

	writeBuffer(trtModelStream->data(), trtModelStream->size(), engineName);

	
   // Deserialize the engine
   // engine = runtime->deserializeCudaEngine(trtModelStream->data(), trtModelStream->size(), nullptr);
	gLogInfo << "*** deserializing starts" << std::endl;
	mEngine = std::shared_ptr<nvinfer1::ICudaEngine>(runtime->deserializeCudaEngine(trtModelStream->data(), trtModelStream->size(), nullptr), samplesCommon::InferDeleter());
	assert(mEngine != nullptr);
	gLogInfo << "*** deserializing success" << std::endl;
	trtModelStream->destroy();
	gLogInfo << "*** destroy success" << std::endl;
	runtime->destroy();
	if (!mEngine)
	{
		return false;
	}
	else
	{
		gLogInfo << "*** Final success creating to disk" << std::endl;
		return true;
	}
}

god_ra · June 12, 2020, 11:46am

Add this to sampleSSD code and run it normally.

I am getting buss error at first run. But it saves the model to disk. (hope this is correctly saved.)

soon after the model is saved, bus error comes up and program ends.

Again when I run the code.

it reads the stored model and starts deserializing it.
that time I getting segmentation fault error.

I am using it with Cmake file not with make.

It works with make also. No problems with that

god_ra · June 12, 2020, 11:50am

Here is the CMakeLists.txt contents.
edit it according to the file names.

CMakeLists.txt (1.1 KB)

Topic		Replies	Views
Error on using a downloaded model mobilenet ssd DeepStream SDK	18	845	October 12, 2021
Segmentation fault occurs while running jetson-inference example application Jetson Nano jetson-inference	2	363	October 15, 2021
How to retrain ssd_inception_v2_coco_2017_11_17 from the tensorrt - samples Jetson TX2	33	7244	October 18, 2021
TRT engine - peculiar behaviour Jetson Nano tensorrt , nvbugs	12	1342	October 18, 2021
TensorRT Inference error on Jetson nano Jetson Nano tensorrt	28	3321	February 1, 2022
TensorRT Sample "sampleSSD" error TensorRT	6	2539	October 12, 2021
Custom trained SSD inception model in tensorRT c++ version Jetson Nano tensorrt , tensorflow , nvbugs , ssd	17	3841	October 18, 2021
Error calling the interface of createSSDPriorBoxPlugin when prase my caffe model TensorRT	4	790	January 3, 2019
cannot deserialize engine and segmentation fault(core dumped) Jetson TX2	2	2284	October 18, 2021
Tensorrt fails for custom ssd_inception Model TensorRT	18	2962	May 14, 2020

sampleSSD inference on jetson Nano in C++ error

Description

Environment

Relevant Files

Steps To Reproduce

Related topics