def create_block_list(self):
self.clear_list()
backbone = PointNet(data_channel=self.data_channel,
feature_transform=self.feature_transform,
bn_name=self.bn_name,
activation_name=self.activation_name)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
input_channel = self.block_out_channels[-1]
fc1 = FcBNActivationBlock(input_channel,
512,
bnName=self.bn_name,
activationName=self.activation_name)
self.add_block_list(fc1.get_name(), fc1, 512)
input_channel = 512
fc2 = nn.Linear(input_channel, 256)
self.add_block_list(LayerType.FcLinear, fc2, 256)
input_channel = 256
dropout = nn.Dropout(p=0.3)
self.add_block_list(LayerType.Dropout, dropout, input_channel)
normalize = NormalizeLayer(self.bn_name, input_channel)
self.add_block_list(normalize.get_name(), normalize, input_channel)
activate = ActivationLayer(self.activation_name, inplace=False)
self.add_block_list(activate.get_name(), activate, input_channel)
fc3 = nn.Linear(input_channel, self.class_number)
self.add_block_list(LayerType.FcLinear, fc3, self.class_number)
self.create_loss()
def create_block_list(self):
self.clear_list()
backbone = self.factory.get_base_model(BackboneName.GhostNet,
self.data_channel)
base_out_channels = backbone.get_outchannel_list()
self.add_block_list(BlockType.BaseNet, backbone, base_out_channels[-1])
avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.add_block_list(LayerType.GlobalAvgPool, avgpool,
base_out_channels[-1])
output_channel = 1280
layer1 = FcLayer(base_out_channels[-1], output_channel)
self.add_block_list(layer1.get_name(), layer1, output_channel)
layer2 = NormalizeLayer(bn_name=NormalizationType.BatchNormalize1d,
out_channel=output_channel)
self.add_block_list(layer2.get_name(), layer2, output_channel)
layer3 = ActivationLayer(self.activation_name, inplace=False)
self.add_block_list(layer3.get_name(), layer3, output_channel)
layer4 = nn.Dropout(0.2)
self.add_block_list(LayerType.Dropout, layer4, output_channel)
layer5 = nn.Linear(output_channel, self.class_number)
self.add_block_list(LayerType.FcLinear, layer5, self.class_number)
self.create_loss()
def __init__(self,
in_channels,
out_channels,
kernel_size,
stride=1,
padding=0,
dilation=1,
bias=True,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(EncNetBlockName.SeperableConv2dNActivation)
self.depthwise = nn.Conv2d(in_channels,
in_channels,
kernel_size,
stride,
padding,
dilation,
in_channels,
bias=bias)
self.norm_layer = NormalizeLayer(bn_name, in_channels)
self.pointwise = ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
bias=bias,
bnName=bn_name,
activationName=activation_name)
def __init__(self,
in_channels,
nclass,
ncodes=32,
se_loss=True,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(EncNetBlockName.EncBlock)
self.se_loss = se_loss
self.encoding = nn.Sequential(
ConvBNActivationBlock(in_channels=in_channels,
out_channels=in_channels,
kernel_size=1,
bias=False,
bnName=bn_name,
activationName=activation_name),
Encoding(D=in_channels, K=ncodes),
NormalizeLayer(NormalizationType.BatchNormalize1d, ncodes),
ActivationLayer(activation_name), MeanLayer(dim=1))
self.fc = nn.Sequential(nn.Linear(in_channels, in_channels),
nn.Sigmoid())
self.activate = ActivationLayer(activation_name)
if self.se_loss:
self.se_layer = nn.Linear(in_channels, nclass)
def __init__(self, in_channels, out_channels, stride=1, dilation=1,
start_with_relu=True, bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(XceptionBlockName.BlockA)
if out_channels != in_channels or stride != 1:
self.skip = ConvBNActivationBlock(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
stride=stride,
bias=False,
bnName=bn_name,
activationName=ActivationType.Linear)
else:
self.skip = None
self.relu = ActivationLayer(activation_name, inplace=False)
rep = list()
inter_channels = out_channels // 4
if start_with_relu:
rep.append(self.relu)
rep.append(SeparableConv2dBNActivation(in_channels, inter_channels, 3, 1,
dilation, bn_name=bn_name,
activation_name=activation_name))
rep.append(NormalizeLayer(bn_name, inter_channels))
rep.append(self.relu)
rep.append(SeparableConv2dBNActivation(inter_channels, inter_channels, 3, 1,
dilation, bn_name=bn_name,
activation_name=activation_name))
rep.append(NormalizeLayer(bn_name, inter_channels))
if stride != 1:
rep.append(self.relu)
rep.append(SeparableConv2dBNActivation(inter_channels, out_channels, 3, stride,
bn_name=bn_name,
activation_name=activation_name))
rep.append(NormalizeLayer(bn_name, out_channels))
else:
rep.append(self.relu)
rep.append(SeparableConv2dBNActivation(inter_channels, out_channels, 3, 1,
bn_name=bn_name,
activation_name=activation_name))
rep.append(NormalizeLayer(bn_name, out_channels))
self.rep = nn.Sequential(*rep)
def create_block_list(self):
self.clear_list()
layer1 = ConvBNActivationBlock(in_channels=self.data_channel,
out_channels=self.num_init_features,
kernel_size=7,
stride=2,
padding=3,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(layer1.get_name(), layer1, self.num_init_features)
layer2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.add_block_list(LayerType.MyMaxPool2d, layer2,
self.num_init_features)
self.in_channels = self.num_init_features
for index, num_block in enumerate(self.num_blocks):
self.make_densenet_layer(num_block, self.dilations[index],
self.bn_size, self.growth_rate,
self.drop_rate, self.bnName,
self.activationName)
self.in_channels = self.block_out_channels[-1]
if index != len(self.num_blocks) - 1:
trans = TransitionBlock(in_channel=self.in_channels,
output_channel=self.in_channels // 2,
stride=1,
bnName=self.bnName,
activationName=self.activationName)
self.add_block_list(trans.get_name(), trans,
self.in_channels // 2)
avg_pool = nn.AvgPool2d(kernel_size=2, stride=2)
self.add_block_list(LayerType.GlobalAvgPool, avg_pool,
self.block_out_channels[-1])
self.in_channels = self.block_out_channels[-1]
layer3 = NormalizeLayer(bn_name=self.bnName,
out_channel=self.in_channels)
self.add_block_list(layer3.get_name(), layer3, self.in_channels)
layer4 = ActivationLayer(self.activationName, False)
self.add_block_list(layer4.get_name(), layer4, self.in_channels)
def __init__(self, in_channel, kernel_size,
padding=0, stride=1, dilation=1, bias=False,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(BlockType.DepthwiseConv2dBlock)
conv = nn.Conv2d(in_channel, in_channel, kernel_size,
padding=padding, stride=stride, dilation=dilation,
groups=in_channel, bias=bias)
normal = NormalizeLayer(bn_name, in_channel)
activation = ActivationLayer(activation_name)
self.block = nn.Sequential(OrderedDict([
(LayerType.Convolutional, conv),
(bn_name, normal),
(activation_name, activation)
]))
def __init__(self,
in_planes,
out_planes,
kernel_size,
stride,
bn_name=NormalizationType.BatchNormalize2d):
super().__init__(PNASNetBlockName.SeparableConv)
self.conv1 = nn.Conv2d(in_planes,
out_planes,
kernel_size,
stride,
padding=(kernel_size - 1) // 2,
bias=False,
groups=in_planes)
self.bn1 = NormalizeLayer(bn_name, out_planes)
def __init__(self,
input_channel,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(InceptionBlockName.InceptionResNetA)
self.branch3x3stack = nn.Sequential(
ConvBNActivationBlock(input_channel,
32,
kernel_size=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(32,
48,
kernel_size=3,
padding=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(48,
64,
kernel_size=3,
padding=1,
bnName=bn_name,
activationName=activation_name))
self.branch3x3 = nn.Sequential(
ConvBNActivationBlock(input_channel,
32,
kernel_size=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(32,
32,
kernel_size=3,
padding=1,
bnName=bn_name,
activationName=activation_name))
self.branch1x1 = ConvBNActivationBlock(input_channel,
32,
kernel_size=1,
bnName=bn_name,
activationName=activation_name)
self.reduction1x1 = nn.Conv2d(128, 384, kernel_size=1)
self.shortcut = nn.Conv2d(input_channel, 384, kernel_size=1)
self.bn = NormalizeLayer(bn_name=bn_name, out_channel=384)
self.relu = ActivationLayer(activation_name=activation_name,
inplace=False)
def create_layer(self, module_def):
if module_def['type'] == LayerType.MyMaxPool2d:
kernel_size = int(module_def['size'])
stride = int(module_def['stride'])
maxpool = MyMaxPool2d(kernel_size, stride)
self.addBlockList(LayerType.MyMaxPool2d, maxpool, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.GlobalAvgPool:
globalAvgPool = GlobalAvgPool2d()
self.addBlockList(LayerType.GlobalAvgPool, globalAvgPool, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.FcLayer:
num_output = int(module_def['num_output'])
self.filters = num_output
layer = FcLayer(self.input_channels, num_output)
self.addBlockList(LayerType.FcLayer, layer, num_output)
self.input_channels = num_output
elif module_def['type'] == LayerType.Upsample:
scale = int(module_def['stride'])
mode = module_def.get('model', 'bilinear')
upsample = Upsample(scale_factor=scale, mode=mode)
self.addBlockList(LayerType.Upsample, upsample, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.MultiplyLayer:
layer = MultiplyLayer(module_def['layers'])
self.addBlockList(LayerType.MultiplyLayer, layer, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.AddLayer:
layer = AddLayer(module_def['layers'])
self.addBlockList(LayerType.AddLayer, layer, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.Dropout:
probability = float(module_def['probability'])
layer = nn.Dropout(p=probability, inplace=False)
self.addBlockList(LayerType.Dropout, layer, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.NormalizeLayer:
bn_name = module_def['batch_normalize'].strip()
layer = NormalizeLayer(bn_name, self.filters)
self.addBlockList(LayerType.NormalizeLayer, layer, self.filters)
self.input_channels = self.filters
elif module_def['type'] == LayerType.ActivationLayer:
activation_name = module_def['activation'].strip()
layer = ActivationLayer(activation_name, inplace=False)
self.addBlockList(LayerType.ActivationLayer, layer, self.filters)
self.input_channels = self.filters
def __init__(self,
input_channel,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
# Figure 19. The schema for 8×8 grid (Inception-ResNet-C)
# module of the Inception-ResNet-v2 network."""
super().__init__(InceptionBlockName.InceptionResNetC)
self.branch3x3 = nn.Sequential(
ConvBNActivationBlock(input_channel,
192,
kernel_size=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(192,
224,
kernel_size=(1, 3),
padding=(0, 1),
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(224,
256,
kernel_size=(3, 1),
padding=(1, 0),
bnName=bn_name,
activationName=activation_name))
self.branch1x1 = ConvBNActivationBlock(input_channel,
192,
kernel_size=1,
bnName=bn_name,
activationName=activation_name)
self.reduction1x1 = nn.Conv2d(448, 2048, kernel_size=1)
self.shorcut = nn.Conv2d(input_channel, 2048, kernel_size=1)
self.bn = NormalizeLayer(bn_name=bn_name, out_channel=2048)
self.relu = ActivationLayer(activation_name=activation_name,
inplace=False)
def __init__(self,
input_channel,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(InceptionBlockName.InceptionResNetB)
self.branch7x7 = nn.Sequential(
ConvBNActivationBlock(input_channel,
128,
kernel_size=1,
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(128,
160,
kernel_size=(1, 7),
padding=(0, 3),
bnName=bn_name,
activationName=activation_name),
ConvBNActivationBlock(160,
192,
kernel_size=(7, 1),
padding=(3, 0),
bnName=bn_name,
activationName=activation_name))
self.branch1x1 = ConvBNActivationBlock(input_channel,
192,
kernel_size=1,
bnName=bn_name,
activationName=activation_name)
self.reduction1x1 = nn.Conv2d(384, 1154, kernel_size=1)
self.shortcut = nn.Conv2d(input_channel, 1154, kernel_size=1)
self.bn = NormalizeLayer(bn_name=bn_name, out_channel=1154)
self.relu = ActivationLayer(activation_name=activation_name,
inplace=False)
def __init__(self,
in_channels,
channels,
stride=1,
dilation=1,
groups=1,
dropout=None,
dist_bn=False,
bn_name=NormalizationType.BatchNormalize2d,
activation_name=ActivationType.ReLU):
super().__init__(WiderResNetBlockName.IdentityResidualBlock)
# Check parameters for inconsistencies
if len(channels) != 2 and len(channels) != 3:
raise ValueError(
"channels must contain either two or three values")
if len(channels) == 2 and groups != 1:
raise ValueError("groups > 1 are only valid if len(channels) == 3")
self.dist_bn = dist_bn
is_bottleneck = len(channels) == 3
need_proj_conv = stride != 1 or in_channels != channels[-1]
self.normal = NormalizeLayer(bn_name, in_channels)
self.activate = ActivationLayer(activation_name, inplace=False)
if not is_bottleneck:
layers = [("conv1",
ConvBNActivationBlock(in_channels=in_channels,
out_channels=channels[0],
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
bias=False,
bnName=bn_name,
activationName=activation_name)),
("conv2",
nn.Conv2d(channels[0],
channels[1],
kernel_size=3,
stride=1,
padding=dilation,
dilation=dilation,
bias=False))]
if dropout is not None:
layers = [layers[0], ("dropout", dropout()), layers[1]]
else:
layers = [("conv1",
ConvBNActivationBlock(in_channels=in_channels,
out_channels=channels[0],
kernel_size=1,
stride=stride,
padding=0,
bias=False,
bnName=bn_name,
activationName=activation_name)),
("conv2",
ConvBNActivationBlock(in_channels=channels[0],
out_channels=channels[1],
kernel_size=3,
stride=1,
padding=dilation,
dilation=dilation,
groups=groups,
bias=False,
bnName=bn_name,
activationName=activation_name)),
("conv3",
nn.Conv2d(channels[1],
channels[2],
kernel_size=1,
stride=1,
padding=0,
bias=False))]
if dropout is not None:
layers = [
layers[0], layers[1], ("dropout", dropout()), layers[2]
]
self.convs = nn.Sequential(OrderedDict(layers))
self.shortcut = nn.Sequential()
if need_proj_conv:
self.shortcut = nn.Conv2d(in_channels,
channels[-1],
kernel_size=1,
stride=stride,
padding=0,
bias=False)