class SerialBackbone(Module):
"""Serial Net for spnas."""
def __init__(self, code='111-2111-211111-211', block='BottleneckBlock', in_channels=64, weight_file=None,
out_layers=None):
"""Init SerialBackbone."""
super(SerialBackbone, self).__init__()
self.inplanes = in_channels
self.planes = self.inplanes
self.weight_file = weight_file
self.channels = [3]
self.code = code.split('-')
self.block = ClassFactory.get_cls(ClassType.NETWORK, block)
self._make_stem_layer()
self.layers = Sequential() if out_layers == -1 else OutDictSequential()
self.make_cells()
@property
def out_channels(self):
"""Output Channel for Module."""
return self.layers.out_channels
def load_state_dict(self, state_dict=None, strict=None):
"""Remove backbone."""
state_dict = {k.replace('backbone.', ''): v for k, v in state_dict.items()}
super().load_state_dict(state_dict, strict or False)
def _make_stem_layer(self):
"""Make stem layer."""
self.conv1 = ops.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = ops.BatchNorm2d(self.inplanes)
self.relu = ops.Relu(inplace=True)
self.maxpool = ops.MaxPool2d(kernel_size=3, stride=2, padding=1)
def make_cells(self):
"""Make ResNet Cell."""
for i, code in enumerate(self.code):
layer, planes = self.make_layers(self.block, self.inplanes, self.planes, code=code)
self.channels.append(planes)
self.inplanes = planes
self.layers.append(layer)
self.planes = self.planes * 2
def make_layers(self, block, inplanes, planes, code=None):
"""Make ResNet layers."""
strides = list(map(int, code))
layers = []
layers.append(block(inplanes, planes, stride=strides[0]))
inplanes = planes * block.expansion
for stride in strides[1:]:
layers.append(block(inplanes, planes, stride=stride))
inplanes = planes * block.expansion
return Sequential(*layers), inplanes
class DNet(Module):
"""DNet network."""
def __init__(self, encoding, n_class=1000):
super(DNet, self).__init__()
op_names = ["conv3", "conv1", "conv3_grp2", "conv3_grp4", "conv3_base1", "conv3_base32", "conv3_sep"]
block_str, num_channel, macro_str = encoding.split('_')
curr_channel, index = int(num_channel), 0
_big_model = "*" in block_str
if _big_model:
block_encoding_list = block_str.split('*')
# stem
self.layers = Sequential(
create_op('conv3', 3, curr_channel // 2, stride=2),
ops.Relu(),
create_op('conv3', curr_channel // 2, curr_channel // 2),
ops.Relu(),
create_op('conv3', curr_channel // 2, curr_channel, stride=2),
ops.Relu()
)
# body
if not _big_model:
while index < len(macro_str):
stride = 1
if macro_str[index] == '-':
stride = 2
index += 1
channel_increase = int(macro_str[index])
block = EncodedBlock(block_str, curr_channel, op_names, stride, channel_increase)
self.layers.append(block)
curr_channel *= channel_increase
index += 1
else:
block_encoding_index = 0
while index < len(macro_str):
stride = 1
if macro_str[index] == '-':
stride = 2
index += 1
block_encoding_index += 1
channel_increase = int(macro_str[index])
block_encoding = block_encoding_list[block_encoding_index]
block = EncodedBlock(block_encoding, curr_channel, op_names, stride, channel_increase)
self.layers.append(block)
curr_channel *= channel_increase
index += 1
self.layers.append(ops.AdaptiveAvgPool2d((1, 1)))
self.view = ops.View()
self.fc = ops.Linear(in_features=curr_channel, out_features=n_class)
