def __init__(self, in_channels_left, out_channels_left, in_channels_right, out_channels_right):
super(ReductionCell1, self).__init__()
self.conv_prev_1x1 = []
self.conv_prev_1x1.append(M.ReLU())
self.conv_prev_1x1.append(M.Conv2d(in_channels_left, out_channels_left, 1, stride=1, bias=False))
self.conv_prev_1x1.append(M.BatchNorm2d(out_channels_left, eps=0.001, momentum=0.1, affine=True))
self.conv_prev_1x1 = M.Sequential(*self.conv_prev_1x1)
self.conv_1x1 = []
self.conv_1x1.append(M.ReLU())
self.conv_1x1.append(M.Conv2d(in_channels_right, out_channels_right, 1, stride=1, bias=False))
self.conv_1x1.append(M.BatchNorm2d(out_channels_right, eps=0.001, momentum=0.1, affine=True))
self.conv_1x1 = M.Sequential(*self.conv_1x1)
self.comb_iter_0_left = BranchSeparables(out_channels_right, out_channels_right, 5, 2, 2, bias=False)
self.comb_iter_0_right = BranchSeparables(out_channels_right, out_channels_right, 7, 2, 3, bias=False)
self.comb_iter_1_left = M.MaxPool2d(3, stride=2, padding=1)
self.comb_iter_1_right = BranchSeparables(out_channels_right, out_channels_right, 7, 2, 3, bias=False)
self.comb_iter_2_left = M.AvgPool2d(3, stride=2, padding=1)
self.comb_iter_2_right = BranchSeparables(out_channels_right, out_channels_right, 5, 2, 2, bias=False)
self.comb_iter_3_right = M.AvgPool2d(3, stride=1, padding=1)
self.comb_iter_4_left = BranchSeparables(out_channels_right, out_channels_right, 3, 1, 1, bias=False)
self.comb_iter_4_right = M.MaxPool2d(3, stride=2, padding=1)
def __init__(self, intLevel):
super(Basic, self).__init__()
self.netBasic = M.Sequential(
Conv2d(in_channels=8,
out_channels=32,
kernel_size=7,
stride=1,
padding=3), # 8=3+3+2
M.ReLU(),
Conv2d(in_channels=32,
out_channels=64,
kernel_size=7,
stride=1,
padding=3),
M.ReLU(),
Conv2d(in_channels=64,
out_channels=32,
kernel_size=7,
stride=1,
padding=3),
M.ReLU(),
Conv2d(in_channels=32,
out_channels=16,
kernel_size=7,
stride=1,
padding=3),
M.ReLU(),
Conv2d(in_channels=16,
out_channels=2,
kernel_size=7,
stride=1,
padding=3))
def __init__(self,
in_channels=3,
out_channels=3,
mid_channels=128,
hidden_channels=3 * 4 * 4,
blocknums=5,
upscale_factor=4,
hsa=False,
pixel_shuffle=False):
super(RSDN, self).__init__()
if hsa:
self.hsa = HSA(3)
else:
self.hsa = Identi()
self.blocknums = blocknums
self.hidden_channels = hidden_channels
SDBlocks = []
for _ in range(blocknums):
SDBlocks.append(SDBlock(mid_channels))
self.SDBlocks = M.Sequential(*SDBlocks)
self.pre_SD_S = M.Sequential(
Conv2d(2 * (3 + hidden_channels), mid_channels, 3, 1, 1),
M.ReLU(),
)
self.pre_SD_D = M.Sequential(
Conv2d(2 * (3 + hidden_channels), mid_channels, 3, 1, 1),
M.ReLU(),
)
self.conv_SD = M.Sequential(
Conv2d(mid_channels, hidden_channels, 3, 1, 1),
M.ReLU(),
)
self.convS = Conv2d(mid_channels, hidden_channels, 3, 1, 1)
self.convD = Conv2d(mid_channels, hidden_channels, 3, 1, 1)
self.convHR = Conv2d(2 * hidden_channels, hidden_channels, 3, 1, 1)
if pixel_shuffle:
self.trans_S = PixelShuffle(upscale_factor)
self.trans_D = PixelShuffle(upscale_factor)
self.trans_HR = PixelShuffle(upscale_factor)
else:
self.trans_S = ConvTranspose2d(hidden_channels,
3,
4,
4,
0,
bias=False)
self.trans_D = ConvTranspose2d(hidden_channels,
3,
4,
4,
0,
bias=False)
self.trans_HR = ConvTranspose2d(hidden_channels,
3,
4,
4,
0,
bias=False)
def __init__(self, in_channels_left, out_channels_left, in_channels_right, out_channels_right):
super(FirstCell, self).__init__()
self.conv_1x1 = []
self.conv_1x1.append(M.ReLU())
self.conv_1x1.append(M.Conv2d(in_channels_right, out_channels_right, 1, stride=1, bias=False))
self.conv_1x1.append(M.BatchNorm2d(out_channels_right, eps=0.001, momentum=0.1, affine=True))
self.conv_1x1 = M.Sequential(*self.conv_1x1)
self.relu = M.ReLU()
self.path_1 = []
self.path_1.append(M.AvgPool2d(1, stride=2))
self.path_1.append(M.Conv2d(in_channels_left, out_channels_left, 1, stride=1, bias=False))
self.path_1 = M.Sequential(*self.path_1)
self.path_2 = []
# self.path_2.append(M.ZeroPad2d((0, 1, 0, 1)))
self.path_2.append(M.AvgPool2d(1, stride=2))
self.path_2.append(M.Conv2d(in_channels_left, out_channels_left, 1, stride=1, bias=False))
self.path_2 = M.Sequential(*self.path_2)
self.final_path_bn = M.BatchNorm2d(out_channels_left * 2, eps=0.001, momentum=0.1, affine=True)
self.comb_iter_0_left = BranchSeparables(out_channels_right, out_channels_right, 5, 1, 2, bias=False)
self.comb_iter_0_right = BranchSeparables(out_channels_right, out_channels_right, 3, 1, 1, bias=False)
self.comb_iter_1_left = BranchSeparables(out_channels_right, out_channels_right, 5, 1, 2, bias=False)
self.comb_iter_1_right = BranchSeparables(out_channels_right, out_channels_right, 3, 1, 1, bias=False)
self.comb_iter_2_left = M.AvgPool2d(3, stride=1, padding=1)
self.comb_iter_3_left = M.AvgPool2d(3, stride=1, padding=1)
self.comb_iter_3_right = M.AvgPool2d(3, stride=1, padding=1)
self.comb_iter_4_left = BranchSeparables(out_channels_right, out_channels_right, 3, 1, 1, bias=False)
def __init__(self, channel_num):
super(CARBBlock, self).__init__()
self.conv1 = M.Sequential(
M.Conv2d(channel_num,
channel_num,
kernel_size=3,
padding=1,
stride=1),
M.ReLU(),
M.Conv2d(channel_num,
channel_num,
kernel_size=3,
padding=1,
stride=1),
)
# self.global_average_pooling = nn.AdaptiveAvgPool2d((1,1)) # B,C,H,W -> B,C,1,1
self.linear = M.Sequential(M.Linear(channel_num, channel_num // 2),
M.ReLU(),
M.Linear(channel_num // 2, channel_num),
M.Sigmoid())
self.conv2 = M.Conv2d(channel_num * 2,
channel_num,
kernel_size=1,
padding=0,
stride=1)
self.lrelu = M.LeakyReLU()
def __init__(self, cfg, input_shape: List[layers.ShapeSpec]):
super().__init__()
in_channels = input_shape[0].channels
num_classes = cfg.num_classes
num_convs = 4
prior_prob = cfg.cls_prior_prob
num_anchors = [
len(cfg.anchor_scales[i]) * len(cfg.anchor_ratios[i])
for i in range(len(input_shape))
]
assert (len(set(num_anchors)) == 1
), "not support different number of anchors between levels"
num_anchors = num_anchors[0]
cls_subnet = []
bbox_subnet = []
for _ in range(num_convs):
cls_subnet.append(
M.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1))
cls_subnet.append(M.ReLU())
bbox_subnet.append(
M.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1))
bbox_subnet.append(M.ReLU())
self.cls_subnet = M.Sequential(*cls_subnet)
self.bbox_subnet = M.Sequential(*bbox_subnet)
self.cls_score = M.Conv2d(in_channels,
num_anchors * num_classes,
kernel_size=3,
stride=1,
padding=1)
self.bbox_pred = M.Conv2d(in_channels,
num_anchors * 4,
kernel_size=3,
stride=1,
padding=1)
# Initialization
for modules in [
self.cls_subnet, self.bbox_subnet, self.cls_score,
self.bbox_pred
]:
for layer in modules.modules():
if isinstance(layer, M.Conv2d):
M.init.normal_(layer.weight, mean=0, std=0.01)
M.init.fill_(layer.bias, 0)
# Use prior in model initialization to improve stability
bias_value = -math.log((1 - prior_prob) / prior_prob)
M.init.fill_(self.cls_score.bias, bias_value)
def __init__(self, channel_nums):
super(SDBlock, self).__init__()
self.netS = M.Sequential(Conv2d(channel_nums, channel_nums, 3, 1, 1),
M.ReLU(),
Conv2d(channel_nums, channel_nums, 3, 1, 1))
self.netD = M.Sequential(Conv2d(channel_nums, channel_nums, 3, 1, 1),
M.ReLU(),
Conv2d(channel_nums, channel_nums, 3, 1, 1))
def __init__(self, in_channels, out_channels, kernel_size, stride, padding, bias=False):
super(BranchSeparablesStem, self).__init__()
self.relu = M.ReLU()
self.separable_1 = SeparableConv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias)
self.bn_sep_1 = M.BatchNorm2d(out_channels, eps=0.001, momentum=0.1, affine=True)
self.relu1 = M.ReLU()
self.separable_2 = SeparableConv2d(out_channels, out_channels, kernel_size, 1, padding, bias=bias)
self.bn_sep_2 = M.BatchNorm2d(out_channels, eps=0.001, momentum=0.1, affine=True)
def __init__(self, in_ch, out_ch):
super(DoubleConv, self).__init__()
self.conv = M.Sequential(
M.Conv2d(in_ch, out_ch, 3, padding=1),
M.BatchNorm2d(out_ch),
M.ReLU(),
M.Conv2d(out_ch, out_ch, 3, padding=1),
M.BatchNorm2d(out_ch),
M.ReLU())
def conv_dw(inp, oup, stride):
return M.Sequential(
M.Conv2d(inp, inp, 3, stride, 1, groups=inp),
M.BatchNorm2d(inp),
M.ReLU(),
M.Conv2d(inp, oup, 1, 1, 0),
M.BatchNorm2d(oup),
M.ReLU(),
)
def __init__(self):
super().__init__()
self.conv0 = M.Conv2d(1, 20, kernel_size=5, bias=False)
self.bn0 = M.BatchNorm2d(20)
self.relu0 = M.ReLU()
self.pool0 = M.MaxPool2d(2)
self.conv1 = M.Conv2d(20, 20, kernel_size=5, bias=False)
self.bn1 = M.BatchNorm2d(20)
self.relu1 = M.ReLU()
self.pool1 = M.MaxPool2d(2)
self.fc0 = M.Linear(500, 64, bias=True)
self.relu2 = M.ReLU()
self.fc1 = M.Linear(64, 10, bias=True)
def __init__(self,
in_ch,
out_ch,
ksize,
stride=1,
expansion=1.0,
bias=False,
norm_layer=M.BatchNorm2d,
activation=M.ReLU()):
super(XXBlock, self).__init__()
if norm_layer is None:
norm_layer = M.BatchNorm2d
if activation is None:
activation = M.ReLU()
expansion_out_ch = round(out_ch * expansion)
self.conv_block = M.Sequential(
M.Conv2d(in_ch,
expansion_out_ch,
ksize,
stride=stride,
padding=ksize // 2), norm_layer(expansion_out_ch),
activation,
M.Conv2d(expansion_out_ch,
out_ch,
ksize,
stride=1,
padding=(ksize - 1) // 2,
bias=bias), norm_layer(out_ch))
self.activation = activation
self.shortcut = M.Sequential()
if stride > 1 or in_ch != out_ch:
if stride > 1:
self.shortcut = M.Sequential(
M.AvgPool2d(kernel_size=stride + 1,
stride=stride,
padding=stride // 2),
M.Conv2d(in_ch,
out_ch,
kernel_size=1,
stride=1,
padding=0,
bias=bias), norm_layer(out_ch))
else:
self.shortcut = M.Sequential(
M.Conv2d(in_ch,
out_ch,
kernel_size=1,
stride=1,
padding=0,
bias=bias), norm_layer(out_ch))
def __init__(self, inp, oup, mid_channels, *, ksize, stride):
super().__init__()
self.stride = stride
assert stride in [1, 2]
self.mid_channels = mid_channels
self.ksize = ksize
pad = ksize // 2
self.pad = pad
self.inp = inp
outputs = oup - inp
branch_main = [
# pw
M.Conv2d(inp, mid_channels, 1, 1, 0, bias=False),
M.BatchNorm2d(mid_channels),
M.ReLU(),
# dw
M.Conv2d(
mid_channels,
mid_channels,
ksize,
stride,
pad,
groups=mid_channels,
bias=False,
),
M.BatchNorm2d(mid_channels),
# pw-linear
M.Conv2d(mid_channels, outputs, 1, 1, 0, bias=False),
M.BatchNorm2d(outputs),
M.ReLU(),
]
self.branch_main = M.Sequential(*branch_main)
if stride == 2:
branch_proj = [
# dw
M.Conv2d(inp, inp, ksize, stride, pad, groups=inp, bias=False),
M.BatchNorm2d(inp),
# pw-linear
M.Conv2d(inp, inp, 1, 1, 0, bias=False),
M.BatchNorm2d(inp),
M.ReLU(),
]
self.branch_proj = M.Sequential(*branch_proj)
else:
self.branch_proj = None
def __init__(self,
in_ch,
out_ch,
ksize=1,
stride=1,
padding=0,
bias=False,
dilation=1,
groups=1,
norm_layer=M.BatchNorm2d,
activation=M.ReLU(),
gn_groups=32,
**kwargs):
super(Conv2d, self).__init__()
ksize = _pair(ksize)
stride = _pair(stride)
padding = _pair(padding)
self.conv = M.Conv2d(in_ch,
out_ch,
ksize,
stride=stride,
padding=padding,
dilation=dilation,
groups=groups,
bias=bias,
**kwargs)
self.norm_layer = None
if norm_layer is not None:
if isinstance(norm_layer, M.GroupNorm):
self.norm_layer = norm_layer(gn_groups, out_ch)
else:
self.norm_layer = norm_layer(out_ch)
self.activation = activation
def __init__(self,
in_channels,
out_channels,
kernel_size=3,
activation='prelu'):
super(ResBlock, self).__init__()
if activation == 'relu':
self.act = M.ReLU()
elif activation == 'prelu':
self.act = M.PReLU(num_parameters=1, init=0.25)
else:
raise NotImplementedError("not implemented activation")
m = []
m.append(
M.Conv2d(in_channels,
out_channels,
kernel_size=kernel_size,
stride=1,
padding=(kernel_size // 2)))
m.append(self.act)
m.append(
M.Conv2d(out_channels,
out_channels,
kernel_size=kernel_size,
stride=1,
padding=(kernel_size // 2)))
self.body = M.Sequential(*m)
def __init__(self, in_channels, out_channels, kernel_size):
super(SqueezeInitBlock, self).__init__()
self.conv = M.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=2)
self.activ = M.ReLU()
def __init__(self, in_channels, out_channels, kernel_size, padding):
super(FireConv, self).__init__()
self.conv = M.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
padding=padding)
self.activation = M.ReLU()
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride,
padding,
dilation=1,
groups=1,
bias=False,
use_bn=True,
bn_eps=1e-5,
activation=M.ReLU()):
super(ConvBlock, self).__init__()
self.activation = activation
self.use_bn = use_bn
self.conv = M.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
dilation=dilation,
groups=groups,
bias=bias)
if self.use_bn:
self.bn = M.BatchNorm2d(num_features=out_channels, eps=bn_eps)
def __init__(self,
in_channels,
out_channels,
hidden_channels=None,
downsample=False):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.hidden_channels = hidden_channels if hidden_channels is not None else in_channels
self.downsample = downsample
self.learnable_sc = (in_channels != out_channels) or downsample
# Build the layers
self.c1 = M.Conv2d(self.in_channels, self.hidden_channels, 3, 1,
1)
self.c2 = M.Conv2d(self.hidden_channels, self.out_channels, 3, 1,
1)
self.activation = M.ReLU()
M.init.xavier_uniform_(self.c1.weight, math.sqrt(2.0))
M.init.xavier_uniform_(self.c2.weight, math.sqrt(2.0))
# Shortcut layer
if self.learnable_sc:
self.c_sc = M.Conv2d(in_channels, out_channels, 1, 1, 0)
M.init.xavier_uniform_(self.c_sc.weight, 1.0)
def __init__(self,
in_channels: int,
mid_channels: int,
out_channels: int,
stride: int = 1):
super().__init__()
self.conv1 = Conv2D(in_channels,
mid_channels,
kernel_size=5,
stride=stride,
padding=2,
is_seperable=True,
has_relu=True)
self.conv2 = Conv2D(mid_channels,
out_channels,
kernel_size=5,
stride=1,
padding=2,
is_seperable=True,
has_relu=False)
self.proj = (M.Identity()
if stride == 1 and in_channels == out_channels else
Conv2D(in_channels,
out_channels,
kernel_size=3,
stride=stride,
padding=1,
is_seperable=True,
has_relu=False))
self.relu = M.ReLU()
def __init__(self,
channels,
reduction=16,
norm_layer=M.BatchNorm2d,
activation=M.ReLU(),
attention_act=M.Sigmoid()):
"""
Args:
channels (int):
reduction (int):
norm_layer (M.Module):
activation (M.Module):
attention_act (M.Module):
"""
super(SEModule, self).__init__()
inter_ch = int(channels // reduction)
self.fc = M.Sequential(
M.AdaptiveAvgPool2d(1),
Conv2d(channels,
inter_ch,
norm_layer=norm_layer,
activation=activation),
Conv2d(inter_ch,
channels,
norm_layer=norm_layer,
activation=attention_act))
def __init__(self,
in_channels: int,
out_channels: int,
kernel_size: int,
max_pool=True,
max_pool_factor=1.0):
super(ConvBlock, self).__init__()
stride = (int(2 * max_pool_factor), int(2 * max_pool_factor))
if max_pool:
self.max_pool = M.MaxPool2d(kernel_size=stride, stride=stride)
stride = (1, 1)
else:
self.max_pool = lambda x: x
self.normalize = M.BatchNorm2d(out_channels, affine=True)
minit.uniform_(self.normalize.weight)
self.relu = M.ReLU()
self.conv = M.Conv2d(
in_channels,
out_channels,
kernel_size,
stride=stride,
padding=1,
bias=True,
)
maml_init_(self.conv)
def __init__(self):
super().__init__()
# 单信道图片, 两层 5x5 卷积 + ReLU + 池化
self.conv1 = M.Conv2d(1, 6, 5)
self.relu1 = M.ReLU()
self.pool1 = M.MaxPool2d(2, 2)
self.conv2 = M.Conv2d(6, 16, 5)
self.relu2 = M.ReLU()
self.pool2 = M.MaxPool2d(2, 2)
# 两层全连接 + ReLU
self.fc1 = M.Linear(16 * 5 * 5, 120)
self.relu3 = M.ReLU()
self.fc2 = M.Linear(120, 84)
self.relu4 = M.ReLU()
# 分类器
self.classifier = M.Linear(84, 10)
def __init__(self):
super().__init__()
num_convs = 4
in_channels = 256
cls_subnet, bbox_subnet = [], []
for _ in range(num_convs):
cls_subnet.append(
M.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1))
cls_subnet.append(M.ReLU())
bbox_subnet.append(
M.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1))
bbox_subnet.append(M.ReLU())
self.cls_subnet = M.Sequential(*cls_subnet)
self.bbox_subnet = M.Sequential(*bbox_subnet)
# predictor
self.cls_score = M.Conv2d(in_channels,
config.num_cell_anchors *
(config.num_classes - 1) * 1,
kernel_size=3,
stride=1,
padding=1)
self.bbox_pred = M.Conv2d(in_channels,
config.num_cell_anchors * 4 * 1,
kernel_size=3,
stride=1,
padding=1)
self.iou_pred = M.Conv2d(in_channels,
config.num_cell_anchors * 1,
kernel_size=3,
stride=1,
padding=1)
self.num_pred = M.Conv2d(in_channels,
config.num_cell_anchors * 1,
kernel_size=3,
stride=1,
padding=1)
self._init_weights()
def __init__(self,
channels,
exp_channels,
init_block_channels,
final_block_channels,
classifier_mid_channels,
kernels3,
use_relu,
use_se,
first_stride,
final_use_se,
in_channels=3,
in_size=(224, 224),
num_classes=1000):
super(MobileNetV3, self).__init__()
self.in_size = in_size
self.num_classes = num_classes
self.features = []
init_block = conv3x3_block(in_channels=in_channels,
out_channels=init_block_channels,
stride=2,
activation=HSwish())
self.features.append(init_block)
in_channels = init_block_channels
for i, channels_per_stage in enumerate(channels):
stage = []
for j, out_channels in enumerate(channels_per_stage):
exp_channels_ij = exp_channels[i][j]
stride = 2 if (j == 0) and ((i != 0) or first_stride) else 1
use_kernel3 = kernels3[i][j] == 1
activation = M.ReLU() if use_relu[i][j] == 1 else HSwish()
use_se_flag = use_se[i][j] == 1
unit = MobileNetV3Unit(in_channels=in_channels,
out_channels=out_channels,
exp_channels=exp_channels_ij,
use_kernel3=use_kernel3,
stride=stride,
activation=activation,
use_se=use_se_flag)
stage.append(unit)
in_channels = out_channels
self.features += stage
final_block = MobileNetV3FinalBlock(in_channels=in_channels,
out_channels=final_block_channels,
use_se=final_use_se)
self.features.append(final_block)
in_channels = final_block_channels
final_pool = M.AvgPool2d(kernel_size=7, stride=1)
self.features.append(final_pool)
self.features = M.Sequential(*self.features)
self.output = MobileNetV3Classifier(
in_channels=in_channels,
out_channels=num_classes,
mid_channels=classifier_mid_channels,
dropout_rate=0.2)
def __init__(self, class_num=21, pretrained=None):
super().__init__()
self.output_stride = 16
self.sub_output_stride = self.output_stride // 4
self.class_num = class_num
self.aspp = ASPP(in_channels=2048,
out_channels=256,
dr=16 // self.output_stride)
self.dropout = M.Dropout(0.5)
self.upstage1 = M.Sequential(
M.Conv2d(256, 48, 1, 1, padding=1 // 2, bias=True),
M.BatchNorm2d(48),
M.ReLU(),
)
self.upstage2 = M.Sequential(
M.Conv2d(256 + 48, 256, 3, 1, padding=1, bias=True),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.5),
M.Conv2d(256, 256, 3, 1, padding=1, bias=True),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.1),
)
self.convout = M.Conv2d(256, self.class_num, 1, 1, padding=0)
for m in self.modules():
if isinstance(m, M.Conv2d):
M.init.msra_normal_(m.weight,
mode="fan_out",
nonlinearity="relu")
elif isinstance(m, M.BatchNorm2d):
M.init.ones_(m.weight)
M.init.zeros_(m.bias)
self.backbone = ModifiedResNet(
Bottleneck, [3, 4, 23, 3],
replace_stride_with_dilation=[False, False, True])
if pretrained is not None:
model_dict = mge.load(pretrained)
self.backbone.load_state_dict(model_dict)
def __init__(self, in_ch=3, num_classes=1000):
'''
The AlexNet.
args:
in_ch: int, the number of channels of inputs
num_classes: int, the number of classes that need to predict
reference:
"One weird trick for parallelizing convolutional neural networks"<https://arxiv.org/abs/1404.5997>
'''
super(AlexNet, self).__init__()
#the part to extract feature
self.features = M.Sequential(
M.Conv2d(in_ch, 64, kernel_size=11, stride=4, padding=11 // 4),
M.ReLU(),
M.MaxPool2d(kernel_size=3, stride=2),
M.Conv2d(64, 192, kernel_size=5, padding=2),
M.ReLU(),
M.MaxPool2d(kernel_size=3, stride=2),
M.Conv2d(192, 384, kernel_size=3, stride=1, padding=1),
M.ReLU(),
M.Conv2d(384, 256, kernel_size=3, stride=1, padding=1),
M.ReLU(),
M.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
M.ReLU(),
M.MaxPool2d(kernel_size=3, stride=2),
)
#global avg pooling
self.avgpool = M.AdaptiveAvgPool2d((6, 6))
#classify part
self.classifier = M.Sequential(M.Dropout(),
M.Linear(256 * 6 * 6, 4096), M.ReLU(),
M.Dropout(), M.Linear(4096, 4096),
M.ReLU(), M.Linear(4096, num_classes))
def __init__(self, cfg):
super().__init__()
self.cfg = cfg
self.output_stride = 16
self.sub_output_stride = self.output_stride // 4
self.num_classes = cfg.num_classes
self.aspp = ASPP(in_channels=2048,
out_channels=256,
dr=16 // self.output_stride)
self.dropout = M.Dropout(0.5)
self.upstage1 = M.Sequential(
M.Conv2d(256, 48, 1, 1, padding=1 // 2, bias=False),
M.BatchNorm2d(48),
M.ReLU(),
)
self.upstage2 = M.Sequential(
M.Conv2d(256 + 48, 256, 3, 1, padding=1, bias=False),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.5),
M.Conv2d(256, 256, 3, 1, padding=1, bias=False),
M.BatchNorm2d(256),
M.ReLU(),
M.Dropout(0.1),
)
self.conv_out = M.Conv2d(256, self.num_classes, 1, 1, padding=0)
for m in self.modules():
if isinstance(m, M.Conv2d):
M.init.msra_normal_(m.weight,
mode="fan_out",
nonlinearity="relu")
elif isinstance(m, M.BatchNorm2d):
M.init.ones_(m.weight)
M.init.zeros_(m.bias)
self.backbone = getattr(resnet, cfg.backbone)(
replace_stride_with_dilation=[False, False, True],
pretrained=cfg.backbone_pretrained,
)
del self.backbone.fc
def __init__(self,
inplanes,
outplanes,
stride=1,
dilation=1,
groups=1,
downsample=None,
base_width=64,
norm_layer=None,
se_module=None,
radix=2,
reduction=4,
avd=False,
avd_first=False,
is_first=False):
'''
Implementation of the basic block.
Args:
inplanes (int): the number of channels of input
outplanes (int): the number of channels of output (the number of kernels of conv layers)
stride (int, tuple or list): the stride of the first conv3x3 layer
dilation (int):the dilation rate of the first conv layer of the block
groups (int): the number of groups for the first conv3x3 layer
downsample (megendine.module.Module or None): if not None, will do the downsample for x
base_width (int): the basic width of the layer
norm_layer (None or megendine.module.Module): the normalization layer of the block, default is batch normalization
se_module (SEModule or None): the semodule from SENet
'''
super(BasicBlock, self).__init__()
if norm_layer is None:
norm_layer = M.BatchNorm2d
if groups != 1 or base_width != 64:
raise ValueError(
'BasicBlock only supports groups=1 and base_width=64')
if dilation > 1:
raise NotImplementedError(
"Dilation > 1 not supportes in BasicBlock")
# self.downsample and self.conv1 layer will do the downsample of the input both when stride != 1
# layer1
self.conv1 = conv3x3(inplanes,
outplanes,
stride=stride,
dilation=dilation,
groups=groups)
self.bn1 = norm_layer(outplanes)
# activation layer
self.relu = M.ReLU()
# layer2
self.conv2 = conv3x3(outplanes, outplanes)
self.bn2 = norm_layer(outplanes)
# downsample layer
self.downsample = downsample
# semodule
self.se = se_module
self.stride = stride
def __init__(self,
gate_channel,
reduction_ratio=16,
dilation_conv_num=2,
dilation_val=4):
super(SpatialGate, self).__init__()
self.gate_s = M.Sequential(
M.Conv2d(gate_channel, gate_channel//reduction_ratio, kernel_size=1),
M.BatchNorm2d(gate_channel//reduction_ratio),
M.ReLU(),
M.Conv2d(gate_channel // reduction_ratio, gate_channel // reduction_ratio, kernel_size=3, \
padding=dilation_val, dilation=dilation_val),
M.BatchNorm2d(gate_channel // reduction_ratio),
M.ReLU(),
M.Conv2d(gate_channel // reduction_ratio, gate_channel // reduction_ratio, kernel_size=3, \
padding=dilation_val, dilation=dilation_val),
M.BatchNorm2d(gate_channel // reduction_ratio),
M.ReLU(),
M.Conv2d(gate_channel//reduction_ratio, 1, kernel_size=1))
