def __init__(self,
block,
layers,
num_classes=65,
groups=1,
width_per_group=64):
super(MyCNN, self).__init__()
norm_layer = dg.BatchNorm
self._norm_layer = norm_layer
self.inplanes = 64
self.dilation = 1
self.groups = groups
self.base_width = width_per_group
self.conv1 = dg.Conv2D(1,
self.inplanes,
filter_size=3,
stride=1,
padding=1)
self.bn1 = norm_layer(self.inplanes,
param_attr=fluid.ParamAttr(
initializer=fluid.initializer.Constant(1.0)))
self.maxpool = dg.Pool2D(pool_size=3, pool_stride=2, pool_padding=1)
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=2)
# self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = dg.Pool2D(5, pool_type="avg")
self.fc = Linear(128 * block.expansion, num_classes)
def __init__(self,
pool_size=-1,
pool_type='max',
pool_stride=1,
pool_padding=0,
global_pooling=False,
use_cudnn=True,
ceil_mode=False,
exclusive=True,
data_format='NCT'):
super(Pool1D, self).__init__()
self.pool_size = pool_size
self.pool_type = pool_type
self.pool_stride = pool_stride
self.pool_padding = pool_padding
self.global_pooling = global_pooling
self.use_cudnn = use_cudnn
self.ceil_mode = ceil_mode
self.exclusive = exclusive
self.data_format = data_format
self.pool2d = dg.Pool2D(
[1, pool_size],
pool_type=pool_type,
pool_stride=[1, pool_stride],
pool_padding=[0, pool_padding],
global_pooling=global_pooling,
use_cudnn=use_cudnn,
ceil_mode=ceil_mode,
exclusive=exclusive)
def __init__(self, in_channels=384):
super().__init__()
self.pool = dg.Pool2D(pool_size=3, pool_stride=2, pool_type='max')
self.conv_3x3 = ConvBN(in_channels, 384, 3, 2, 0)
self.conv_3x3_2_reduce = ConvBN(in_channels, 192, 1, 1, 0)
self.conv_3x3_2 = ConvBN(192, 224, 3, 1, 1)
self.conv_3x3_3 = ConvBN(224, 256, 3, 2, 0)
def maxpool(kernel_size, stride, padding):
return dg.Pool2D(
pool_size=kernel_size,
pool_type='max',
pool_stride=stride,
pool_padding=padding,
)
def __init__(self, in_channels=3, out_channels=64, norm="AN"):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.conv1 = conv7x7(in_channels, out_channels, stride=2, bias=False)
self.conv1_norm = get_norm(norm, out_channels)
self.pool = dg.Pool2D(pool_size=3, pool_type='max',
pool_stride=2, pool_padding=1)
def __init__(self, ):
super().__init__()
self.conv1_3x3_s2 = ConvBN(3, 32, 3, 2, 0)
self.conv2_3x3_s1 = ConvBN(32, 32, 3, 1, 0)
self.conv3_3x3_s1 = ConvBN(32, 64, 3, 1, 1)
self.pool1 = dg.Pool2D(pool_size=3, pool_stride=2, pool_type='max')
self.stem1_3x3_s2 = ConvBN(64, 96, 3, 2, 0)
self.stem2_3x3_reduce = ConvBN(96 + 64, 64, 1, 1, 0)
self.stem2_3x3 = ConvBN(64, 96, 3, 1, 0)
self.stem2_1x7_reduce = ConvBN(64 + 96, 64, 1, 1, 0)
self.stem2_1x7 = ConvBN(64, 64, (7, 1), 1, (3, 0))
self.stem2_7x1 = ConvBN(64, 64, (1, 7), 1, (0, 3))
self.stem2_3x3_2 = ConvBN(64, 96, 3, 1, 0)
self.stem3_3x3_s2 = ConvBN(192, 192, 3, 2, 0)
self.pool2 = dg.Pool2D(pool_size=3, pool_stride=2, pool_type='max')
def __init__(self, in_channels=1024):
super().__init__()
self.pool = dg.Pool2D(pool_size=3, pool_stride=2, pool_type='max')
self.conv_3x3_reduce = ConvBN(in_channels, 192, 1, 1, 0)
self.conv_3x3 = ConvBN(192, 192, 3, 2, 0)
self.conv_1x7_reduce = ConvBN(in_channels, 256, 1, 1, 0)
self.conv_1x7 = ConvBN(256, 256, (1, 7), 1, (0, 3))
self.conv_7x1 = ConvBN(256, 320, (7, 1), 1, (3, 0))
self.conv_3x3_2 = ConvBN(320, 320, 3, 2, 0)
def __init__(self, block, layers, num_classes=1000, zero_init_residual=False,
groups=1, width_per_group=64, replace_stride_with_dilation=None,
norm_layer=None):
super(ResNet, self).__init__()
if norm_layer is None:
norm_layer = dg.BatchNorm
self._norm_layer = norm_layer
self.inplanes = 64
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}".format(replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.conv1 = dg.Conv2D(3, self.inplanes, filter_size=7, stride=2,
padding=3, bias_attr=False)
self.bn1 = norm_layer(self.inplanes)
self.relu = ReLU()
self.maxpool = dg.Pool2D(pool_size=3, pool_type='max', pool_stride=2, pool_padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
dilate=replace_stride_with_dilation[0])
self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
dilate=replace_stride_with_dilation[1])
self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
dilate=replace_stride_with_dilation[2])
self.avgpool = lambda x: L.adaptive_pool2d(x, (1, 1), pool_type='avg')
self.fc = dg.Linear(512 * block.expansion, num_classes)
for m in self.sublayers():
if isinstance(m, dg.Conv2D):
m.param_attr = F.ParamAttr(initializer=F.initializer.MSRAInitializer())
elif isinstance(m, (dg.BatchNorm, dg.GroupNorm)):
m.param_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0.0))
m.bias_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0.0))
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.sublayers():
if isinstance(m, Bottleneck):
m.bn3.param_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0.0))
elif isinstance(m, BasicBlock):
m.bn2.param_attr = F.ParamAttr(initializer=F.initializer.ConstantInitializer(value=0.0))
def __init__(self,
in_features,
out_features,
kernel_size=3,
padding=1,
groups=1):
super(DownBlock2d, self).__init__()
self.conv = dygraph.Conv2D(num_channels=in_features,
num_filters=out_features,
filter_size=kernel_size,
padding=padding,
groups=groups)
self.norm = dygraph.BatchNorm(num_channels=out_features, momentum=0.1)
self.pool = dygraph.Pool2D(pool_size=(2, 2),
pool_type='avg',
pool_stride=2)
def __init__(self, in_channels=1024):
super().__init__()
self.pool = dg.Pool2D(pool_size=3, pool_padding=1, pool_type='avg')
self.conv_1x1 = ConvBN(in_channels, 128, 1, 1, 0)
self.conv_1x1_2 = ConvBN(in_channels, 384, 1, 1, 0)
self.conv_1x7_reduce = ConvBN(in_channels, 192, 1, 1, 0)
self.conv_1x7 = ConvBN(192, 224, (1, 7), 1, (0, 3))
self.conv_7x1 = ConvBN(224, 256, (7, 1), 1, (3, 0))
self.conv_7x1_2_reduce = ConvBN(in_channels, 192, 1, 1, 0)
self.conv_1x7_2 = ConvBN(192, 192, (1, 7), 1, (0, 3))
self.conv_7x1_2 = ConvBN(192, 224, (7, 1), 1, (3, 0))
self.conv_1x7_3 = ConvBN(224, 224, (1, 7), 1, (0, 3))
self.conv_7x1_3 = ConvBN(224, 256, (7, 1), 1, (3, 0))
def __init__(
self,
in_channels,
):
super().__init__()
self.pool = dg.Pool2D(pool_size=3, pool_padding=1, pool_type='avg')
self.conv_1x1 = ConvBN(in_channels, 96, 1, 1, 0)
self.conv_1x1_2 = ConvBN(in_channels, 96, 1, 1, 0)
self.conv_3x3_reduce = ConvBN(in_channels, 64, 1, 1, 0)
self.conv_3x3 = ConvBN(64, 96, 3, 1, 1)
self.conv_3x3_2_reduce = ConvBN(in_channels, 64, 1, 1, 0)
self.conv_3x3_2 = ConvBN(64, 96, 3, 1, 1)
self.conv_3x3_3 = ConvBN(96, 96, 3, 1, 1)
def __init__(self, in_channels=1536):
super().__init__()
self.pool = dg.Pool2D(pool_size=3, pool_padding=1, pool_type='avg')
self.conv_1x1 = ConvBN(in_channels, 256, 1, 1, 0)
self.conv_1x1_2 = ConvBN(in_channels, 256, 1, 1, 0)
self.conv_1x1_3 = ConvBN(in_channels, 384, 1, 1, 0)
self.conv_1x3 = ConvBN(384, 256, (1, 3), 1, (0, 1))
self.conv_3x1 = ConvBN(384, 256, (3, 1), 1, (1, 0))
self.conv_1x1_4 = ConvBN(in_channels, 384, 1, 1, 0)
self.conv_1x3_2 = ConvBN(384, 448, (1, 3), 1, (0, 1))
self.conv_3x1_2 = ConvBN(448, 512, (3, 1), 1, (1, 0))
self.conv_1x3_3 = ConvBN(512, 256, (1, 3), 1, (0, 1))
self.conv_3x1_3 = ConvBN(512, 256, (3, 1), 1, (1, 0))
def convpool(in_channel,
out_channel,
padding=None,
pooling=2,
kernel=3,
act='relu'):
if padding == None:
padding = int((kernel - 1) / 2)
layers = [
dygraph.Conv2D(in_channel,
out_channel,
kernel,
padding=padding,
act=act),
dygraph.BatchNorm(out_channel)
]
if pooling > 1:
layers.append(dygraph.Pool2D(pooling, pool_stride=pooling))
return fluid.dygraph.Sequential(*layers)
def __init__(self, in_dim, activation=layers.relu):
super().__init__()
self.chanel_in = in_dim
self.activation = activation
self.theta = SpectralNorm(
dg.Conv2D(in_dim, in_dim // 8, 1, bias_attr=False))
self.phi = SpectralNorm(
dg.Conv2D(in_dim, in_dim // 8, 1, bias_attr=False))
self.pool = dg.Pool2D(2, 'max', 2)
self.g = SpectralNorm(
dg.Conv2D(in_dim, in_dim // 2, 1, bias_attr=False))
self.o_conv = SpectralNorm(
dg.Conv2D(in_dim // 2, in_dim, 1, bias_attr=False))
self.gamma = self.create_parameter([
1,
],
default_initializer=Constant(0.0))
self.softmax = SoftMax(axis=-1)
def __init__(self):
super().__init__()
self.stem = Stem()
inception_a = []
for i in range(4):
inception_a.append(InceptionA(384))
self.inception_a = dg.LayerList(inception_a)
self.reduction_a = ReductionA(384)
inception_b = []
for i in range(7):
inception_b.append(InceptionB(1024))
self.inception_b = dg.LayerList(inception_b)
self.reduction_b = ReductionB(1024)
inception_c = []
for i in range(3):
inception_c.append(InceptionC(1536))
self.inception_c = dg.LayerList(inception_c)
self.pool = dg.Pool2D(pool_type='avg', global_pooling=True)
def __init__(self):
super().__init__()
self.emb = D.Embedding([30002, 128], padding_idx=0)
self.cnn = D.Conv2D(128, 128, (1, 3), padding=(0, 1), act='relu')
self.pool = D.Pool2D((1, 3), pool_padding=(0, 1))
self.fc = D.Linear(128, 2)
def __init__(
self,
resolution=1024,
fmap_base=8192,
num_channels=3,
structure='fixed', # 'fixed' = no progressive growing, 'linear' = human-readable, 'recursive' = efficient, only support 'fixed' mode now.
fmap_max=512,
fmap_decay=1.0,
# f=[1, 2, 1] # (Huge overload, if you dont have enough resouces, please pass it as `f = None`)Low-pass filter to apply when resampling activations. None = no filtering.
f=None # (Huge overload, if you dont have enough resouces, please pass it as `f = None`)Low-pass filter to apply when resampling activations. None = no filtering.
):
"""
if H or W >= 128, we use avgpooling2d to do feature map shrinkage.
else: we use ordinary conv2d.
"""
super().__init__()
self.resolution_log2 = int(np.log2(resolution))
assert resolution == 2**self.resolution_log2 and resolution >= 4
self.nf = lambda stage: min(
int(fmap_base / (2.0**(stage * fmap_decay))), fmap_max)
# fromrgb: fixed mode
self.fromrgb = dygraph.Conv2D(num_channels,
self.nf(self.resolution_log2 - 1), 1)
self.structure = structure
# blur2d
self.blur2d = Blur2d(f)
# down_sample
self.down1 = dygraph.Pool2D(pool_size=2,
pool_stride=2,
pool_type='avg')
self.down21 = dygraph.Conv2D(self.nf(self.resolution_log2 - 5),
self.nf(self.resolution_log2 - 5),
2,
stride=2)
self.down22 = dygraph.Conv2D(self.nf(self.resolution_log2 - 6),
self.nf(self.resolution_log2 - 6),
2,
stride=2)
self.down23 = dygraph.Conv2D(self.nf(self.resolution_log2 - 7),
self.nf(self.resolution_log2 - 7),
2,
stride=2)
self.down24 = dygraph.Conv2D(self.nf(self.resolution_log2 - 8),
self.nf(self.resolution_log2 - 8),
2,
stride=2)
# conv1: padding=same
self.conv1 = Conv2d(self.nf(self.resolution_log2 - 1),
self.nf(self.resolution_log2 - 1), 3)
self.conv2 = Conv2d(self.nf(self.resolution_log2 - 1),
self.nf(self.resolution_log2 - 2), 3)
self.conv3 = Conv2d(self.nf(self.resolution_log2 - 2),
self.nf(self.resolution_log2 - 3), 3)
self.conv4 = Conv2d(self.nf(self.resolution_log2 - 3),
self.nf(self.resolution_log2 - 4), 3)
self.conv5 = Conv2d(self.nf(self.resolution_log2 - 4),
self.nf(self.resolution_log2 - 5), 3)
self.conv6 = Conv2d(self.nf(self.resolution_log2 - 5),
self.nf(self.resolution_log2 - 6), 3)
self.conv7 = Conv2d(self.nf(self.resolution_log2 - 6),
self.nf(self.resolution_log2 - 7), 3)
self.conv8 = Conv2d(self.nf(self.resolution_log2 - 7),
self.nf(self.resolution_log2 - 8), 3)
# calculate point:
self.conv_last = Conv2d(self.nf(self.resolution_log2 - 8), self.nf(1),
3)
self.dense0 = dygraph.Linear(fmap_base, self.nf(0))
self.dense1 = dygraph.Linear(self.nf(0), 1)
