Description
model(network) : deeplab v3
I export deeplabv3 to onnx. Then, using trtexec, we want to test the performance (speed) in TensorAlti.
The export to pytorch-> onnx was successful.
However, an error occurred in output.onnx (deeplabv3) with trtexec.
The code below is an error code.
terminate called after throwing an instance of ‘std :: out_of_range’
what (): Attribute not found: pads
Aborted (core dumped)
There was no answer through Google search, so I left this article. In addition, please tell me if you need to let me know.
I look forward to a successful response.
Environment
TensorRT Version: tensorrt 7.0.0.11
GPU Type: RTX 2080ti
Nvidia Driver Version: 440.64
CUDA Version: 10.2
CUDNN Version: i don’t know
Operating System + Version: ubuntu 18.04
Python Version (if applicable): 3.6x
TensorFlow Version (if applicable): X
PyTorch Version (if applicable): 1.4.0
Baremetal or Container (if container which image + tag): Ok ( _tensorrt git(url:GitHub - NVIDIA/TensorRT: TensorRT is a C++ library for high performance inference on NVIDIA GPUs and deep learning accelerators.))
Relevant Files
Please attach or include links to any models, data, files, or scripts necessary to reproduce your issue. (Github repo, Google Drive, Dropbox, etc.)
#deeplabv3.py#
import torch.nn as nn
from torch.nn import functional as F
import math
import torch.utils.model_zoo as model_zoo
import torch
import numpy as np
from torch.autograd import Variable
affine_par = True
import functools
import sys, os
BatchNorm2d = nn.BatchNorm2d
def conv3x3(in_planes, out_planes, stride=1):
“3x3 convolution with padding”
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
class Bottleneck(nn.Module):
expansion = 4
def init(self, inplanes, planes, stride=1, dilation=1, downsample=None, fist_dilation=1, multi_grid=1):
super(Bottleneck, self).init()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
padding=dilationmulti_grid, dilation=dilationmulti_grid, bias=False)
self.bn2 = BatchNorm2d(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = BatchNorm2d(planes * 4)
self.relu = nn.ReLU(inplace=False)
self.relu_inplace = nn.ReLU(inplace=True)
self.downsample = downsample
self.dilation = dilation
self.stride = stride
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
residual = self.downsample(x)
out = out + residual
out = self.relu_inplace(out)
return out
class ASPPModule(nn.Module):
“”"
Reference:
Chen, Liang-Chieh, et al. “Rethinking Atrous Convolution for Semantic Image Segmentation.”
“”"
def init(self, features, inner_features=256, out_features=512, dilations=(12, 24, 36)):
super(ASPPModule, self).init()
self.avg = torch.mean
self.conv1 = nn.Sequential(nn.AvgPool2d((129,257)),
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
)
self.conv2 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
nn.BatchNorm2d(inner_features))
self.conv3 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[0], dilation=dilations[0], bias=False),
nn.BatchNorm2d(inner_features))
self.conv4 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[1], dilation=dilations[1], bias=False),
nn.BatchNorm2d(inner_features))
self.conv5 = nn.Sequential(nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[2], dilation=dilations[2], bias=False),
nn.BatchNorm2d(inner_features))
self.bottleneck = nn.Sequential(
nn.Conv2d(inner_features * 5, out_features, padding=0, kernel_size=1, dilation=1, bias=False),
nn.BatchNorm2d(out_features),
nn.Dropout2d(0.1)
)
self.conv1_batchnorm1d= nn.BatchNorm1d(256)
def forward(self, x):
inter_x = self.conv1(x)
inter_x = inter_x.view(1, -1)
inter_x = self.conv1_batchnorm1d(inter_x)
inter_x = inter_x.view(1, 256, 1, 1)
feat1 = F.interpolate(inter_x, size=(129, 257), mode='bilinear', align_corners=True)
feat2 = self.conv2(x)
feat3 = self.conv3(x)
feat4 = self.conv4(x)
feat5 = self.conv5(x)
out = torch.cat([feat1, feat2, feat3, feat4, feat5], 1)
bottle = self.bottleneck(out)
return bottle
class ResNet(nn.Module):
def init(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).init()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True) # change
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4, multi_grid=(1,1,1))
self.head = nn.Sequential(ASPPModule(2048),
nn.Conv2d(512, num_classes, kernel_size=1, stride=1, padding=0, bias=True))
def _make_layer(self, block, planes, blocks, stride=1, dilation=1, multi_grid=1):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(self.inplanes, planes * block.expansion,
kernel_size=1, stride=stride, bias=False),
BatchNorm2d(planes * block.expansion))
layers = []
generate_multi_grid = lambda index, grids: grids[index%len(grids)] if isinstance(grids, tuple) else 1
layers.append(block(self.inplanes, planes, stride,dilation=dilation, downsample=downsample, multi_grid=generate_multi_grid(0, multi_grid)))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes, dilation=dilation, multi_grid=generate_multi_grid(i, multi_grid)))
return nn.Sequential(*layers)
def forward(self, x):
x = self.relu1(self.bn1(self.conv1(x)))
x = self.relu2(self.bn2(self.conv2(x)))
x = self.relu3(self.bn3(self.conv3(x)))
x = self.maxpool(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.head(x)
return x
def Res_Deeplab(num_classes=21):
model = ResNet(Bottleneck,[3, 4, 23, 3], num_classes)
return model
##export.py##
from deeplabv3 import *
import torch
torch_model = Res_Deeplab()
torch_model.eval()
x = torch.randn(1, 3, 1024, 2048, requires_grad=True)
torch_out = torch_model(x)
orch.onnx.export(torch_model,
x,
“super_resolution.onnx”,
export_params=True,
opset_version=11,
do_constant_folding=True,
input_names = [‘input’],
output_names = [‘output’],
dynamic_axes={‘input’ : {0 : ‘batch_size’},
‘output’ : {0 : ‘batch_size’}})
Steps To Reproduce
i want : pytorch (deeplabv3.py) → onnx(export.py) → trtexec
command : trtexec --onnx=deeplabv3.onnx --maxBatch=1 --shapes=input:1x3x1024x2048 --iterations=500 --workspace 9000
error code :
terminate called after throwing an instance of ‘std :: out_of_range’
what (): Attribute not found: pads
Aborted (core dumped)