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')