def __init__(self, num_channels, num_filters):
super(Decoder, self).__init__()
# TODO: decoder contains:
# 1 2x2 transpose conv (makes feature map 2x larger)
# 1 3x3 conv + 1bn + 1relu +
# 1 3x3 conv + 1bn + 1relu
self.up = Conv2DTranspose(num_channels=num_channels,
num_filters=num_filters,
filter_size=2,
stride=2)
self.conv1 = Conv2D(num_channels,
num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn1 = BatchNorm(num_filters, act='relu')
self.conv2 = Conv2D(num_filters,
num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn2 = BatchNorm(num_filters, act='relu')
def __init__(self, num_channels, num_filters):
super(Encoder, self).__init__()
#TODO: encoder contains:
# 1 3x3conv + 1bn + relu +
# 1 3x3conc + 1bn + relu +
# 1 2x2 pool
# return features before and after pool
self.conv1 = Conv2D(num_channels,
num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn1 = BatchNorm(num_filters, act='relu')
self.conv2 = Conv2D(num_filters,
num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn2 = BatchNorm(num_filters, act='relu')
self.pool = Pool2D(pool_size=2,
pool_stride=2,
pool_type='max',
ceil_mode=True)
def __init__(self, in_planes, planes, stride=1, downsample=None):
super().__init__()
self.conv1 = conv3x3x3(in_planes, planes, stride)
self.bn1 = BatchNorm(num_channels=planes, act='relu')
self.conv2 = conv3x3x3(planes, planes)
self.bn2 = BatchNorm(num_channels=planes)
self.downsample = downsample
self.stride = stride
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = BatchNorm(planes)
self.relu = fluid.layers.relu #nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = BatchNorm(planes)
self.downsample = downsample
self.stride = stride
def __init__(self):
super(Invertor,self).__init__()
self.conv1 = Conv2D(num_channels=1,num_filters=64,filter_size=3,padding=1,stride=2,act='leaky_relu')
self.conv2 = Conv2D(num_channels=64,num_filters=128,filter_size=3,padding=1,stride=2)
self.bn2 = BatchNorm(num_channels=128,act='leaky_relu')
self.conv3 = Conv2D(num_channels=128,num_filters=192,filter_size=3,padding=1,stride=2)
self.bn3 = BatchNorm(num_channels=192,act='leaky_relu')
self.conv4 = Conv2D(num_channels=192,num_filters=256,filter_size=3,padding=1,stride=2)
self.bn4 = BatchNorm(num_channels=256,act='leaky_relu')
self.fc = Linear(input_dim=1024,output_dim=64,act='tanh')
def __init__(self):
super(Generator,self).__init__()
self.fc1 = Linear(input_dim=64,output_dim=1024)
self.bn1 = BatchNorm(num_channels=256,act='relu')
self.conv2 = Conv2DTranspose(num_channels=256,num_filters=192,filter_size=3,padding=1,output_size=4,stride=2)
self.bn2 = BatchNorm(num_channels=192,act='relu')
self.conv3 = Conv2DTranspose(num_channels=192,num_filters=128,filter_size=3,padding=1,output_size=8,stride=2)
self.bn3 = BatchNorm(num_channels=128,act='relu')
self.conv4 = Conv2DTranspose(num_channels=128,num_filters=64,filter_size=3,padding=1,output_size=16,stride=2)
self.bn4 = BatchNorm(num_channels=64,act='relu')
self.conv5 = Conv2DTranspose(num_channels=64,num_filters=1,filter_size=3,padding=1,output_size=32,stride=2,act='tanh')
def __init__(self, num_scales, each_scales_size, point_scales_list, k=40):
super(PointcloudCls, self).__init__()
self.latentfeature = Latentfeature(num_scales, each_scales_size, point_scales_list)
self.fc1 = Linear(1920, 1024)
self.fc2 = Linear(1024, 512)
self.fc3 = Linear(512, 256)
self.fc4 = Linear(256, k)
# self.dropout = nn.Dropout(p=0.3)
self.bn1 = BatchNorm(1024, act='relu')
self.bn2 = BatchNorm(512, act='relu')
self.bn3 = BatchNorm(256, act='relu')
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = Conv2D(inplanes, planes, filter_size=1, bias_attr=False)
self.bn1 = BatchNorm(planes)
self.conv2 = Conv2D(planes, planes, filter_size=3, stride=stride,
padding=1, bias_attr=False)
self.bn2 = BatchNorm(planes)
self.conv3 = Conv2D(planes, planes * self.expansion, filter_size=1, bias_attr=False)
self.bn3 = BatchNorm(planes * self.expansion)
self.relu = fluid.layers.relu #nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self,
inputs,
filters,
is_training,
strides,
use_projection=False,
T=3,
data_format='channels_last',
non_local=False):
super(Bottleneck3D, self).__init__()
self.use_projection = use_projection
filters_out = 4 * filters
self.conv2d_1 = None if not (strides != 1 or inputs != filters_out
) else fluid.dygraph.Sequential(
Conv2D(inputs,
filters_out,
filter_size=1,
stride=strides,
padding=0,
bias_attr=fluid.ParamAttr(
trainable=False)),
BatchNorm(filters_out))
self.conv2d_2 = Conv2D(
inputs,
filters,
filter_size=1,
stride=1,
param_attr=fluid.initializer.MSRAInitializer(uniform=False),
bias_attr=fluid.ParamAttr(trainable=False))
self.bn_2 = BatchNorm(filters, act='relu')
self.conv2d_3 = Conv2D(
filters,
filters,
filter_size=3,
stride=(strides, strides),
padding=1,
param_attr=fluid.initializer.MSRAInitializer(uniform=False),
bias_attr=fluid.ParamAttr(trainable=False))
self.bn_3 = BatchNorm(filters, act='relu')
self.conv2d_4 = Conv2D(
filters,
filters * 4,
filter_size=1,
stride=1,
padding=0,
param_attr=fluid.initializer.MSRAInitializer(uniform=False),
bias_attr=fluid.ParamAttr(trainable=False))
self.bn_4 = BatchNorm(4 * filters)
def __init__(self, num_channels, num_filters):
super(DoubleConv, self).__init__()
self.conv0 = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn0 = BatchNorm(num_channels=num_filters)
self.conv1 = Conv2D(num_channels=num_filters,
num_filters=num_filters,
filter_size=3,
stride=1,
padding=1)
self.bn1 = BatchNorm(num_channels=num_filters)
def __init__(self, num_channels, num_filters, rates):
super(ASPPModule, self).__init__()
self.features = []
self.features.append(
fluid.dygraph.Sequential(Conv2D(num_channels, num_filters, 1),
BatchNorm(num_filters, act='relu')))
self.features.append(ASPPPooling(num_channels, num_filters))
for r in rates:
# ASPPConv 就是dilateConv,具体dilateConv的大小就是传入的参数r
self.features.append(ASPPConv(num_channels, num_filters, r))
self.project = fluid.dygraph.Sequential(
Conv2D(num_filters * (2 + len(rates)), 256, 1),
BatchNorm(num_filters, act='relu'))
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None):
"""
num_channels, 卷积层的输入通道数
num_filters, 卷积层的输出通道数
stride, 卷积层的步幅
groups, 分组卷积的组数，默认groups=1不使用分组卷积
act, 激活函数类型，默认act=None不使用激活函数
"""
super(ConvBNLayer, self).__init__()
# 创建卷积层
self._conv = Conv2D(
num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
bias_attr=False,
)
# 创建BatchNorm层
self._batch_norm = BatchNorm(num_filters, act=act)
def __init__(self, num_channels, num_filters, filter_size, **kwargs):
super(ConvBn, self).__init__()
self.conv = Conv2D(num_channels,
num_filters,
filter_size,
**kwargs)
self.batch_norm = BatchNorm(num_filters)
def __init__(self,
num_channels,
num_filters,
filter_size=3,
stride=1,
groups=1,
use_bn=True,
act='relu',
name=None):
super(ConvBNLayer, self).__init__(name)
self.use_bn = use_bn
if use_bn:
self.conv = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size-1)//2,
groups=groups,
act=None,
bias_attr=None)
self.bn = BatchNorm(num_filters, act=act)
else:
self.conv = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size-1)//2,
groups=groups,
act=act,
bias_attr=None)
def __init__(self, num_channels, num_classes):
super(DeepLabHead, self).__init__(
ASPPModule(num_channels, 256, [12, 24, 36]),
Conv2D(256, 256, 3, padding=1),
BatchNorm(256, act='relu'),
Conv2D(256, num_classes, 1)
)
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
dilation=1,
padding=None,
name=None):
super(ConvBNLayer, self).__init__(name)
if padding is None:
padding = (filter_size - 1) // 2
else:
padding = padding
self.conv = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=padding,
groups=groups,
act=None,
dilation=dilation,
bias_attr=False)
self.bn = BatchNorm(num_filters, act=act)
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act="relu",
name=None):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
param_attr=ParamAttr(
initializer=Normal(scale=0.001),
name=name + "_weights"),
bias_attr=False)
bn_name = name + '_bn'
self._batch_norm = BatchNorm(
num_filters,
act=act,
param_attr=ParamAttr(name=bn_name + '_scale',
initializer=fluid.initializer.Constant(1.0)),
bias_attr=ParamAttr(bn_name + '_offset',
initializer=fluid.initializer.Constant(0.0)),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance')
def __init__(self,
in_c=768,
out_c=768,
filter_size=[3, 1],
dilation=1,
stride=1,
affine=False,
use_cudnn=True,
name=None):
super(ReluConvBN, self).__init__()
#conv_std = (2.0 /
# (filter_size[0] * filter_size[1] * out_c * in_c))**0.5
conv_param = fluid.ParamAttr(name=name if name is None else
(name + "_conv.weights"),
initializer=fluid.initializer.MSRA())
self.conv = Conv2D(in_c,
out_c,
filter_size,
dilation=[dilation, 1],
stride=stride,
padding=[(filter_size[0] - 1) * dilation // 2, 0],
param_attr=conv_param,
act=None,
bias_attr=False,
use_cudnn=use_cudnn)
gama = ParamAttr(initializer=fluid.initializer.Constant(value=1),
trainable=affine)
beta = ParamAttr(initializer=fluid.initializer.Constant(value=0),
trainable=affine)
self.bn = BatchNorm(out_c, param_attr=gama, bias_attr=beta)
def __init__(self, in_channels, out_channels, spatial_stride=1, temporal_stride=1,
dilation=1, act=None):
super(Conv3x3x3BN, self).__init__()
self.conv = Conv3D(in_channels, out_channels, filter_size=3,
stride=(temporal_stride, spatial_stride, spatial_stride),
padding=(1, dilation, dilation), dilation=dilation, bias_attr=False)
self.bn = BatchNorm(out_channels, act=act)
def __init__(
self,
num_filters,
num_channels,
filter_size,
stride=1,
groups=1, # group参数暂时不用改
act='relu',
padding=None,
name_scope=None,
use_bias=False):
super(ConvBNLayer, self).__init__(name_scope)
self._conv = Conv2D(num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) //
2 if padding is None else padding,
groups=groups,
act=None,
bias_attr=use_bias)
self._batch_norm = BatchNorm(num_filters, act=act)
def __init__(self,
block=BasicBlock,
layers=50,
inp=3,
num_classes=400,
input_size=112,
dropout=0.5):
self.inplanes = 64
self.inp = inp
super(ResNet, self).__init__()
self.conv1 = Conv2D(inp,
64,
filter_size=7,
stride=2,
padding=3,
bias_attr=False)
self.bn1 = BatchNorm(64)
self.relu = fluid.layers.relu #nn.ReLU(inplace=True)
self.maxpool = Pool2D(
pool_size=3, pool_stride=2, pool_padding=1,
pool_type='max') #nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.rep_of_rep = repofrep("flowofflow")
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
# probably need to adjust this based on input spatial size
size = int(math.ceil(input_size / 32))
self.avgpool = Pool2D(pool_size=size,
pool_stride=1,
pool_padding=0,
pool_type='avg') #nn.AvgPool2d(size, stride=1)
self.dropout = Dropout(dropout) #nn.Dropout(p=dropout)
self.fc = Linear(512 * block.expansion, num_classes)
def __init__(self, num_classes=59, backbone='resnet50'):
super(PSPNet, self).__init__()
res = ResNet50(pretrained=False)
# stem: res.conv, res.pool2d_max
self.layer0 = fluid.dygraph.Sequential(
res.conv,
res.pool2d_max
)
self.layer1 = res.layer1
self.layer2 = res.layer2
self.layer3 = res.layer3
self.layer4 = res.layer4
num_channels = 2048
# psp: 2048 -> 2048*2
self.pspmodule = PSPModule(num_channels, [1, 2, 3, 6])
num_channels *= 2
# cls: 2048*2 -> 512 -> num_classes
self.classifier = fluid.dygraph.Sequential(
Conv2D(num_channels, num_filters=512, filter_size=3, padding=1),
BatchNorm(512, act='relu'),
Dropout(0.1),
Conv2D(512, num_classes, filter_size=1)
)
def __init__(self, in_channels, out_channels, filter_size=3, stride=1,
groups=1, act='relu'):
super(ConvBN, self).__init__()
self.conv = Conv2D(num_channels=in_channels, num_filters=out_channels,
filter_size=filter_size, stride=stride, padding=(filter_size - 1) // 2,
groups=groups, act=None, bias_attr=False)
self.bn = BatchNorm(num_channels=out_channels, act=act)
def __init__(self, in_channels, out_channels, filter_size=1, stride=1, dilation=1, act=None):
super(SeparateConvBN, self).__init__()
self.conv = Conv2D(num_channels=in_channels, num_filters=in_channels,
filter_size=filter_size, stride=stride, padding=(filter_size // 2) * dilation,
groups=in_channels, dilation=dilation)
self.pointwise = Conv2D(num_channels=in_channels, num_filters=out_channels,
filter_size=1, stride=1, padding=0, groups=1, dilation=1)
self.bn = BatchNorm(out_channels, act=act)
def __init__(self, num_channels, num_filters, dilation):
super(ASPPConv, self).__init__(
# dilation 既是所谓的空洞卷积。
Conv2D(num_channels,
num_filters,
filter_size=3,
padding=dilation,
dilation=dilation),
BatchNorm(num_filters, act='relu'))
def __init__(self, num_channels, bin_size_list):
super(PSPModule, self).__init__()
self.bin_size_list = bin_size_list
num_filters = num_channels // len(bin_size_list)
self.features = []
for i in range(len(bin_size_list)):
self.features.append(
fluid.dygraph.Sequential(Conv2D(num_channels, num_filters, 1),
BatchNorm(num_filters, act='relu')))
def __init__(self, num_scales, each_scales_size, point_scales_list):
super(Latentfeature, self).__init__()
self.num_scales = num_scales
self.each_scales_size = each_scales_size
self.point_scales_list = point_scales_list
self.Convlayers1 = Convlayer(point_scales=self.point_scales_list[0])
self.Convlayers2 = Convlayer(point_scales=self.point_scales_list[1])
self.Convlayers3 = Convlayer(point_scales=self.point_scales_list[2])
self.conv1 = Conv1D(prefix='lf', num_channels=3, num_filters=1, size_k=1, act=None)
self.bn1 = BatchNorm(1, act='relu')
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, act=None):
super(SeparateConv3DBN, self).__init__()
padding = kernel_size // 2 if isinstance(kernel_size, int) else \
(kernel_size[0] // 2, kernel_size[1] // 2, kernel_size[2] // 2)
self.depthwise = Conv3D(in_channels, in_channels, filter_size=kernel_size,
stride=stride, padding=padding, groups=in_channels)
self.pointwise = Conv3D(in_channels, out_channels, filter_size=1,
stride=1, padding=0, groups=1)
self.bn = BatchNorm(out_channels, act=act)
def __init__(self, name_scope, out_chs=20, in_chs=1024, inter_chs=512):
super(DANet, self).__init__(name_scope)
name_scope = self.full_name()
self.in_chs = in_chs
self.out_chs = out_chs
self.inter_chs = inter_chs if inter_chs else in_chs
self.backbone = ResNet(50)
self.conv5p = Sequential(
Conv2D(self.in_chs, self.inter_chs, 3, padding=1),
BatchNorm(self.inter_chs, act='relu'),
)
self.conv5c = Sequential(
Conv2D(self.in_chs, self.inter_chs, 3, padding=1),
BatchNorm(self.inter_chs, act='relu'),
)
self.sp = PAM_module(self.inter_chs)
self.sc = CAM_module(self.inter_chs)
self.conv6p = Sequential(
Conv2D(self.inter_chs, self.inter_chs, 3, padding=1),
BatchNorm(self.inter_chs, act='relu'),
)
self.conv6c = Sequential(
Conv2D(self.inter_chs, self.inter_chs, 3, padding=1),
BatchNorm(self.inter_chs, act='relu'),
)
self.conv7p = Sequential(
Dropout(0.1),
Conv2D(self.inter_chs, self.out_chs, 1),
)
self.conv7c = Sequential(
Dropout(0.1),
Conv2D(self.inter_chs, self.out_chs, 1),
)
self.conv7pc = Sequential(
Dropout(0.1),
Conv2D(self.inter_chs, self.out_chs, 1),
)
def __init__(self, num_classes=1):
super(CNN_LeakyRelu, self).__init__()
self.conv1 = Conv2D(3, 64, 5, padding=2, stride=1, act='leaky_relu')
self.bn1 = BatchNorm(64)
self.conv2 = Conv2D(64, 128, 5, padding=2, stride=1, act='leaky_relu')
self.bn2 = BatchNorm(128)
self.conv3 = Conv2D(128, 256, 5, padding=2, stride=1, act='leaky_relu')
self.bn3 = BatchNorm(256)
self.conv4 = Conv2D(256, 512, 5, padding=2, stride=1, act='leaky_relu')
self.bn4 = BatchNorm(512)
self.conv5 = Conv2D(512,
1024,
5,
padding=2,
stride=1,
act='leaky_relu')
self.bn5 = BatchNorm(1024)
self.conv6 = Conv2D(1024,
1024,
5,
padding=2,
stride=1,
act='leaky_relu')
self.bn6 = BatchNorm(1024)
self.fc1 = Linear(1024 * 7 * 7, 1024, act='leaky_relu')
self.fc2 = Linear(1024, num_classes)
self.pool_down = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
