How can I add new backbone network for SSD and DSSD

[sd59202]

I try to add darknet53 for backbone and modify the network but not work. Please help to check how can I add this SSD & ZQPei/DSSD network.

`` import torch from torch import nn import math

from dssd.utils.model_zoo import load_state_dict_from_url from collections import OrderedDict from torchsummary import summary

all = ['darknet53'] model_urls = { 'darknet53':"https://github.com/Jintao-Huang/Darknet53_PyTorch/releases/download/1.0/darknet53-26b80406.pth" }

def load_pretrained(model, state_dict): model.load_state_dict(state_dict, strict=False)

def _darknet(arch, layers, pretrained, progress, **kwargs): model = DarkNet(layers) if pretrained: state_dict = load_state_dict_from_url(model_urls[arch]) load_pretrained(model, state_dict) return model

class BasicBlock(nn.Module): def init(self, inplanes, planes): super(BasicBlock, self).init() self.conv1 = nn.Conv2d(inplanes, planes[0], kernel_size=1, stride=1, padding=0, bias=False) self.bn1 = nn.BatchNorm2d(planes[0]) self.relu1 = nn.LeakyReLU(0.1) self.conv2 = nn.Conv2d(planes[0], planes[1], kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes[1]) self.relu2 = nn.LeakyReLU(0.1)

def forward(self, x):
    residual = x

    out = self.conv1(x)
    out = self.bn1(out)
    out = self.relu1(out)

    out = self.conv2(out)
    out = self.bn2(out)
    out = self.relu2(out)

    out += residual
    return out

class DarkNet(nn.Module): def init(self, layers): super(DarkNet, self).init() self.inplanes = 32 self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(self.inplanes) self.relu1 = nn.LeakyReLU(0.1)

    self.layer1 = self._make_layer([32, 64], layers[0])
    self.layer2 = self._make_layer([64, 128], layers[1])
    self.layer3 = self._make_layer([128, 256], layers[2])
    self.layer4 = self._make_layer([256, 512], layers[3])
    self.layer5 = self._make_layer([512, 1024], layers[4])
    self.layer6 = self._make_extra_layer([1024, 1024])
    self.layer7 = self._make_extra_layer([1024, 1024])
    self.layer8 = self._make_extra_layer([1024, 1024])
    self.layer9 = self._make_extra_layer([1024, 1024])

    self.layers_out_filters = [64, 128, 256, 512, 1024]
    self.init_params()

# initialize the parameters in convolution and batch normalization layers
def init_params(self):
    for m in self.modules():
        if isinstance(m, nn.Conv2d):
            n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
            m.weight.data.normal_(0, math.sqrt(2. / n))
        elif isinstance(m, nn.BatchNorm2d):
            m.weight.data.fill_(1)
            m.bias.data.zero_()

def _make_layer(self, planes, blocks):
    layers = []
    #  downsample
    layers.append(("ds_conv", nn.Conv2d(self.inplanes, planes[1], kernel_size=3,
                            stride=2, padding=1, bias=False)))
    layers.append(("ds_bn", nn.BatchNorm2d(planes[1])))
    layers.append(("ds_relu", nn.LeakyReLU(0.1)))
    #  blocks
    self.inplanes = planes[1]
    for i in range(0, blocks):
        layers.append(("residual_{}".format(i), BasicBlock(self.inplanes, planes)))
    return nn.Sequential(OrderedDict(layers))

def _make_extra_layer(self, planes):
    layers = []
    #  downsample
    layers.append(("ds_conv", nn.Conv2d(self.inplanes, planes[1], kernel_size=3,
                            stride=2, padding=1, bias=False)))
    layers.append(("ds_bn", nn.BatchNorm2d(planes[1])))
    layers.append(("ds_relu", nn.LeakyReLU(0.1)))
    #  blocks
    self.inplanes = planes[1]
    for i in range(0, 1):
        layers.append(("residual_{}".format(i), BasicBlock(self.inplanes, planes)))
    return nn.Sequential(OrderedDict(layers))

def forward(self, x):
    x = self.conv1(x)
    x = self.bn1(x)
    x = self.relu1(x)

    out1 = self.layer1(x)
    out2 = self.layer2(out1)
    out3 = self.layer3(out2)
    out4 = self.layer4(out3)
    out5 = self.layer5(out4)
    out6 = self.layer6(out5)
    out7 = self.layer7(out6)
    out8 = self.layer8(out7)
    out9 = self.layer9(out8)

    return out3, out4, out5, out6, out7, out8, out9       

def darknet21(pretrained, **kwargs): """Constructs a darknet-21 model. """ model = DarkNet([1, 1, 2, 2, 1]) if pretrained: if isinstance(pretrained, str): model.load_state_dict(torch.load(pretrained)) else: raise Exception("darknet request a pretrained path. got [{}]".format(pretrained)) return model

def darknet53(pretrained=False, progress=True, **kwargs): """Constructs a darknet-53 model. """

model = DarkNet([1, 2, 8, 8, 4])

#if pretrained:
#    if isinstance(pretrained, str):
#        model.load_state_dict(torch.load(pretrained))
#    else:
#        raise Exception("darknet request a pretrained path. got [{}]".format(pretrained))
#return model
return _darknet('darknet53', [1, 2, 8, 8, 4], pretrained, progress, **kwargs)

if name == 'main': darknet = DarkNet([1,2,8,8,4]).cuda() summary(darknet, (3,320,320)) ``