def __init__(self, num_classes=10, max_points=1024):
super(PointNet_Basic_Clas, self).__init__()
self.mlp_1 = nn.Sequential(
nn.Conv1D(3, 64, 1),
nn.BatchNorm(64),
nn.ReLU(),
nn.Conv1D(64, 64, 1),
nn.BatchNorm(64),
nn.ReLU(),
)
self.mlp_2 = nn.Sequential(
nn.Conv1D(64, 64, 1),
nn.BatchNorm(64),
nn.ReLU(),
nn.Conv1D(64, 128, 1),
nn.BatchNorm(128),
nn.ReLU(),
nn.Conv1D(128, max_points, 1),
nn.BatchNorm(max_points),
nn.ReLU(),
)
self.fc = self.fc = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(),
nn.Linear(512, 256), nn.ReLU(),
nn.Dropout(p=0.7),
nn.Linear(256, num_classes))
def __init__(self, num_channels, num_filters):
super(Decoder, self).__init__()
self.conv1 = nn.Conv2D(num_channels,
num_filters,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
self.bn1 = nn.BatchNorm(num_filters, act='relu')
self.conv2 = nn.Conv2D(num_filters,
num_filters,
kernel_size=3,
stride=1,
padding=1,
bias_attr=False)
self.bn2 = nn.BatchNorm(num_filters, act='relu')
self.conv0 = nn.Conv2D(num_channels,
num_filters,
kernel_size=1,
stride=1,
padding=0,
bias_attr=False)
self.bn0 = nn.BatchNorm(num_filters, act='relu')
def __init__(self, in_planes, planes, stride=1, downsample=None, reduction=16):
super(SEBasicBlock, self).__init__()
self.conv1 = nn.Conv2D(in_planes, planes, kernel_size=3, stride=stride, padding=1)
self.bn1 = nn.BatchNorm(planes)
self.conv2 = nn.Conv2D(planes, planes, kernel_size=3, stride=1, padding=1)
self.bn2 = nn.BatchNorm(planes)
self.se = SELayer(planes, reduction)
self.downsample = downsample
self.stride = stride
def __init__(self, in_channels, n_filters):
super(DecoderBlock, self).__init__()
self.conv1 = nn.Conv2D(in_channels, in_channels//4, 1)
self.norm1 = nn.BatchNorm(in_channels//4)
self.scse = SCSEBlock(in_channels//4)
self.deconv2 = nn.Conv2DTranspose(in_channels//4, in_channels//4, 3, stride=2, padding=1, output_padding=1)
self.norm2 = nn.BatchNorm(in_channels//4)
self.conv3 = nn.Conv2D(in_channels//4, n_filters, 1)
self.norm3 = nn.BatchNorm(n_filters)
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = nn.BatchNorm(planes)
self.relu = nn.ReLU()
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm(planes)
self.downsample = downsample
self.stride = stride
def __init__(self, feature_channels=256, num_classes=50, max_points=1024):
super(VFE_Seg, self).__init__()
self.max_points = max_points
self.vfe = VFE(feature_channels, max_points)
self.seg_net = nn.Sequential(
nn.Conv1D(max_points + feature_channels * 2, 512, 1),
nn.BatchNorm(512), nn.ReLU(), nn.Conv1D(512, 256, 1),
nn.BatchNorm(256), nn.ReLU(), nn.Conv1D(256, 128, 1),
nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, 128, 1),
nn.BatchNorm(128), nn.ReLU(), nn.Conv1D(128, num_classes, 1))
def __init__(self, num_classes=50, max_points=1024):
super(PointNet_Basic_Seg, self).__init__()
self.max_points = max_points
self.pointnet_bacic = PointNet_Basic(max_points)
self.seg_net = nn.Sequential(nn.Conv1D(max_points + 64, 512, 1),
nn.BatchNorm(512), nn.ReLU(),
nn.Conv1D(512, 256, 1), nn.BatchNorm(256),
nn.ReLU(), nn.Conv1D(256, 128, 1),
nn.BatchNorm(128), nn.ReLU(),
nn.Conv1D(128, 128, 1), nn.BatchNorm(128),
nn.ReLU(), nn.Conv1D(128, num_classes, 1))
def __init__(self, in_features, kernel_size, padding, **kwargs):
super(ResBlock2d, self).__init__(**kwargs)
self.conv1 = nn.Conv2D(in_features,
in_features,
kernel_size=kernel_size,
padding=padding)
self.conv2 = nn.Conv2D(in_features,
in_features,
kernel_size=kernel_size,
padding=padding)
self.norm1 = nn.BatchNorm(num_channels=in_features)
self.norm2 = nn.BatchNorm(num_channels=in_features)
def __init__(self, in_channels, name_list):
super(Head, self).__init__()
self.conv1 = nn.Conv2D(in_channels=in_channels,
out_channels=in_channels // 4,
kernel_size=3,
padding=1,
weight_attr=ParamAttr(name=name_list[0] +
'.w_0'),
bias_attr=False)
self.conv_bn1 = nn.BatchNorm(
num_channels=in_channels // 4,
param_attr=ParamAttr(
name=name_list[1] + '.w_0',
initializer=paddle.nn.initializer.Constant(value=1.0)),
bias_attr=ParamAttr(
name=name_list[1] + '.b_0',
initializer=paddle.nn.initializer.Constant(value=1e-4)),
moving_mean_name=name_list[1] + '.w_1',
moving_variance_name=name_list[1] + '.w_2',
act='relu')
self.conv2 = nn.Conv2DTranspose(
in_channels=in_channels // 4,
out_channels=in_channels // 4,
kernel_size=2,
stride=2,
weight_attr=ParamAttr(
name=name_list[2] + '.w_0',
initializer=paddle.nn.initializer.KaimingUniform()),
bias_attr=get_bias_attr(in_channels // 4, name_list[-1] + "conv2"))
self.conv_bn2 = nn.BatchNorm(
num_channels=in_channels // 4,
param_attr=ParamAttr(
name=name_list[3] + '.w_0',
initializer=paddle.nn.initializer.Constant(value=1.0)),
bias_attr=ParamAttr(
name=name_list[3] + '.b_0',
initializer=paddle.nn.initializer.Constant(value=1e-4)),
moving_mean_name=name_list[3] + '.w_1',
moving_variance_name=name_list[3] + '.w_2',
act="relu")
self.conv3 = nn.Conv2DTranspose(
in_channels=in_channels // 4,
out_channels=1,
kernel_size=2,
stride=2,
weight_attr=ParamAttr(
name=name_list[4] + '.w_0',
initializer=paddle.nn.initializer.KaimingUniform()),
bias_attr=get_bias_attr(in_channels // 4, name_list[-1] + "conv3"),
)
def __init__(self,
in_channels,
out_channels,
is_batchnorm,
num_conv=2,
kernel_size=3,
stride=1,
padding=1):
super(UnetConv2D, self).__init__()
self.num_conv = num_conv
for i in range(num_conv):
conv = (nn.Sequential(nn.Conv2D(in_channels, out_channels, kernel_size, stride, padding),
nn.BatchNorm(out_channels),
nn.ReLU()) \
if is_batchnorm else \
nn.Sequential(nn.Conv2D(in_channels, out_channels, kernel_size, stride, padding),
nn.ReLU()))
setattr(self, 'conv%d' % (i + 1), conv)
in_channels = out_channels
# initialise the blocks
for children in self.children():
children.weight_attr = paddle.framework.ParamAttr(
initializer=paddle.nn.initializer.KaimingNormal)
children.bias_attr = paddle.framework.ParamAttr(
initializer=paddle.nn.initializer.KaimingNormal)
def __init__(
self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
is_vd_mode=False,
act=None,
name=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,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self._batch_norm = nn.BatchNorm(
out_channels,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
dilation=1,
groups=1,
act=None,
lr_mult=1.0,
name=None,
data_format="NCHW"):
super(ConvBNLayer, self).__init__()
conv_stdv = filter_size * filter_size * num_filters
self._conv = nn.Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
dilation=dilation,
groups=groups,
weight_attr=ParamAttr(learning_rate=lr_mult,
initializer=Normal(
0,
math.sqrt(
2. / conv_stdv))),
bias_attr=False,
data_format=data_format)
self._batch_norm = nn.BatchNorm(num_filters,
act=act,
data_layout=data_format)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
act=None,
name=None):
super(ConvBNLayer, self).__init__()
self.conv = nn.Conv2D(
in_channels=in_channels,
out_channels=out_channels,
kernel_size=2 if stride == (1, 1) else kernel_size,
dilation=2 if stride == (1, 1) else 1,
stride=stride,
padding=(kernel_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(name=name + '.conv2d.output.1.w_0'),
bias_attr=False,
)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self.bn = nn.BatchNorm(
num_channels=out_channels,
act=act,
param_attr=ParamAttr(name=name + '.output.1.w_0'),
bias_attr=ParamAttr(name=name + '.output.1.b_0'),
moving_mean_name=bn_name + "_mean",
moving_variance_name=bn_name + "_variance")
def __init__(self,
in_channels,
out_channels,
kernel_size=4,
stride=2,
padding=1,
groups=1,
if_act=True,
act=None,
name=None):
super(DeConvBNLayer, self).__init__()
self.if_act = if_act
self.act = act
self.deconv = nn.Conv2DTranspose(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
groups=groups,
weight_attr=ParamAttr(name=name +
'_weights'),
bias_attr=False)
self.bn = nn.BatchNorm(
num_channels=out_channels,
act=act,
param_attr=ParamAttr(name="bn_" + name + "_scale"),
bias_attr=ParamAttr(name="bn_" + name + "_offset"),
moving_mean_name="bn_" + name + "_mean",
moving_variance_name="bn_" + name + "_variance",
use_global_stats=False)
def __init__(self,
up_in_c: int,
x_in_c: int,
n_out: int,
hook,
final_div: bool = True,
blur: bool = False,
leaky: float = None,
self_attention: bool = False,
**kwargs):
super().__init__()
self.hook = hook
up_out = x_out = n_out // 2
self.shuf = CustomPixelShuffle_ICNR(up_in_c,
up_out,
blur=blur,
leaky=leaky,
**kwargs)
self.bn = nn.BatchNorm(x_in_c)
ni = up_out + x_in_c
self.conv = custom_conv_layer(ni,
x_out,
leaky=leaky,
self_attention=self_attention,
**kwargs)
self.relu = relu(leaky=leaky)
def __init__(
self,
up_in_c: int,
x_in_c: int,
# hook: Hook,
final_div: bool = True,
blur: bool = False,
leaky: float = None,
self_attention: bool = False,
nf_factor: float = 1.0,
**kwargs):
super().__init__()
self.shuf = CustomPixelShuffle_ICNR(up_in_c,
up_in_c // 2,
blur=blur,
leaky=leaky,
**kwargs)
self.bn = nn.BatchNorm(x_in_c)
ni = up_in_c // 2 + x_in_c
nf = int((ni if final_div else ni // 2) * nf_factor)
self.conv1 = custom_conv_layer(ni, nf, leaky=leaky, **kwargs)
self.conv2 = custom_conv_layer(nf,
nf,
leaky=leaky,
self_attention=self_attention,
**kwargs)
self.relu = relu(leaky=leaky)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
num_groups=1,
act='relu',
conv_lr=0.1,
conv_decay=0.,
norm_decay=0.,
norm_type='bn',
name=None):
super(ConvBNLayer, self).__init__()
self.act = act
self._conv = nn.Conv2D(
in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
groups=num_groups,
weight_attr=ParamAttr(
learning_rate=conv_lr, initializer=KaimingNormal()),
bias_attr=False)
if norm_type == 'sync_bn':
self._batch_norm = nn.SyncBatchNorm(out_channels)
else:
self._batch_norm = nn.BatchNorm(
out_channels, act=None, use_global_stats=False)
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
groups=1,
if_act=True,
act=None,
name=None):
super(ConvBNLayer, self).__init__()
self.if_act = if_act
self.act = act
self.conv = nn.Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
groups=groups,
weight_attr=ParamAttr(name=name + '_weights'),
bias_attr=False)
self.bn = nn.BatchNorm(num_channels=out_channels,
act=None,
param_attr=ParamAttr(name=name + "_bn_scale"),
bias_attr=ParamAttr(name=name + "_bn_offset"),
moving_mean_name=name + "_bn_mean",
moving_variance_name=name + "_bn_variance")
def __init__(self,
ch_in: int,
ch_out: int,
filter_size: int = 3,
stride: int = 1,
groups: int = 1,
padding: int = 0,
act: str = 'leakly',
is_test: bool = False):
super(ConvBNLayer, self).__init__()
self.conv = nn.Conv2d(
ch_in,
ch_out,
filter_size,
padding=padding,
stride=stride,
groups=groups,
weight_attr=paddle.ParamAttr(initializer=Normal(0., 0.02)),
bias_attr=False)
self.batch_norm = nn.BatchNorm(num_channels=ch_out,
is_test=is_test,
param_attr=paddle.ParamAttr(
initializer=Normal(0., 0.02),
regularizer=L2Decay(0.)))
self.act = act
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
groups=1,
act="relu",
name=None):
super(ConvBNLayer, self).__init__()
self._conv = nn.Conv2D(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=(kernel_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(
initializer=KaimingNormal(),
name=name + "_weights"),
bias_attr=False)
bn_name = name + "_bn"
self._batch_norm = nn.BatchNorm(
num_channels=out_channels,
act=act,
param_attr=ParamAttr(name=bn_name + "_scale",
regularizer=paddle.regularizer.L2Decay(0.0)),
bias_attr=ParamAttr(name=bn_name + "_offset",
regularizer=paddle.regularizer.L2Decay(0.0)),
moving_mean_name=bn_name + "_mean",
moving_variance_name=bn_name + "_variance")
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act="relu",
name=None):
super(ConvBNLayer, self).__init__()
self._conv = nn.Conv2D(in_channels=num_channels,
out_channels=num_filters,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
bn_name = name + '_bn'
self._batch_norm = nn.BatchNorm(
num_filters,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def __init__(self, name_scope='VoxNet_', num_classes=10):
super(VoxNet, self).__init__()
self.backbone = nn.Sequential(nn.Conv3D(1, 32, 5, 2), nn.BatchNorm(32),
nn.LeakyReLU(), nn.Conv3D(32, 32, 3, 1),
nn.MaxPool3D(2, 2, 0))
self.head = nn.Sequential(nn.Linear(32 * 6 * 6 * 6, 128),
nn.LeakyReLU(), nn.Dropout(0.2),
nn.Linear(128, num_classes))
def __init__(self, in_chan, out_chan, stride=1):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(in_chan, out_chan, stride)
self.bn1 = nn.BatchNorm(out_chan)
self.conv2 = conv3x3(out_chan, out_chan)
self.bn2 = nn.BatchNorm(out_chan)
self.relu = nn.ReLU()
self.downsample = None
if in_chan != out_chan or stride != 1:
self.downsample = nn.Sequential(
nn.Conv2d(in_chan,
out_chan,
kernel_size=1,
stride=stride,
bias_attr=False),
nn.BatchNorm(out_chan),
)
def __init__(self,
in_c,
out_c,
filter_size,
stride,
padding,
num_groups=1,
act=None,
lr_mult=1.,
conv_decay=0.,
norm_type='bn',
norm_decay=0.,
freeze_norm=False,
name=""):
super(ConvBNLayer, self).__init__()
self.act = act
self.conv = nn.Conv2D(
in_channels=in_c,
out_channels=out_c,
kernel_size=filter_size,
stride=stride,
padding=padding,
groups=num_groups,
weight_attr=ParamAttr(
learning_rate=lr_mult,
regularizer=L2Decay(conv_decay),
name=name + "_weights"),
bias_attr=False)
norm_lr = 0. if freeze_norm else lr_mult
param_attr = ParamAttr(
learning_rate=norm_lr,
regularizer=L2Decay(norm_decay),
name=name + "_bn_scale",
trainable=False if freeze_norm else True)
bias_attr = ParamAttr(
learning_rate=norm_lr,
regularizer=L2Decay(norm_decay),
name=name + "_bn_offset",
trainable=False if freeze_norm else True)
global_stats = True if freeze_norm else False
if norm_type == 'sync_bn':
self.bn = nn.SyncBatchNorm(
out_c, weight_attr=param_attr, bias_attr=bias_attr)
else:
self.bn = nn.BatchNorm(
out_c,
act=None,
param_attr=param_attr,
bias_attr=bias_attr,
use_global_stats=global_stats,
moving_mean_name=name + '_bn_mean',
moving_variance_name=name + '_bn_variance')
norm_params = self.bn.parameters()
if freeze_norm:
for param in norm_params:
param.stop_gradient = True
def __init__(self, in_chan, out_chan, *args, **kwargs):
super(AttentionRefinementModule, self).__init__()
self.conv = ConvBNReLU(in_chan, out_chan, ks=3, stride=1, padding=1)
self.conv_atten = nn.Conv2D(out_chan,
out_chan,
kernel_size=1,
bias_attr=False)
self.bn_atten = nn.BatchNorm(out_chan)
self.sigmoid_atten = nn.Sigmoid()
def __init__(self, in_planes, out_planes, scale_factor=(1, 2, 2)):
super(Upsample, self).__init__()
self.scale_factor = scale_factor
self.conv3d = nn.Conv3D(in_planes,
out_planes,
kernel_size=(3, 3, 3),
stride=(1, 1, 1),
padding=(1, 1, 1))
self.bn = nn.BatchNorm(out_planes)
def __init__(self,
ch_in,
ch_out,
filter_size,
stride=1,
groups=1,
norm_type=None,
norm_groups=32,
norm_decay=0.,
freeze_norm=False,
act=None):
super(ConvNormLayer, self).__init__()
self.act = act
norm_lr = 0. if freeze_norm else 1.
if norm_type is not None:
assert norm_type in ['bn', 'sync_bn', 'gn'],\
"norm_type should be one of ['bn', 'sync_bn', 'gn'], but got {}".format(norm_type)
param_attr = ParamAttr(
initializer=Constant(1.0),
learning_rate=norm_lr,
regularizer=L2Decay(norm_decay),
)
bias_attr = ParamAttr(learning_rate=norm_lr,
regularizer=L2Decay(norm_decay))
global_stats = True if freeze_norm else False
if norm_type in ['bn', 'sync_bn']:
self.norm = nn.BatchNorm(
ch_out,
param_attr=param_attr,
bias_attr=bias_attr,
use_global_stats=global_stats,
)
elif norm_type == 'gn':
self.norm = nn.GroupNorm(num_groups=norm_groups,
num_channels=ch_out,
weight_attr=param_attr,
bias_attr=bias_attr)
norm_params = self.norm.parameters()
if freeze_norm:
for param in norm_params:
param.stop_gradient = True
conv_bias_attr = False
else:
conv_bias_attr = True
self.norm = None
self.conv = nn.Conv2D(
in_channels=ch_in,
out_channels=ch_out,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
weight_attr=ParamAttr(initializer=Normal(mean=0., std=0.001)),
bias_attr=conv_bias_attr)
def __init__(self, in_channels=3, num_classes=2):
super().__init__()
self.backbone = Vgg16Base(in_channels=in_channels)
self.sa1 = SAM()
self.sa2 = SAM()
self.sa3 = SAM()
self.sa4 = SAM()
self.sa5 = SAM()
# branch1
self.ca1 = CAM(in_channels=1024, ratio=8)
self.bn_ca1 = nn.BatchNorm(1024)
self.o1_conv1 = CPBD(1024, 512)
self.o1_conv2 = CPBD(512, 512)
self.bn_sa1 = nn.BatchNorm(512)
self.o1_conv3 = nn.Conv2D(512, num_classes, 1)
self.trans_conv1 = nn.Conv2DTranspose(512,
512,
kernel_size=2,
stride=2)
# branch 2
self.ca2 = CAM(in_channels=1536, ratio=8)
self.bn_ca2 = nn.BatchNorm(1536)
self.o2_conv1 = CPBD(1536, 512)
self.o2_conv2 = CPBD(512, 256)
self.o2_conv3 = CPBD(256, 256)
self.bn_sa2 = nn.BatchNorm(256)
self.o2_conv4 = nn.Conv2D(256, num_classes, 1)
self.trans_conv2 = nn.Conv2DTranspose(256,
256,
kernel_size=2,
stride=2)
# branch 3
self.ca3 = CAM(in_channels=768, ratio=8)
self.o3_conv1 = CPBD(768, 256)
self.o3_conv2 = CPBD(256, 128)
self.o3_conv3 = CPBD(128, 128)
self.bn_sa3 = nn.BatchNorm(128)
self.o3_conv4 = nn.Conv2D(128, num_classes, 1)
self.trans_conv3 = nn.Conv2DTranspose(128,
128,
kernel_size=2,
stride=2)
# branch 4
self.ca4 = CAM(in_channels=384, ratio=8)
self.o4_conv1 = CPBD(384, 128)
self.o4_conv2 = CPBD(128, 64)
self.o4_conv3 = CPBD(64, 64)
self.bn_sa4 = nn.BatchNorm(64)
self.o4_conv4 = nn.Conv2D(64, num_classes, 1)
self.trans_conv4 = nn.Conv2DTranspose(64, 64, kernel_size=2, stride=2)
# branch 5
self.ca5 = CAM(in_channels=192, ratio=8)
self.o5_conv1 = CPBD(192, 64)
self.o5_conv2 = CPBD(64, 32)
self.o5_conv3 = CPBD(32, 16)
self.bn_sa5 = nn.BatchNorm(16)
self.o5_conv4 = nn.Conv2D(16, num_classes, 1)
def __init__(self,
ch_in,
ch_out,
filter_size,
stride=1,
norm_type='bn',
norm_groups=32,
use_dcn=False,
norm_decay=0.,
freeze_norm=False,
act=None,
name=None):
super(ConvNormLayer, self).__init__()
assert norm_type in ['bn', 'sync_bn', 'gn']
self.act = act
self.conv = nn.Conv2D(in_channels=ch_in,
out_channels=ch_out,
kernel_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=1,
weight_attr=ParamAttr(name=name + "_weights",
initializer=Normal(
mean=0., std=0.01)),
bias_attr=False)
norm_lr = 0. if freeze_norm else 1.
norm_name = name + '_bn'
param_attr = ParamAttr(name=norm_name + "_scale",
learning_rate=norm_lr,
regularizer=L2Decay(norm_decay))
bias_attr = ParamAttr(name=norm_name + "_offset",
learning_rate=norm_lr,
regularizer=L2Decay(norm_decay))
global_stats = True if freeze_norm else False
if norm_type in ['bn', 'sync_bn']:
self.norm = nn.BatchNorm(ch_out,
param_attr=param_attr,
bias_attr=bias_attr,
use_global_stats=global_stats,
moving_mean_name=norm_name + '_mean',
moving_variance_name=norm_name +
'_variance')
elif norm_type == 'gn':
self.norm = nn.GroupNorm(num_groups=norm_groups,
num_channels=ch_out,
weight_attr=param_attr,
bias_attr=bias_attr)
norm_params = self.norm.parameters()
if freeze_norm:
for param in norm_params:
param.stop_gradient = True
def __init__(self, in_channels, out_channels):
super(CPBD, self).__init__(
nn.Conv2D(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1),
nn.PReLU(),
nn.BatchNorm(out_channels),
nn.Dropout(p=0.6),
)
