def im_detect(self, im_list, root_dir=None, extension=None, show_timer=False): """ wrapper for detecting multiple images Parameters: ---------- im_list : list of str image path or list of image paths root_dir : str directory of input images, optional if image path already has full directory information extension : str image extension, eg. ".jpg", optional Returns: ---------- list of detection results in format [det0, det1...], det is in format np.array([id, score, xmin, ymin, xmax, ymax]...) """ test_db = TestDB(im_list, root_dir=root_dir, extension=extension) test_iter = DetIter(test_db, 1, self.data_shape, self.mean_pixels, is_train=False) return self.detect(test_iter, show_timer)
def train_net(net, dataset, image_set, devkit_path, batch_size, data_shape, mean_pixels, resume, finetune, from_scratch, pretrained, epoch, prefix, ctx, begin_epoch, end_epoch, frequent, optimizer_name='adam', learning_rate=1e-03, momentum=0.9, weight_decay=5e-04, lr_refactor_step=(3, 4, 5, 6), lr_refactor_ratio=0.1, val_image_set='', val_year='', use_plateau=True, year='', freeze_layer_pattern='', force_resize=True, min_obj_size=32.0, use_difficult=False, nms_thresh=0.45, force_suppress=False, ovp_thresh=0.5, voc07_metric=True, nms_topk=400, iter_monitor=0, monitor_pattern=".*", log_file=None): """ Wrapper for training phase. Parameters: ---------- net : str symbol name for the network structure dataset : str pascal_voc, imagenet... image_set : str train, trainval... devkit_path : str root directory of dataset batch_size : int training batch-size data_shape : int or tuple width/height as integer or (3, height, width) tuple mean_pixels : tuple of floats mean pixel values for red, green and blue resume : int resume from previous checkpoint if > 0 finetune : int fine-tune from previous checkpoint if > 0 pretrained : str prefix of pretrained model, including path epoch : int load epoch of either resume/finetune/pretrained model prefix : str prefix for saving checkpoints ctx : [mx.cpu()] or [mx.gpu(x)] list of mxnet contexts begin_epoch : int starting epoch for training, should be 0 if not otherwise specified end_epoch : int end epoch of training frequent : int frequency to print out training status learning_rate : float training learning rate momentum : float trainig momentum weight_decay : float training weight decay param lr_refactor_ratio : float multiplier for reducing learning rate lr_refactor_step : comma separated integers at which epoch to rescale learning rate, e.g. '30, 60, 90' year : str 2007, 2012 or combinations splitted by comma freeze_layer_pattern : str regex pattern for layers need to be fixed iter_monitor : int monitor internal stats in networks if > 0, specified by monitor_pattern monitor_pattern : str regex pattern for monitoring network stats log_file : str log to file if enabled """ # set up logger logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.INFO) if log_file: fh = logging.FileHandler(log_file) logger.addHandler(fh) # check args if isinstance(data_shape, int): data_shape = (3, data_shape, data_shape) assert len(data_shape) == 3 and data_shape[0] == 3 if isinstance(mean_pixels, (int, float)): mean_pixels = [mean_pixels, mean_pixels, mean_pixels] assert len(mean_pixels) == 3, "must provide all RGB mean values" # load dataset val_imdb = None if dataset == 'pascal_voc': imdb = load_pascal(image_set, year, devkit_path, cfg.train['shuffle']) if val_image_set: assert val_year val_imdb = load_pascal(val_image_set, val_year, devkit_path, False) max_objects = max(imdb.max_objects, val_imdb.max_objects) imdb.pad_labels(max_objects) val_imdb.pad_labels(max_objects) force_resize = True elif dataset == 'wider': imdb = load_wider(image_set, devkit_path, cfg.train['shuffle']) force_resize = False elif dataset == 'mscoco': imdb = load_mscoco(image_set, devkit_path, cfg.train['shuffle']) force_resize = True else: raise NotImplementedError("Dataset " + dataset + " not supported") # init iterator patch_size = data_shape[1] min_gt_scale = min_obj_size / float(patch_size) rand_scaler = RandScaler(patch_size, min_gt_scale=min_gt_scale, force_resize=force_resize) rand_eraser = RandEraser() if force_resize else None train_iter = DetIter(imdb, batch_size, data_shape[1], rand_scaler, rand_eraser=rand_eraser, mean_pixels=mean_pixels, rand_mirror=cfg.train['rand_mirror_prob'] > 0, shuffle=cfg.train['shuffle'], rand_seed=cfg.train['seed'], is_train=True) if val_imdb: rand_scaler = RandScaler(patch_size, no_random=True, force_resize=force_resize) val_iter = DetIter(val_imdb, batch_size, data_shape[1], rand_scaler, mean_pixels=mean_pixels, is_train=True) else: val_iter = None train_net_common(net, train_iter, val_iter, batch_size, data_shape, resume, finetune, pretrained, epoch, prefix, ctx, begin_epoch, end_epoch, frequent, learning_rate, momentum, weight_decay, use_plateau, lr_refactor_step, lr_refactor_ratio, freeze_layer_pattern, imdb.num_images, imdb.max_objects, nms_thresh, force_suppress, ovp_thresh, use_difficult, imdb.classes, optimizer_name, voc07_metric, nms_topk, iter_monitor, monitor_pattern, logger)
def train_net(net, dataset, image_set, year, devkit_path, batch_size, data_shape, mean_pixels, resume, finetune, pretrained, epoch, prefix, ctx, begin_epoch, end_epoch, frequent, learning_rate, momentum, weight_decay, val_set, val_year, lr_refactor_epoch, lr_refactor_ratio, iter_monitor=0, log_file=None): """ Wrapper for training module Parameters: --------- net : mx.Symbol training network dataset : str pascal, imagenet... image_set : str train, trainval... year : str 2007, 2012 or combinations splitted by comma devkit_path : str root directory of dataset batch_size : int training batch size data_shape : int or (int, int) resize image size mean_pixels : tuple (float, float, float) mean pixel values in (R, G, B) resume : int if > 0, will load trained epoch with name given by prefix finetune : int if > 0, will load trained epoch with name given by prefix, in this mode all convolutional layers except the last(prediction layer) are fixed pretrained : str prefix of pretrained model name epoch : int epoch of pretrained model prefix : str prefix of new model ctx : mx.gpu(?) or list of mx.gpu(?) training context begin_epoch : int begin epoch, default should be 0 end_epoch : int when to stop training frequent : int frequency to log out batch_end_callback learning_rate : float learning rate, will be divided by batch_size automatically momentum : float (0, 1), training momentum weight_decay : float decay weights regardless of gradient val_set : str similar to image_set, used for validation val_year : str similar to year, used for validation lr_refactor_epoch : int number of epoch to change learning rate lr_refactor_ratio : float new_lr = old_lr * lr_refactor_ratio iter_monitor : int if larger than 0, will print weights/gradients every iter_monitor iters log_file : str log to file if not None Returns: --------- None """ # set up logger logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.INFO) if log_file: fh = logging.FileHandler(log_file) logger.addHandler(fh) # check args if isinstance(data_shape, int): data_shape = (data_shape, data_shape) assert len(data_shape) == 2, "data_shape must be (h, w) tuple or list or int" prefix += '_' + str(data_shape[0]) if isinstance(mean_pixels, (int, float)): mean_pixels = [mean_pixels, mean_pixels, mean_pixels] assert len(mean_pixels) == 3, "must provide all RGB mean values" # load dataset if dataset == 'pascal': imdb = load_pascal(image_set, year, devkit_path, cfg.TRAIN.INIT_SHUFFLE) if val_set and val_year: val_imdb = load_pascal(val_set, val_year, devkit_path, False) else: val_imdb = None else: raise NotImplementedError, "Dataset " + dataset + " not supported" # init data iterator train_iter = DetIter(imdb, batch_size, data_shape, mean_pixels, cfg.TRAIN.RAND_SAMPLERS, cfg.TRAIN.RAND_MIRROR, cfg.TRAIN.EPOCH_SHUFFLE, cfg.TRAIN.RAND_SEED, is_train=True) # save per N epoch, avoid saving too frequently resize_epoch = int(cfg.TRAIN.RESIZE_EPOCH) if resize_epoch > 1: batches_per_epoch = ((imdb.num_images - 1) / batch_size + 1) * resize_epoch train_iter = mx.io.ResizeIter(train_iter, batches_per_epoch) train_iter = mx.io.PrefetchingIter(train_iter) if val_imdb: val_iter = DetIter(val_imdb, batch_size, data_shape, mean_pixels, cfg.VALID.RAND_SAMPLERS, cfg.VALID.RAND_MIRROR, cfg.VALID.EPOCH_SHUFFLE, cfg.VALID.RAND_SEED, is_train=True) val_iter = mx.io.PrefetchingIter(val_iter) else: val_iter = None # load symbol sys.path.append(os.path.join(cfg.ROOT_DIR, 'symbol')) net = importlib.import_module("symbol_" + net).get_symbol_train(imdb.num_classes) # define layers with fixed weight/bias fixed_param_names = [name for name in net.list_arguments() \ if name.startswith('conv1_') or name.startswith('conv2_')] # load pretrained or resume from previous state ctx_str = '('+ ','.join([str(c) for c in ctx]) + ')' if resume > 0: logger.info("Resume training with {} from epoch {}" .format(ctx_str, resume)) _, args, auxs = mx.model.load_checkpoint(prefix, resume) begin_epoch = resume elif finetune > 0: logger.info("Start finetuning with {} from epoch {}" .format(ctx_str, finetune)) _, args, auxs = mx.model.load_checkpoint(prefix, finetune) begin_epoch = finetune # the prediction convolution layers name starts with relu, so it's fine fixed_param_names = [name for name in net.list_arguments() \ if name.startswith('conv')] elif pretrained: logger.info("Start training with {} from pretrained model {}" .format(ctx_str, pretrained)) _, args, auxs = mx.model.load_checkpoint(pretrained, epoch) args = convert_pretrained(pretrained, args) else: logger.info("Experimental: start training from scratch with {}" .format(ctx_str)) args = None auxs = None fixed_param_names = None # helper information if fixed_param_names: logger.info("Freezed parameters: [" + ','.join(fixed_param_names) + ']') # init training module mod = mx.mod.Module(net, label_names=('label',), logger=logger, context=ctx, fixed_param_names=fixed_param_names) # fit batch_end_callback = mx.callback.Speedometer(train_iter.batch_size, frequent=frequent) epoch_end_callback = mx.callback.do_checkpoint(prefix) iter_refactor = lr_refactor_epoch * imdb.num_images / train_iter.batch_size lr_scheduler = mx.lr_scheduler.FactorScheduler(iter_refactor, lr_refactor_ratio) optimizer_params={'learning_rate':learning_rate, 'momentum':momentum, 'wd':weight_decay, 'lr_scheduler':lr_scheduler, 'clip_gradient':None, 'rescale_grad': 1.0} monitor = mx.mon.Monitor(iter_monitor, pattern=".*") if iter_monitor > 0 else None mod.fit(train_iter, eval_data=val_iter, eval_metric=MultiBoxMetric(), batch_end_callback=batch_end_callback, epoch_end_callback=epoch_end_callback, optimizer='sgd', optimizer_params=optimizer_params, begin_epoch=begin_epoch, num_epoch=end_epoch, initializer=CustomInitializer(factor_type="in", magnitude=1), arg_params=args, aux_params=auxs, allow_missing=True, monitor=monitor)
def evaluate_net(net, dataset, devkit_path, mean_pixels, data_shape, model_prefix, epoch, ctx, year=None, sets='test', batch_size=1, nms_thresh=0.5, force_nms=False): """ Evaluate entire dataset, basically simple wrapper for detections Parameters: --------- dataset : str name of dataset to evaluate devkit_path : str root directory of dataset mean_pixels : tuple of float (R, G, B) mean pixel values data_shape : int resize input data shape model_prefix : str load model prefix epoch : int load model epoch ctx : mx.ctx running context, mx.cpu() or mx.gpu(0)... year : str or None evaluate on which year's data sets : str evaluation set batch_size : int using batch_size for evaluation nms_thresh : float non-maximum suppression threshold force_nms : bool force suppress different categories """ # set up logger logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.INFO) if dataset == "pascal": if not year: year = '2007' imdb = PascalVoc(sets, year, devkit_path, shuffle=False, is_train=False) data_iter = DetIter(imdb, batch_size, data_shape, mean_pixels, rand_samplers=[], rand_mirror=False, is_train=False, shuffle=False) sys.path.append(os.path.join(cfg.ROOT_DIR, 'symbol')) net = importlib.import_module("symbol_" + net) \ .get_symbol(imdb.num_classes, nms_thresh, force_nms) model_prefix += "_" + str(data_shape) detector = Detector(net, model_prefix, epoch, data_shape, mean_pixels, batch_size, ctx) logger.info("Start evaluation with {} images, be patient...".format( imdb.num_images)) detections = detector.detect(data_iter) imdb.evaluate_detections(detections) else: raise NotImplementedError("No support for dataset: " + dataset)
def train_net(net, train_path, num_classes, batch_size, data_shape, mean_pixels, resume, finetune, pretrained, epoch, prefix, ctx, begin_epoch, end_epoch, frequent, learning_rate, momentum, weight_decay, lr_refactor_step, lr_refactor_ratio, freeze_layer_pattern='', num_example=10000, label_pad_width=350, nms_thresh=0.45, force_nms=False, ovp_thresh=0.5, use_difficult=False, class_names=None, voc07_metric=False, nms_topk=400, force_suppress=False, train_list="", val_path="", val_list="", iter_monitor=0, monitor_pattern=".*", log_file=None): """ Wrapper for training phase. Parameters: ---------- net : str symbol name for the network structure train_path : str record file path for training num_classes : int number of object classes, not including background batch_size : int training batch-size data_shape : int or tuple width/height as integer or (3, height, width) tuple mean_pixels : tuple of floats mean pixel values for red, green and blue resume : int resume from previous checkpoint if > 0 finetune : int fine-tune from previous checkpoint if > 0 pretrained : str prefix of pretrained model, including path epoch : int load epoch of either resume/finetune/pretrained model prefix : str prefix for saving checkpoints ctx : [mx.cpu()] or [mx.gpu(x)] list of mxnet contexts begin_epoch : int starting epoch for training, should be 0 if not otherwise specified end_epoch : int end epoch of training frequent : int frequency to print out training status learning_rate : float training learning rate momentum : float trainig momentum weight_decay : float training weight decay param lr_refactor_ratio : float multiplier for reducing learning rate lr_refactor_step : comma separated integers at which epoch to rescale learning rate, e.g. '30, 60, 90' freeze_layer_pattern : str regex pattern for layers need to be fixed num_example : int number of training images label_pad_width : int force padding training and validation labels to sync their label widths nms_thresh : float non-maximum suppression threshold for validation force_nms : boolean suppress overlaped objects from different classes train_list : str list file path for training, this will replace the embeded labels in record val_path : str record file path for validation val_list : str list file path for validation, this will replace the embeded labels in record iter_monitor : int monitor internal stats in networks if > 0, specified by monitor_pattern monitor_pattern : str regex pattern for monitoring network stats log_file : str log to file if enabled """ if net == 'resnet101_two_stream' or net == 'resnetsub101_test' or \ net == 'resnetsub101_one_shared' or net == 'resnetsub101_two_shared' or \ net == 'resnet50_two_stream_w_four_layers' \ and resume == -1 and pretrained is not False: convert_model = True else: convert_model = False if net == 'resnet50_two_stream' \ and resume == -1 \ and pretrained is not False: convert_model_concat = True else: convert_model_concat = False # set up logger logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.INFO) if log_file: fh = logging.FileHandler(log_file) logger.addHandler(fh) # check args num_channel = 3 if isinstance(data_shape, int): data_shape = (num_channel, data_shape, data_shape) if isinstance(data_shape, list): data_shape = (num_channel, data_shape[0], data_shape[1]) #assert len(data_shape) == 3 and data_shape[0] == 3 if prefix.endswith('_'): prefix += '_' + str(data_shape[1]) if isinstance(mean_pixels, (int, float)): mean_pixels = [mean_pixels, mean_pixels, mean_pixels] assert len(mean_pixels) == 3, "must provide all RGB mean values" #train_iter = DetRecordIter(train_path, batch_size, data_shape, mean_pixels=mean_pixels, # label_pad_width=label_pad_width, path_imglist=train_list, **cfg.train) # load imdb curr_path = os.path.abspath(os.path.dirname(__file__)) imdb_train = load_caltech(image_set='train', caltech_path=os.path.join( curr_path, '..', 'data', 'caltech-pedestrian-dataset-converter'), shuffle=True) train_iter = DetIter(imdb_train, batch_size, (data_shape[1], data_shape[2]), \ mean_pixels=mean_pixels, rand_samplers=[], \ rand_mirror=False, shuffle=False, rand_seed=None, \ is_train=True, max_crop_trial=50) if val_path: #val_iter = DetRecordIter(val_path, batch_size, data_shape, mean_pixels=mean_pixels, # label_pad_width=label_pad_width, path_imglist=val_list, **cfg.valid) imdb_val = load_caltech(image_set='val', caltech_path=os.path.join( curr_path, '..', 'data', 'caltech-pedestrian-dataset-converter'), shuffle=False) val_iter = DetIter(imdb_val, batch_size, (data_shape[1], data_shape[2]), \ mean_pixels=mean_pixels, rand_samplers=[], \ rand_mirror=False, shuffle=False, rand_seed=None, \ is_train=True, max_crop_trial=50) else: val_iter = None # load symbol #net = get_symbol_train(net, data_shape[1], num_classes=num_classes, net = get_symbol_train_concat(net, data_shape[1], num_classes=num_classes, nms_thresh=nms_thresh, force_suppress=force_suppress, nms_topk=nms_topk) # define layers with fixed weight/bias if freeze_layer_pattern.strip(): re_prog = re.compile(freeze_layer_pattern) fixed_param_names = [ name for name in net.list_arguments() if re_prog.match(name) ] else: fixed_param_names = None # load pretrained or resume from previous state ctx_str = '(' + ','.join([str(c) for c in ctx]) + ')' if resume > 0: logger.info("Resume training with {} from epoch {}".format( ctx_str, resume)) _, args, auxs = mx.model.load_checkpoint(prefix, resume) begin_epoch = resume elif finetune > 0: logger.info("Start finetuning with {} from epoch {}".format( ctx_str, finetune)) _, args, auxs = mx.model.load_checkpoint(prefix, finetune) begin_epoch = finetune # check what layers mismatch with the loaded parameters exe = net.simple_bind(mx.cpu(), data=(1, 3, 300, 300), label=(1, 1, 5), grad_req='null') arg_dict = exe.arg_dict fixed_param_names = [] for k, v in arg_dict.items(): if k in args: if v.shape != args[k].shape: del args[k] logging.info("Removed %s" % k) else: if not 'pred' in k: fixed_param_names.append(k) elif pretrained: logger.info("Start training with {} from pretrained model {}".format( ctx_str, pretrained)) _, args, auxs = mx.model.load_checkpoint(pretrained, epoch) if convert_model: args = convert_pretrained(pretrained, args) if convert_model_concat: args, auxs = convert_pretrained_concat(pretrained, args) else: logger.info("Experimental: start training from scratch with {}".format( ctx_str)) args = None auxs = None fixed_param_names = None # helper information if fixed_param_names: logger.info("Freezed parameters: [" + ','.join(fixed_param_names) + ']') # init training module #mod = mx.mod.Module(net, label_names=('label',), logger=logger, context=ctx, mod = mx.mod.Module(net, label_names=('label', 'label2'), logger=logger, context=ctx, fixed_param_names=fixed_param_names) # fit parameters batch_end_callback = mx.callback.Speedometer(train_iter.batch_size, frequent=frequent) epoch_end_callback = mx.callback.do_checkpoint(prefix) learning_rate, lr_scheduler = get_lr_scheduler(learning_rate, lr_refactor_step, lr_refactor_ratio, num_example, batch_size, begin_epoch) optimizer_params = { 'learning_rate': learning_rate, 'momentum': momentum, 'wd': weight_decay, 'lr_scheduler': lr_scheduler, 'clip_gradient': None, 'rescale_grad': 1.0 / len(ctx) if len(ctx) > 0 else 1.0 } monitor = mx.mon.Monitor( iter_monitor, pattern=monitor_pattern) if iter_monitor > 0 else None # run fit net, every n epochs we run evaluation network to get mAP if voc07_metric: #valid_metric = VOC07MApMetric(ovp_thresh, use_difficult, class_names, pred_idx=3) valid_metric = VOC07MApMetric( ovp_thresh, use_difficult, class_names, pred_idx=[0, 1], output_names=['det_out_output', 'det_out2_output'], label_names=['label', 'label2']) else: #valid_metric = MApMetric(ovp_thresh, use_difficult, class_names, pred_idx=3) valid_metric = MApMetric( ovp_thresh, use_difficult, class_names, pred_idx=[0, 1], output_names=['det_out_output', 'det_out2_output'], label_names=['label', 'label2']) # messager is activated in base_module mod.fit(train_iter, val_iter, eval_metric=MultiBoxMetric(), validation_metric=valid_metric, batch_end_callback=batch_end_callback, epoch_end_callback=epoch_end_callback, optimizer='sgd', optimizer_params=optimizer_params, begin_epoch=begin_epoch, num_epoch=end_epoch, initializer=mx.init.Xavier(), arg_params=args, aux_params=auxs, allow_missing=True, monitor=monitor)
def evaluate_net(net, path_imgrec, num_classes, mean_pixels, data_shape, model_prefix, epoch, ctx=mx.cpu(), batch_size=1, path_imglist="", nms_thresh=0.45, force_nms=False, ovp_thresh=0.5, use_difficult=False, class_names=None, voc07_metric=False, use_second_network=False, net1=None, path_imgrec1=None, epoch1=None, model_prefix1=None, data_shape1=None): """ evalute network given validation record file Parameters: ---------- net : str or None Network name or use None to load from json without modifying path_imgrec : str path to the record validation file path_imglist : str path to the list file to replace labels in record file, optional num_classes : int number of classes, not including background mean_pixels : tuple (mean_r, mean_g, mean_b) data_shape : tuple or int (3, height, width) or height/width model_prefix : str model prefix of saved checkpoint epoch : int load model epoch ctx : mx.ctx mx.gpu() or mx.cpu() batch_size : int validation batch size nms_thresh : float non-maximum suppression threshold force_nms : boolean whether suppress different class objects ovp_thresh : float AP overlap threshold for true/false postives use_difficult : boolean whether to use difficult objects in evaluation if applicable class_names : comma separated str class names in string, must correspond to num_classes if set voc07_metric : boolean whether to use 11-point evluation as in VOC07 competition """ # set up logger logging.basicConfig() logger = logging.getLogger() logger.setLevel(logging.INFO) # args if isinstance(data_shape, int): data_shape = (3, data_shape, data_shape) elif isinstance(data_shape, list): data_shape = (3, data_shape[0], data_shape[1]) assert len(data_shape) == 3 and data_shape[0] == 3 # model_prefix += '_' + str(data_shape[1]) # iterator #eval_iter = DetRecordIter(path_imgrec, batch_size, data_shape, # path_imglist=path_imglist, **cfg.valid) curr_path = os.path.abspath(os.path.dirname(__file__)) imdb_val = load_caltech(image_set='val', caltech_path=os.path.join( curr_path, '..', 'data', 'caltech-pedestrian-dataset-converter'), shuffle=False) eval_iter = DetIter(imdb_val, batch_size, (data_shape[1], data_shape[2]), \ mean_pixels=[128, 128, 128], rand_samplers=[], \ rand_mirror=False, shuffle=False, rand_seed=None, \ is_train=True, max_crop_trial=50) # model params load_net, args, auxs = mx.model.load_checkpoint(model_prefix, epoch) # network if net is None: net = load_net else: #net = get_symbol(net, data_shape[1], num_classes=num_classes, net = get_symbol_concat(net, data_shape[1], num_classes=num_classes, nms_thresh=nms_thresh, force_suppress=force_nms) if not 'label' in net.list_arguments(): label = mx.sym.Variable(name='label') label2 = mx.sym.Variable(name='label2') net = mx.sym.Group([net, label, label2]) # init module #mod = mx.mod.Module(net, label_names=('label',), logger=logger, context=ctx, mod = mx.mod.Module(net, label_names=('label', 'label2'), logger=logger, context=ctx, fixed_param_names=net.list_arguments()) mod.bind(data_shapes=eval_iter.provide_data, label_shapes=eval_iter.provide_label) mod.set_params(args, auxs, allow_missing=False, force_init=True) if voc07_metric: #metric = VOC07MApMetric(ovp_thresh, use_difficult, class_names, pred_idx=1) metric = VOC07MApMetric( ovp_thresh, use_difficult, class_names, pred_idx=[0, 1], output_names=['detection_output', 'detection2_output'], label_names=['label', 'label2']) else: #metric = MApMetric(ovp_thresh, use_difficult, class_names, pred_idx=1) metric = MApMetric( ovp_thresh, use_difficult, class_names, pred_idx=[0, 1], output_names=['detection_output', 'detection2_output'], label_names=['label', 'label2']) # run evaluation if not use_second_network: results = mod.score(eval_iter, metric, num_batch=None) for k, v in results: print("{}: {}".format(k, v)) else: logging.basicConfig() logger1 = logging.getLogger() logger1.setLevel(logging.INFO) # load sub network if isinstance(data_shape1, int): data_shape1 = (3, data_shape1, data_shape1) elif isinstance(data_shape1, list): data_shape1 = (3, data_shape1[0], data_shape1[1]) assert len(data_shape1) == 3 and data_shape1[0] == 3 # iterator eval_iter1 = DetRecordIter(path_imgrec1, batch_size, data_shape1, path_imglist=path_imglist, **cfg.valid) # model params load_net1, args1, auxs1 = mx.model.load_checkpoint( model_prefix1, epoch1) # network if net1 is None: net1 = load_net1 else: net1 = net if 'label' not in net1.list_arguments(): label1 = mx.sym.Variable(name='label') net1 = mx.sym.Group([net1, label1]) # init module mod1 = mx.mod.Module(net1, label_names=('label', ), logger=logger1, context=ctx, fixed_param_names=net1.list_arguments()) mod1.bind(data_shapes=eval_iter1.provide_data, label_shapes=eval_iter1.provide_label) mod1.set_params(args1, auxs1, allow_missing=False, force_init=True) if voc07_metric: metric1 = VOC07MApMetric(ovp_thresh, use_difficult, class_names) else: metric1 = MApMetric(ovp_thresh, use_difficult, class_names) # filepath = '/home/binghao/workspace/MXNet-SSD/matlab/kitti/outputs/ssd/' filepath1 = '/home/binghao/workspace/MXNet-SSD/matlab/kitti/outputs/ssd_small/' # mod.score_m(filepath, eval_iter, metric, num_batch=None) mod1.score_m(filepath1, eval_iter1, metric1, num_batch=None)