def train(self): self.buildDataset('train') opt = optim.SGD(self.model.parameters(), lr=self.lr) region_loss = RegionLoss(num_classes=self.num_classes, num_anchors=self.num_anchors) region_loss = region_loss.to(self.device) # Dataloader data_loader = DataLoader(self.dataset, self.batch_size, shuffle=True, pin_memory=False) log_step = 10 best_loss = 10000 self.model.train() for epoch in range(self.epochs): running_loss = 0 running_nCorrect = 0 running_nGT = 0 for idx, data in enumerate(data_loader): # pdb.set_trace() rgb_map = data[0] target = data[1] rgb_map = rgb_map.float().to(self.device) output = self.model(rgb_map) loss, nCorrect, nGT = region_loss(output, target) loss.backward() running_loss += loss.item() running_nCorrect += nGT running_nCorrect += nCorrect if idx % log_step == 0: mean_loss = running_loss / log_step print("Epoch: {}, Loss: {m:=5.4f}".format(epoch, m=mean_loss)) print("nCorrect = {m:=5.4f}, nGT = {p:=5.4f}".format( m=running_nCorrect / log_step, p=running_nGT / log_step)) if mean_loss < best_loss: best_loss = mean_loss path = os.path.join( self.save_dir, 'ep-{}-{m:=5.4f}.pth'.format(epoch, m=mean_loss)) torch.save(self.model.state_dict(), path) print("Saved model for {} epoch\n".format(epoch)) running_loss = 0 running_nCorrect = 0 running_nGT = 0 opt.step()
def get_config(): opt = parse_opts() # Training settings dataset_use = opt.dataset # which dataset to use datacfg = opt.data_cfg # path for dataset of training and validation, e.g: cfg/ucf24.data cfgfile = opt.cfg_file # path for cfg file, e.g: cfg/ucf24.cfg # assert dataset_use == 'ucf101-24' or dataset_use == 'jhmdb-21', 'invalid dataset' # loss parameters loss_options = parse_cfg(cfgfile)[1] region_loss = RegionLoss() anchors = loss_options['anchors'].split(',') region_loss.anchors = [float(i) for i in anchors] region_loss.num_classes = int(loss_options['classes']) region_loss.num_anchors = int(loss_options['num']) return opt, region_loss
def __init__(self, protofile, caffemodel): super(CaffeNet, self).__init__() self.seen = 0 self.num_classes = 1 self.is_pretrained = True if not caffemodel is None: self.is_pretrained = True self.anchors = [0.625,0.750, 0.625,0.750, 0.625,0.750, \ 0.625,0.750, 0.625,0.750, 1.000,1.200, \ 1.000,1.200, 1.000,1.200, 1.000,1.200, \ 1.600,1.920, 2.560,3.072, 4.096,4.915, \ 6.554,7.864, 10.486,12.583] #self.anchors = [1.3221, 1.73145, 3.19275, 4.00944, 5.05587, 8.09892, 9.47112, 4.84053, 11.2364, 10.0071] self.num_anchors = len(self.anchors)/2 self.width = 480 self.height = 320 self.loss = RegionLoss(self.num_classes, self.anchors, self.num_anchors) self.net_info = parse_prototxt(protofile) self.models = self.create_network(self.net_info) self.modelList = nn.ModuleList() if self.is_pretrained: self.load_weigths_from_caffe(protofile, caffemodel) for name,model in self.models.items(): self.modelList.append(model)
def __init__(self): super(HalfChannels, self).__init__() self.width = int(320) self.height = int(176) self.header = torch.IntTensor([0, 0, 0, 0]) self.seen = 0 def conv_bn(inp, oup, stride): return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=True), nn.ReLU(inplace=True)) def conv_dw(inp, oup, stride): return nn.Sequential( nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=True), nn.ReLU(inplace=True), nn.Conv2d(inp, oup, 1, 1, 0, bias=True), nn.ReLU(inplace=True), ) self.model = nn.Sequential( conv_dw(3, 16, 1), nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(16, 32, 1), nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(32, 64, 1), nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(64, 128, 1), nn.Conv2d(128, 10, 1, 1, bias=False), ) self.loss = RegionLoss([1, 1.06357021727, 1, 2.65376815391], 2) self.anchors = self.loss.anchors self.num_anchors = self.loss.num_anchors self.anchor_step = self.loss.anchor_step
def __init__(self): super(Resnet, self).__init__() self.seen = 0 self.num_classes = 20 self.anchors = [1.08,1.19, 3.42,4.41, 6.63,11.38, 9.42,5.11, 16.62,10.52] self.num_anchors = len(self.anchors)/2 num_output = (5+self.num_classes)*self.num_anchors self.width = 160 self.height = 160 self.loss = RegionLoss(self.num_classes, self.anchors, self.num_anchors) self.model = ResNet(Bottleneck, [3, 4, 6, 3])
def __init__(self): super(SkyNet, self).__init__() self.width = int(320) self.height = int(160) self.header = torch.IntTensor([0, 0, 0, 0]) self.seen = 0 self.reorg = ReorgLayer(stride=2) def conv_bn(inp, oup, stride): return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False), nn.BatchNorm2d(oup), nn.ReLU(inplace=True)) def conv_dw(inp, oup, stride): return nn.Sequential( nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False), nn.BatchNorm2d(inp), nn.ReLU6(inplace=True), nn.Conv2d(inp, oup, 1, 1, 0, bias=False), nn.BatchNorm2d(oup), nn.ReLU6(inplace=True), ) self.model_p1 = nn.Sequential( conv_dw(3, 48, 1), #dw1 nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(48, 96, 1), #dw2 nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(96, 192, 1), #dw3 ) self.model_p2 = nn.Sequential( nn.MaxPool2d(kernel_size=2, stride=2), conv_dw(192, 384, 1), #dw4 conv_dw(384, 512, 1), #dw5 ) self.model_p3 = nn.Sequential( #cat dw3(ch:192 -> 768) and dw5(ch:512) conv_dw(1280, 96, 1), nn.Conv2d(96, 10, 1, 1, bias=False), ) self.loss = RegionLoss([ 1.4940052559648322, 2.3598481287086823, 4.0113013115312155, 5.760873975661669 ], 2) self.anchors = self.loss.anchors self.num_anchors = self.loss.num_anchors self.anchor_step = self.loss.anchor_step self._initialize_weights()
def __init__(self): super(FullChannels, self).__init__() self.width = int(256) self.height = int(256) self.header = torch.IntTensor([0,0,0,0]) self.seen = 0 def newlayer(inp, mid, oup, stride): return nn.Sequential( nn.Conv2d(inp, mid, 1, 1, 0, bias = False) #conv2_1/expand nn.ReLU6(inplace = True) nn.Conv2d(mid, mid, 3, stride, 1, bias = False) #conv2_1/depthwise nn.ReLU6(inplace = True) nn.Conv2d(mid, oup, 1, 1, 0, bias = False) #conv2_1/linear nn.ReLU6(inplace = True) #need ammend ) self.model = nn.Sequential( nn.Conv2d(3, 32, 3, 2, 1, bias = False) #conv1 nn.ReLU6(inplace = True) newlayer(32, 32, 16, 1) #conv2_1 newlayer(16, 96, 24, 2) #conv2_2 newlayer(24, 144, 24, 1) #conv3_1 newlayer(24, 144, 32, 2) #conv3_2 newlayer(32, 192, 32, 1) #conv4_1 newlayer(32, 192, 32, 1) #conv4_2 newlayer(32, 192, 64, 1) #conv4_3 newlayer(64, 384, 64, 1) #conv4_4 newlayer(64, 384, 64, 1) #conv4_5 newlayer(64, 384, 64, 1) #conv4_6 newlayer(64, 384, 96, 2) #conv4_7 newlayer(96, 576, 96, 1) #conv5_1 newlayer(96, 576, 96, 1) #conv5_2 newlayer(96, 576, 160, 2) #conv5_3 newlayer(160, 960, 160, 1) #conv6_1 newlayer(160, 960, 160, 1) #conv6_2 newlayer(160, 960, 320, 1) #conv6_3 nn.Conv2d(320, 1280, 1, 0, 0) nn.ReLU6(inplace = True) nn.AvgPool2d(7) ) self.loss = RegionLoss([1,1.06357021727,1,2.65376815391],2) self.anchors = self.loss.anchors self.num_anchors = self.loss.num_anchors self.anchor_step = self.loss.anchor_step
batch_size, shuffle=True, pin_memory=False) model = ComplexYOLO() model.cuda() # define optimizer optimizer = optim.SGD(model.parameters(), lr=1e-5, momentum=0.9, weight_decay=0.0005) # define loss function region_loss = RegionLoss(num_classes=8, num_anchors=5) lossList = [] totalLossList = [] for epoch in range(200): for group in optimizer.param_groups: if (epoch >= 4 & epoch < 80): group['lr'] = 1e-4 if (epoch >= 80 & epoch < 160): group['lr'] = 1e-5 if (epoch >= 160): group['lr'] = 1e-6 losses = 0
train_n_sample_from = 1 if dataset_use != 'ucf101-24' else 15 test_n_sample_from = 1 if opt.evaluate or dataset_use != 'ucf101-24' else 30 net_options['batch'] = ngpus*int(net_options['batch']) batch_size = net_options['batch'] clip_duration = int(net_options['clip_duration']) max_batches = int(net_options['max_batches']) learning_rate = float(net_options['learning_rate']) momentum = float(net_options['momentum']) decay = float(net_options['decay']) steps = [float(step) for step in net_options['steps'].split(',')] scales = [float(scale) for scale in net_options['scales'].split(',')] # loss parameters loss_options = parse_cfg(cfgfile)[1] region_loss = RegionLoss() anchors = loss_options['anchors'].split(',') region_loss.anchors = [float(i) for i in anchors] region_loss.num_classes = int(loss_options['classes']) region_loss.num_anchors = int(loss_options['num']) region_loss.anchor_step = len(region_loss.anchors)//region_loss.num_anchors region_loss.object_scale = float(loss_options['object_scale']) region_loss.noobject_scale = float(loss_options['noobject_scale']) region_loss.class_scale = float(loss_options['class_scale']) region_loss.coord_scale = float(loss_options['coord_scale']) region_loss.batch = batch_size #Train parameters max_epochs = max_batches*batch_size//nsamples+1 use_cuda = True seed = int(time.time())
def create_network(self, blocks): """ :param blocks: list of dictionary containing parameters for the convolutional network architecture :return: nn.ModuleList() which contains the architecture """ models = nn.ModuleList() prev_filters = 3 out_filters = [] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) # pad = (kernel_size-1)/2 if is_pad else 0 # This may return float value which is invalid for padding pad = ( kernel_size - 1 ) // 2 if is_pad else 0 # This does not return float values activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [ int(i) if int(i) > 0 else int(i) + ind for i in layers ] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[ layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind - 1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors) / loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) models.append(loss) else: print('unknown type %s' % (block['type'])) return models
def __init__(self): super(TinyYoloNet, self).__init__() self.seen = 0 self.num_classes = 20 self.anchors = [ 1.08, 1.19, 3.42, 4.41, 6.63, 11.38, 9.42, 5.11, 16.62, 10.52 ] self.num_anchors = len(self.anchors) / 2 num_output = (5 + self.num_classes) * self.num_anchors self.width = 160 self.height = 160 self.loss = RegionLoss(self.num_classes, self.anchors, self.num_anchors) self.cnn = nn.Sequential( OrderedDict([ # conv1 ('conv1', nn.Conv2d(3, 16, 3, 1, 1, bias=False)), ('bn1', nn.BatchNorm2d(16)), ('leaky1', nn.LeakyReLU(0.1, inplace=True)), ('pool1', nn.MaxPool2d(2, 2)), # conv2 ('conv2', nn.Conv2d(16, 32, 3, 1, 1, bias=False)), ('bn2', nn.BatchNorm2d(32)), ('leaky2', nn.LeakyReLU(0.1, inplace=True)), ('pool2', nn.MaxPool2d(2, 2)), # conv3 ('conv3', nn.Conv2d(32, 64, 3, 1, 1, bias=False)), ('bn3', nn.BatchNorm2d(64)), ('leaky3', nn.LeakyReLU(0.1, inplace=True)), ('pool3', nn.MaxPool2d(2, 2)), # conv4 ('conv4', nn.Conv2d(64, 128, 3, 1, 1, bias=False)), ('bn4', nn.BatchNorm2d(128)), ('leaky4', nn.LeakyReLU(0.1, inplace=True)), ('pool4', nn.MaxPool2d(2, 2)), # conv5 ('conv5', nn.Conv2d(128, 256, 3, 1, 1, bias=False)), ('bn5', nn.BatchNorm2d(256)), ('leaky5', nn.LeakyReLU(0.1, inplace=True)), ('pool5', nn.MaxPool2d(2, 2)), # conv6 ('conv6', nn.Conv2d(256, 512, 3, 1, 1, bias=False)), ('bn6', nn.BatchNorm2d(512)), ('leaky6', nn.LeakyReLU(0.1, inplace=True)), ('pool6', MaxPoolStride1()), # conv7 ('conv7', nn.Conv2d(512, 1024, 3, 1, 1, bias=False)), ('bn7', nn.BatchNorm2d(1024)), ('leaky7', nn.LeakyReLU(0.1, inplace=True)), # conv8 ('conv8', nn.Conv2d(1024, 1024, 3, 1, 1, bias=False)), ('bn8', nn.BatchNorm2d(1024)), ('leaky8', nn.LeakyReLU(0.1, inplace=True)), # output ('output', nn.Conv2d(1024, num_output, 1, 1, 0)), ]))
def create_network(self, blocks, het_part): models = nn.ModuleList() prev_filters = 3 out_filters = [] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) pad = (kernel_size - 1) // 2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [ int(i) if int(i) > 0 else int(i) + ind for i in layers ] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[ layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind - 1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors) / loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) models.append(loss) else: print('unknown type %s' % (block['type'])) # After model parsing and definition load divide depending on the het_part vector for model_id in range(len(het_part)): if het_part[model_id] == 1: models[model_id] = models[model_id].cuda( ) # Set the model in the GPU return models
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters =[] conv_id = 0 decon_id = 0 iv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) if 'groups' in block.keys(): ngroup = int(block['groups']) print(ngroup) else: ngroup = 1 pad = (kernel_size-1)//2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False,groups=ngroup)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad,groups=ngroup)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) elif activation == 'relu6': model.add_module('relu6{0}'.format(conv_id),nn.ReLU6(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'invertedResidual': iv_id += 1 inp = int(block['inp']) oup = int(block['oup']) filters = oup stride = int(block['stride']) ep = int(block['ep']) model = nn.Sequential() model.add_module('invres{0}'.format(iv_id),InvertedResidual(inp,oup,stride,ep)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'upsample': decon_id += 1 # decon_id += 1 # # int(block['scale']) # model = nn.MaxUnpool2d(2,1) model = nn.ConvTranspose2d(prev_filters,prev_filters,2,2,bias=False) # out_filters.append(prev_filters) # model = nn.MaxUnpool2d(int(block['scale']),2) out_filters.append(prev_filters) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert(layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind-1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential( nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential( nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors)//loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) models.append(loss) else: print('unknown type while create %s' % (block['type'])) return models
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters =[] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) pad = (kernel_size-1)/2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) # to get index of feature if filters == 1024: self.feature_extraction_idx = len(models)-1 elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [int(i) if int(i) > 0 else int(i)+ind for i in layers] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert(layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind-1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential( nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential( nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors)/loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) models.append(loss) else: print('unknown type %s' % (block['type'])) # for semantic branch, 20180502 # for 5 anchor, 20180510 semantic_branch = nn.Sequential(nn.Conv2d(1024, self.num_attributes*5, 3, 1, 1, 1), nn.ReLU(inplace=True)) models.append(semantic_branch) # confidence_prediction, 20180502 # the number of input filter is 1024+20+self.attributes, 20180510 # output is 5*(1+self.num_classes) confidence_prediction = nn.Sequential(nn.Conv2d(1024+20+self.num_attributes*5, 5*(1+loss.num_classes), 3, 1, 1, 1), nn.ReLU(inplace=True)) models.append(confidence_prediction) return models
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters = [] conv_id = 0 for block in blocks: if block["type"] == "net": prev_filters = int(block["channels"]) continue elif block["type"] == "convolutional": conv_id = conv_id + 1 batch_normalize = int(block["batch_normalize"]) filters = int(block["filters"]) kernel_size = int(block["size"]) stride = int(block["stride"]) is_pad = int(block["pad"]) pad = (kernel_size - 1) // 2 if is_pad else 0 activation = block["activation"] model = nn.Sequential() if batch_normalize: model.add_module( "conv{0}".format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module("bn{0}".format(conv_id), nn.BatchNorm2d(filters)) # model.add_module("bn{0}".format(conv_id), BN2d(filters)) else: model.add_module( "conv{0}".format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == "leaky": model.add_module("leaky{0}".format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == "relu": model.add_module("relu{0}".format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block["type"] == "maxpool": pool_size = int(block["size"]) stride = int(block["stride"]) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block["type"] == "avgpool": model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block["type"] == "softmax": model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block["type"] == "cost": if block["_type"] == "sse": model = nn.MSELoss(size_average=True) elif block["_type"] == "L1": model = nn.L1Loss(size_average=True) elif block["_type"] == "smooth": model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block["type"] == "reorg": stride = int(block["stride"]) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block["type"] == "route": layers = block["layers"].split(",") ind = len(models) layers = [ int(i) if int(i) > 0 else int(i) + ind for i in layers ] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[ layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block["type"] == "shortcut": ind = len(models) prev_filters = out_filters[ind - 1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block["type"] == "connected": filters = int(block["output"]) if block["activation"] == "linear": model = nn.Linear(prev_filters, filters) elif block["activation"] == "leaky": model = nn.Sequential(nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block["activation"] == "relu": model = nn.Sequential(nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block["type"] == "region": loss = RegionLoss() anchors = block["anchors"].split(",") loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block["classes"]) loss.num_anchors = int(block["num"]) loss.anchor_step = len(loss.anchors) / loss.num_anchors loss.object_scale = float(block["object_scale"]) loss.noobject_scale = float(block["noobject_scale"]) loss.class_scale = float(block["class_scale"]) loss.coord_scale = float(block["coord_scale"]) out_filters.append(prev_filters) models.append(loss) else: print("unknown type %s" % (block["type"])) return models
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters = [] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) # 下面这一行输出的是float型,torch.nn.conv2d是不接受的,改成int # pad = (kernel_size-1)/2 if is_pad else 0 pad = int((kernel_size - 1) / 2) if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) models.append(Reorg(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [ int(i) if int(i) > 0 else int(i) + ind for i in layers ] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[ layers[1]] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind - 1] out_filters.append(prev_filters) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] """ [1.3221, 1.73145, 3.19275, 4.00944, 5.05587, 8.09892, 9.47112, 4.84053, 11.2364, 10.0071] """ loss.num_classes = int(block['classes']) # loss.num_classes = 20 loss.num_anchors = int(block['num']) # loss.num_anchors = 5 # loss.anchor_step = len(loss.anchors)/loss.num_anchors loss.anchor_step = len(loss.anchors) // loss.num_anchors # 原来会产生float型,改了 # loss.anchor_step = 2 loss.object_scale = float(block['object_scale']) # 5.0 loss.noobject_scale = float(block['noobject_scale']) # 1.0 loss.class_scale = float(block['class_scale']) # 1.0 loss.coord_scale = float(block['coord_scale']) # 1.0 out_filters.append(prev_filters) models.append(loss) else: print('unknown type %s' % (block['type'])) return models
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters = [] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'iorn_convolutional': conv_id = conv_id + 1 iorn_id = 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) activation = block['activation'] pad = int(block['pad']) dilate = int(block['dilate']) stride = int(block['stride']) nOrientation = int(block['nOrientation']) model = nn.Sequential() if batch_normalize: if iorn_id == 1: model.add_module('conv{0}'.format(conv_id), ORConv2d(prev_filters, filters // nOrientation, arf_config=(1, nOrientation), kernel_size=3, padding=pad, stride=stride, dilation=dilate)) else: model.add_module('conv{0}'.format(conv_id), ORConv2d(prev_filters // nOrientation, filters // nOrientation, arf_config=nOrientation, kernel_size=3, padding=pad, stride=stride, dilation=dilate)) model.add_module('bn{0}'.format(conv_id), ORBatchNorm2d(filters // nOrientation, nOrientation)) else: if iorn_id == 1: model.add_module('conv{0}'.format(conv_id), ORConv2d(prev_filters, filters / nOrientation, arf_config=nOrientation, kernel_size=3, padding=1)) else: model.add_module('conv{0}'.format(conv_id), ORConv2d(prev_filters // nOrientation, filters // nOrientation, arf_config=nOrientation, kernel_size=3, padding=1)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) pad = (kernel_size - 1) // 2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) else: model.add_module('conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'trans_conv': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) pad = (kernel_size - 1) // 2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module('conv{0}'.format(conv_id), nn.ConvTranspose2d(prev_filters, filters, kernel_size, stride, pad, output_padding=1, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) else: model.add_module('conv{0}'.format(conv_id), nn.ConvTranspose2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [int(i) if int(i) > 0 else int(i) + ind for i in layers] if len(layers) == 1: prev_filters = out_filters[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[layers[1]] elif len(layers) == 3: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[layers[1]] + out_filters[layers[2]] out_filters.append(prev_filters) models.append(EmpotyModule()) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors) // loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) models.append(loss) else: print('unknown type %s' % (block['type'])) return models
test_width = int(net_options['test_width']) test_height = int(net_options['test_height']) # Specify which gpus to use use_cuda = True seed = int(time.time()) torch.manual_seed(seed) if use_cuda: os.environ['CUDA_VISIBLE_DEVICES'] = gpus torch.cuda.manual_seed(seed) # Specifiy the model and the loss model = Darknet(modelcfg) region_loss = RegionLoss(num_keypoints=9, num_classes=1, anchors=[], num_anchors=1, pretrain_num_epochs=15) # Model settings model.load_weights_until_last(initweightfile) model.print_network() model.seen = 0 region_loss.iter = model.iter region_loss.seen = model.seen processed_batches = model.seen // batch_size init_width = model.width init_height = model.height init_epoch = model.seen // nsamples # Variable to save
test_height = int(net_options['test_height']) num_workers = int(data_options['num_workers']) # Specify which gpus to use use_cuda = True seed = int(time.time()) torch.manual_seed(seed) if use_cuda: os.environ['CUDA_VISIBLE_DEVICES'] = gpus torch.cuda.manual_seed(seed) # Specifiy the model and the loss model = Darknet(modelcfg) region_loss = RegionLoss(num_keypoints=9, num_classes=1, anchors=[], num_anchors=1, pretrain_num_epochs=15) kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {} test_loader = torch.utils.data.DataLoader(dataset.listDataset( testlist, shape=(test_width, test_height), shuffle=False, transform=transforms.Compose([ transforms.ToTensor(), ]), train=False), batch_size=1, shuffle=False,
batch_size, shuffle=True, pin_memory=False) # Initialize a model model = ComplexYOLO() model.cuda() # Define optimizer optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum, weight_decay=weight_decay) # Define the loss function region_loss = RegionLoss(num_classes=num_classes, num_anchors=num_anchors) # Initialize a record to store loss history: # epochs X # batches X # classes num_batch = int(np.ceil(len(data_loader.dataset) / batch_size)) loss_history = np.zeros((len(epochs), num_batch, num_classes)) print("intialize OK") # Loop over epoch for epoch in epochs: # Log epoch idx if do_logging: logging.info('Running epoch = %d' % epoch) print('Running epoch=%d' % epoch) # Learning rate varies with epoch for group in optimizer.param_groups:
def __init__(self): super(TinyYoloNet, self).__init__() self.seen = 0 self.num_classes = 80 self.anchors = [ 0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.1682 ] self.num_anchors = len(self.anchors) / 2 num_output = int((5 + self.num_classes) * self.num_anchors) self.width = 416 self.height = 416 self.loss = RegionLoss(self.num_classes, self.anchors, self.num_anchors) self.cnn = nn.Sequential( OrderedDict([ # conv1 ('conv1', nn.Conv2d(3, 16, 3, 1, 1, bias=False)), ('bn1', nn.BatchNorm2d(16)), ('leaky1', nn.LeakyReLU(0.1, inplace=True)), ('pool1', nn.MaxPool2d(2, 2)), # conv2 ('conv2', nn.Conv2d(16, 32, 3, 1, 1, bias=False)), ('bn2', nn.BatchNorm2d(32)), ('leaky2', nn.LeakyReLU(0.1, inplace=True)), ('pool2', nn.MaxPool2d(2, 2)), # conv3 ('conv3', nn.Conv2d(32, 64, 3, 1, 1, bias=False)), ('bn3', nn.BatchNorm2d(64)), ('leaky3', nn.LeakyReLU(0.1, inplace=True)), ('pool3', nn.MaxPool2d(2, 2)), # conv4 ('conv4', nn.Conv2d(64, 128, 3, 1, 1, bias=False)), ('bn4', nn.BatchNorm2d(128)), ('leaky4', nn.LeakyReLU(0.1, inplace=True)), ('pool4', nn.MaxPool2d(2, 2)), # conv5 ('conv5', nn.Conv2d(128, 256, 3, 1, 1, bias=False)), ('bn5', nn.BatchNorm2d(256)), ('leaky5', nn.LeakyReLU(0.1, inplace=True)), ('pool5', nn.MaxPool2d(2, 2)), # conv6 ('conv6', nn.Conv2d(256, 512, 3, 1, 1, bias=False)), ('bn6', nn.BatchNorm2d(512)), ('leaky6', nn.LeakyReLU(0.1, inplace=True)), ('pool6', MaxPoolStride1()), # conv7 ('conv7', nn.Conv2d(512, 1024, 3, 1, 1, bias=False)), ('bn7', nn.BatchNorm2d(1024)), ('leaky7', nn.LeakyReLU(0.1, inplace=True)), # conv8 ('conv8', nn.Conv2d(1024, 512, 3, 1, 1, bias=False)), ('bn8', nn.BatchNorm2d(512)), ('leaky8', nn.LeakyReLU(0.1, inplace=True)), # output ('output', nn.Conv2d(512, num_output, 1, 1, 0)), ]))
def create_network(self, blocks): models = nn.ModuleList() prev_filters = 3 out_filters = [] prev_stride = 1 out_strides = [] conv_id = 0 for block in blocks: if block['type'] == 'net': prev_filters = int(block['channels']) continue elif block['type'] == 'convolutional': conv_id = conv_id + 1 batch_normalize = int(block['batch_normalize']) filters = int(block['filters']) kernel_size = int(block['size']) stride = int(block['stride']) is_pad = int(block['pad']) pad = (kernel_size - 1) / 2 if is_pad else 0 activation = block['activation'] model = nn.Sequential() if batch_normalize: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias=False)) model.add_module('bn{0}'.format(conv_id), nn.BatchNorm2d(filters)) #model.add_module('bn{0}'.format(conv_id), BN2d(filters)) else: model.add_module( 'conv{0}'.format(conv_id), nn.Conv2d(prev_filters, filters, kernel_size, stride, pad)) if activation == 'leaky': model.add_module('leaky{0}'.format(conv_id), nn.LeakyReLU(0.1, inplace=True)) elif activation == 'relu': model.add_module('relu{0}'.format(conv_id), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) prev_stride = stride * prev_stride out_strides.append(prev_stride) models.append(model) elif block['type'] == 'maxpool': pool_size = int(block['size']) stride = int(block['stride']) if stride > 1: model = nn.MaxPool2d(pool_size, stride) else: model = MaxPoolStride1() out_filters.append(prev_filters) prev_stride = stride * prev_stride out_strides.append(prev_stride) models.append(model) elif block['type'] == 'avgpool': model = GlobalAvgPool2d() out_filters.append(prev_filters) models.append(model) elif block['type'] == 'softmax': model = nn.Softmax() out_strides.append(prev_stride) out_filters.append(prev_filters) models.append(model) elif block['type'] == 'cost': if block['_type'] == 'sse': model = nn.MSELoss(size_average=True) elif block['_type'] == 'L1': model = nn.L1Loss(size_average=True) elif block['_type'] == 'smooth': model = nn.SmoothL1Loss(size_average=True) out_filters.append(1) out_strides.append(prev_stride) models.append(model) elif block['type'] == 'reorg': stride = int(block['stride']) prev_filters = stride * stride * prev_filters out_filters.append(prev_filters) prev_stride = prev_stride * stride out_strides.append(prev_stride) models.append(Reorg(stride)) elif block['type'] == 'upsample': stride = int(block['stride']) out_filters.append(prev_filters) prev_stride = prev_stride / stride out_strides.append(prev_stride) #models.append(nn.Upsample(scale_factor=stride, mode='nearest')) models.append(Upsample(stride)) elif block['type'] == 'route': layers = block['layers'].split(',') ind = len(models) layers = [ int(i) if int(i) > 0 else int(i) + ind for i in layers ] if len(layers) == 1: prev_filters = out_filters[layers[0]] prev_stride = out_strides[layers[0]] elif len(layers) == 2: assert (layers[0] == ind - 1) prev_filters = out_filters[layers[0]] + out_filters[ layers[1]] prev_stride = out_strides[layers[0]] out_filters.append(prev_filters) out_strides.append(prev_stride) models.append(EmptyModule()) elif block['type'] == 'shortcut': ind = len(models) prev_filters = out_filters[ind - 1] out_filters.append(prev_filters) prev_stride = out_strides[ind - 1] out_strides.append(prev_stride) models.append(EmptyModule()) elif block['type'] == 'connected': filters = int(block['output']) if block['activation'] == 'linear': model = nn.Linear(prev_filters, filters) elif block['activation'] == 'leaky': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.LeakyReLU(0.1, inplace=True)) elif block['activation'] == 'relu': model = nn.Sequential(nn.Linear(prev_filters, filters), nn.ReLU(inplace=True)) prev_filters = filters out_filters.append(prev_filters) out_strides.append(prev_stride) models.append(model) elif block['type'] == 'region': loss = RegionLoss() anchors = block['anchors'].split(',') loss.anchors = [float(i) for i in anchors] loss.num_classes = int(block['classes']) loss.num_anchors = int(block['num']) loss.anchor_step = len(loss.anchors) / loss.num_anchors loss.object_scale = float(block['object_scale']) loss.noobject_scale = float(block['noobject_scale']) loss.class_scale = float(block['class_scale']) loss.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) out_strides.append(prev_stride) models.append(loss) elif block['type'] == 'yolo': yolo_layer = YoloLayer() anchors = block['anchors'].split(',') anchor_mask = block['mask'].split(',') yolo_layer.anchor_mask = [int(i) for i in anchor_mask] yolo_layer.anchors = [float(i) for i in anchors] yolo_layer.num_classes = int(block['classes']) yolo_layer.num_anchors = int(block['num']) yolo_layer.anchor_step = len( yolo_layer.anchors) / yolo_layer.num_anchors yolo_layer.stride = prev_stride #yolo_layer.object_scale = float(block['object_scale']) #yolo_layer.noobject_scale = float(block['noobject_scale']) #yolo_layer.class_scale = float(block['class_scale']) #yolo_layer.coord_scale = float(block['coord_scale']) out_filters.append(prev_filters) out_strides.append(prev_stride) models.append(yolo_layer) else: print('unknown type %s' % (block['type'])) return models
def my_loss(y_input, y_target): return RegionLoss(y_input, y_target)