def build_model(checkpoint, device):
model = ssd.build_ssd(cfg)
state = torch.load(checkpoint, map_location=device)
state_dict = dict()
for k, v in state['model'].items():
state_dict[k.replace('module.', '')] = v
model.load_state_dict(state_dict)
return model
def main(args):
if args.gpus is not None:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpus
print('Using {} GPUs'.format(args.gpus))
train_transform = Compose(
[Resize(args.input_size),
ToTensor(),
Norm(mean=(123, 117, 104))])
trainset = VOCDetection(args.data_root,
args.train_set,
transform=train_transform,
do_norm=True)
train_loader = torch.utils.data.DataLoader(trainset,
shuffle=True,
batch_size=args.batch_size,
num_workers=args.workers,
collate_fn=detection_collate)
model = build_ssd(cfg)
if not args.checkpoint and args.pretrain:
print('load pretrain model: {}'.format(args.pretrain))
model.load_weight(args.pretrain)
if args.gpus:
model = torch.nn.DataParallel(model).cuda()
criterion = multibox_loss.MultiboxLoss(args.num_classes,
args.neg_pos_ratio)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
args.start_epoch = 0
if args.checkpoint:
print('=> loading checkpoint from {}...'.format(args.checkpoint))
state = torch.load(args.checkpoint)
args.start_epoch = state['epoch']
model.load_state_dict(state['model'])
optimizer.load_state_dict(state['optimizer'])
for epoch in range(args.start_epoch, args.epochs):
train(train_loader, model, criterion, optimizer, epoch, args)
state = {
'epoch': epoch + 1,
'model': model.state_dict(),
'optimizer': optimizer.state_dict()
}
# save checkpoint
os.makedirs(args.checkpoint_dir, exist_ok=True)
checkpoint_file = os.path.join(
args.checkpoint_dir,
'checkpoint_epoch_{:04d}.pth.tar'.format(state['epoch']))
torch.save(state, checkpoint_file)
def get_model(device):
image_size = CONFIG['image_size']
num_classes = CONFIG['num_classes']
model = build_ssd(image_size, num_classes, 'test')
pretrain_model = '/data1/jiang.yang/output/ssd/SSD_epoch_221_1.9046952678341007.pth'
model.load_state_dict(torch.load(pretrain_model, map_location=device))
model.eval()
model.to(device)
return model
def main():
device = 'cuda' if torch.cuda.is_available() else 'cpu'
image_size = CONFIG['image_size']
num_classes = CONFIG['num_classes']
model = build_ssd(image_size, num_classes)
model.to(device)
pretrain_model = CONFIG['pretrain_model']
vgg_pretrain = CONFIG['vgg_pretrain']
if pretrain_model is not None:
model.load_state_dict(torch.load(pretrain_model, map_location=device))
elif vgg_pretrain is not None:
model.base.load_state_dict(torch.load(vgg_pretrain))
train(model, device)
def test_voc():
# load net
num_classes = len(VOC_CLASSES) + 1 # +1 background
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
testset = VOCDetection(args.voc_root, [('2007', 'test')], None,
VOCAnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
testset,
BaseTransform(net.size, (104, 117, 123)),
thresh=args.visual_threshold)
def _create_net():
"""Creates the SSD neural network.
### Parameters:
-none,
### Returns:
(obj): returns the neural network,
(fct): returns the transformation function,
### Raises:
none
"""
# Create the SSD neural network and the transformation
net = build_ssd('test')
net.load_state_dict(
torch.load(WEIGHTS, map_location=lambda storage, loc: storage))
transform = BaseTransform(net.size,
(104 / 256.0, 117 / 256.0, 123 / 256.0))
return net, transform
def get_model(config, anchors):
"""
returns the model
"""
model = None
if config['model'] == 'SSD':
model = build_ssd(mode=config['mode'],
new_size=config['new_size'],
anchors=anchors,
class_count=config['class_count'])
elif config['model'] == 'FSSD':
model = build_fssd(mode=config['mode'],
new_size=config['new_size'],
anchors=anchors,
class_count=config['class_count'])
elif config['model'] == 'RFBNet':
model = build_rfbnet(mode=config['mode'],
new_size=config['new_size'],
anchors=anchors,
class_count=config['class_count'])
elif config['model'] == 'ShuffleSSD':
model = build_shuffle_ssd(mode=config['mode'],
new_size=config['new_size'],
anchors=anchors,
class_count=config['class_count'])
elif config['model'] == 'RShuffleSSD':
model = build_rshuffle_ssd(mode=config['mode'],
new_size=config['new_size'],
resnet_model=config['resnet_model'],
anchors=anchors,
class_count=config['class_count'])
return model
model.phase='test'
model.eval()
dataset = VOCDetection(args.voc_root, BaseTransform(im_size, dataset_mean),VOCAnnotationTransform(),phase='valid')
map=eval_net(save_folder, model, cuda, dataset,
BaseTransform(im_size, dataset_mean), top_k, im_size,
thresh=thresh)
return map
if __name__ == '__main__':
# load net
num_classes = len(labelmap) + 1 # +1 for background
image_size = 300
net = build_ssd('test', image_size, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
# net.eval()
# print('Finished loading model!')
# # load data
# dataset = VOCDetection(args.voc_root, [('2007', set_type)],
# BaseTransform(300, dataset_mean),
# VOCAnnotationTransform(),phase='valid')
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# # evaluation
# eval_net(args.save_folder, net, args.cuda, dataset,
# BaseTransform(net.size, dataset_mean), args.top_k, 300,
# thresh=args.confidence_threshold)
evaluate(net,args.save_folder,args.cuda, args.top_k, image_size,thresh=args.confidence_threshold)
def make_one_net_model(self, cf, in_shape, loss, metrics, optimizer):
# Create the *Keras* model
if cf.model_name == 'fcn8':
model = build_fcn8(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
#path_weights='weights/pascal-fcn8s-dag.mat')
path_weights=None)
elif cf.model_name == 'unet':
model = build_unet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'segnet_basic':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None, basic=True)
elif cf.model_name == 'segnet_vgg':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None, basic=False)
elif cf.model_name == 'resnetFCN':
model = build_resnetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'densenetFCN':
model = build_densenetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'lenet':
model = build_lenet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'alexNet':
model = build_alexNet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'vgg16':
model = build_vgg(in_shape, cf.dataset.n_classes, 16, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, out_name=cf.dataset_name)
elif cf.model_name == 'vgg19':
model = build_vgg(in_shape, cf.dataset.n_classes, 19, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'resnet50':
model = build_resnet50(in_shape, cf.dataset.n_classes, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'wideresnet':
model = build_wideresnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'InceptionV3':
model = build_inceptionV3(in_shape, cf.dataset.n_classes,
cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=False)
elif cf.model_name == 'tiny-yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=True)
elif cf.model_name == 'ssd':
model = build_ssd(in_shape, cf.dataset.n_classes+1,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
else:
raise ValueError('Unknown model')
# Load pretrained weights
if cf.load_pretrained:
print(' loading model weights from: ' + cf.pretrained_weights_file + '...')
model.load_weights(cf.pretrained_weights_file, by_name=True)
# Compile model
model.compile(loss=loss, metrics=metrics, optimizer=optimizer)
# Show model structure
if cf.show_model:
model.summary()
plot(model, to_file=os.path.join(cf.savepath, 'model.png'))
# Output the model
print (' Model: ' + cf.model_name)
# model is a keras model, Model is a class wrapper so that we can have
# other models (like GANs) made of a pair of keras models, with their
# own ways to train, test and predict
return One_Net_Model(model, cf, optimizer)
def train():
best_map = 0
if args.dataset == 'VOC':
if args.dataset_root == COCO_ROOT:
parser.error('Must specify dataset if specifying dataset_root')
cfg = voc
dataset = VOCDetection(root=args.dataset_root,
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
if args.cuda:
# net = torch.nn.DataParallel(ssd_net)
net = net.to(device)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.basenet)
print('Loading base network...')
net.vgg.load_state_dict(vgg_weights)
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
net.extras.apply(weights_init)
net.loc.apply(weights_init)
net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
# loss counters
loc_loss = 0
conf_loss = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
print(epoch_size)
step_index = 0
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
iteration = 0
for epoch in range(args.epochs):
net.phase = 'train'
net.train()
for batch_i, (images, targets) in enumerate(data_loader):
iteration += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
images = images.to(device)
targets = [ann.to(device) for ann in targets]
# forward
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('epoch ' + repr(epoch + 1) + ': iter ' +
repr(iteration) + ' || Loss: %.4f ||' % (loss.item()),
end=' ')
if epoch % args.evaluation_interval == 0:
print("\n---- Evaluating Model ----")
map = evaluate(model=net,
save_folder=args.save_folders,
cuda=args.cuda,
top_k=5,
im_size=300,
thresh=0.05,
dataset_mean=((104, 117, 123)))
if map > best_map: #取最好的map保存
torch.save(net.state_dict(),
f"checkpoints/ssd300_%d.pth" % (epoch + 1))
best_map = map
with open(det_file, 'wb') as f:
pickle.dump(all_boxes, f, pickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
evaluate_detections(all_boxes, output_dir, dataset)
def evaluate_detections(box_list, output_dir, dataset):
write_voc_results_file(box_list, dataset)
do_python_eval(output_dir)
if __name__ == '__main__':
# load net
num_classes = len(VOC_CLASSES) + 1 # +1 background
net = build_ssd('test', 300, num_classes) # initialize SSD
net.load_state_dict(torch.load(args.trained_model))
net.eval()
print('Finished loading model!')
# load data
dataset = VOCDetection(args.voc_root, [('2007', set_type)],
BaseTransform(300, dataset_mean),
AnnotationTransform())
if args.cuda:
net = net.cuda()
cudnn.benchmark = True
# evaluation
test_net(args.save_folder,
net,
args.cuda,
dataset,
def make_one_net_model(self, cf, in_shape, loss, metrics, optimizer):
# Create the *Keras* model
if cf.model_name == 'fcn8':
model = build_fcn8(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=cf.load_imageNet)
elif cf.model_name == 'unet':
model = build_unet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'segnet_basic':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
basic=True)
elif cf.model_name == 'segnet_vgg':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
basic=False)
elif cf.model_name == 'resnetFCN':
model = build_resnetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'inceptionFCN':
model = build_inceptionFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'densenet':
model = build_densenet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'lenet':
model = build_lenet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'alexNet':
model = build_alexNet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'vgg16':
model = build_vgg(in_shape, cf.dataset.n_classes, 16, cf.weight_decay,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'vgg19':
model = build_vgg(in_shape, cf.dataset.n_classes, 19, cf.weight_decay,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'resnet50':
model = build_resnet50(in_shape, cf.dataset.n_classes, cf.weight_decay,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'InceptionV3':
model = build_inceptionV3(in_shape, cf.dataset.n_classes,
cf.weight_decay,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=False)
elif cf.model_name == 'tiny-yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_imageNet=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=True)
elif cf.model_name == 'ssd':
model = build_ssd(in_shape, cf.dataset.n_classes+1,
cf.dataset.n_priors,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'densenet_segmentation':
model = build_densenet_segmentation(in_shape, cf.dataset.n_classes, weight_decay = cf.weight_decay,
freeze_layers_from = cf.freeze_layers_from, path_weights = cf.load_imageNet)
else:
raise ValueError('Unknown model')
# Load pretrained weights
if cf.load_pretrained:
print(' loading model weights from: ' + cf.weights_file + '...')
# If the weights are from different datasets
if cf.different_datasets:
if cf.freeze_layers_from == 'base_model':
raise TypeError('Please, enter the layer id instead of "base_model"'
' for the freeze_layers_from config parameter')
croppedmodel = model_from_json(model.to_json())
# Remove not frozen layers
for i in range(len(model.layers[cf.freeze_layers_from:])):
croppedmodel.layers.pop()
# Load weights only for the frozen layers
croppedmodel.load_weights(cf.weights_file, by_name=True)
model.set_weights(croppedmodel.get_weights())
else:
model.load_weights(cf.weights_file, by_name=True)
# Compile model
model.compile(loss=loss, metrics=metrics, optimizer=optimizer)
# Show model structure
if cf.show_model:
model.summary()
plot(model, to_file=os.path.join(cf.savepath, 'model.png'))
# Output the model
print (' Model: ' + cf.model_name)
# model is a keras model, Model is a class wrapper so that we can have
# other models (like GANs) made of a pair of keras models, with their
# own ways to train, test and predict
return One_Net_Model(model, cf, optimizer)
if 'TT100K' in sys.argv[2]:
# only for TT100K
classes = [
'i2', 'i4', 'i5', 'il100', 'il60', 'il80', 'io', 'ip', 'p10', 'p11',
'p12', 'p19', 'p23', 'p26', 'p27', 'p3', 'p5', 'p6', 'pg', 'ph4',
'ph4.5', 'ph5', 'pl100', 'pl120', 'pl20', 'pl30', 'pl40', 'pl5',
'pl50', 'pl60', 'pl70', 'pl80', 'pm20', 'pm30', 'pm55', 'pn', 'pne',
'po', 'pr40', 'w13', 'w32', 'w55', 'w57', 'w59', 'wo'
]
elif 'Udacity' in sys.argv[2]:
classes = ['Car', 'Pedestrian', 'Truck']
input_shape = (300, 300, 3)
NUM_CLASSES = len(classes) + 1
model = build_ssd(img_shape=input_shape, n_classes=NUM_CLASSES)
model.load_weights(sys.argv[1])
test_dir = sys.argv[2]
imfiles = [
os.path.join(test_dir, f) for f in os.listdir(test_dir)
if os.path.isfile(os.path.join(test_dir, f)) and f.endswith('jpg')
]
if len(imfiles) == 0:
print "ERR: path_to_images do not contain any jpg file"
quit()
inputs = []
img_paths = []
chunk_size = 128 # we are going to process all image files in chunks
'po', 'pr40', 'w13', 'w32', 'w55', 'w57', 'w59', 'wo'
]
elif dataset_name == 'Udacity':
classes = ['Car', 'Pedestrian', 'Truck']
else:
print "Error: Dataset not found!"
quit()
priors = [[0.9, 1.2], [1.05, 1.35], [2.15, 2.55], [3.25, 3.75], [5.35, 5.1]]
input_shape = (300, 300, 3)
NUM_PRIORS = len(priors)
NUM_CLASSES = len(classes)
model = build_ssd(img_shape=input_shape,
n_classes=NUM_CLASSES + 1,
freeze_layers_from=None)
model.load_weights(sys.argv[1], by_name=True)
bbox_util = BBoxUtility(num_classes=NUM_CLASSES,
priors=None,
overlap_threshold=0.5,
nms_thresh=nms_threshold)
test_dir = sys.argv[2]
imfiles = [
os.path.join(test_dir, f) for f in os.listdir(test_dir)
if os.path.isfile(os.path.join(test_dir, f)) and f.endswith('jpg')
]
def make_one_net_model(self, cf, in_shape, loss, metrics, optimizer):
# Create the *Keras* model
if 'tiramisu' in cf.model_name:
input_rows, input_cols = cf.target_size_train[0], cf.target_size_train[1]
multiple = 2 ** 5 # 5 transition blocks
if input_rows is not None:
if input_rows % multiple != 0:
raise ValueError('The number of rows of the input data must be a multiple of {}'.format(multiple))
if input_cols is not None:
if input_cols % multiple != 0:
raise ValueError(
'The number of columns of the input data must be a multiple of {}'.format(multiple))
if cf.model_name == 'fcn8':
model = build_fcn8(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
#path_weights='weights/pascal-fcn8s-dag.mat')
path_weights=cf.load_imageNet)
elif cf.model_name == 'unet':
model = build_unet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'tiramisu':
# model = build_tiramisu(in_shape, cf.dataset.n_classes, cf.weight_decay,
# nb_filter=48, dropout=0.4, freeze_layers_from=None)
model = build_tiramisu(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'segnet_basic':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None, basic=True)
elif cf.model_name == 'segnet_vgg':
model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None, basic=False)
elif cf.model_name == 'resnetFCN':
model = build_resnetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'densenetFCN':
model = build_densenetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay,
freeze_layers_from=cf.freeze_layers_from,
path_weights=None)
elif cf.model_name == 'lenet':
model = build_lenet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'alexNet':
model = build_alexNet(in_shape, cf.dataset.n_classes, cf.weight_decay)
elif cf.model_name == 'vgg16':
model = build_vgg(in_shape, cf.dataset.n_classes, 16, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'vgg19':
model = build_vgg(in_shape, cf.dataset.n_classes, 19, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'resnet50':
model = build_resnet50(in_shape, cf.dataset.n_classes, cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'InceptionV3':
model = build_inceptionV3(in_shape, cf.dataset.n_classes,
cf.weight_decay,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
elif cf.model_name == 'yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=False)
elif cf.model_name == 'tiny-yolo':
model = build_yolo(in_shape, cf.dataset.n_classes,
cf.dataset.n_priors,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from, tiny=True)
elif cf.model_name == 'ssd':
print(in_shape)
model = build_ssd(in_shape, cf.dataset.n_classes,
load_pretrained=cf.load_imageNet,
freeze_layers_from=cf.freeze_layers_from)
else:
raise ValueError('Unknown model')
# Load pretrained weights
if cf.load_pretrained:
print(' loading model weights from: ' + cf.weights_file + '...')
model.load_weights(cf.weights_file, by_name=True)
# Compile model
model.compile(loss=loss, metrics=metrics, optimizer=optimizer)
# Show model structure
if cf.show_model:
model.summary()
plot(model, to_file=os.path.join(cf.savepath, 'model_'+cf.model_name+'.png'))
# Output the model
print (' Model: ' + cf.model_name)
# model is a keras model, Model is a class wrapper so that we can have
# other models (like GANs) made of a pair of keras models, with their
# own ways to train, test and predict
return One_Net_Model(model, cf, optimizer)
def main():
global args
global minmum_loss
args.gpu = 0
args.world_size = 1
if args.distributed:
args.gpu = args.local_rank % torch.cuda.device_count()
torch.cuda.set_device(args.gpu)
torch.distributed.init_process_group(backend='nccl',
init_method='env://')
args.world_size = torch.distributed.get_world_size()
args.total_batch_size = args.world_size * args.batch_size
## DATA loading code
if args.dataset == 'COCO':
if not os.path.exists(cfg['coco_root']):
parser.error('Must specify dataset_root if specifying dataset')
print("WARNING: Using default COCO dataset_root because " +
"--dataset_root was not specified.")
cfg = coco
dataset = COCODetection(root=cfg['coco_root'],
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
if args.dataset == 'VOC':
cfg = voc
dataset = VOCDetection(root=cfg['voc_root'],
transform=SSDAugmentation(
cfg['min_dim'], MEANS))
print('Training SSD on:', dataset.name)
print('Loading the dataset...')
train_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
print("Build ssd network")
model = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
if args.pretrained:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
model.vgg.load_state_dict(vgg_weights)
model = model.cuda()
# optimizer and loss function
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, True)
## get the priorbox of ssd
priorbox = PriorBox(cfg)
with torch.no_grad():
priors = priorbox.forward()
priors = priors.cuda()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(
args.resume,
map_location=lambda storage, loc: storage.cuda(args.gpu))
args.start_epoch = checkpoint['epoch']
minmum_loss = checkpoint['minmum_loss']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
else:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
model.extras.apply(weights_init)
model.loc.apply(weights_init)
model.conf.apply(weights_init)
print('Using the specified args:')
print(args)
for epoch in range(args.start_epoch, args.epochs):
# train for one epoch
end = time.time()
loss = train(train_loader, model, priors, criterion, optimizer, epoch)
# remember best prec@1 and save checkpoint
if args.local_rank == 0:
is_best = loss < minmum_loss
minmum_loss = min(loss, minmum_loss)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_prec1': minmum_loss,
'optimizer': optimizer.state_dict(),
}, is_best, epoch)
epoch_time = time.time() - end
print('Epoch %s time cost %f' % (epoch, epoch_time))
def train():
# 构造数据集
dataset = VOCDetection(root=args.dataset_root,
phase='train',
transform=SSDAugmentation(cfg['min_dim'], MEANS))
data_loader = data.DataLoader(dataset,
args.batch_size,
num_workers=args.num_workers,
shuffle=True,
collate_fn=detection_collate,
pin_memory=True)
# 建立SSD模型
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume: # 初始权重
print('Initializing weights...')
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
# 优化器
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# 返回MultiBoxLoss类对象
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, 3, args.cuda)
net.train()
print('Loading the dataset...')
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
batch_iterator = iter(data_loader) # 创建迭代器
# 0-120000,迭代一次遍历batch_size张图像，共2501张训练图片，共需要2501//4=425批
# 总共遍历图像的次数为120000/425=282次
for iteration in range(args.start_iter, cfg['max_iter']):
if iteration in cfg['lr_steps']: # 调整学习率
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
try: # 以迭代方式获取数据
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
if args.cuda:
images = Variable(images.cuda())
with torch.no_grad():
targets = [Variable(ann.cuda()) for ann in targets]
else:
images = Variable(images)
with torch.no_grad():
targets = [Variable(ann) for ann in targets]
t0 = time.time()
out = net(images) # 前向传播
optimizer.zero_grad() # 梯度清零
loss_l, loss_c = criterion(out, targets) # 获得回归损失和分类损失
loss = loss_l + loss_c # 总损失值
loss.backward() # 反向传播
optimizer.step() # 参数优化
t1 = time.time()
# 打印信息
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print(
'iter: ' + repr(iteration) +
' || Loc_Loss: %.6f || Conf_Loss: %.6f || Total_Loss: %.6f ||'
% (loss_l.data.item(), loss_c.data.item(), loss.data.item()),
end=' ')
# 更新visdom显示
if args.visdom:
update_vis_plot(iteration, loss_l.data.item(), loss_c.data.item(),
iter_plot, 'append')
# 打印信息
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(ssd_net.state_dict(),
'weights/ssd300_VOC2007_' + repr(iteration) + '.pth')
# 保存模型
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
if model_name == 'yolo' or model_name == 'tiny_yolo':
input_shape = (3, 320, 320)
if model_name == 'tiny_yolo':
tiny_yolo = True
else:
tiny_yolo = False
model = build_yolo(img_shape=input_shape,n_classes=NUM_CLASSES, n_priors=5,
load_pretrained=False,freeze_layers_from='base_model',
tiny=tiny_yolo)
elif model_name == 'ssd':
if K.image_dim_ordering() == 'th':
input_shape = (3,300,300)
else:
input_shape = (300,300,3)
model = build_ssd(img_shape=input_shape,n_classes=NUM_CLASSES + 1, # +1 to consider background
load_pretrained=False,freeze_layers_from='base_model')
model.load_weights(sys.argv[1])
test_dir = sys.argv[2]
imfiles = [os.path.join(test_dir,f) for f in os.listdir(test_dir)
if os.path.isfile(os.path.join(test_dir,f))
and f.endswith('jpg')]
if len(imfiles) == 0:
print "ERR: path_to_images do not contain any jpg file"
quit()
inputs = []
img_paths = []
# resnet = models.alexnet()
# resnet = models.resnet152()
model = model
foo(model)
input = Variable(torch.rand(3, size, size).unsqueeze(0),
requires_grad=True).cuda()
out = model(input)
total_flops = (sum(list_conv) + sum(list_linear) + sum(list_bn) +
sum(list_relu) + sum(list_pooling))
print(' + Number of FLOPs: %.2fG' % (total_flops / 1e9))
if __name__ == "__main__":
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Set up model
net1 = build_ssd('train', 300, 7).to(device)
net2 = build_refinedet('train', 320, 7).to(device)
# summary(net1, input_size=(3,300,300))
total1 = sum([param.nelement() for param in net1.parameters()])
total2 = sum([param.nelement() for param in net2.parameters()])
print(' + SSD Number of params: %.2fM' % (total1 / 1e6))
print(' + RefineDet Number of params: %.2fM' % (total2 / 1e6))
print_model_parm_flops(net1, 300)
print_model_parm_flops(net2, 320)
print "Error: Dataset not found!"
quit()
priors = [[0.9,1.2], [1.05,1.35], [2.15,2.55], [3.25,3.75], [5.35,5.1]]
input_shape = (3, 320, 320)
NUM_PRIORS = len(priors)
NUM_CLASSES = len(classes)
if model_name == 'tiny-yolo':
tiny_yolo = True
else:
tiny_yolo = False
#############################################################################
if model_name == 'SSD300':
model = build_ssd(img_shape=input_shape,n_classes=NUM_CLASSES, n_priors=5,
load_pretrained=False,freeze_layers_from='base_model')
else:
model = build_yolo(img_shape=input_shape,n_classes=NUM_CLASSES, n_priors=5,
load_pretrained=False,freeze_layers_from='base_model',
tiny=tiny_yolo)
#############################################################################
model.load_weights(sys.argv[1])
test_dir = sys.argv[2]
imfiles = [os.path.join(test_dir,f) for f in os.listdir(test_dir)
if os.path.isfile(os.path.join(test_dir,f))
and f.endswith('jpg')]
if len(imfiles) == 0:
coord_ssd = np.zeros((coord.shape[0], 5))
for idx in range(coord.shape[0]):
# each channels have different gt => since they are nearly same, just use the middle gt as main target
crd = coord[idx][1]
# add zero as class index: it is treated to 1 by adding +1 to that
# loss function automatically defines another zero as background
# https://github.com/amdegroot/ssd.pytorch/issues/17
crd = np.append(crd, [0])
coord_ssd[idx] = crd
# split train & valid set: subject-level (without shuffle)
ct_train, ct_valid, coord_ssd_train, coord_ssd_valid = train_test_split(
ct, coord_ssd, test_size=0.1, shuffle=False)
"""#########################################################"""
"""#################### Network Definition ####################"""
ssd_net = build_ssd('train', 300, num_classes)
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('pretrained weights not loaded: training from scratch...')
# print('Loading base network...')
# ssd_net.vgg.load_state_dict(vgg_weights)
type=int,
default=1,
help="size of the batches")
parser.add_argument(
"--n_cpu",
type=int,
default=0,
help="number of cpu threads to use during batch generation")
parser.add_argument("--img_size",
type=int,
default=300,
help="size of each image dimension")
args = parser.parse_args()
os.makedirs("ssd_output", exist_ok=True)
net = build_ssd('test', 300, 7) # initialize SSD
net.load_weights(args.trained_model) #ssd300_701.pth是经过数据增强的
net = net.cuda()
dataloader = DataLoader(
ImageFolder(args.dataset_root, img_size=args.img_size),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.n_cpu,
)
TIME = 0
for batch_i, (img_paths, input_imgs) in enumerate(dataloader):
# Configure input
# input_imgs = Variable(input_imgs.type(Tensor))
def train():
if args.dataset == 'COCO':
cfg = coco
dataset = COCODetection(root=cfg['coco_root'],
transform=SSDAugmentation(cfg['min_dim'],
MEANS))
if args.dataset == 'VOC':
cfg = voc
dataset = VOCDetection(root=cfg['voc_root'],
transform=SSDAugmentation(cfg['min_dim'],
MEANS))
if args.visdom:
import visdom
viz = visdom.Visdom()
ssd_net = build_ssd('train', cfg['min_dim'], cfg['num_classes'])
net = ssd_net
if args.cuda:
net = torch.nn.DataParallel(ssd_net)
cudnn.benchmark = True
if args.resume:
print('Resuming training, loading {}...'.format(args.resume))
ssd_net.load_weights(args.resume)
else:
vgg_weights = torch.load(args.save_folder + args.basenet)
print('Loading base network...')
ssd_net.vgg.load_state_dict(vgg_weights)
if args.cuda:
net = net.cuda()
if not args.resume:
print('Initializing weights...')
# initialize newly added layers' weights with xavier method
ssd_net.extras.apply(weights_init)
ssd_net.loc.apply(weights_init)
ssd_net.conf.apply(weights_init)
optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum,
weight_decay=args.weight_decay)
criterion = MultiBoxLoss(cfg['num_classes'], 0.5, True, 0, True, 3, 0.5,
False, args.cuda)
priorbox = PriorBox(cfg)
with torch.no_grad():
priors = priorbox.forward()
priors = priors.cuda()
net.train()
# loss counters
loc_loss = 0
conf_loss = 0
epoch = 0
print('Loading the dataset...')
epoch_size = len(dataset) // args.batch_size
print('Training SSD on:', dataset.name)
print('Using the specified args:')
print(args)
step_index = 0
if args.visdom:
vis_title = 'SSD.PyTorch on ' + dataset.name
vis_legend = ['Loc Loss', 'Conf Loss', 'Total Loss']
iter_plot = create_vis_plot('Iteration', 'Loss', vis_title, vis_legend)
epoch_plot = create_vis_plot('Epoch', 'Loss', vis_title, vis_legend)
data_loader = data.DataLoader(dataset, args.batch_size,
num_workers=args.num_workers,
shuffle=True, collate_fn=detection_collate,
pin_memory=True)
# create batch iterator
batch_iterator = iter(data_loader)
for iteration in range(args.start_iter, cfg['max_iter']):
if args.visdom and iteration != 0 and (iteration % epoch_size == 0):
update_vis_plot(epoch, loc_loss, conf_loss, epoch_plot, None,
'append', epoch_size)
# reset epoch loss counters
loc_loss = 0
conf_loss = 0
epoch += 1
if iteration in cfg['lr_steps']:
step_index += 1
adjust_learning_rate(optimizer, args.gamma, step_index)
# load train data
try:
images, targets = next(batch_iterator)
except StopIteration:
batch_iterator = iter(data_loader)
images, targets = next(batch_iterator)
if args.cuda:
images = Variable(images.cuda())
targets = [Variable(ann.cuda(), requires_grad=False) for ann in targets]
else:
images = Variable(images)
targets = [Variable(ann, requires_grad=False) for ann in targets]
# forward
t0 = time.time()
out = net(images)
# backprop
optimizer.zero_grad()
loss_l, loss_c = criterion(out, priors, targets)
loss = loss_l + loss_c
loss.backward()
optimizer.step()
t1 = time.time()
loc_loss += loss_l.item()
conf_loss += loss_c.item()
if iteration % 10 == 0:
print('timer: %.4f sec.' % (t1 - t0))
print('iter ' + repr(iteration) + ' || Loss: %.4f ||' % (loss.item()), end=' ')
if args.visdom:
update_vis_plot(iteration, loss_l.item(), loss_c.item(),
iter_plot, epoch_plot, 'append')
if iteration != 0 and iteration % 5000 == 0:
print('Saving state, iter:', iteration)
torch.save(ssd_net.state_dict(), 'weights/ssd300_COCO_' +
repr(iteration) + '.pth')
torch.save(ssd_net.state_dict(),
args.save_folder + '' + args.dataset + '.pth')
