def __init__(self, inp, oup, stride, benchmodel, activation=nn.ReLU):
super(ShuffleInvertedResidual, self).__init__()
self.benchmodel = benchmodel
self.stride = stride
assert stride in [1, 2]
oup_inc = oup // 2
if self.benchmodel == 1:
# assert inp == oup_inc
self.branch2 = nn.Sequential(
# pw
nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup_inc),
make_activation(activation),
# dw
nn.Conv2d(oup_inc,
oup_inc,
3,
stride,
1,
groups=oup_inc,
bias=False),
nn.BatchNorm2d(oup_inc),
# pw-linear
nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup_inc),
make_activation(activation),
)
else:
self.branch1 = nn.Sequential(
# dw
nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
nn.BatchNorm2d(inp),
# pw-linear
nn.Conv2d(inp, oup_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup_inc),
make_activation(activation),
)
self.branch2 = nn.Sequential(
# pw
nn.Conv2d(inp, oup_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup_inc),
make_activation(activation),
# dw
nn.Conv2d(oup_inc,
oup_inc,
3,
stride,
1,
groups=oup_inc,
bias=False),
nn.BatchNorm2d(oup_inc),
# pw-linear
nn.Conv2d(oup_inc, oup_inc, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup_inc),
make_activation(activation),
)
self.init_weights()
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
activation=nn.ReLU):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.act1 = make_activation(activation)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.act2 = make_activation(activation)
self.conv3 = nn.Conv2d(planes,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.act3 = make_activation(activation)
self.downsample = downsample
self.stride = stride
def __init__(self, input_planes, squeeze_planes, output_planes, downsample=False, dropout_ratio=0.1,
activation=nn.ELU):
super(RMBlock, self).__init__()
self.downsample = downsample
self.input_planes = input_planes
self.output_planes = output_planes
self.squeeze_conv = nn.Conv2d(input_planes, squeeze_planes, kernel_size=1, bias=False)
self.squeeze_bn = nn.BatchNorm2d(squeeze_planes)
self.dw_conv = nn.Conv2d(squeeze_planes, squeeze_planes, groups=squeeze_planes, kernel_size=3, padding=1,
stride=2 if downsample else 1, bias=False)
self.dw_bn = nn.BatchNorm2d(squeeze_planes)
self.expand_conv = nn.Conv2d(squeeze_planes, output_planes, kernel_size=1, bias=False)
self.expand_bn = nn.BatchNorm2d(output_planes)
self.activation = make_activation(activation)
self.dropout_ratio = dropout_ratio
if self.downsample:
self.skip_conv = nn.Conv2d(input_planes, output_planes, kernel_size=1, bias=False)
self.skip_conv_bn = nn.BatchNorm2d(output_planes)
self.init_weights()
def __init__(self, block, layers, num_classes=1000, activation=nn.ReLU, head=False):
self.inplanes = 64
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = make_activation(nn.ReLU)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0], activation=activation)
self.layer2 = self._make_layer(block, 128, layers[1], stride=2, activation=activation)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2, activation=activation)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2, activation=activation)
self.avgpool = nn.Conv2d(512 * block.expansion, 512 * block.expansion, 7,
groups=512 * block.expansion, bias=False)
self.head = head
if not self.head:
self.output_channels = 512 * block.expansion
else:
self.fc = nn.Conv2d(512 * block.expansion, num_classes, 1, stride=1, padding=0, bias=False)
self.output_channels = num_classes
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def init_block(in_channels, out_channels, stride, activation=nn.PReLU):
"""Builds the first block of the MobileFaceNet"""
return nn.Sequential(
nn.BatchNorm2d(3),
nn.Conv2d(in_channels, out_channels, 3, stride, 1, bias=False),
nn.BatchNorm2d(out_channels),
make_activation(activation)
)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
activation=nn.ReLU):
super(SEBottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * 4)
self.relu1 = make_activation(activation)
self.relu2 = make_activation(activation)
self.relu3 = make_activation(activation)
self.relu4 = make_activation(activation)
# SE
self.global_pool = nn.AdaptiveAvgPool2d(1)
self.conv_down = nn.Conv2d(planes * 4,
planes // 4,
kernel_size=1,
bias=False)
self.conv_up = nn.Conv2d(planes // 4,
planes * 4,
kernel_size=1,
bias=False)
self.sig = nn.Sigmoid()
# Downsample
self.downsample = downsample
self.stride = stride
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
activation=nn.ReLU):
super(BasicBlock, self).__init__()
self.conv1 = nn.Conv2d(inplanes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.relu = make_activation(activation)
self.conv2 = nn.Conv2d(inplanes,
planes,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
def conv_1x1_bn(inp, oup, activation=nn.ReLU):
conv = nn.Sequential(nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup), make_activation(activation))
nn.init.kaiming_normal_(conv[0].weight, mode='fan_out')
return conv