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)
