def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
bn_momentum=0.1,
bn_eps=1e-05):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = SynchronizedBatchNorm2d(planes,
momentum=bn_momentum,
eps=bn_eps)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bias=False)
self.bn2 = SynchronizedBatchNorm2d(planes,
momentum=bn_momentum,
eps=bn_eps)
self.conv3 = nn.Conv2d(planes,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = SynchronizedBatchNorm2d(planes * self.expansion,
momentum=bn_momentum,
eps=bn_eps)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, class_num, bn_momentum=0.1):
super(Decoder, self).__init__()
self.conv1 = nn.Conv2d(256, 48, kernel_size=1, bias=False)
self.bn1 = SynchronizedBatchNorm2d(48, momentum=bn_momentum)
self.relu = nn.ReLU()
# self.conv2 = SeparableConv2d(304, 256, kernel_size=3)
# self.conv3 = SeparableConv2d(256, 256, kernel_size=3)
self.conv2 = nn.Conv2d(304, 256, kernel_size=3, padding=1, bias=False)
self.bn2 = SynchronizedBatchNorm2d(256, momentum=bn_momentum)
self.dropout2 = nn.Dropout(0.5)
self.conv3 = nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False)
self.bn3 = SynchronizedBatchNorm2d(256, momentum=bn_momentum)
self.dropout3 = nn.Dropout(0.1)
self.conv4 = nn.Conv2d(256, class_num, kernel_size=1)
self._init_weight()
def __init__(self, bn_momentum=0.1, output_stride=16):
super(Encoder, self).__init__()
self.ASPP = AsppModule(bn_momentum=bn_momentum,
output_stride=output_stride)
self.relu = nn.ReLU()
self.conv1 = nn.Conv2d(1280, 256, 1, bias=False)
self.bn1 = SynchronizedBatchNorm2d(256, momentum=bn_momentum)
self.dropout = nn.Dropout(0.5)
self.__init_weight()
def __init__(self,
block,
layers,
bn_momentum=0.1,
pretrained=False,
output_stride=16):
if output_stride == 16:
dilations = [1, 1, 1, 2]
strides = [1, 2, 2, 1]
elif output_stride == 8:
dilations = [1, 1, 2, 4]
strides = [1, 2, 1, 1]
else:
raise Warning("output_stride must be 8 or 16!")
self.inplanes = 64
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = SynchronizedBatchNorm2d(64, momentum=bn_momentum)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block,
64,
layers[0],
stride=strides[0],
dilation=dilations[0],
bn_momentum=bn_momentum)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=strides[1],
dilation=dilations[1],
bn_momentum=bn_momentum)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=strides[2],
dilation=dilations[2],
bn_momentum=bn_momentum)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=strides[3],
dilation=dilations[3],
bn_momentum=bn_momentum)
self._init_weight()
if pretrained:
self._load_pretrained_model()
def __init__(self, bn_momentum=0.1, output_stride=16, bn_eps=1e-05):
super(AsppModule, self).__init__()
# output_stride choice
if output_stride == 16:
atrous_rates = [0, 6, 12, 18]
elif output_stride == 8:
atrous_rates = 2 * [0, 12, 24, 36]
else:
raise Warning("output_stride must be 8 or 16!")
# atrous_spatial_pyramid_pooling part
self._atrous_convolution1 = _AsppConv(2048,
256,
1,
1,
bn_momentum=bn_momentum,
bn_eps=bn_eps)
self._atrous_convolution2 = _AsppConv(2048,
256,
3,
1,
padding=atrous_rates[1],
dilation=atrous_rates[1],
bn_momentum=bn_momentum,
bn_eps=bn_eps)
self._atrous_convolution3 = _AsppConv(2048,
256,
3,
1,
padding=atrous_rates[2],
dilation=atrous_rates[2],
bn_momentum=bn_momentum,
bn_eps=bn_eps)
self._atrous_convolution4 = _AsppConv(2048,
256,
3,
1,
padding=atrous_rates[3],
dilation=atrous_rates[3],
bn_momentum=bn_momentum,
bn_eps=bn_eps)
#image_pooling part
self._image_pool = nn.Sequential(
nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(2048, 256, kernel_size=1, bias=False),
SynchronizedBatchNorm2d(256, momentum=bn_momentum, eps=bn_eps),
nn.ReLU())
self.__init_weight()
def _AsppConv(in_channels,
out_channels,
kernel_size,
stride=1,
padding=0,
dilation=1,
bn_momentum=0.1):
asppconv = nn.Sequential(
nn.Conv2d(in_channels,
out_channels,
kernel_size,
stride,
padding,
dilation,
bias=False),
SynchronizedBatchNorm2d(out_channels, momentum=bn_momentum), nn.ReLU())
return asppconv
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilation=1,
bn_momentum=0.1,
bn_eps=1e-05):
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),
SynchronizedBatchNorm2d(planes * block.expansion,
momentum=bn_momentum,
eps=bn_eps),
)
layers = []
layers.append(
block(self.inplanes,
planes,
stride,
dilation,
downsample,
bn_momentum=bn_momentum,
bn_eps=bn_eps))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
dilation=dilation,
bn_momentum=bn_momentum,
bn_eps=bn_eps))
return nn.Sequential(*layers)
