def __init__(self,in_channels, out_channels, kernel_size=3, stride=1, padding = 0,
dilation=1, groups=1, bias=True):
super(ComplexConv2d, self).__init__()
self.conv_r = Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
self.conv_i = Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
def create_Mb_Tiny_RFB_fd(num_classes,
is_test=False,
device="cuda",
without_postprocessing=False):
base_net = Mb_Tiny_RFB(2)
base_net_model = base_net.model # disable dropout layer
source_layer_indexes = [8, 11, 13]
extras = ModuleList([
Sequential(
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=base_net.base_channel * 4,
kernel_size=1), ReLU(),
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=base_net.base_channel * 16,
kernel_size=3,
stride=2,
padding=1), ReLU())
])
regression_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=3 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=2 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=2 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=3 * 4,
kernel_size=3,
padding=1)
])
classification_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=3 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=2 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=2 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=3 * num_classes,
kernel_size=3,
padding=1)
])
return SSD(num_classes,
base_net_model,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config,
device=device,
without_postprocessing=without_postprocessing)
def __init__(self,
in_channels,
channels,
kernel_size,
stride=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
bias=True,
radix=2,
reduction_factor=4,
rectify=False,
rectify_avg=False,
norm_layer=None,
dropblock_prob=0.0,
**kwargs):
super(SplAtConv2d, self).__init__()
padding = _pair(padding)
self.rectify = rectify and (padding[0] > 0 or padding[1] > 0)
self.rectify_avg = rectify_avg
inter_channels = max(in_channels * radix // reduction_factor, 32)
self.radix = radix
self.cardinality = groups
self.channels = channels
self.dropblock_prob = dropblock_prob
if self.rectify:
from rfconv import RFConv2d
self.conv = RFConv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
average_mode=rectify_avg,
**kwargs)
else:
self.conv = Conv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
**kwargs)
self.use_bn = norm_layer is not None
if self.use_bn:
self.bn0 = norm_layer(channels * radix)
self.relu = ReLU(inplace=True)
self.fc1 = Conv2d(channels, inter_channels, 1, groups=self.cardinality)
if self.use_bn:
self.bn1 = norm_layer(inter_channels)
self.fc2 = Conv2d(inter_channels,
channels * radix,
1,
groups=self.cardinality)
if dropblock_prob > 0.0:
self.dropblock = DropBlock2D(dropblock_prob, 3)
self.rsoftmax = rSoftMax(radix, groups)
def __init__(self, in_c, out_c, kernel=(1, 1), stride=(1, 1), padding=(0, 0), groups=1):
super(Linear_block, self).__init__()
self.conv = Conv2d(in_c, out_channels=out_c, kernel_size=kernel, groups=groups, stride=stride, padding=padding, bias=False)
self.bn = BatchNorm2d(out_c)
def __init__(self, attention=False, multi_scale=True):
super(OctMLT, self).__init__()
self.inplanes = 64
alpha = 0.5
self.layer0 = nn.Sequential(
OctConv2d(3,
16,
3,
stride=1,
padding=1,
bias=False,
alpha=(0, 0.5)), CReLU_IN(16),
OctConv2d(32, 32, 3, stride=2, padding=1, bias=False),
CReLU_IN(32))
self.layer0_1 = nn.Sequential(
OctConv2d(64, 64, 3, stride=1, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
_ReLU(),
OctConv2d(64, 64, 3, stride=2, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
_ReLU(inplace=True))
self.conv5 = OctConv2d(64, 128, 3, padding=1, bias=False, gated=True)
self.conv6 = OctConv2d(128, 128, 3, padding=1, bias=False, gated=True)
self.conv7 = OctConv2d(128, 256, 3, padding=1, bias=False, gated=True)
self.conv8 = OctConv2d(256, 256, 3, padding=1, bias=False, gated=True)
self.conv9_1 = OctConv2d(256,
256,
3,
padding=1,
bias=False,
gated=True)
self.conv9_2 = OctConv2d(256,
256,
3,
padding=1,
bias=False,
alpha=(0.5, 0),
gated=True)
self.conv10_s = GatedConv(256, 256, (2, 3), padding=(0, 1), bias=False)
self.conv11 = Conv2d(256, 74, 1, padding=(0, 0))
self.batch5 = _InstanceNorm2d(128,
eps=1e-05,
momentum=0.1,
affine=True)
self.batch6 = _InstanceNorm2d(128,
eps=1e-05,
momentum=0.1,
affine=True)
self.batch7 = _InstanceNorm2d(256,
eps=1e-05,
momentum=0.1,
affine=True)
self.batch8 = _InstanceNorm2d(256,
eps=1e-05,
momentum=0.1,
affine=True)
self.batch9 = _InstanceNorm2d(256,
eps=1e-05,
momentum=0.1,
affine=True)
self.batch10_s = InstanceNorm2d(256,
eps=1e-05,
momentum=0.1,
affine=True)
self.max2_1 = nn.MaxPool2d((2, 1), stride=(2, 1))
self.max2 = _MaxPool2d((2, 1), stride=(2, 1))
self.leaky = _LeakyReLU(negative_slope=0.01, inplace=True)
self.leaky2 = LeakyReLU(negative_slope=0.01, inplace=True)
self.groups = 3
self.stage_out_channels = [-1, 24, 240, 480, 960]
self.stage_repeats = [3, 7, 3]
self.layer1 = self._make_layer(BasicBlockIn,
24,
3,
stride=1,
alpha=alpha)
self.layer2 = self._make_stage(2)
self.layer3 = self._make_stage(3)
self.layer4 = self._make_stage(4)
self.feature4 = OctConv2d(960,
256,
1,
stride=1,
padding=0,
bias=False,
alpha=(0.5, 0))
self.feature3 = OctConv2d(480,
256,
1,
stride=1,
padding=0,
bias=False,
alpha=(0.5, 0))
self.feature2 = OctConv2d(240,
256,
1,
stride=1,
padding=0,
bias=False,
alpha=(0.5, 0))
self.upconv2 = conv_dw_plain(256, 256, stride=1, alpha=0)
self.upconv1 = conv_dw_plain(256, 256, stride=1, alpha=0)
self.feature1 = OctConv2d(24,
256,
1,
stride=1,
padding=0,
bias=False,
alpha=(0.5, 0))
self.act = OctConv2d(256, 1, 1, padding=0, stride=1, alpha=0)
self.rbox = OctConv2d(256, 4, 1, padding=0, stride=1, alpha=0)
self.angle = OctConv2d(256, 2, 1, padding=0, stride=1, alpha=0)
self.drop0 = _Dropout2d(p=0.2, inplace=False)
self.drop1 = Dropout2d(p=0.2, inplace=False)
self.angle_loss = nn.MSELoss(reduction='elementwise_mean')
self.h_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.w_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.attention = attention
if self.attention:
self.conv_attenton = OctConv2d(256,
1,
kernel_size=1,
stride=1,
padding=0,
bias=True,
alpha=0)
self.multi_scale = multi_scale
def create_resnet18_ssd(num_classes, is_test=False):
resnet = resnet18(pretrained=False)
modules = list(resnet.children())[:-2] # delete the last fc layer.
pool5 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
conv6 = nn.Conv2d(512, 1024, kernel_size=1, padding=0, dilation=6)
# # conv7 = nn.Conv2d(1024, 1024, kernel_size=1)
# modules += [conv6, nn.ReLU()]
modules += [pool5, conv6, nn.ReLU()]
base_net = nn.Sequential(*modules)
source_layer_indexes = [
7,
10,
]
extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1), ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128, out_channels=256, kernel_size=3),
ReLU()),
Sequential(Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128, out_channels=256, kernel_size=3),
ReLU())
])
regression_headers = ModuleList([
Conv2d(in_channels=512, out_channels=4 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=1024, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=512, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=4 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=4 * 4, kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
classification_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
return SSD(num_classes,
base_net,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config)
def __init__(self, in_f, f, k=3):
super(ConvNormRelu, self).__init__()
self.conv = Conv2d(in_f, f, k,padding=1, bias=False)
self.bnorm = BatchNorm2d(f, eps=1e-03)
def __init__(self, in_channels, out_channels, **kwargs):
super(BasicConv2d, self).__init__()
self.conv = Conv2d(in_channels, out_channels, bias=False, **kwargs)
self.bn = BatchNorm2d(out_channels, eps=0.001)
def __init__(self, attention=False, multi_scale=True):
super(ModelMLTRCTW, self).__init__()
self.inplanes = 64
self.layer0 = nn.Sequential(
Conv2d(3, 16, 3, stride=1, padding=1, bias=False), CReLU_IN(16),
Conv2d(32, 32, 3, stride=2, padding=1, bias=False), CReLU_IN(32))
self.layer0_1 = nn.Sequential(
Conv2d(64, 64, 3, stride=1, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
nn.ReLU(),
Conv2d(64, 64, 3, stride=2, padding=1, bias=False),
#nn.InstanceNorm2d(64, affine=True),
nn.ReLU(inplace=True))
self.conv5 = Conv2d(64, 128, (3, 3), padding=(1, 1), bias=False)
self.conv6 = Conv2d(128, 128, (3, 3), padding=1, bias=False)
self.conv7 = Conv2d(128, 256, 3, padding=1, bias=False)
self.conv8 = Conv2d(256, 256, (3, 3), padding=1, bias=False)
self.conv9 = Conv2d(256, 256, (3, 3), padding=(1, 1), bias=False)
self.conv10_s = Conv2d(256, 256, (2, 3), padding=(0, 1), bias=False)
self.conv11 = Conv2d(256, 7500, (1, 1), padding=(0, 0))
self.batch5 = InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
self.batch6 = InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
self.batch7 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch8 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch9 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch10_s = InstanceNorm2d(256,
eps=1e-05,
momentum=0.1,
affine=True)
self.max2 = nn.MaxPool2d((2, 1), stride=(2, 1))
self.leaky = LeakyReLU(negative_slope=0.01, inplace=True)
self.layer1 = self._make_layer(BasicBlockIn, 64, 3, stride=1)
self.inplanes = 64
self.layer2 = self._make_layer(BasicBlockIn, 128, 4, stride=2)
self.layer3 = self._make_layer(BasicBlockSepIn, 256, 6, stride=2)
self.layer4 = self._make_layer(BasicBlockSepIn, 512, 4, stride=2)
self.feature4 = nn.Conv2d(512, 256, 1, stride=1, padding=0, bias=False)
self.feature3 = nn.Conv2d(256, 256, 1, stride=1, padding=0, bias=False)
self.feature2 = nn.Conv2d(128, 256, 1, stride=1, padding=0, bias=False)
self.upconv2 = conv_dw_plain(256, 256, stride=1)
self.upconv1 = conv_dw_plain(256, 256, stride=1)
self.feature1 = nn.Conv2d(64, 256, 1, stride=1, padding=0, bias=False)
self.act = Conv2d(256, 1, (1, 1), padding=0, stride=1)
self.rbox = Conv2d(256, 4, (1, 1), padding=0, stride=1)
self.angle = Conv2d(256, 2, (1, 1), padding=0, stride=1)
self.drop1 = Dropout2d(p=0.2, inplace=False)
self.angle_loss = nn.MSELoss(reduction='elementwise_mean')
self.h_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.w_loss = nn.SmoothL1Loss(reduction='elementwise_mean')
self.attention = attention
if self.attention:
self.conv_attenton = nn.Conv2d(256,
1,
kernel_size=1,
stride=1,
padding=0,
bias=True)
self.multi_scale = multi_scale
def __init__(self, inChannels, outChannels):
super().__init__()
# store the convolution and RELU layers
self.conv1 = Conv2d(inChannels, outChannels, 3)
self.relu = ReLU()
self.conv2 = Conv2d(outChannels, outChannels, 3)
def create_mobilenetv1_ssd(num_classes, is_test=False, device='cpu'):
base_net = MobileNetV1(1001).model # disable dropout layer
source_layer_indexes = [
12,
14,
]
extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1), ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU())
])
regression_headers = ModuleList([
Conv2d(in_channels=512, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=1024, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=512, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=6 * 4, kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
classification_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
return SSD(num_classes,
base_net,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config,
device=device)
def __init__(self,
num_classes: int,
is_test=False,
config=None,
device=None):
""" Create default SSD model.
"""
super(SSD, self).__init__()
self.num_classes = num_classes
self.base_net = MobileNetV1(self.num_classes).model
self.source_layer_indexes = [
12,
14,
]
self.extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1),
ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU())
])
self.regression_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1),
# TODO: change to kernel_size=1, padding=0?
])
self.classification_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
# TODO: change to kernel_size=1, padding=0?
])
self.is_test = is_test
self.config = config
# register layers in source_layer_indexes by adding them to a module list
self.source_layer_add_ons = nn.ModuleList(
[t[1] for t in self.source_layer_indexes if isinstance(t, tuple)])
if device:
self.device = device
else:
self.device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
if is_test:
self.config = config
self.priors = config.priors.to(self.device)
def __init__(self, in_channels, out_channels, kernel_size, stride, upsample=None):
super(UpsampleConLayer, self).__init__()
self.upsample = upsample
reflection_padding = kernel_size // 2
self.reflection_pad = ReflectionPad2d(reflection_padding)
self.conv2d = Conv2d(in_channels, out_channels, kernel_size, stride)
def test_conv_bn_relu(
self,
batch_size,
input_channels_per_group,
height,
width,
output_channels_per_group,
groups,
kernel_h,
kernel_w,
stride_h,
stride_w,
pad_h,
pad_w,
dilation,
padding_mode,
use_relu,
eps,
momentum,
freeze_bn
):
input_channels = input_channels_per_group * groups
output_channels = output_channels_per_group * groups
dilation_h = dilation_w = dilation
conv_op = Conv2d(
input_channels,
output_channels,
(kernel_h, kernel_w),
(stride_h, stride_w),
(pad_h, pad_w),
(dilation_h, dilation_w),
groups,
False, # No bias
padding_mode
).to(dtype=torch.float)
bn_op = BatchNorm2d(output_channels, eps, momentum).to(dtype=torch.float)
relu_op = ReLU()
cls = ConvBnReLU2d if use_relu else ConvBn2d
qat_op = cls(
input_channels,
output_channels,
(kernel_h, kernel_w),
(stride_h, stride_w),
(pad_h, pad_w),
(dilation_h, dilation_w),
groups,
padding_mode,
eps,
momentum,
freeze_bn,
default_qat_qconfig.activation,
default_qat_qconfig.weight
).to(dtype=torch.float).disable_fake_quant()
# align inputs and internal parameters
input = torch.randn(batch_size, input_channels, height, width, dtype=torch.float)
input.requires_grad_()
conv_op.weight = Parameter(qat_op.weight)
bn_op.running_mean = qat_op.running_mean
bn_op.running_var = qat_op.running_var
bn_op.weight = qat_op.gamma
bn_op.bias = qat_op.beta
def compose(functions):
# functions are reversed for natural reading order
return reduce(lambda f, g: lambda x: f(g(x)), functions[::-1], lambda x: x)
if not use_relu:
def relu_op(x):
return x
if freeze_bn:
def ref_op(x):
x = conv_op(x)
x = (x - bn_op.running_mean.reshape([1, -1, 1, 1])) * \
(bn_op.weight / torch.sqrt(bn_op.running_var + bn_op.eps)) \
.reshape([1, -1, 1, 1]) + bn_op.bias.reshape([1, -1, 1, 1])
x = relu_op(x)
return x
else:
ref_op = compose([conv_op, bn_op, relu_op])
result_ref = ref_op(input)
result_actual = qat_op(input)
self.assertEqual(result_ref, result_actual)
# backward
dout = torch.randn(result_ref.size(), dtype=torch.float)
result_actual.backward(dout, retain_graph=True)
grad_ref = input.grad.cpu()
result_actual.backward(dout)
grad_actual = input.grad.cpu()
self.assertEqual(grad_ref, grad_actual)
pred = net(data[0].cuda())
pred = pred.argmax()
counter += 1
if pred.item() == data[1]:
num_correct += 1
accuracy = num_correct / (ldr.__len__())
print("Accuracy: ", accuracy)
set_grad_enabled(True)
net.train()
return accuracy
#Define the binary classifier network
net = Sequential(
Conv2d(3, filter1, kernel_size=2, stride=1, padding=0),
ReLU(),
MaxPool2d(kernel_size=2, stride=2),
Conv2d(filter1, filter2, kernel_size=4, stride=1, padding=0),
ReLU(),
#MaxPool2d(kernel_size=2, stride=2),
Flatten(),
Linear(input_dim, layer1),
ReLU(),
Linear(layer1, layer2),
ReLU(),
Linear(layer2, layer3),
ReLU(),
Linear(layer3, out_dim),
)
def __init__(self,
device,
num_nodes,
dropout=0.3,
supports=None,
do_graph_conv=True,
addaptadj=True,
aptinit=None,
in_dim=2,
out_dim=12,
residual_channels=32,
dilation_channels=32,
cat_feat_gc=False,
skip_channels=256,
end_channels=512,
kernel_size=2,
blocks=4,
layers=2,
apt_size=10,
scale_dim=168,
downscale_input=False,
upscale_output=False,
pwn=False):
super().__init__()
self.dropout = dropout
self.blocks = blocks
self.layers = layers
self.do_graph_conv = do_graph_conv
self.cat_feat_gc = cat_feat_gc
self.addaptadj = addaptadj
self.scale_dim = scale_dim
self.downscale_input = downscale_input
self.upscale_output = upscale_output
self.pwn = pwn
if self.downscale_input:
self.start_linear = nn.Linear(in_features=self.scale_dim,
out_features=num_nodes,
bias=True)
if self.upscale_output:
if num_nodes < self.scale_dim:
self.end_linear = nn.Linear(in_features=num_nodes,
out_features=self.scale_dim,
bias=True)
else:
self.end_linear = nn.Linear(in_features=self.scale_dim,
out_features=num_nodes,
bias=True)
if self.pwn:
pwn_params = torch.randn(num_nodes, self.scale_dim)
self.pwn_embedding = Parameter(pwn_params.to(device),
requires_grad=True)
if self.cat_feat_gc:
self.start_conv = nn.Conv2d(
in_channels=1, # hard code to avoid errors
out_channels=residual_channels,
kernel_size=(1, 1))
self.cat_feature_conv = nn.Conv2d(in_channels=in_dim - 1,
out_channels=residual_channels,
kernel_size=(1, 1))
else:
self.start_conv = nn.Conv2d(in_channels=in_dim,
out_channels=residual_channels,
kernel_size=(1, 1))
self.fixed_supports = supports or []
receptive_field = 1
self.supports_len = len(self.fixed_supports)
if do_graph_conv and addaptadj:
if aptinit is None:
nodevecs = torch.randn(num_nodes, apt_size), torch.randn(
apt_size, num_nodes)
else:
nodevecs = self.svd_init(apt_size, aptinit)
self.supports_len += 1
self.nodevec1, self.nodevec2 = [
Parameter(n.to(device), requires_grad=True) for n in nodevecs
]
depth = list(range(blocks * layers))
# 1x1 convolution for residual and skip connections (slightly different see docstring)
self.residual_convs = ModuleList([
Conv1d(dilation_channels, residual_channels, (1, 1)) for _ in depth
])
self.skip_convs = ModuleList(
[Conv1d(dilation_channels, skip_channels, (1, 1)) for _ in depth])
self.bn = ModuleList([BatchNorm2d(residual_channels) for _ in depth])
self.graph_convs = ModuleList([
GraphConvNet(dilation_channels,
residual_channels,
dropout,
support_len=self.supports_len) for _ in depth
])
self.filter_convs = ModuleList()
self.gate_convs = ModuleList()
for b in range(blocks):
additional_scope = kernel_size - 1
D = 1 # dilation
for i in range(layers):
# dilated convolutions
self.filter_convs.append(
Conv2d(residual_channels,
dilation_channels, (1, kernel_size),
dilation=D))
self.gate_convs.append(
Conv1d(residual_channels,
dilation_channels, (1, kernel_size),
dilation=D))
D *= 2
receptive_field += additional_scope
additional_scope *= 2
self.receptive_field = receptive_field
self.end_conv_1 = Conv2d(skip_channels,
end_channels, (1, 1),
bias=True)
self.end_conv_2 = Conv2d(end_channels, out_dim, (1, 1), bias=True)
device=None):
predictor = Predictor(net,
config.image_size,
config.image_mean,
config.image_std,
nms_method=nms_method,
iou_threshold=config.iou_threshold,
candidate_size=candidate_size,
sigma=sigma,
device=device)
return predictor
extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1), ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(Conv2d(in_channels=256, out_channels=128,
kernel_size=1), ReLU(),
Conv2d(in_channels=128, out_channels=256, kernel_size=3),
def create_mobilenetv3_ssd_lite_large(num_classes,
width_mult=1.0,
use_batch_norm=True,
onnx_compatible=False,
is_test=False):
base_net = MobileNetV3(model_mode="LARGE").features
source_layer_indexes = [
GraphPath(15, 'conv', -1),
22,
]
extras = ModuleList([
InvertedResidual(1280, 512, stride=2, expand_ratio=0.2),
InvertedResidual(512, 256, stride=2, expand_ratio=0.25),
InvertedResidual(256, 256, stride=2, expand_ratio=0.5),
InvertedResidual(256, 64, stride=2, expand_ratio=0.25)
])
regression_headers = ModuleList([
SeperableConv2d(in_channels=round(672 * width_mult),
out_channels=6 * 4,
kernel_size=3,
padding=1,
onnx_compatible=False),
SeperableConv2d(in_channels=1280,
out_channels=6 * 4,
kernel_size=3,
padding=1,
onnx_compatible=False),
SeperableConv2d(in_channels=512,
out_channels=6 * 4,
kernel_size=3,
padding=1,
onnx_compatible=False),
SeperableConv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1,
onnx_compatible=False),
SeperableConv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1,
onnx_compatible=False),
Conv2d(in_channels=64, out_channels=6 * 4, kernel_size=1),
])
classification_headers = ModuleList([
SeperableConv2d(in_channels=round(672 * width_mult),
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=1280,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=64, out_channels=6 * num_classes, kernel_size=1),
])
return SSD(num_classes,
base_net,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config)
def __init__(self, in_f, f):
super(ConvStride2NormRelu, self).__init__()
self.zero = ZeroPad2d((1, 0, 1, 0))
self.conv = Conv2d(in_f, f, 3, stride=2, bias=False)
self.bnorm = BatchNorm2d(f, eps=1e-03)
def test_conv_bn_relu(self, batch_size, input_channels_per_group, height,
width, output_channels_per_group, groups, kernel_h,
kernel_w, stride_h, stride_w, pad_h, pad_w, dilation,
padding_mode, use_relu, eps, momentum, freeze_bn):
# **** WARNING: This is used to temporarily disable MKL-DNN convolution due
# to a bug: https://github.com/pytorch/pytorch/issues/23825
# Once this bug is fixed, this context manager as well as its callsites
# should be removed!
with torch.backends.mkldnn.flags(enabled=False):
input_channels = input_channels_per_group * groups
output_channels = output_channels_per_group * groups
dilation_h = dilation_w = dilation
conv_op = Conv2d(
input_channels,
output_channels,
(kernel_h, kernel_w),
(stride_h, stride_w),
(pad_h, pad_w),
(dilation_h, dilation_w),
groups,
False, # No bias
padding_mode).to(dtype=torch.double)
bn_op = BatchNorm2d(output_channels, eps,
momentum).to(dtype=torch.double)
relu_op = ReLU()
cls = ConvBnReLU2d if use_relu else ConvBn2d
qat_op = cls(input_channels, output_channels, (kernel_h, kernel_w),
(stride_h, stride_w), (pad_h, pad_w),
(dilation_h, dilation_w), groups, padding_mode, eps,
momentum, freeze_bn,
default_qat_qconfig).to(dtype=torch.double)
qat_op.apply(torch.quantization.disable_fake_quant)
# align inputs and internal parameters
input = torch.randn(batch_size,
input_channels,
height,
width,
dtype=torch.double,
requires_grad=True)
conv_op.weight = torch.nn.Parameter(qat_op.weight.detach())
bn_op.running_mean = qat_op.running_mean.clone()
bn_op.running_var = qat_op.running_var.clone()
bn_op.weight = torch.nn.Parameter(qat_op.gamma.detach())
bn_op.bias = torch.nn.Parameter(qat_op.beta.detach())
def compose(functions):
# functions are reversed for natural reading order
return reduce(lambda f, g: lambda x: f(g(x)), functions[::-1],
lambda x: x)
if not use_relu:
def relu_op(x):
return x
if freeze_bn:
def ref_op(x):
x = conv_op(x)
x = (x - bn_op.running_mean.reshape([1, -1, 1, 1])) * \
(bn_op.weight / torch.sqrt(bn_op.running_var + bn_op.eps)) \
.reshape([1, -1, 1, 1]) + bn_op.bias.reshape([1, -1, 1, 1])
x = relu_op(x)
return x
else:
ref_op = compose([conv_op, bn_op, relu_op])
input_clone = input.clone().detach().requires_grad_()
for i in range(2):
result_ref = ref_op(input)
result_actual = qat_op(input_clone)
self.assertEqual(result_ref, result_actual)
# backward
dout = torch.randn(result_ref.size(), dtype=torch.double)
loss = (result_ref - dout).sum()
loss.backward()
input_grad_ref = input.grad.cpu()
weight_grad_ref = conv_op.weight.grad.cpu()
gamma_grad_ref = bn_op.weight.grad.cpu()
beta_grad_ref = bn_op.bias.grad.cpu()
running_mean_ref = bn_op.running_mean
running_var_ref = bn_op.running_var
num_batches_tracked_ref = bn_op.num_batches_tracked
loss = (result_actual - dout).sum()
loss.backward()
input_grad_actual = input_clone.grad.cpu()
weight_grad_actual = qat_op.weight.grad.cpu()
gamma_grad_actual = qat_op.gamma.grad.cpu()
beta_grad_actual = qat_op.beta.grad.cpu()
running_mean_actual = qat_op.running_mean
running_var_actual = qat_op.running_var
num_batches_tracked_actual = qat_op.num_batches_tracked
precision = 1e-10
self.assertEqual(input_grad_ref,
input_grad_actual,
prec=precision)
self.assertEqual(weight_grad_ref,
weight_grad_actual,
prec=precision)
self.assertEqual(gamma_grad_ref,
gamma_grad_actual,
prec=precision)
self.assertEqual(beta_grad_ref,
beta_grad_actual,
prec=precision)
self.assertEqual(num_batches_tracked_ref,
num_batches_tracked_actual,
prec=precision)
self.assertEqual(running_mean_ref,
running_mean_actual,
prec=precision)
self.assertEqual(running_var_ref,
running_var_actual,
prec=precision)
def create_vgg_ssd(num_classes, is_test=False):
vgg_config = [
64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'C', 512, 512, 512, 'M',
512, 512, 512
]
base_net = ModuleList(vgg(vgg_config))
source_layer_indexes = [
(23, BatchNorm2d(512)),
len(base_net),
]
extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1), ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1), ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128, out_channels=256, kernel_size=3),
ReLU()),
Sequential(Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128, out_channels=256, kernel_size=3),
ReLU())
])
regression_headers = ModuleList([
Conv2d(in_channels=512, out_channels=4 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=1024, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=512, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=6 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=4 * 4, kernel_size=3, padding=1),
Conv2d(in_channels=256, out_channels=4 * 4, kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
classification_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
return SSD(num_classes,
base_net,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config)
def __init__(self):
super(TorchModel, self).__init__()
self.conv = Conv2d(3, 16, 3)
self.bn = BatchNorm2d(16)
self.relu = ReLU(inplace=True)
self.fc = nn.Linear(3136, 3)
def __init__(self,
n_channels=3,
num_levels=17,
padding="same",
momentum=0.1):
super(FullConvNet, self).__init__()
self._num_levels = num_levels
self._actfun = [
ReLU(),
] * (self._num_levels - 1) + [
None,
]
self._f_size = [
3,
] * self._num_levels
padding = padding.lower()
if padding == 'valid':
self._f_pad = [
0,
] * self._num_levels
elif padding == 'same':
self._f_pad = [
1,
] * self._num_levels
else:
raise ValueError(
'Padding must be either "valid" or "same", instead "%s" is given.'
% padding)
self._f_num = [
64,
] * (self._num_levels - 1) + [
1,
]
self._f_in = [
n_channels,
] + [
64,
] * (self._num_levels - 1)
self._f_stride = [
1,
] * self._num_levels
self._bnorm = [
False,
] + [
True,
] * (self._num_levels - 2) + [
False,
]
self._bnorm_epsilon = 1e-5
self._bnorm_momentum = momentum
self.decay_list = []
self.features = Sequential()
for i in range(self._num_levels):
# convolution (with bias if batch normalization is not executed in this level)
self.features.add_module(module=Conv2d(self._f_in[i],
self._f_num[i],
self._f_size[i],
self._f_stride[i],
self._f_pad[i],
bias=not self._bnorm[i]),
name='level_%d/conv' % i)
torch.nn.init.normal_(
self.features[-1].weight,
std=sqrt(2.0 / self._f_size[i] * self._f_size[i] *
maximum(self._f_in[i], self._f_num[i])))
self.decay_list.append(self.features[-1].weight)
# eventual batch normalization
if self._bnorm[i]:
self.features.add_module(module=BatchNorm2d(
self._f_num[i],
eps=self._bnorm_epsilon,
momentum=self._bnorm_momentum,
affine=True),
name='level_%d/bn' % i)
# eventual activation
if self._actfun[i] is not None:
self.features.add_module(module=self._actfun[i],
name='level_%d/activation' % i)
def from_rgb(out_channels):
return Conv2d(3, out_channels, (1, 1), bias=True)
def __init__(self, train_df):
super(MaskDetector, self).__init__()
self.train_df = train_df
self.convLayer1 = Sequential(
Conv2d(3, 32, kernel_size=(3, 3), padding=(1, 1)),
# BatchNorm2d(32),
ReLU(),
# MaxPool2d(kernel_size=(2, 2))
)
self.convLayer2 = Sequential(
Conv2d(32, 64, kernel_size=(3, 3), padding=(1, 1)),
# BatchNorm2d(64),
ReLU(),
# MaxPool2d(kernel_size=(2, 2))
)
self.convLayer3 = Sequential(
Conv2d(64, 128, kernel_size=(3, 3), padding=(1, 1)),
# BatchNorm2d(128),
ReLU(),
# MaxPool2d(kernel_size=(2, 2))
)
self.convLayer4 = Sequential(
Conv2d(128, 256, kernel_size=(3, 3), padding=(1, 1), stride=(3, 3)),
# BatchNorm2d(128),
ReLU(),
# MaxPool2d(kernel_size=(2, 2))
)
self.convLayer5 = Sequential(
Conv2d(256, 512, kernel_size=(3, 3), padding=(1, 1), stride=(2, 2)),
# BatchNorm2d(128),
ReLU(),
MaxPool2d(kernel_size=(2, 2))
)
self.convLayer6 = Sequential(
Conv2d(512, 256, kernel_size=(3, 3), padding=(1, 1), stride=(2, 2)),
# BatchNorm2d(128),
ReLU(),
MaxPool2d(kernel_size=(2, 2))
)
self.linearLayers = Sequential(
Linear(in_features=1024, out_features=512),
Dropout(p=0.1),
ReLU(),
Linear(in_features=512, out_features=256),
Dropout(p=0.1),
ReLU(),
Linear(in_features=256, out_features=2),
Dropout(p=0.1),
Softmax(dim=1)
)
# Initialize layers' weights
for sequential in [self.convLayer1, self.convLayer2, self.convLayer3,
self.convLayer4, self.convLayer5, self.convLayer6, self.linearLayers]:
for layer in sequential.children():
if isinstance(layer, (Linear, Conv2d)):
init.xavier_uniform_(layer.weight)
def to_rgb(in_channels):
return Conv2d(in_channels, 3, (1, 1), bias=True)
def __init__(self):
super().__init__()
self.prep_conv = Conv2d(3,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer1_block0_bn1 = BatchNorm(64,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer1_block0_relu1 = ReLU(inplace=True)
self.layer1_block0_branch_conv1 = Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer1_block0_branch_bn2 = BatchNorm(64,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer1_block0_branch_relu2 = ReLU(inplace=True)
self.layer1_block0_branch_conv2 = Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer1_block0_add = Add()
self.layer1_block1_bn1 = BatchNorm(64,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer1_block1_relu1 = ReLU(inplace=True)
self.layer1_block1_branch_conv1 = Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer1_block1_branch_bn2 = BatchNorm(64,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer1_block1_branch_relu2 = ReLU(inplace=True)
self.layer1_block1_branch_conv2 = Conv2d(64,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer1_block1_add = Add()
self.layer2_block0_bn1 = BatchNorm(64,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer2_block0_relu1 = ReLU(inplace=True)
self.layer2_block0_branch_conv1 = Conv2d(64,
128,
kernel_size=(3, 3),
stride=(2, 2),
padding=(1, 1),
bias=False)
self.layer2_block0_branch_bn2 = BatchNorm(128,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer2_block0_branch_relu2 = ReLU(inplace=True)
self.layer2_block0_branch_conv2 = Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer2_block0_conv3 = Conv2d(64,
128,
kernel_size=(1, 1),
stride=(2, 2),
bias=False)
self.layer2_block0_add = Add()
self.layer2_block1_bn1 = BatchNorm(128,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer2_block1_relu1 = ReLU(inplace=True)
self.layer2_block1_branch_conv1 = Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer2_block1_branch_bn2 = BatchNorm(128,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer2_block1_branch_relu2 = ReLU(inplace=True)
self.layer2_block1_branch_conv2 = Conv2d(128,
128,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer2_block1_add = Add()
self.layer3_block0_bn1 = BatchNorm(128,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer3_block0_relu1 = ReLU(inplace=True)
self.layer3_block0_branch_conv1 = Conv2d(128,
256,
kernel_size=(3, 3),
stride=(2, 2),
padding=(1, 1),
bias=False)
self.layer3_block0_branch_bn2 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer3_block0_branch_relu2 = ReLU(inplace=True)
self.layer3_block0_branch_conv2 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer3_block0_conv3 = Conv2d(128,
256,
kernel_size=(1, 1),
stride=(2, 2),
bias=False)
self.layer3_block0_add = Add()
self.layer3_block1_bn1 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer3_block1_relu1 = ReLU(inplace=True)
self.layer3_block1_branch_conv1 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer3_block1_branch_bn2 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer3_block1_branch_relu2 = ReLU(inplace=True)
self.layer3_block1_branch_conv2 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer3_block1_add = Add()
self.layer4_block0_bn1 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer4_block0_relu1 = ReLU(inplace=True)
self.layer4_block0_branch_conv1 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(2, 2),
padding=(1, 1),
bias=False)
self.layer4_block0_branch_bn2 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer4_block0_branch_relu2 = ReLU(inplace=True)
self.layer4_block0_branch_conv2 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer4_block0_conv3 = Conv2d(256,
256,
kernel_size=(1, 1),
stride=(2, 2),
bias=False)
self.layer4_block0_add = Add()
self.layer4_block1_bn1 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer4_block1_relu1 = ReLU(inplace=True)
self.layer4_block1_branch_conv1 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer4_block1_branch_bn2 = BatchNorm(256,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.layer4_block1_branch_relu2 = ReLU(inplace=True)
self.layer4_block1_branch_conv2 = Conv2d(256,
256,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False)
self.layer4_block1_add = Add()
self.final_in = Identity()
self.final_maxpool = MaxPool2d(kernel_size=4,
stride=4,
padding=0,
dilation=1,
ceil_mode=False)
self.final_avgpool = AvgPool2d(kernel_size=4, stride=4, padding=0)
self.final_concat = Concat()
self.final_flatten = Flatten()
self.final_linear = Linear(in_features=512, out_features=10, bias=True)
self.logits = Identity()
def __init__(self,
num_classes: int = 1,
iterations: int = 2,
multiplier: float = 1.0,
num_layers: int = 4,
integrate: bool = False):
super(BiONet, self).__init__()
# 参数
self.iterations = iterations
self.multiplier = multiplier
self.num_layers = num_layers
self.integrate = integrate
self.batch_norm_momentum = 0.01
# 生成通道参数，此处通道是从第一个Encoder输出的量开始的，直到语义向量
self.filters_list = [
int(32 * (2**i) * self.multiplier)
for i in range(self.num_layers + 1)
]
# 预处理卷积块，不参与循环，最终输出的是32*256*256
self.pre_transform_conv_block = Sequential(
# 这里看代码实现，应该永远和第一个Encoder输出的层数是一样的
Conv2d(3,
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)), # 生成f[1]*512*512
ReLU(),
BatchNorm2d(self.filters_list[0],
momentum=self.batch_norm_momentum),
Conv2d(self.filters_list[0],
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)),
# 生成f[1]*512*512
ReLU(),
BatchNorm2d(self.filters_list[0],
momentum=self.batch_norm_momentum),
Conv2d(self.filters_list[0],
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)),
# 生成f[1]*512*512
ReLU(),
BatchNorm2d(self.filters_list[0],
momentum=self.batch_norm_momentum),
MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=(0, 0)))
self.reuse_convs = [] # encoder复用的卷积核，每个encoder对应一个元组（共3个卷积核，不包括ReLU）
self.encoders = [
] # 由encoder构成的列表。由于encoder的一部分不参与循环，因此每个encoder是一个元组(两个CONV的Sequential, DOWN)
self.reuse_deconvs = [
] # decoder复用的卷积、反卷积核，每个decoder对应一个元组（共3个卷积核，不包括ReLU）
self.decoders = [
] # 由decoder构成的列表。由于decoder的一部分不参与循环，因此每个decoder是一个元组(两个CONV的Sequential, UP)
for iteration in range(self.iterations):
for layer in range(self.num_layers):
# 创建encoders的部分。虽然部分代码可以合写，但是为了看起来清晰（而且构造函数也不是很要求效率），所以分开考虑encoder和decoder
# 和层次有关的常数
in_channel = self.filters_list[
layer] * 2 # 由于有输出部分传入的数据，因此需要翻倍输入通道
mid_channel = self.filters_list[layer]
out_channel = self.filters_list[layer + 1]
# 创建encoders模型
if iteration == 0:
# 创建并添加复用卷积核
# 只有最后一个卷积核负责升高通道
conv1 = Conv2d(in_channel,
mid_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
conv2 = Conv2d(mid_channel,
mid_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
conv3 = Conv2d(mid_channel,
out_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
self.reuse_convs.append((conv1, conv2, conv3))
# 创建encoder
# 首先构造两个CONV
convs = Sequential(
self.reuse_convs[layer][0], ReLU(),
BatchNorm2d(mid_channel,
momentum=self.batch_norm_momentum),
self.reuse_convs[layer][1], ReLU(),
BatchNorm2d(mid_channel,
momentum=self.batch_norm_momentum))
# 构建DOWN
down = Sequential(
self.reuse_convs[layer][2], ReLU(),
BatchNorm2d(out_channel,
momentum=self.batch_norm_momentum),
MaxPool2d(kernel_size=(2, 2),
stride=(2, 2),
padding=(0, 0)))
self.add_module(
"iteration{0}_layer{1}_encoder_convs".format(
iteration, layer), convs)
self.add_module(
"iteration{0}_layer{1}_encoder_down".format(
iteration, layer), down)
self.encoders.append((convs, down))
# 创建decoders的部分，仿照encoders
# 和层次有关的常数，注意本部分不需要mid_channel，因为第一个卷积核就已经升高维度了
in_channel = self.filters_list[self.num_layers -
layer] + self.filters_list[
self.num_layers - 1 - layer]
out_channel = self.filters_list[self.num_layers - 1 - layer]
# 创建decoders模型
if iteration == 0:
# 创建并添加复用卷积核
# 从第一个卷积核就升高通道数
conv1 = Conv2d(in_channel,
out_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
conv2 = Conv2d(out_channel,
out_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
conv3 = ConvTranspose2d(
out_channel,
out_channel,
kernel_size=(3, 3),
padding=(1, 1),
stride=(2, 2),
output_padding=(
1, 1)) # 此处和tensorflow有点区别，为了完整的形状，需要用output补一补
self.reuse_deconvs.append((conv1, conv2, conv3))
# 创建encoder
# 首先构造两个CONV
convs = Sequential(
self.reuse_deconvs[layer][0], ReLU(),
BatchNorm2d(out_channel,
momentum=self.batch_norm_momentum),
self.reuse_deconvs[layer][1], ReLU(),
BatchNorm2d(out_channel,
momentum=self.batch_norm_momentum))
# 构造UP
up = Sequential(
self.reuse_deconvs[layer][2], ReLU(),
BatchNorm2d(out_channel,
momentum=self.batch_norm_momentum))
self.add_module(
"iteration{0}_layer{1}_decoder_convs".format(
iteration, layer), convs)
self.add_module(
"iteration{0}_layer{1}_decoder_up".format(
iteration, layer), up)
self.decoders.append((convs, up))
# 创建middle层
self.middles = Sequential(
Conv2d(self.filters_list[-1],
self.filters_list[-1],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)), ReLU(),
BatchNorm2d(self.filters_list[-1],
momentum=self.batch_norm_momentum),
Conv2d(self.filters_list[-1],
self.filters_list[-1],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)), ReLU(),
BatchNorm2d(self.filters_list[-1],
momentum=self.batch_norm_momentum),
ConvTranspose2d(self.filters_list[-1],
self.filters_list[-1],
kernel_size=(3, 3),
padding=(1, 1),
stride=(2, 2),
output_padding=(1, 1)), ReLU(),
BatchNorm2d(self.filters_list[-1],
momentum=self.batch_norm_momentum))
self.post_transform_conv_block = Sequential(
Conv2d(self.filters_list[0] * self.iterations,
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1))
if self.integrate else Conv2d(self.filters_list[0],
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)),
ReLU(),
BatchNorm2d(self.filters_list[0],
momentum=self.batch_norm_momentum),
Conv2d(self.filters_list[0],
self.filters_list[0],
kernel_size=(3, 3),
padding=(1, 1),
stride=(1, 1)),
ReLU(),
BatchNorm2d(self.filters_list[0],
momentum=self.batch_norm_momentum),
Conv2d(self.filters_list[0], 1, kernel_size=(1, 1), stride=(1, 1)),
Sigmoid(),
)
"loss_function_fn": lambda: CrossEntropyLoss(reduction="sum"),
"target_fn": lambda: classification_targets((3, 2, 3, 2), 4),
"id_prefix": "multi-d-CrossEntropyLoss",
},
]
###############################################################################
# Custom Pad mod #
###############################################################################
SECONDORDER_SETTINGS += [
{
"input_fn":
lambda: rand(5, 3, 4, 4),
"module_fn":
lambda: Sequential(
Conv2d(in_channels=3, out_channels=2, kernel_size=2),
Pad((1, 1, 0, 2), mode="constant", value=0.0),
Conv2d(in_channels=2, out_channels=2, kernel_size=3, stride=2),
Flatten(),
Linear(8, 2),
),
"loss_function_fn":
lambda: MSELoss(reduction="mean"),
"target_fn":
lambda: regression_targets((5, 2)),
},
{
"input_fn":
lambda: rand(5, 3, 4, 4),
"module_fn":
lambda: Sequential(
def __init__(self, ic, oc, *kwargs):
super().__init__()
self.conv = Conv2d(ic, oc, bias=False, *kwargs)
self.batch_norm = BatchNorm2d(oc)
self.activation = LeakyReLU()
