def __init__(self,
in_channels,
out_channels,
internal_ratio=4,
return_indices=False,
dropout_prob=0,
bias=False,
relu=True):
super(DownsamplingBottleneck, self).__init__()
self.return_indices = return_indices
if internal_ratio <= 1 or internal_ratio > in_channels:
raise RuntimeError(
"Value out of range. Expected value in the "
"interval [1, {0}], got internal_scale={1}. ".format(
in_channels, internal_ratio))
internal_channels = in_channels // internal_ratio
if relu:
activation = nn.ReLU
else:
activation = nn.PReLU
self.main_max1 = nn.MaxPool2D(2, stride=2, return_mask=return_indices)
self.ext_conv1 = nn.Sequential(
nn.Conv2D(in_channels,
internal_channels,
kernel_size=2,
stride=2,
bias_attr=bias), layers.SyncBatchNorm(internal_channels),
activation())
self.ext_conv2 = nn.Sequential(
nn.Conv2D(internal_channels,
internal_channels,
kernel_size=3,
stride=1,
padding=1,
bias_attr=bias), layers.SyncBatchNorm(internal_channels),
activation())
self.ext_conv3 = nn.Sequential(
nn.Conv2D(internal_channels,
out_channels,
kernel_size=1,
stride=1,
bias_attr=bias), layers.SyncBatchNorm(out_channels),
activation())
self.ext_regul = nn.Dropout2D(p=dropout_prob)
self.out_activation = activation()
def __init__(self,
in_channels,
out_channels,
kernel_size,
padding=0,
stride=1,
conv_cfg='Conv1D',
norm_cfg='None',
**kwargs):
super().__init__()
if (conv_cfg == 'Conv1D'):
self._conv = nn.Conv1D(in_channels,
out_channels,
kernel_size,
stride=stride,
padding=padding,
**kwargs)
if (conv_cfg == 'Conv2D'):
self._conv = nn.Conv2D(in_channels,
out_channels,
kernel_size,
stride=stride,
padding=padding,
**kwargs)
if 'data_format' in kwargs:
data_format = kwargs['data_format']
else:
data_format = 'NCHW'
if (norm_cfg != 'None'):
self._batch_norm = layers.SyncBatchNorm(out_channels,
data_format=data_format)
else:
self._batch_norm = None
def __init__(self,
in_c,
out_c,
filter_size,
stride,
padding,
dilation=1,
num_groups=1,
if_act=True,
act=None):
super(ConvBNLayer, self).__init__()
self.if_act = if_act
self.act = act
self.conv = nn.Conv2D(in_channels=in_c,
out_channels=out_c,
kernel_size=filter_size,
stride=stride,
padding=padding,
dilation=dilation,
groups=num_groups,
bias_attr=False)
self.bn = layers.SyncBatchNorm(
num_features=out_c,
weight_attr=paddle.ParamAttr(
regularizer=paddle.regularizer.L2Decay(0.0)),
bias_attr=paddle.ParamAttr(
regularizer=paddle.regularizer.L2Decay(0.0)))
self._act_op = layers.Activation(act='hardswish')
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride=1,
dilation=1,
groups=1,
is_vd_mode=False,
act=None,
):
super(ConvBNLayer, self).__init__()
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True)
self._conv = nn.Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) //
2 if dilation == 1 else 0,
dilation=dilation,
groups=groups,
bias_attr=False)
self._batch_norm = layers.SyncBatchNorm(out_channels)
self._act_op = layers.Activation(act=act)
def __init__(self, in_dim, out_dim):
super(ContextEmbeddingBlock, self).__init__()
self.gap = nn.AdaptiveAvgPool2D(1)
self.bn = layers.SyncBatchNorm(in_dim)
self.conv_1x1 = layers.ConvBNReLU(in_dim, out_dim, 1)
self.conv_3x3 = nn.Conv2D(out_dim, out_dim, 3, 1, 1)
def __init__(self, out_channels, **kwargs):
super().__init__()
if 'data_format' in kwargs:
data_format = kwargs['data_format']
else:
data_format = 'NCHW'
self._batch_norm = layers.SyncBatchNorm(out_channels,
data_format=data_format)
self._prelu = layers.Activation("prelu")
def __init__(self, in_channels, num_state=256, num_node=84, nclass=59):
super().__init__()
self.num_state = num_state
self.conv_theta = nn.Conv2D(
in_channels, num_node, kernel_size=1, stride=1, padding=0)
self.conv_phi = nn.Conv2D(
in_channels, num_state, kernel_size=1, stride=1, padding=0)
self.graph = GraphLayer(num_state, num_node, nclass)
self.extend_dim = nn.Conv2D(
num_state, in_channels, kernel_size=1, bias_attr=False)
self.bn = layers.SyncBatchNorm(in_channels)
def __init__(self,
in_channels,
out_channels,
kernel_size=1,
stride=1,
padding=0,
dilation=1,
groups=1,
bias_attr=False):
super().__init__()
self._gate_conv = nn.Sequential(
layers.SyncBatchNorm(in_channels + 1),
nn.Conv2D(in_channels + 1, in_channels + 1, kernel_size=1),
nn.ReLU(), nn.Conv2D(in_channels + 1, 1, kernel_size=1),
layers.SyncBatchNorm(1), nn.Sigmoid())
self.conv = nn.Conv2D(in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
dilation=dilation,
groups=groups,
bias_attr=bias_attr)
def __init__(self,
num_classes,
in_channels=3,
level2_depth=2,
level3_depth=3,
pretrained=None):
super().__init__()
self.encoder = ESPNetEncoder(num_classes, in_channels, level2_depth,
level3_depth)
self.level3_up = nn.Conv2DTranspose(num_classes,
num_classes,
2,
stride=2,
padding=0,
output_padding=0,
bias_attr=False)
self.br3 = layers.SyncBatchNorm(num_classes)
self.level2_proj = nn.Conv2D(in_channels + 128,
num_classes,
1,
bias_attr=False)
self.combine_l2_l3 = nn.Sequential(
BNPReLU(2 * num_classes),
DilatedResidualBlock(2 * num_classes, num_classes, residual=False),
)
self.level2_up = nn.Sequential(
nn.Conv2DTranspose(num_classes,
num_classes,
2,
stride=2,
padding=0,
output_padding=0,
bias_attr=False),
BNPReLU(num_classes),
)
self.out_proj = layers.ConvBNPReLU(16 + in_channels + num_classes,
num_classes,
3,
padding='same',
stride=1)
self.out_up = nn.Conv2DTranspose(num_classes,
num_classes,
2,
stride=2,
padding=0,
output_padding=0,
bias_attr=False)
self.pretrained = pretrained
def __init__(self,
input_channels,
output_channels,
stride,
filter,
dilation=1,
act=None,
name=None):
super(Seperate_Conv, self).__init__()
self._conv1 = nn.Conv2D(in_channels=input_channels,
out_channels=input_channels,
kernel_size=filter,
stride=stride,
groups=input_channels,
padding=(filter) // 2 * dilation,
dilation=dilation,
bias_attr=False)
self._bn1 = layers.SyncBatchNorm(input_channels,
epsilon=1e-3,
momentum=0.99)
self._act_op1 = layers.Activation(act=act)
self._conv2 = nn.Conv2D(input_channels,
output_channels,
1,
stride=1,
groups=1,
padding=0,
bias_attr=False)
self._bn2 = layers.SyncBatchNorm(output_channels,
epsilon=1e-3,
momentum=0.99)
self._act_op2 = layers.Activation(act=act)
def __init__(self,
inplane,
num_class,
fpn_inplanes,
fpn_dim=256,
enable_auxiliary_loss=False):
super(SFNetHead, self).__init__()
self.ppm = layers.PPModule(in_channels=inplane,
out_channels=fpn_dim,
bin_sizes=(1, 2, 3, 6),
dim_reduction=True,
align_corners=True)
self.enable_auxiliary_loss = enable_auxiliary_loss
self.fpn_in = []
for fpn_inplane in fpn_inplanes[:-1]:
self.fpn_in.append(
nn.Sequential(nn.Conv2D(fpn_inplane, fpn_dim, 1),
layers.SyncBatchNorm(fpn_dim), nn.ReLU()))
self.fpn_in = nn.LayerList(self.fpn_in)
self.fpn_out = []
self.fpn_out_align = []
self.dsn = []
for i in range(len(fpn_inplanes) - 1):
self.fpn_out.append(
nn.Sequential(
layers.ConvBNReLU(fpn_dim, fpn_dim, 3, bias_attr=False)))
self.fpn_out_align.append(
AlignedModule(inplane=fpn_dim, outplane=fpn_dim // 2))
if self.enable_auxiliary_loss:
self.dsn.append(
nn.Sequential(layers.AuxLayer(fpn_dim, fpn_dim,
num_class)))
self.fpn_out = nn.LayerList(self.fpn_out)
self.fpn_out_align = nn.LayerList(self.fpn_out_align)
if self.enable_auxiliary_loss:
self.dsn = nn.LayerList(self.dsn)
self.conv_last = nn.Sequential(
layers.ConvBNReLU(len(fpn_inplanes) * fpn_dim,
fpn_dim,
3,
bias_attr=False),
nn.Conv2D(fpn_dim, num_class, kernel_size=1))
def __init__(self, in_channels, out_channels, bias=False, relu=True):
super(InitialBlock, self).__init__()
if relu:
activation = nn.ReLU
else:
activation = nn.PReLU
self.main_branch = nn.Conv2D(in_channels,
out_channels - 3,
kernel_size=3,
stride=2,
padding=1,
bias_attr=bias)
self.ext_branch = nn.MaxPool2D(3, stride=2, padding=1)
self.batch_norm = layers.SyncBatchNorm(out_channels)
self.out_activation = activation()
def __init__(self, in_channels, out_channels):
super().__init__()
branch_channels = out_channels // 5
remain_channels = out_channels - branch_channels * 4
self.conv1 = nn.Conv2D(in_channels,
branch_channels,
3,
stride=2,
padding=1,
bias_attr=False)
self.d_conv1 = nn.Conv2D(branch_channels,
remain_channels,
3,
padding=1,
bias_attr=False)
self.d_conv2 = nn.Conv2D(branch_channels,
branch_channels,
3,
padding=2,
dilation=2,
bias_attr=False)
self.d_conv4 = nn.Conv2D(branch_channels,
branch_channels,
3,
padding=4,
dilation=4,
bias_attr=False)
self.d_conv8 = nn.Conv2D(branch_channels,
branch_channels,
3,
padding=8,
dilation=8,
bias_attr=False)
self.d_conv16 = nn.Conv2D(branch_channels,
branch_channels,
3,
padding=16,
dilation=16,
bias_attr=False)
self.bn = layers.SyncBatchNorm(out_channels)
self.act = nn.PReLU(out_channels)
def __init__(self, filter_size, fusion, in_channels, channels):
super().__init__()
self.filter_size = filter_size
self.fusion = fusion
self.channels = channels
pad = (self.filter_size - 1) // 2
if (self.filter_size - 1) % 2 == 0:
self.pad = (pad, pad, pad, pad)
else:
self.pad = (pad + 1, pad, pad + 1, pad)
self.avg_pool = nn.AdaptiveAvgPool2D(filter_size)
self.filter_gen_conv = nn.Conv2D(in_channels, channels, 1)
self.input_redu_conv = layers.ConvBNReLU(in_channels, channels, 1)
self.norm = layers.SyncBatchNorm(channels)
self.act = nn.ReLU()
if self.fusion:
self.fusion_conv = layers.ConvBNReLU(channels, channels, 1)
def __init__(self,
input_channels,
output_channels,
filter_size,
stride=1,
padding=0,
act=None,
name=None):
super(ConvBNLayer, self).__init__()
self._conv = nn.Conv2D(in_channels=input_channels,
out_channels=output_channels,
kernel_size=filter_size,
stride=stride,
padding=padding,
bias_attr=False)
self._bn = layers.SyncBatchNorm(num_features=output_channels,
epsilon=1e-3,
momentum=0.99)
self._act_op = layers.Activation(act=act)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
groups=1,
**kwargs):
super().__init__()
weight_attr = paddle.ParamAttr(
learning_rate=1, initializer=nn.initializer.KaimingUniform())
self._conv = nn.Conv2D(in_channels,
out_channels,
kernel_size,
padding=padding,
stride=stride,
groups=groups,
weight_attr=weight_attr,
bias_attr=False,
**kwargs)
self._batch_norm = layers.SyncBatchNorm(out_channels)
def __init__(
self,
fpn_inplanes=[256, 512, 1024, 2048],
fpn_outplanes=256,
):
super(FPNNeck, self).__init__()
self.lateral_convs = []
self.fpn_out = []
# FPN head
for fpn_inplane in fpn_inplanes:
self.lateral_convs.append(
nn.Sequential(nn.Conv2D(fpn_inplane, fpn_outplanes, 1),
layers.SyncBatchNorm(fpn_outplanes), nn.ReLU()))
self.fpn_out.append(
nn.Sequential(
layers.ConvBNReLU(fpn_outplanes,
fpn_outplanes,
3,
bias_attr=False)))
self.lateral_convs = nn.LayerList(self.lateral_convs)
self.fpn_out = nn.LayerList(self.fpn_out)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
dilation=1,
groups=1,
is_vd_mode=False,
act=None,
data_format='NCHW'):
super(ConvBNLayer, self).__init__()
if dilation != 1 and kernel_size != 3:
raise RuntimeError("When the dilation isn't 1," \
"the kernel_size should be 3.")
self.is_vd_mode = is_vd_mode
self._pool2d_avg = nn.AvgPool2D(kernel_size=2,
stride=2,
padding=0,
ceil_mode=True,
data_format=data_format)
self._conv = nn.Conv2D(
in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) // 2 \
if dilation == 1 else dilation,
dilation=dilation,
groups=groups,
bias_attr=False,
data_format=data_format)
self._batch_norm = layers.SyncBatchNorm(out_channels,
data_format=data_format)
self._act_op = layers.Activation(act=act)
def __init__(self,
channels,
internal_ratio=4,
kernel_size=3,
padding=0,
dilation=1,
asymmetric=False,
dropout_prob=0,
bias=False,
relu=True):
super(RegularBottleneck, self).__init__()
if internal_ratio <= 1 or internal_ratio > channels:
raise RuntimeError(
"Value out of range. Expected value in the "
"interval [1, {0}], got internal_scale={1}.".format(
channels, internal_ratio))
internal_channels = channels // internal_ratio
if relu:
activation = nn.ReLU
else:
activation = nn.PReLU
self.ext_conv1 = nn.Sequential(
nn.Conv2D(channels,
internal_channels,
kernel_size=1,
stride=1,
bias_attr=bias), layers.SyncBatchNorm(internal_channels),
activation())
if asymmetric:
self.ext_conv2 = nn.Sequential(
nn.Conv2D(internal_channels,
internal_channels,
kernel_size=(kernel_size, 1),
stride=1,
padding=(padding, 0),
dilation=dilation,
bias_attr=bias),
layers.SyncBatchNorm(internal_channels), activation(),
nn.Conv2D(internal_channels,
internal_channels,
kernel_size=(1, kernel_size),
stride=1,
padding=(0, padding),
dilation=dilation,
bias_attr=bias),
layers.SyncBatchNorm(internal_channels), activation())
else:
self.ext_conv2 = nn.Sequential(
nn.Conv2D(internal_channels,
internal_channels,
kernel_size=kernel_size,
stride=1,
padding=padding,
dilation=dilation,
bias_attr=bias),
layers.SyncBatchNorm(internal_channels), activation())
self.ext_conv3 = nn.Sequential(
nn.Conv2D(internal_channels,
channels,
kernel_size=1,
stride=1,
bias_attr=bias), layers.SyncBatchNorm(channels),
activation())
self.ext_regul = nn.Dropout2D(p=dropout_prob)
self.out_activation = activation()
def __init__(self, channels):
super().__init__()
self.bn = layers.SyncBatchNorm(channels)
self.act = nn.PReLU(channels)
def __init__(self,
num_class,
fpn_inplanes,
channels,
dropout_ratio=0.1,
fpn_dim=256,
enable_auxiliary_loss=False,
align_corners=False):
super(PFPNHead, self).__init__()
self.enable_auxiliary_loss = enable_auxiliary_loss
self.align_corners = align_corners
self.lateral_convs = nn.LayerList()
self.fpn_out = nn.LayerList()
for fpn_inplane in fpn_inplanes:
self.lateral_convs.append(
nn.Sequential(nn.Conv2D(fpn_inplane, fpn_dim, 1),
layers.SyncBatchNorm(fpn_dim), nn.ReLU()))
self.fpn_out.append(
nn.Sequential(
layers.ConvBNReLU(fpn_dim, fpn_dim, 3, bias_attr=False)))
self.scale_heads = nn.LayerList()
for index in range(len(fpn_inplanes)):
head_length = max(
1,
int(np.log2(fpn_inplanes[index]) - np.log2(fpn_inplanes[0])))
scale_head = nn.LayerList()
for head_index in range(head_length):
scale_head.append(
layers.ConvBNReLU(
fpn_dim,
channels,
3,
padding=1,
))
if fpn_inplanes[index] != fpn_inplanes[0]:
scale_head.append(
nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=align_corners))
self.scale_heads.append(nn.Sequential(*scale_head))
if dropout_ratio:
self.dropout = nn.Dropout2D(dropout_ratio)
if self.enable_auxiliary_loss:
self.dsn = nn.Sequential(
layers.ConvBNReLU(fpn_inplanes[2],
fpn_inplanes[2],
3,
padding=1), nn.Dropout2D(dropout_ratio),
nn.Conv2D(fpn_inplanes[2], num_class, kernel_size=1))
else:
self.dropout = None
if self.enable_auxiliary_loss:
self.dsn = nn.Sequential(
layers.ConvBNReLU(fpn_inplanes[2],
fpn_inplanes[2],
3,
padding=1),
nn.Conv2D(fpn_inplanes[2], num_class, kernel_size=1))
self.conv_last = nn.Sequential(
layers.ConvBNReLU(len(fpn_inplanes) * fpn_dim,
fpn_dim,
3,
bias_attr=False),
nn.Conv2D(fpn_dim, num_class, kernel_size=1))
self.conv_seg = nn.Conv2D(channels, num_class, kernel_size=1)
