# Sample object detector tracker YOLOV3 model error inference

**URL:** <https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917>\
**Category:** DRIVE AGX Xavier General\
**Tags:** driveworks\
**Created:** [June 27, 2022, 12:07pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917 "2022-06-27T12:07:17Z")\
**Posts on this page:** 15\
**Page:** 1

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [June 27, 2022, 12:07pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/1 "2022-06-27T12:07:17Z")

</div>

Please provide the following info (check/uncheck the boxes after creating this topic):  
**Software Version**  
 DRIVE OS Linux 5.2.6  
 DRIVE OS Linux 5.2.6 and DriveWorks 4.0  
 DRIVE OS Linux 5.2.0  
[\*] DRIVE OS Linux 5.2.0 and DriveWorks 3.5  
 NVIDIA DRIVE™ Software 10.0 (Linux)  
 NVIDIA DRIVE™ Software 9.0 (Linux)  
 other DRIVE OS version  
 other

**Target Operating System**  
[\*] Linux  
 QNX  
 other

**Hardware Platform**  
 NVIDIA DRIVE™ AGX Xavier DevKit (E3550)  
[\*] NVIDIA DRIVE™ AGX Pegasus DevKit (E3550)  
 other

**SDK Manager Version**  
[\*] 1.8.0.10363  
 other

**Host Machine Version**  
[\*] native Ubuntu 18.04  
 other

Followed this post [Yolov3 Implementation error in inference](https://forums.developer.nvidia.com/t/yolov3-implementation-error-in-inference/218326) to convert to yolov3.bin and use it for inference in the sample.  
Facing the below issue:

```auto
bin$ ./sample_object_detector_tracker --input-type=video --video=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264
[27-06-2022 16:56:30] Platform: Detected DDPX - Tegra B
[27-06-2022 16:56:30] TimeSource: monotonic epoch time offset is 1656309134410035
[27-06-2022 16:56:30] TimeSource: Could not detect valid PTP time source at nvpps. Fallback to eth0
[27-06-2022 16:56:30] TimeSource Eth: Lost PTP time synchronizaton. Synchronized time will not be available from this timesource.
[27-06-2022 16:56:30] TimeSource: Could not detect valid PTP time source at 'eth0'. Fallback to CLOCK_MONOTONIC.
[27-06-2022 16:56:30] Platform: number of GPU devices detected 2
[27-06-2022 16:56:30] Platform: currently selected GPU device discrete ID 0
[27-06-2022 16:56:30] Context::getDataPathFromSelfLocation DATA_ROOT found at: /usr/local/driveworks-3.5/data
[27-06-2022 16:56:30] SDK: No resources(.pak) mounted, some modules will not function properly
[27-06-2022 16:56:30] SDK: Create NvMediaDevice
[27-06-2022 16:56:30] SDK: Create NvMedia2D
[27-06-2022 16:56:30] SDK: use EGL display as provided
[27-06-2022 16:56:30] TimeSource: monotonic epoch time offset is 1656309134410035
[27-06-2022 16:56:30] TimeSource: Could not detect valid PTP time source at nvpps. Fallback to eth0
[27-06-2022 16:56:30] TimeSource Eth: Lost PTP time synchronizaton. Synchronized time will not be available from this timesource.
[27-06-2022 16:56:30] TimeSource: Could not detect valid PTP time source at 'eth0'. Fallback to CLOCK_MONOTONIC.
[27-06-2022 16:56:30] Initialize DriveWorks SDK v3.5.75
[27-06-2022 16:56:30] Release build with GNU 7.3.1 from heads/buildbrain-branch-0-gc61a9a35bd0 against Drive PDK v5.2.0.0
[27-06-2022 16:56:30] Initialize DriveWorks VisualizationSDK v3.5.75
[27-06-2022 16:56:30] Initialize DriveWorksGL SDK v3.5.75
[27-06-2022 16:56:30] SensorFactory::createSensor() -> camera.virtual, camera-group=a,camera-index=0,camera-type=ar0231-rccb-bae-sf3324,input-type=video,offscreen=0,profiling=1,slave=0,tensorRT_model=,video=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264
[27-06-2022 16:56:30] CameraVirtual: defaulting to non SIPL
[27-06-2022 16:56:30] CameraBase: pool size set to 8
[27-06-2022 16:56:30] CameraVirtualNvMedia: no seek table found at /media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264.seek, seeking is not available.
SimpleCamera: Camera image: 1280x800
Camera image with 1280x800 at 30 FPS
[27-06-2022 16:56:30] StreamConsumerGL: successfully initialized
[27-06-2022 16:56:30] StreamProducerCUDA: successfully initialized
[27-06-2022 16:56:33] INVALID_CONFIG: Using an engine plan file across different models of devices is not recommended and is likely to affect performance or even cause errors.
[27-06-2022 16:56:33] INVALID_CONFIG: Deserialize the cuda engine failed.
[27-06-2022 16:56:34] Driveworks exception thrown: DW_INTERNAL_ERROR: DNN: Unable to load model.

terminate called after throwing an instance of 'std::runtime_error'
  what(): [2022-06-27 16:56:34] DW Error DW_INTERNAL_ERROR executing DW function:
 dwDNN_initializeTensorRTFromFile(&m_dnn, tensorRTModel.c_str(), nullptr, DW_PROCESSOR_TYPE_GPU, m_sdk)
 at /usr/local/driveworks-3.5/samples/src/dnn/sample_object_detector_tracker/main.cpp:268
Aborted (core dumped)
bin$ 

```

Error stacktrace:

```auto
//------------------------------------------------------------------------------
// initialize DNN
//------------------------------------------------------------------------------
{
    // If not specified, load the correct network based on platform
    std::string tensorRTModel = getArgument("tensorRT_model");
    if (tensorRTModel.empty())
    {
        tensorRTModel = dw_samples::DataPath::get() + "/samples/detector/";
        tensorRTModel += getPlatformPrefix();
        tensorRTModel += "/yolov3.bin";
    }
    std::cout << "Model path: " << tensorRTModel;
    // Initialize DNN from a TensorRT file
    CHECK_DW_ERROR(dwDNN_initializeTensorRTFromFile(&m_dnn, tensorRTModel.c_str(), nullptr,
                                                    DW_PROCESSOR_TYPE_GPU, m_sdk));

```

Main function:

```auto

ProgramArguments::Option_t("video", (dw_samples::DataPath::get() + "/samples/sfm/triangulation/video_0.h264").c_str(), "path to video"),
ProgramArguments::Option_t("tensorRT_model", "", (std::string("path to TensorRT model file. By default: ") + dw_samples::DataPath::get() + "/samples/detector/yolov3.bin").c_str())},
"Object Tracker sample which detects and tracks cars.");

```

Please help in resolving the issue.

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [June 27, 2022, 1:01pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/2 "2022-06-27T13:01:29Z")

</div>

Dear @raji,  
Could you share the tensorRT\_optimization log when preparing model. Also, please double check if the same model is loaded? As per error, it seems you are loading another model. Does your machine has two GPUs?

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [June 27, 2022, 1:49pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/4 "2022-06-27T13:49:18Z")

</div>

My HOST system has only one GPU.

After generating the cross-compiled install executable, I’m transferring build folder to Pegasus and using the yolov3.bin.  
In code I’ve already specified which model to pick. Do I need to mention it during sample runtime too?

tensorRT optimization log:

```auto
$ /usr/local/driveworks-3.5/tools/dnn/tensorRT_optimization --modelType=onnx --onnxFile=/home/lidar/Documents/Nvidia_Drive/buildCrossCompile/yolov3.onnx --out=/home/lidar/Documents/Nvidia_Drive/buildCrossCompile/yolov3.bin

--------------------------------------------------------------
WARNING: Using default Logger, most probably DriveWorks
         library was linked more than once.
--------------------------------------------------------------

DefaultLogger: [27-06-2022 16:22:25] DefaultLogger: WARNING: ExplicitBatch is enabled by default for ONNX models.
Initializing TensorRT generation on model /home/lidar/Documents/Nvidia_Drive/buildCrossCompile/yolov3.onnx.
----------------------------------------------------------------
Input filename: /home/lidar/Documents/Nvidia_Drive/buildCrossCompile/yolov3.onnx
ONNX IR version: 0.0.8
Opset version: 15
Producer name: NVIDIA TensorRT sample
Producer version: 
Domain:           
Model version: 0
Doc string:       
----------------------------------------------------------------
Input "000_net": 1x3x608x608
Output "082_convolutional": 1x255x19x19
Output "094_convolutional": 1x255x38x38
Output "106_convolutional": 1x255x76x76
Building Engine...
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 0: 58.8356 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 1: 44.5033 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 2: 48.4751 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 3: 46.9769 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 4: 47.3496 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 5: 47.5444 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 6: 47.9423 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 7: 47.6099 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 8: 47.8791 ms.
Explicit batch network detected and batch size specified, use enqueue without batch size instead.
Iteration 9: 48.5833 ms.
CUDA graph OFF, Average over 10 runs is 48.5699 ms.

```

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [June 27, 2022, 1:58pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/5 "2022-06-27T13:58:34Z")

</div>

Dear @raji,  
If you want to run the executable on target, make sure you run the tensorRT\_optimization tool on target to generate model. Make sure to choose correct cudaDevice value([DriveWorks SDK Reference: TensorRT Optimizer Tool](https://docs.nvidia.com/drive/driveworks-4.0/dwx_tensorRT_tool.html)). On Pegasus, by default, it uses dGPU whose index ID is 0

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [June 28, 2022, 7:41am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/6 "2022-06-28T07:41:15Z")

</div>

@SivaRamaKrishnaNV ,

How to generate yolov3 network json?  
Now I’m facing the below error:

```auto
Driveworks exception thrown: DW_INVALID_ARGUMENT: blobName not found

terminate called after throwing an instance of 'std::runtime_error'
  what(): [2022-06-27 17:54:54] DW Error DW_INVALID_ARGUMENT executing DW function:
 dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn)
 at /usr/local/driveworks-3.5/samples/src/dnn/sample_object_detector_tracker/main.cpp:289

```

Log:

```auto
bin$ ./sample_object_detector_tracker --input-type=video --video=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264 --tensorRT_model=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/detector/yolov3.bin
[27-06-2022 17:54:46] Platform: Detected DDPX - Tegra B
[27-06-2022 17:54:46] TimeSource: monotonic epoch time offset is 1656331688718902
[27-06-2022 17:54:46] TimeSource: Could not detect valid PTP time source at nvpps. Fallback to eth0
[27-06-2022 17:54:46] TimeSource Eth: Lost PTP time synchronizaton. Synchronized time will not be available from this timesource.
[27-06-2022 17:54:46] TimeSource: Could not detect valid PTP time source at 'eth0'. Fallback to CLOCK_MONOTONIC.
[27-06-2022 17:54:46] Platform: number of GPU devices detected 2
[27-06-2022 17:54:46] Platform: currently selected GPU device discrete ID 0
[27-06-2022 17:54:46] Context::getDataPathFromSelfLocation DATA_ROOT found at: /usr/local/driveworks-3.5/data
[27-06-2022 17:54:46] SDK: No resources(.pak) mounted, some modules will not function properly
[27-06-2022 17:54:46] SDK: Create NvMediaDevice
[27-06-2022 17:54:46] SDK: Create NvMedia2D
[27-06-2022 17:54:46] SDK: use EGL display as provided
[27-06-2022 17:54:46] TimeSource: monotonic epoch time offset is 1656331688718902
[27-06-2022 17:54:46] TimeSource: Could not detect valid PTP time source at nvpps. Fallback to eth0
[27-06-2022 17:54:46] TimeSource Eth: Lost PTP time synchronizaton. Synchronized time will not be available from this timesource.
[27-06-2022 17:54:46] TimeSource: Could not detect valid PTP time source at 'eth0'. Fallback to CLOCK_MONOTONIC.
[27-06-2022 17:54:46] Initialize DriveWorks SDK v3.5.75
[27-06-2022 17:54:46] Release build with GNU 7.3.1 from heads/buildbrain-branch-0-gc61a9a35bd0 against Drive PDK v5.2.0.0
[27-06-2022 17:54:46] Initialize DriveWorks VisualizationSDK v3.5.75
[27-06-2022 17:54:46] Initialize DriveWorksGL SDK v3.5.75
[27-06-2022 17:54:46] SensorFactory::createSensor() -> camera.virtual, camera-group=a,camera-index=0,camera-type=ar0231-rccb-bae-sf3324,input-type=video,offscreen=0,profiling=1,slave=0,tensorRT_model=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/detector/yolov3.bin,video=/media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264
[27-06-2022 17:54:46] CameraVirtual: defaulting to non SIPL
[27-06-2022 17:54:46] CameraBase: pool size set to 8
[27-06-2022 17:54:46] CameraVirtualNvMedia: no seek table found at /media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/sfm/triangulation/video_0.h264.seek, seeking is not available.
SimpleCamera: Camera image: 1280x800
Camera image with 1280x800 at 30 FPS
[27-06-2022 17:54:46] StreamConsumerGL: successfully initialized
[27-06-2022 17:54:46] StreamProducerCUDA: successfully initialized
Model path: /media/nvidia/1574c8ec-78a4-40b8-b4d8-882cc419c2a0/dl-workspace/buildCrossCompile/_data/samples/detector/yolov3.bin[27-06-2022 17:54:54] Deserialize required 4844016 microseconds.
[27-06-2022 17:54:54] DNN: Metadata json file could not be found. Metadata has been filled with default values. Please place <network_filename>.json in the same directory as the network file if custom metadata is needed.
[27-06-2022 17:54:54] Driveworks exception thrown: DW_INVALID_ARGUMENT: blobName not found

terminate called after throwing an instance of 'std::runtime_error'
  what(): [2022-06-27 17:54:54] DW Error DW_INVALID_ARGUMENT executing DW function:
 dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn)
 at /usr/local/driveworks-3.5/samples/src/dnn/sample_object_detector_tracker/main.cpp:289
Aborted (core dumped)

```

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [June 30, 2022, 6:40am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/7 "2022-06-30T06:40:44Z")

</div>

Is this output from Onnx required as Metadata json file?

```auto
{
  %001_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%000_net, %001_convolutional_conv_weights)
  %001_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%001_convolutional, %001_convolutional_bn_scale, %001_convolutional_bn_bias, %001_convolutional_bn_mean, %001_convolutional_bn_var)
  %001_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%001_convolutional_bn)
  %002_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [2, 2]](%001_convolutional_lrelu, %002_convolutional_conv_weights)
  %002_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%002_convolutional, %002_convolutional_bn_scale, %002_convolutional_bn_bias, %002_convolutional_bn_mean, %002_convolutional_bn_var)
  %002_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%002_convolutional_bn)
  %003_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%002_convolutional_lrelu, %003_convolutional_conv_weights)
  %003_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%003_convolutional, %003_convolutional_bn_scale, %003_convolutional_bn_bias, %003_convolutional_bn_mean, %003_convolutional_bn_var)
  %003_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%003_convolutional_bn)
  %004_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%003_convolutional_lrelu, %004_convolutional_conv_weights)
  %004_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%004_convolutional, %004_convolutional_bn_scale, %004_convolutional_bn_bias, %004_convolutional_bn_mean, %004_convolutional_bn_var)
  %004_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%004_convolutional_bn)
  %005_shortcut = Add(%004_convolutional_lrelu, %002_convolutional_lrelu)
  %006_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [2, 2]](%005_shortcut, %006_convolutional_conv_weights)
  %006_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%006_convolutional, %006_convolutional_bn_scale, %006_convolutional_bn_bias, %006_convolutional_bn_mean, %006_convolutional_bn_var)
  %006_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%006_convolutional_bn)
  %007_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%006_convolutional_lrelu, %007_convolutional_conv_weights)
  %007_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%007_convolutional, %007_convolutional_bn_scale, %007_convolutional_bn_bias, %007_convolutional_bn_mean, %007_convolutional_bn_var)
  %007_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%007_convolutional_bn)
  %008_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%007_convolutional_lrelu, %008_convolutional_conv_weights)
  %008_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%008_convolutional, %008_convolutional_bn_scale, %008_convolutional_bn_bias, %008_convolutional_bn_mean, %008_convolutional_bn_var)
  %008_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%008_convolutional_bn)
  %009_shortcut = Add(%008_convolutional_lrelu, %006_convolutional_lrelu)
  %010_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%009_shortcut, %010_convolutional_conv_weights)
  %010_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%010_convolutional, %010_convolutional_bn_scale, %010_convolutional_bn_bias, %010_convolutional_bn_mean, %010_convolutional_bn_var)
  %010_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%010_convolutional_bn)
  %011_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%010_convolutional_lrelu, %011_convolutional_conv_weights)
  %011_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%011_convolutional, %011_convolutional_bn_scale, %011_convolutional_bn_bias, %011_convolutional_bn_mean, %011_convolutional_bn_var)
  %011_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%011_convolutional_bn)
  %012_shortcut = Add(%011_convolutional_lrelu, %009_shortcut)
  %013_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [2, 2]](%012_shortcut, %013_convolutional_conv_weights)
  %013_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%013_convolutional, %013_convolutional_bn_scale, %013_convolutional_bn_bias, %013_convolutional_bn_mean, %013_convolutional_bn_var)
  %013_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%013_convolutional_bn)
  %014_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%013_convolutional_lrelu, %014_convolutional_conv_weights)
  %014_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%014_convolutional, %014_convolutional_bn_scale, %014_convolutional_bn_bias, %014_convolutional_bn_mean, %014_convolutional_bn_var)
  %014_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%014_convolutional_bn)
  %015_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%014_convolutional_lrelu, %015_convolutional_conv_weights)
  %015_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%015_convolutional, %015_convolutional_bn_scale, %015_convolutional_bn_bias, %015_convolutional_bn_mean, %015_convolutional_bn_var)
  %015_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%015_convolutional_bn)
  %016_shortcut = Add(%015_convolutional_lrelu, %013_convolutional_lrelu)
  %017_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%016_shortcut, %017_convolutional_conv_weights)
  %017_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%017_convolutional, %017_convolutional_bn_scale, %017_convolutional_bn_bias, %017_convolutional_bn_mean, %017_convolutional_bn_var)
  %017_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%017_convolutional_bn)
  %018_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%017_convolutional_lrelu, %018_convolutional_conv_weights)
  %018_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%018_convolutional, %018_convolutional_bn_scale, %018_convolutional_bn_bias, %018_convolutional_bn_mean, %018_convolutional_bn_var)
  %018_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%018_convolutional_bn)
  %019_shortcut = Add(%018_convolutional_lrelu, %016_shortcut)
  %020_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%019_shortcut, %020_convolutional_conv_weights)
  %020_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%020_convolutional, %020_convolutional_bn_scale, %020_convolutional_bn_bias, %020_convolutional_bn_mean, %020_convolutional_bn_var)
  %020_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%020_convolutional_bn)
  %021_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%020_convolutional_lrelu, %021_convolutional_conv_weights)
  %021_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%021_convolutional, %021_convolutional_bn_scale, %021_convolutional_bn_bias, %021_convolutional_bn_mean, %021_convolutional_bn_var)
  %021_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%021_convolutional_bn)
  %022_shortcut = Add(%021_convolutional_lrelu, %019_shortcut)
  %023_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%022_shortcut, %023_convolutional_conv_weights)
  %023_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%023_convolutional, %023_convolutional_bn_scale, %023_convolutional_bn_bias, %023_convolutional_bn_mean, %023_convolutional_bn_var)
  %023_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%023_convolutional_bn)
  %024_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%023_convolutional_lrelu, %024_convolutional_conv_weights)
  %024_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%024_convolutional, %024_convolutional_bn_scale, %024_convolutional_bn_bias, %024_convolutional_bn_mean, %024_convolutional_bn_var)
  %024_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%024_convolutional_bn)
  %025_shortcut = Add(%024_convolutional_lrelu, %022_shortcut)
  %026_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%025_shortcut, %026_convolutional_conv_weights)
  %026_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%026_convolutional, %026_convolutional_bn_scale, %026_convolutional_bn_bias, %026_convolutional_bn_mean, %026_convolutional_bn_var)
  %026_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%026_convolutional_bn)
  %027_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%026_convolutional_lrelu, %027_convolutional_conv_weights)
  %027_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%027_convolutional, %027_convolutional_bn_scale, %027_convolutional_bn_bias, %027_convolutional_bn_mean, %027_convolutional_bn_var)
  %027_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%027_convolutional_bn)
  %028_shortcut = Add(%027_convolutional_lrelu, %025_shortcut)
  %029_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%028_shortcut, %029_convolutional_conv_weights)
  %029_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%029_convolutional, %029_convolutional_bn_scale, %029_convolutional_bn_bias, %029_convolutional_bn_mean, %029_convolutional_bn_var)
  %029_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%029_convolutional_bn)
  %030_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%029_convolutional_lrelu, %030_convolutional_conv_weights)
  %030_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%030_convolutional, %030_convolutional_bn_scale, %030_convolutional_bn_bias, %030_convolutional_bn_mean, %030_convolutional_bn_var)
  %030_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%030_convolutional_bn)
  %031_shortcut = Add(%030_convolutional_lrelu, %028_shortcut)
  %032_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%031_shortcut, %032_convolutional_conv_weights)
  %032_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%032_convolutional, %032_convolutional_bn_scale, %032_convolutional_bn_bias, %032_convolutional_bn_mean, %032_convolutional_bn_var)
  %032_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%032_convolutional_bn)
  %033_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%032_convolutional_lrelu, %033_convolutional_conv_weights)
  %033_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%033_convolutional, %033_convolutional_bn_scale, %033_convolutional_bn_bias, %033_convolutional_bn_mean, %033_convolutional_bn_var)
  %033_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%033_convolutional_bn)
  %034_shortcut = Add(%033_convolutional_lrelu, %031_shortcut)
  %035_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%034_shortcut, %035_convolutional_conv_weights)
  %035_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%035_convolutional, %035_convolutional_bn_scale, %035_convolutional_bn_bias, %035_convolutional_bn_mean, %035_convolutional_bn_var)
  %035_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%035_convolutional_bn)
  %036_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%035_convolutional_lrelu, %036_convolutional_conv_weights)
  %036_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%036_convolutional, %036_convolutional_bn_scale, %036_convolutional_bn_bias, %036_convolutional_bn_mean, %036_convolutional_bn_var)
  %036_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%036_convolutional_bn)
  %037_shortcut = Add(%036_convolutional_lrelu, %034_shortcut)
  %038_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [2, 2]](%037_shortcut, %038_convolutional_conv_weights)
  %038_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%038_convolutional, %038_convolutional_bn_scale, %038_convolutional_bn_bias, %038_convolutional_bn_mean, %038_convolutional_bn_var)
  %038_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%038_convolutional_bn)
  %039_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%038_convolutional_lrelu, %039_convolutional_conv_weights)
  %039_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%039_convolutional, %039_convolutional_bn_scale, %039_convolutional_bn_bias, %039_convolutional_bn_mean, %039_convolutional_bn_var)
  %039_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%039_convolutional_bn)
  %040_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%039_convolutional_lrelu, %040_convolutional_conv_weights)
  %040_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%040_convolutional, %040_convolutional_bn_scale, %040_convolutional_bn_bias, %040_convolutional_bn_mean, %040_convolutional_bn_var)
  %040_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%040_convolutional_bn)
  %041_shortcut = Add(%040_convolutional_lrelu, %038_convolutional_lrelu)
  %042_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%041_shortcut, %042_convolutional_conv_weights)
  %042_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%042_convolutional, %042_convolutional_bn_scale, %042_convolutional_bn_bias, %042_convolutional_bn_mean, %042_convolutional_bn_var)
  %042_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%042_convolutional_bn)
  %043_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%042_convolutional_lrelu, %043_convolutional_conv_weights)
  %043_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%043_convolutional, %043_convolutional_bn_scale, %043_convolutional_bn_bias, %043_convolutional_bn_mean, %043_convolutional_bn_var)
  %043_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%043_convolutional_bn)
  %044_shortcut = Add(%043_convolutional_lrelu, %041_shortcut)
  %045_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%044_shortcut, %045_convolutional_conv_weights)
  %045_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%045_convolutional, %045_convolutional_bn_scale, %045_convolutional_bn_bias, %045_convolutional_bn_mean, %045_convolutional_bn_var)
  %045_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%045_convolutional_bn)
  %046_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%045_convolutional_lrelu, %046_convolutional_conv_weights)
  %046_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%046_convolutional, %046_convolutional_bn_scale, %046_convolutional_bn_bias, %046_convolutional_bn_mean, %046_convolutional_bn_var)
  %046_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%046_convolutional_bn)
  %047_shortcut = Add(%046_convolutional_lrelu, %044_shortcut)
  %048_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%047_shortcut, %048_convolutional_conv_weights)
  %048_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%048_convolutional, %048_convolutional_bn_scale, %048_convolutional_bn_bias, %048_convolutional_bn_mean, %048_convolutional_bn_var)
  %048_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%048_convolutional_bn)
  %049_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%048_convolutional_lrelu, %049_convolutional_conv_weights)
  %049_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%049_convolutional, %049_convolutional_bn_scale, %049_convolutional_bn_bias, %049_convolutional_bn_mean, %049_convolutional_bn_var)
  %049_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%049_convolutional_bn)
  %050_shortcut = Add(%049_convolutional_lrelu, %047_shortcut)
  %051_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%050_shortcut, %051_convolutional_conv_weights)
  %051_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%051_convolutional, %051_convolutional_bn_scale, %051_convolutional_bn_bias, %051_convolutional_bn_mean, %051_convolutional_bn_var)
  %051_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%051_convolutional_bn)
  %052_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%051_convolutional_lrelu, %052_convolutional_conv_weights)
  %052_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%052_convolutional, %052_convolutional_bn_scale, %052_convolutional_bn_bias, %052_convolutional_bn_mean, %052_convolutional_bn_var)
  %052_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%052_convolutional_bn)
  %053_shortcut = Add(%052_convolutional_lrelu, %050_shortcut)
  %054_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%053_shortcut, %054_convolutional_conv_weights)
  %054_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%054_convolutional, %054_convolutional_bn_scale, %054_convolutional_bn_bias, %054_convolutional_bn_mean, %054_convolutional_bn_var)
  %054_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%054_convolutional_bn)
  %055_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%054_convolutional_lrelu, %055_convolutional_conv_weights)
  %055_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%055_convolutional, %055_convolutional_bn_scale, %055_convolutional_bn_bias, %055_convolutional_bn_mean, %055_convolutional_bn_var)
  %055_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%055_convolutional_bn)
  %056_shortcut = Add(%055_convolutional_lrelu, %053_shortcut)
  %057_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%056_shortcut, %057_convolutional_conv_weights)
  %057_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%057_convolutional, %057_convolutional_bn_scale, %057_convolutional_bn_bias, %057_convolutional_bn_mean, %057_convolutional_bn_var)
  %057_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%057_convolutional_bn)
  %058_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%057_convolutional_lrelu, %058_convolutional_conv_weights)
  %058_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%058_convolutional, %058_convolutional_bn_scale, %058_convolutional_bn_bias, %058_convolutional_bn_mean, %058_convolutional_bn_var)
  %058_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%058_convolutional_bn)
  %059_shortcut = Add(%058_convolutional_lrelu, %056_shortcut)
  %060_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%059_shortcut, %060_convolutional_conv_weights)
  %060_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%060_convolutional, %060_convolutional_bn_scale, %060_convolutional_bn_bias, %060_convolutional_bn_mean, %060_convolutional_bn_var)
  %060_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%060_convolutional_bn)
  %061_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%060_convolutional_lrelu, %061_convolutional_conv_weights)
  %061_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%061_convolutional, %061_convolutional_bn_scale, %061_convolutional_bn_bias, %061_convolutional_bn_mean, %061_convolutional_bn_var)
  %061_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%061_convolutional_bn)
  %062_shortcut = Add(%061_convolutional_lrelu, %059_shortcut)
  %063_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [2, 2]](%062_shortcut, %063_convolutional_conv_weights)
  %063_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%063_convolutional, %063_convolutional_bn_scale, %063_convolutional_bn_bias, %063_convolutional_bn_mean, %063_convolutional_bn_var)
  %063_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%063_convolutional_bn)
  %064_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%063_convolutional_lrelu, %064_convolutional_conv_weights)
  %064_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%064_convolutional, %064_convolutional_bn_scale, %064_convolutional_bn_bias, %064_convolutional_bn_mean, %064_convolutional_bn_var)
  %064_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%064_convolutional_bn)
  %065_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%064_convolutional_lrelu, %065_convolutional_conv_weights)
  %065_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%065_convolutional, %065_convolutional_bn_scale, %065_convolutional_bn_bias, %065_convolutional_bn_mean, %065_convolutional_bn_var)
  %065_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%065_convolutional_bn)
  %066_shortcut = Add(%065_convolutional_lrelu, %063_convolutional_lrelu)
  %067_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%066_shortcut, %067_convolutional_conv_weights)
  %067_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%067_convolutional, %067_convolutional_bn_scale, %067_convolutional_bn_bias, %067_convolutional_bn_mean, %067_convolutional_bn_var)
  %067_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%067_convolutional_bn)
  %068_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%067_convolutional_lrelu, %068_convolutional_conv_weights)
  %068_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%068_convolutional, %068_convolutional_bn_scale, %068_convolutional_bn_bias, %068_convolutional_bn_mean, %068_convolutional_bn_var)
  %068_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%068_convolutional_bn)
  %069_shortcut = Add(%068_convolutional_lrelu, %066_shortcut)
  %070_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%069_shortcut, %070_convolutional_conv_weights)
  %070_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%070_convolutional, %070_convolutional_bn_scale, %070_convolutional_bn_bias, %070_convolutional_bn_mean, %070_convolutional_bn_var)
  %070_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%070_convolutional_bn)
  %071_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%070_convolutional_lrelu, %071_convolutional_conv_weights)
  %071_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%071_convolutional, %071_convolutional_bn_scale, %071_convolutional_bn_bias, %071_convolutional_bn_mean, %071_convolutional_bn_var)
  %071_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%071_convolutional_bn)
  %072_shortcut = Add(%071_convolutional_lrelu, %069_shortcut)
  %073_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%072_shortcut, %073_convolutional_conv_weights)
  %073_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%073_convolutional, %073_convolutional_bn_scale, %073_convolutional_bn_bias, %073_convolutional_bn_mean, %073_convolutional_bn_var)
  %073_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%073_convolutional_bn)
  %074_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%073_convolutional_lrelu, %074_convolutional_conv_weights)
  %074_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%074_convolutional, %074_convolutional_bn_scale, %074_convolutional_bn_bias, %074_convolutional_bn_mean, %074_convolutional_bn_var)
  %074_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%074_convolutional_bn)
  %075_shortcut = Add(%074_convolutional_lrelu, %072_shortcut)
  %076_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%075_shortcut, %076_convolutional_conv_weights)
  %076_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%076_convolutional, %076_convolutional_bn_scale, %076_convolutional_bn_bias, %076_convolutional_bn_mean, %076_convolutional_bn_var)
  %076_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%076_convolutional_bn)
  %077_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%076_convolutional_lrelu, %077_convolutional_conv_weights)
  %077_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%077_convolutional, %077_convolutional_bn_scale, %077_convolutional_bn_bias, %077_convolutional_bn_mean, %077_convolutional_bn_var)
  %077_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%077_convolutional_bn)
  %078_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%077_convolutional_lrelu, %078_convolutional_conv_weights)
  %078_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%078_convolutional, %078_convolutional_bn_scale, %078_convolutional_bn_bias, %078_convolutional_bn_mean, %078_convolutional_bn_var)
  %078_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%078_convolutional_bn)
  %079_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%078_convolutional_lrelu, %079_convolutional_conv_weights)
  %079_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%079_convolutional, %079_convolutional_bn_scale, %079_convolutional_bn_bias, %079_convolutional_bn_mean, %079_convolutional_bn_var)
  %079_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%079_convolutional_bn)
  %080_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%079_convolutional_lrelu, %080_convolutional_conv_weights)
  %080_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%080_convolutional, %080_convolutional_bn_scale, %080_convolutional_bn_bias, %080_convolutional_bn_mean, %080_convolutional_bn_var)
  %080_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%080_convolutional_bn)
  %081_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%080_convolutional_lrelu, %081_convolutional_conv_weights)
  %081_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%081_convolutional, %081_convolutional_bn_scale, %081_convolutional_bn_bias, %081_convolutional_bn_mean, %081_convolutional_bn_var)
  %081_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%081_convolutional_bn)
  %082_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%081_convolutional_lrelu, %082_convolutional_conv_weights, %082_convolutional_conv_bias)
  %085_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%080_convolutional_lrelu, %085_convolutional_conv_weights)
  %085_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%085_convolutional, %085_convolutional_bn_scale, %085_convolutional_bn_bias, %085_convolutional_bn_mean, %085_convolutional_bn_var)
  %085_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%085_convolutional_bn)
  %086_upsample = Resize[coordinate_transformation_mode = 'asymmetric', mode = 'nearest', nearest_mode = 'floor'](%085_convolutional_lrelu, %086_upsample_roi, %086_upsample_scale)
  %087_route = Concat[axis = 1](%086_upsample, %062_shortcut)
  %088_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%087_route, %088_convolutional_conv_weights)
  %088_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%088_convolutional, %088_convolutional_bn_scale, %088_convolutional_bn_bias, %088_convolutional_bn_mean, %088_convolutional_bn_var)
  %088_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%088_convolutional_bn)
  %089_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%088_convolutional_lrelu, %089_convolutional_conv_weights)
  %089_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%089_convolutional, %089_convolutional_bn_scale, %089_convolutional_bn_bias, %089_convolutional_bn_mean, %089_convolutional_bn_var)
  %089_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%089_convolutional_bn)
  %090_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%089_convolutional_lrelu, %090_convolutional_conv_weights)
  %090_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%090_convolutional, %090_convolutional_bn_scale, %090_convolutional_bn_bias, %090_convolutional_bn_mean, %090_convolutional_bn_var)
  %090_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%090_convolutional_bn)
  %091_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%090_convolutional_lrelu, %091_convolutional_conv_weights)
  %091_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%091_convolutional, %091_convolutional_bn_scale, %091_convolutional_bn_bias, %091_convolutional_bn_mean, %091_convolutional_bn_var)
  %091_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%091_convolutional_bn)
  %092_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%091_convolutional_lrelu, %092_convolutional_conv_weights)
  %092_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%092_convolutional, %092_convolutional_bn_scale, %092_convolutional_bn_bias, %092_convolutional_bn_mean, %092_convolutional_bn_var)
  %092_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%092_convolutional_bn)
  %093_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%092_convolutional_lrelu, %093_convolutional_conv_weights)
  %093_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%093_convolutional, %093_convolutional_bn_scale, %093_convolutional_bn_bias, %093_convolutional_bn_mean, %093_convolutional_bn_var)
  %093_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%093_convolutional_bn)
  %094_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%093_convolutional_lrelu, %094_convolutional_conv_weights, %094_convolutional_conv_bias)
  %097_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%092_convolutional_lrelu, %097_convolutional_conv_weights)
  %097_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%097_convolutional, %097_convolutional_bn_scale, %097_convolutional_bn_bias, %097_convolutional_bn_mean, %097_convolutional_bn_var)
  %097_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%097_convolutional_bn)
  %098_upsample = Resize[coordinate_transformation_mode = 'asymmetric', mode = 'nearest', nearest_mode = 'floor'](%097_convolutional_lrelu, %098_upsample_roi, %098_upsample_scale)
  %099_route = Concat[axis = 1](%098_upsample, %037_shortcut)
  %100_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%099_route, %100_convolutional_conv_weights)
  %100_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%100_convolutional, %100_convolutional_bn_scale, %100_convolutional_bn_bias, %100_convolutional_bn_mean, %100_convolutional_bn_var)
  %100_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%100_convolutional_bn)
  %101_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%100_convolutional_lrelu, %101_convolutional_conv_weights)
  %101_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%101_convolutional, %101_convolutional_bn_scale, %101_convolutional_bn_bias, %101_convolutional_bn_mean, %101_convolutional_bn_var)
  %101_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%101_convolutional_bn)
  %102_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%101_convolutional_lrelu, %102_convolutional_conv_weights)
  %102_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%102_convolutional, %102_convolutional_bn_scale, %102_convolutional_bn_bias, %102_convolutional_bn_mean, %102_convolutional_bn_var)
  %102_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%102_convolutional_bn)
  %103_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%102_convolutional_lrelu, %103_convolutional_conv_weights)
  %103_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%103_convolutional, %103_convolutional_bn_scale, %103_convolutional_bn_bias, %103_convolutional_bn_mean, %103_convolutional_bn_var)
  %103_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%103_convolutional_bn)
  %104_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%103_convolutional_lrelu, %104_convolutional_conv_weights)
  %104_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%104_convolutional, %104_convolutional_bn_scale, %104_convolutional_bn_bias, %104_convolutional_bn_mean, %104_convolutional_bn_var)
  %104_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%104_convolutional_bn)
  %105_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [3, 3], strides = [1, 1]](%104_convolutional_lrelu, %105_convolutional_conv_weights)
  %105_convolutional_bn = BatchNormalization[epsilon = 9.99999974737875e-06, momentum = 0.990000009536743](%105_convolutional, %105_convolutional_bn_scale, %105_convolutional_bn_bias, %105_convolutional_bn_mean, %105_convolutional_bn_var)
  %105_convolutional_lrelu = LeakyRelu[alpha = 0.100000001490116](%105_convolutional_bn)
  %106_convolutional = Conv[auto_pad = 'SAME_LOWER', dilations = [1, 1], kernel_shape = [1, 1], strides = [1, 1]](%105_convolutional_lrelu, %106_convolutional_conv_weights, %106_convolutional_conv_bias)
  return %082_convolutional, %094_convolutional, %106_convolutional
}

```

Please help me understand.

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [July 6, 2022, 10:13am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/8 "2022-07-06T10:13:30Z")

</div>

@SivaRamaKrishnaNV , Please advice.

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [July 25, 2022, 1:18pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/9 "2022-07-25T13:18:18Z")

</div>

Dear @raji,  
My apologies for missing the topic update.  
Do you still have issue?

I see `DW_INVALID_ARGUMENT: blobName not found` error. Make sure you are using right output blobs.

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [July 26, 2022, 11:25am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/10 "2022-07-26T11:25:09Z")

</div>

Hi @SivaRamaKrishnaNV ,

Since there is no onnx graph visualiser how am I supposed to understand the output blobs?  
From the logs I can get this information:

```auto
....
....
Input filename: /home/lidar/Documents/Nvidia_Drive/buildCrossCompile/yolov3.onnx
ONNX IR version: 0.0.8
Opset version: 15
Producer name: NVIDIA TensorRT sample
Producer version: 
Domain:           
Model version: 0
Doc string:       
----------------------------------------------------------------
Input "000_net": 1x3x608x608
Output "082_convolutional": 1x255x19x19
Output "094_convolutional": 1x255x38x38
Output "106_convolutional": 1x255x76x76
...
...
...

```

Please elaborate.  
FYR attaching the original json file having the data conditioner params of the model and the logs file.

[Onnx\_TRT.txt](https://forums.developer.nvidia.com/uploads/short-url/s9NwzPa2Z7akEtAhjXlZruk86st.txt) (766 Bytes)  
What should I put in data conditioner params model bin json file? How to know the blob names?

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [July 27, 2022, 9:09am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/11 "2022-07-27T09:09:50Z")

</div>

Dear @raji,  
I can see below are the input/output nodes from ONNX file from TensorRT optimization log.

```auto
Input "000_net": 1x3x608x608
Output "082_convolutional": 1x255x19x19
Output "094_convolutional": 1x255x38x38
Output "106_convolutional": 1x255x76x76

```

Please confirm if you are using files from `/usr/src/tensorrt/samples/python/yolov3_onnx` so that I will check reproducing the issue on object detector sample ?

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [July 27, 2022, 3:31pm UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/12 "2022-07-27T15:31:11Z")

</div>

Dear @raji,  
You need to use blobs names as `082_convolutional, 094_convolutional` and `106_convolutional.`  
It looks like you are using wrong blob name for `coverageBlobName` variable.

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [July 28, 2022, 5:35am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/13 "2022-07-28T05:35:44Z")

</div>

> [@SivaRamaKrishnaNV](#):
>
> /usr/src/tensorrt/samples/python/yolov3\_onnx

Yes in my host system, I’m using files from “/usr/src/tensorrt/samples/python/yolov3\_onnx”

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [July 28, 2022, 5:43am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/14 "2022-07-28T05:43:49Z")

</div>

```auto
 // Get coverage and bounding box blob indices
            const char* coverageBlobName = "coverage";
            const char* boundingBoxBlobName = "bboxes";
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_bboxIdx, boundingBoxBlobName, m_dnn));

```

Shall I modify the code at “/usr/local/driveworks-3.5/samples/src/dnn/sample\_object\_detector\_tracker/main.cpp” as below in my host system and then cross-compile to generate the executable which I will transfer to target system?

```auto
 // Get coverage and bounding box blob indices
            const char* coverageBlobName = "082_convolutional";
            const char* boundingBoxBlobName = "082_convolutional";
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_bboxIdx, boundingBoxBlobName, m_dnn));

 // Get coverage and bounding box blob indices
            const char* coverageBlobName = "094_convolutional";
            const char* boundingBoxBlobName = "094_convolutional";
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_bboxIdx, boundingBoxBlobName, m_dnn));

 // Get coverage and bounding box blob indices
            const char* coverageBlobName = "106_convolutional";
            const char* boundingBoxBlobName = "106_convolutional";
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_bboxIdx, boundingBoxBlobName, m_dnn));

```

---

<div class="post-metadata">

**Author:** ![raji](https://developer.download.nvidia.com/images/forums/profile-default-devtalk-84.png) [@raji](https://forums.developer.nvidia.com/u/raji)\
**Post date:** [August 3, 2022, 6:15am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/15 "2022-08-03T06:15:29Z")

</div>

@SivaRamaKrishnaNV , could you please look into this and let me know if this code changes is going to work?

---

<div class="post-metadata">

**Author:** ![SivaRamaKrishnaNV](https://sea2.discourse-cdn.com/nvidia/user_avatar/forums.developer.nvidia.com/sivaramakrishnanv/32/14043_2.png) [@SivaRamaKrishnaNV](https://forums.developer.nvidia.com/u/SivaRamaKrishnaNV)\
**Post date:** [August 4, 2022, 10:26am UTC](https://forums.developer.nvidia.com/t/sample-object-detector-tracker-yolov3-model-error-inference/218917/16 "2022-08-04T10:26:56Z")

</div>

Dear @raji,  
Note that replacing the model used in object detector tracker sample with yolo v3 does not work out of the box. The post processing of each model is different. In case of yolo v3, you get 3 arrays of different scales. Each array will have information about detected objects like bounding box, object confidence, class array at different scale. You need to post process these arrays to get final bouding boxes. Please check data processing functions in TensorRT yolo v3 python sample.

You may use code like below as a reference

```auto
 CHECK_DW_ERROR(dwDNN_getInputSize(&m_networkInputDimensions, 0U, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputSize(&m_networkOutputDimensions[0], 0U, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputSize(&m_networkOutputDimensions[1], 1U, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputSize(&m_networkOutputDimensions[2], 2U, m_dnn)); //added
            auto getTotalSize = [](const dwBlobSize& blobSize) {
                return blobSize.channels * blobSize.height * blobSize.width;
            };
            // Calculate total size needed to store input and output
            m_totalSizeInput = getTotalSize(m_networkInputDimensions);
            m_totalSizesOutput[0] = getTotalSize(m_networkOutputDimensions[0]);
            m_totalSizesOutput[1] = getTotalSize(m_networkOutputDimensions[1]);
            m_totalSizesOutput[2] = getTotalSize(m_networkOutputDimensions[2]); //added
            // Get coverage and bounding box blob indices
            const char* largeBlobName = "082_convolutional";//added
            const char* mediumBlobName = "094_convolutional";//added
// const char* coverageBlobName = "coverage";
            const char* smallBlobName = "106_convolutional";
// CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_cvgIdx, coverageBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_largeIdx, largeBlobName, m_dnn)); //added
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_mediumIdx, mediumBlobName, m_dnn));
            CHECK_DW_ERROR(dwDNN_getOutputIndex(&m_smallIdx, smallBlobName, m_dnn)); //added
            std::cout<<"m_largeIdx= "<<m_largeIdx<<"m_mediumIdx= "<<m_mediumIdx<<"m_smallIdx= "<<m_smallIdx<<std::endl;
            // Allocate GPU memory
            CHECK_CUDA_ERROR(cudaMalloc((void**)&m_dnnInputDevice, sizeof(float32_t) * m_totalSizeInput));
            CHECK_CUDA_ERROR(cudaMalloc((void**)&m_dnnOutputsDevice[0],
                                        sizeof(float32_t) * m_totalSizesOutput[0]));
            CHECK_CUDA_ERROR(cudaMalloc((void**)&m_dnnOutputsDevice[1],
                                        sizeof(float32_t) * m_totalSizesOutput[1]));
            CHECK_CUDA_ERROR(cudaMalloc((void**)&m_dnnOutputsDevice[2],
                                        sizeof(float32_t) * m_totalSizesOutput[2])); //added

```
