跑了一晚上的模型，实在占GPU资源，这两天已经有很多小朋友说我了。我选择了其中一个参数。

https://github.com/dmlc/gluon-cv/blob/master/scripts/detection/faster_rcnn/train_faster_rcnn.py

train_faster_rcnn的修改之前就弄好了，这里贴一个完整的。

"""Train Faster-RCNN end to end."""

import argparse

import os

# disable autotune

os.environ['MXNET_CUDNN_AUTOTUNE_DEFAULT'] = ''

import logging

import time

import numpy as np

import mxnet as mx

from mxnet import nd

from mxnet import gluon

from mxnet import autograd

import gluoncv as gcv

from gluoncv import data as gdata

from gluoncv import utils as gutils

from gluoncv.model_zoo import get_model

from gluoncv.data import batchify

from gluoncv.data.transforms.presets.rcnn import FasterRCNNDefaultTrainTransform

from gluoncv.data.transforms.presets.rcnn import FasterRCNNDefaultValTransform

from gluoncv.utils.metrics.voc_detection import VOC07MApMetric

from gluoncv.utils.metrics.coco_detection import COCODetectionMetric

from gluoncv.utils.metrics.accuracy import Accuracy

# add_lst

from gluoncv.data import LstDetection

def parse_args():

    parser = argparse.ArgumentParser(description='Train Faster-RCNN networks e2e.')

    parser.add_argument('--network', type=str, default='resnet50_v1b',

                        help="Base network name which serves as feature extraction base.")

    parser.add_argument('--dataset', type=str, default='voc',

                        help='Training dataset. Now support voc and coco.')

    parser.add_argument('--num-workers', '-j', dest='num_workers', type=int,

                        default=4, help='Number of data workers, you can use larger '

                        'number to accelerate data loading, if you CPU and GPUs are powerful.')

    parser.add_argument('--gpus', type=str, default='',

                        help='Training with GPUs, you can specify 1,3 for example.')

    parser.add_argument('--epochs', type=str, default='',

                        help='Training epochs.')

    parser.add_argument('--resume', type=str, default='',

                        help='Resume from previously saved parameters if not None. '

                        'For example, you can resume from ./faster_rcnn_xxx_0123.params')

    parser.add_argument('--start-epoch', type=int, default=0,

                        help='Starting epoch for resuming, default is 0 for new training.'

                        'You can specify it to 100 for example to start from 100 epoch.')

    parser.add_argument('--lr', type=str, default='',

                        help='Learning rate, default is 0.001 for voc single gpu training.')

    parser.add_argument('--lr-decay', type=float, default=0.1,

                        help='decay rate of learning rate. default is 0.1.')

    parser.add_argument('--lr-decay-epoch', type=str, default='',

                        help='epoches at which learning rate decays. default is 14,20 for voc.')

    parser.add_argument('--lr-warmup', type=str, default='',

                        help='warmup iterations to adjust learning rate, default is 0 for voc.')

    parser.add_argument('--momentum', type=float, default=0.9,

                        help='SGD momentum, default is 0.9')

    parser.add_argument('--wd', type=str, default='',

                        help='Weight decay, default is 5e-4 for voc')

    parser.add_argument('--log-interval', type=int, default=100,

                        help='Logging mini-batch interval. Default is 100.')

    parser.add_argument('--save-prefix', type=str, default='',

                        help='Saving parameter prefix')

    parser.add_argument('--save-interval', type=int, default=1,

                        help='Saving parameters epoch interval, best model will always be saved.')

    parser.add_argument('--val-interval', type=int, default=1,

                        help='Epoch interval for validation, increase the number will reduce the '

                             'training time if validation is slow.')

    parser.add_argument('--seed', type=int, default=233,

                        help='Random seed to be fixed.')

    parser.add_argument('--verbose', dest='verbose', action='store_true',

                        help='Print helpful debugging info once set.')

    parser.add_argument('--mixup', action='store_true', help='Use mixup training.')

    parser.add_argument('--no-mixup-epochs', type=int, default=20,

                        help='Disable mixup training if enabled in the last N epochs.')

    args = parser.parse_args()

    if args.dataset == 'voc' or args.dataset == 'pedestrian':

        args.epochs = int(args.epochs) if args.epochs else 20

        args.lr_decay_epoch = args.lr_decay_epoch if args.lr_decay_epoch else '14,20'

        args.lr = float(args.lr) if args.lr else 0.001

        args.lr_warmup = args.lr_warmup if args.lr_warmup else -1

        args.wd = float(args.wd) if args.wd else 5e-4

    elif args.dataset == 'coco':

        args.epochs = int(args.epochs) if args.epochs else 26

        args.lr_decay_epoch = args.lr_decay_epoch if args.lr_decay_epoch else '17,23'

        args.lr = float(args.lr) if args.lr else 0.00125

        args.lr_warmup = args.lr_warmup if args.lr_warmup else 8000

        args.wd = float(args.wd) if args.wd else 1e-4

        num_gpus = len(args.gpus.split(','))

        if num_gpus == 1:

            args.lr_warmup = -1

        else:

            args.lr *=  num_gpus

            args.lr_warmup /= num_gpus

    return args

class RPNAccMetric(mx.metric.EvalMetric):

    def __init__(self):

        super(RPNAccMetric, self).__init__('RPNAcc')

    def update(self, labels, preds):

        # label: [rpn_label, rpn_weight]

        # preds: [rpn_cls_logits]

        rpn_label, rpn_weight = labels

        rpn_cls_logits = preds[0]

        # calculate num_inst (average on those fg anchors)

        num_inst = mx.nd.sum(rpn_weight)

        # cls_logits (b, c, h, w) red_label (b, 1, h, w)

        # pred_label = mx.nd.argmax(rpn_cls_logits, axis=1, keepdims=True)

        pred_label = mx.nd.sigmoid(rpn_cls_logits) >= 0.5

        # label (b, 1, h, w)

        num_acc = mx.nd.sum((pred_label == rpn_label) * rpn_weight)

        self.sum_metric += num_acc.asscalar()

        self.num_inst += num_inst.asscalar()

class RPNL1LossMetric(mx.metric.EvalMetric):

    def __init__(self):

        super(RPNL1LossMetric, self).__init__('RPNL1Loss')

    def update(self, labels, preds):

        # label = [rpn_bbox_target, rpn_bbox_weight]

        # pred = [rpn_bbox_reg]

        rpn_bbox_target, rpn_bbox_weight = labels

        rpn_bbox_reg = preds[0]

        # calculate num_inst (average on those fg anchors)

        num_inst = mx.nd.sum(rpn_bbox_weight) / 4

        # calculate smooth_l1

        loss = mx.nd.sum(rpn_bbox_weight * mx.nd.smooth_l1(rpn_bbox_reg - rpn_bbox_target, scalar=3))

        self.sum_metric += loss.asscalar()

        self.num_inst += num_inst.asscalar()

class RCNNAccMetric(mx.metric.EvalMetric):

    def __init__(self):

        super(RCNNAccMetric, self).__init__('RCNNAcc')

    def update(self, labels, preds):

        # label = [rcnn_label]

        # pred = [rcnn_cls]

        rcnn_label = labels[0]

        rcnn_cls = preds[0]

        # calculate num_acc

        pred_label = mx.nd.argmax(rcnn_cls, axis=-1)

        num_acc = mx.nd.sum(pred_label == rcnn_label)

        self.sum_metric += num_acc.asscalar()

        self.num_inst += rcnn_label.size

class RCNNL1LossMetric(mx.metric.EvalMetric):

    def __init__(self):

        super(RCNNL1LossMetric, self).__init__('RCNNL1Loss')

    def update(self, labels, preds):

        # label = [rcnn_bbox_target, rcnn_bbox_weight]

        # pred = [rcnn_reg]

        rcnn_bbox_target, rcnn_bbox_weight = labels

        rcnn_bbox_reg = preds[0]

        # calculate num_inst

        num_inst = mx.nd.sum(rcnn_bbox_weight) / 4

        # calculate smooth_l1

        loss = mx.nd.sum(rcnn_bbox_weight * mx.nd.smooth_l1(rcnn_bbox_reg - rcnn_bbox_target, scalar=1))

        self.sum_metric += loss.asscalar()

        self.num_inst += num_inst.asscalar()

def get_dataset(dataset, args):

    if dataset.lower() == 'voc':

        train_dataset = gdata.VOCDetection(

            splits=[(2007, 'trainval'), (2012, 'trainval')])

        val_dataset = gdata.VOCDetection(

            splits=[(2007, 'test')])

        #print(val_dataset.classes)

        #('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor')

        val_metric = VOC07MApMetric(iou_thresh=0.5, class_names=val_dataset.classes)

    elif dataset.lower() == 'coco':

        train_dataset = gdata.COCODetection(splits='instances_train2017', use_crowd=False)

        val_dataset = gdata.COCODetection(splits='instances_val2017', skip_empty=False)

        val_metric = COCODetectionMetric(val_dataset, args.save_prefix + '_eval', cleanup=True)

    elif dataset.lower() == 'pedestrian':

        lst_dataset = LstDetection('train_val.lst',root=os.path.expanduser('.'))

        print(len(lst_dataset))

        first_img = lst_dataset[0][0]

        print(first_img.shape)

        print(lst_dataset[0][1])

        train_dataset = LstDetection('train.lst',root=os.path.expanduser('.'))

        val_dataset = LstDetection('val.lst',root=os.path.expanduser('.'))

        classs = ('pedestrian',)

        val_metric = VOC07MApMetric(iou_thresh=0.5,class_names=classs)

    else:

        raise NotImplementedError('Dataset: {} not implemented.'.format(dataset))

    if args.mixup:

        from gluoncv.data.mixup import MixupDetection

        train_dataset = MixupDetection(train_dataset)

    return train_dataset, val_dataset, val_metric

def get_dataloader(net, train_dataset, val_dataset, batch_size, num_workers):

    """Get dataloader."""

    train_bfn = batchify.Tuple(*[batchify.Append() for _ in range(5)])

    train_loader = mx.gluon.data.DataLoader(

        train_dataset.transform(FasterRCNNDefaultTrainTransform(net.short, net.max_size, net)),

        batch_size, True, batchify_fn=train_bfn, last_batch='rollover', num_workers=num_workers)

    val_bfn = batchify.Tuple(*[batchify.Append() for _ in range(3)])

    val_loader = mx.gluon.data.DataLoader(

        val_dataset.transform(FasterRCNNDefaultValTransform(net.short, net.max_size)),

        batch_size, False, batchify_fn=val_bfn, last_batch='keep', num_workers=num_workers)

    return train_loader, val_loader

def save_params(net, logger, best_map, current_map, epoch, save_interval, prefix):

    current_map = float(current_map)

    if current_map > best_map[0]:

        logger.info('[Epoch {}] mAP {} higher than current best {} saving to {}'.format(

                    epoch, current_map, best_map, '{:s}_best.params'.format(prefix)))

        best_map[0] = current_map

        net.save_parameters('{:s}_best.params'.format(prefix))

        with open(prefix+'_best_map.log', 'a') as f:

            f.write('{:04d}:\t{:.4f}\n'.format(epoch, current_map))

    if save_interval and (epoch + 1) % save_interval == 0:

        logger.info('[Epoch {}] Saving parameters to {}'.format(

            epoch, '{:s}_{:04d}_{:.4f}.params'.format(prefix, epoch, current_map)))

        net.save_parameters('{:s}_{:04d}_{:.4f}.params'.format(prefix, epoch, current_map))

def split_and_load(batch, ctx_list):

    """Split data to 1 batch each device."""

    num_ctx = len(ctx_list)

    new_batch = []

    for i, data in enumerate(batch):

        new_data = [x.as_in_context(ctx) for x, ctx in zip(data, ctx_list)]

        new_batch.append(new_data)

    return new_batch

def validate(net, val_data, ctx, eval_metric):

    """Test on validation dataset."""

    clipper = gcv.nn.bbox.BBoxClipToImage()

    eval_metric.reset()

    net.hybridize(static_alloc=True)

    for batch in val_data:

        batch = split_and_load(batch, ctx_list=ctx)

        det_bboxes = []

        det_ids = []

        det_scores = []

        gt_bboxes = []

        gt_ids = []

        gt_difficults = []

        for x, y, im_scale in zip(*batch):

            # get prediction results

            ids, scores, bboxes = net(x)

            det_ids.append(ids)

            det_scores.append(scores)

            # clip to image size

            det_bboxes.append(clipper(bboxes, x))

            # rescale to original resolution

            im_scale = im_scale.reshape((-1)).asscalar()

            det_bboxes[-1] *= im_scale

            # split ground truths

            gt_ids.append(y.slice_axis(axis=-1, begin=4, end=5))

            gt_bboxes.append(y.slice_axis(axis=-1, begin=0, end=4))

            gt_bboxes[-1] *= im_scale

            gt_difficults.append(y.slice_axis(axis=-1, begin=5, end=6) if y.shape[-1] > 5 else None)

        # update metric

        for det_bbox, det_id, det_score, gt_bbox, gt_id, gt_diff in zip(det_bboxes, det_ids, det_scores, gt_bboxes, gt_ids, gt_difficults):

            eval_metric.update(det_bbox, det_id, det_score, gt_bbox, gt_id, gt_diff)

    return eval_metric.get()

def get_lr_at_iter(alpha):

    return 1. / 3. * (1 - alpha) + alpha

def train(net, train_data, val_data, eval_metric, ctx, args):

    """Training pipeline"""

    net.collect_params().setattr('grad_req', 'null')

    net.collect_train_params().setattr('grad_req', 'write')

    trainer = gluon.Trainer(

        net.collect_train_params(),  # fix batchnorm, fix first stage, etc...

        'sgd',

        {'learning_rate': args.lr,

         'wd': args.wd,

         'momentum': args.momentum,

         'clip_gradient': 5})

    # lr decay policy

    lr_decay = float(args.lr_decay)

    lr_steps = sorted([float(ls) for ls in args.lr_decay_epoch.split(',') if ls.strip()])

    lr_warmup = float(args.lr_warmup)  # avoid int division

    # TODO(zhreshold) losses?

    rpn_cls_loss = mx.gluon.loss.SigmoidBinaryCrossEntropyLoss(from_sigmoid=False)

    rpn_box_loss = mx.gluon.loss.HuberLoss(rho=1/9.)  # == smoothl1

    rcnn_cls_loss = mx.gluon.loss.SoftmaxCrossEntropyLoss()

    rcnn_box_loss = mx.gluon.loss.HuberLoss()  # == smoothl1

    metrics = [mx.metric.Loss('RPN_Conf'),

               mx.metric.Loss('RPN_SmoothL1'),

               mx.metric.Loss('RCNN_CrossEntropy'),

               mx.metric.Loss('RCNN_SmoothL1'),]

    rpn_acc_metric = RPNAccMetric()

    rpn_bbox_metric = RPNL1LossMetric()

    rcnn_acc_metric = RCNNAccMetric()

    rcnn_bbox_metric = RCNNL1LossMetric()

    metrics2 = [rpn_acc_metric, rpn_bbox_metric, rcnn_acc_metric, rcnn_bbox_metric]

    # set up logger

    logging.basicConfig()

    logger = logging.getLogger()

    logger.setLevel(logging.INFO)

    log_file_path = args.save_prefix + '_train.log'

    log_dir = os.path.dirname(log_file_path)

    if log_dir and not os.path.exists(log_dir):

        os.makedirs(log_dir)

    fh = logging.FileHandler(log_file_path)

    logger.addHandler(fh)

    logger.info(args)

    if args.verbose:

        logger.info('Trainable parameters:')

        logger.info(net.collect_train_params().keys())

    logger.info('Start training from [Epoch {}]'.format(args.start_epoch))

    best_map = [0]

    for epoch in range(args.start_epoch, args.epochs):

        mix_ratio = 1.0

        if args.mixup:

            # TODO(zhreshold) only support evenly mixup now, target generator needs to be modified otherwise

            train_data._dataset.set_mixup(np.random.uniform, 0.5, 0.5)

            mix_ratio = 0.5

            if epoch >= args.epochs - args.no_mixup_epochs:

                train_data._dataset.set_mixup(None)

                mix_ratio = 1.0

        while lr_steps and epoch >= lr_steps[0]:

            new_lr = trainer.learning_rate * lr_decay

            lr_steps.pop(0)

            trainer.set_learning_rate(new_lr)

            logger.info("[Epoch {}] Set learning rate to {}".format(epoch, new_lr))

        for metric in metrics:

            metric.reset()

        tic = time.time()

        btic = time.time()

        net.hybridize(static_alloc=True)

        base_lr = trainer.learning_rate

        for i, batch in enumerate(train_data):

            if epoch == 0 and i <= lr_warmup:

                # adjust based on real percentage

                new_lr = base_lr * get_lr_at_iter(i / lr_warmup)

                if new_lr != trainer.learning_rate:

                    if i % args.log_interval == 0:

                        logger.info('[Epoch 0 Iteration {}] Set learning rate to {}'.format(i, new_lr))

                    trainer.set_learning_rate(new_lr)

            batch = split_and_load(batch, ctx_list=ctx)

            batch_size = len(batch[0])

            losses = []

            metric_losses = [[] for _ in metrics]

            add_losses = [[] for _ in metrics2]

            with autograd.record():

                for data, label, rpn_cls_targets, rpn_box_targets, rpn_box_masks in zip(*batch):

                    gt_label = label[:, :, 4:5]

                    gt_box = label[:, :, :4]

                    cls_pred, box_pred, roi, samples, matches, rpn_score, rpn_box, anchors = net(data, gt_box)

                    # losses of rpn

                    rpn_score = rpn_score.squeeze(axis=-1)

                    num_rpn_pos = (rpn_cls_targets >= 0).sum()

                    rpn_loss1 = rpn_cls_loss(rpn_score, rpn_cls_targets, rpn_cls_targets >= 0) * rpn_cls_targets.size / num_rpn_pos

                    rpn_loss2 = rpn_box_loss(rpn_box, rpn_box_targets, rpn_box_masks) * rpn_box.size / num_rpn_pos

                    # rpn overall loss, use sum rather than average

                    rpn_loss = rpn_loss1 + rpn_loss2

                    # generate targets for rcnn

                    cls_targets, box_targets, box_masks = net.target_generator(roi, samples, matches, gt_label, gt_box)

                    # losses of rcnn

                    num_rcnn_pos = (cls_targets >= 0).sum()

                    rcnn_loss1 = rcnn_cls_loss(cls_pred, cls_targets, cls_targets >= 0) * cls_targets.size / cls_targets.shape[0] / num_rcnn_pos

                    rcnn_loss2 = rcnn_box_loss(box_pred, box_targets, box_masks) * box_pred.size / box_pred.shape[0] / num_rcnn_pos

                    rcnn_loss = rcnn_loss1 + rcnn_loss2

                    # overall losses

                    losses.append(rpn_loss.sum() * mix_ratio + rcnn_loss.sum() * mix_ratio)

                    metric_losses[0].append(rpn_loss1.sum() * mix_ratio)

                    metric_losses[1].append(rpn_loss2.sum() * mix_ratio)

                    metric_losses[2].append(rcnn_loss1.sum() * mix_ratio)

                    metric_losses[3].append(rcnn_loss2.sum() * mix_ratio)

                    add_losses[0].append([[rpn_cls_targets, rpn_cls_targets>=0], [rpn_score]])

                    add_losses[1].append([[rpn_box_targets, rpn_box_masks], [rpn_box]])

                    add_losses[2].append([[cls_targets], [cls_pred]])

                    add_losses[3].append([[box_targets, box_masks], [box_pred]])

                autograd.backward(losses)

                for metric, record in zip(metrics, metric_losses):

                    metric.update(0, record)

                for metric, records in zip(metrics2, add_losses):

                    for pred in records:

                        metric.update(pred[0], pred[1])

            trainer.step(batch_size)

            # update metrics

            if args.log_interval and not (i + 1) % args.log_interval:

                # msg = ','.join(['{}={:.3f}'.format(*metric.get()) for metric in metrics])

                msg = ','.join(['{}={:.3f}'.format(*metric.get()) for metric in metrics + metrics2])

                logger.info('[Epoch {}][Batch {}], Speed: {:.3f} samples/sec, {}'.format(

                    epoch, i, args.log_interval * batch_size/(time.time()-btic), msg))

                btic = time.time()

        msg = ','.join(['{}={:.3f}'.format(*metric.get()) for metric in metrics])

        logger.info('[Epoch {}] Training cost: {:.3f}, {}'.format(

            epoch, (time.time()-tic), msg))

#         if not (epoch + 1) % args.val_interval:

#             # consider reduce the frequency of validation to save time

#             map_name, mean_ap = validate(net, val_data, ctx, eval_metric)

#             val_msg = '\n'.join(['{}={}'.format(k, v) for k, v in zip(map_name, mean_ap)])

#             logger.info('[Epoch {}] Validation: \n{}'.format(epoch, val_msg))

#             current_map = float(mean_ap[-1])

#         else:

#             current_map = 0.

        current_map = 0

        save_params(net, logger, best_map, current_map, epoch, args.save_interval, args.save_prefix)

if __name__ == '__main__':

    args = parse_args()

    # fix seed for mxnet, numpy and python builtin random generator.

    gutils.random.seed(args.seed)

    # training contexts

    ctx = [mx.gpu(int(i)) for i in args.gpus.split(',') if i.strip()]

    ctx = ctx if ctx else [mx.cpu()]

    args.batch_size = len(ctx)  # 1 batch per device

    # network

    net_name = '_'.join(('faster_rcnn', args.network, args.dataset))

    args.save_prefix += net_name

    net = get_model(net_name, pretrained_base=True)

    if args.resume.strip():

        net.load_parameters(args.resume.strip())

    else:

        for param in net.collect_params().values():

            if param._data is not None:

                continue

            param.initialize()

    net.collect_params().reset_ctx(ctx)

    # training data

    train_dataset, val_dataset, eval_metric = get_dataset(args.dataset, args)

    train_data, val_data = get_dataloader(

        net, train_dataset, val_dataset, args.batch_size, args.num_workers)

    # training

    train(net, train_data, val_data, eval_metric, ctx, args)

检测部分，是在demo 下修改的，填了几个参数，可以用lst文件遍历了，用cv2画图，不用那个matplotlib了

"""Faster RCNN Demo script."""

import os

import argparse

import mxnet as mx

import gluoncv as gcv

from gluoncv.data.transforms import presets

from matplotlib import pyplot as plt

import cv2

font = cv2.FONT_HERSHEY_SIMPLEX

def parse_args():

    parser = argparse.ArgumentParser(description='Test with Faster RCNN networks.')

    parser.add_argument('--network', type=str, default='faster_rcnn_resnet50_v1b_coco',

                        help="Faster RCNN full network name")

    parser.add_argument('--images', type=str, default='',

                        help='Test images, use comma to split multiple.')

    parser.add_argument('--gpus', type=str, default='',

                        help='Training with GPUs, you can specify 1,3 for example.')

    parser.add_argument('--pretrained', type=str, default='True',

                        help='Load weights from previously saved parameters. You can specify parameter file name.')

    parser.add_argument('--thresh', type=float, default=0.5,

                        help='Threshold of object score when visualize the bboxes.')

    # add_lst

    parser.add_argument('--lst', type=str,default='',help="predict's lst file")

    args = parser.parse_args()

    return args

if __name__ == '__main__':

    args = parse_args()

    # context list

    ctx = [mx.gpu(int(i)) for i in args.gpus.split(',') if i.strip()]

    ctx = [mx.cpu()] if not ctx else ctx

    # grab some image if not specified

    if not args.images.strip() and args.lst=='':

        gcv.utils.download('https://github.com/dmlc/web-data/blob/master/' +

                           'gluoncv/detection/biking.jpg?raw=true', 'biking.jpg')

        image_list = ['biking.jpg']

    else:

        image_list = [x.strip() for x in args.images.split(',') if x.strip()]

    cnt = 0

    if args.lst!='':

        print(args.lst)

        file = open('val_front_0913.lst')

        image_list = []

        for line in file:

            line = line.split('\t')

            print('/mnt/hdfs-data-4/data/jian.yin/val_front_0913/'+line[-1][:-1])

            image_list.append('/mnt/hdfs-data-4/data/jian.yin/val_front_0913/'+line[-1][:-1])

            cnt+=1

        print 'sum of pic ',cnt

    if args.pretrained.lower() in ['true', '', 'yes', 't']:

        net = gcv.model_zoo.get_model(args.network, pretrained=True)

    else:

        net = gcv.model_zoo.get_model(args.network, pretrained=False, pretrained_base=False)

        net.load_parameters(args.pretrained)

    net.set_nms(0.3, 200)

    net.collect_params().reset_ctx(ctx = ctx)

    ax = None

    # write plt.txt

    fw = open('draw/plt.txt','w')

    dict = {}

    cnt1 = 0

    for image in image_list:

        dict['url'] = image

        bbox_list = []

        x, img = presets.rcnn.load_test(image, short=net.short, max_size=net.max_size)

        img_h = img.shape[0]

        img_w = img.shape[1]

        x = x.as_in_context(ctx[0])

        ids, scores, bboxes = [xx[0].asnumpy() for xx in net(x)]

        original_img = cv2.imread(image)

        original_img_h = original_img.shape[0]

        original_img_w = original_img.shape[1]

        for i in range(scores.shape[0]):

            if scores[i] > args.thresh:

                x1 = int(bboxes[i][0]*original_img_h/img_h)

                y1 = int(bboxes[i][1]*original_img_w/img_w)

                x2 = int(bboxes[i][2]*original_img_h/img_h)

                y2 = int(bboxes[i][3]*original_img_w/img_w)

                bbox_list.append((float(scores[i]),x1,y1,x2,y2))

        dict['bbox'] = bbox_list

        fw.write(str(dict)+'\n')

        cnt1+=1

        print 'The last ',cnt-cnt1

    fw.close()

#                 cv2.rectangle(original_img, (x1, y1), (x2, y2), (255,0,0), 3)

#                 cv2.putText(original_img,'person '+str(scores[i]),(x1,y1),font,0.5,(255,0,0),2)

#                 cv2.imwrite('draw/'+str(cnt)+'.jpg', original_img)

#         print(bboxes)

#         ax = gcv.utils.viz.plot_bbox(img, bboxes, scores, ids, thresh=args.thresh,

#                                      class_names=net.classes, ax=ax)

#         plt.savefig(str(cnt)+'predict.jpg')

#         cnt+=1

#         plt.show()

把得分情况，锚框位置都写在文件里了，不用每次跑模型来得到，想怎么都可以了。plt.py

import cv2

import os

font = cv2.FONT_HERSHEY_SIMPLEX

file = open('plt.txt')

cnt = 1

for line in file:

    dict = eval(line)

    url = dict['url']

    bbox = dict['bbox']

    img = cv2.imread(url)

    for i in range(len(bbox)):

        score = bbox[i][0]

        score = '%.2f' % score

        x1 = bbox[i][1]

        y1 = bbox[i][2]

        x2 = bbox[i][3]

        y2 = bbox[i][4]

        cv2.rectangle(img, (x1, y1), (x2, y2), (255,0,0), 3)

        cv2.putText(img,'person '+str(score),(x1,y1),font,0.5,(255,0,0),2)

    url = url.split('/')

    x_url = url[5]+'/'+url[6]+'/'+url[7]+'/'+url[8]

    if not os.path.exists(url[5]+'/'+url[6]+'/'+url[7]+'/'):

        os.makedirs(url[5]+'/'+url[6]+'/'+url[7]+'/')

    cv2.imwrite(x_url, img)

    print('The last ',6137-cnt)

    cnt+=1

gluoncv 训练自己的数据集，进行目标检测的更多相关文章

  1. 目标检测之YOLO V2 V3

    YOLO V2 YOLO V2是在YOLO的基础上,融合了其他一些网络结构的特性(比如:Faster R-CNN的Anchor,GooLeNet的\(1\times1\)卷积核等),进行的升级.其目的 ...

  2. AI佳作解读系列(五) － 目标检测二十年技术综述

    计算机视觉中的目标检测,因其在真实世界的大量应用需求,比如自动驾驶.视频监控.机器人视觉等,而被研究学者广泛关注.   上周四,arXiv新出一篇目标检测文献<Object Detection ...

  3. 目标检测：yolo-v3与faster-rcnn

    一. 算法背景 1. 机器视觉实际应用往往涉及包含多个物体的复杂场景,基于深度卷积神经网络的特征提取器,需要结合其他算法来准确定位多个目标,并进行识别. 2. 工业领域,目标检测算法在安防和质检系统都 ...

  4. Notebook交互式完成目标检测任务

    摘要:本文将介绍一种在Notebook中进行算法开发的新方式,新手也能够快速训练自己的模型. 目标检测是计算机视觉中非常常用且基础的任务,但是由于目标检测任务的复杂性,往往令新手望而却步.本文将介绍一 ...

  5. 【神经网络与深度学习】【计算机视觉】RCNN- 将CNN引入目标检测的开山之作

    转自:https://zhuanlan.zhihu.com/p/23006190?refer=xiaoleimlnote 前面一直在写传统机器学习.从本篇开始写一写 深度学习的内容. 可能需要一定的神 ...

  6. 第三十二节，使用谷歌Object Detection API进行目标检测、训练新的模型(使用VOC 2012数据集)

    前面已经介绍了几种经典的目标检测算法,光学习理论不实践的效果并不大,这里我们使用谷歌的开源框架来实现目标检测.至于为什么不去自己实现呢?主要是因为自己实现比较麻烦,而且调参比较麻烦,我们直接利用别人的 ...

  7. 目标检测算法SSD之训练自己的数据集

    目标检测算法SSD之训练自己的数据集 prerequesties 预备知识/前提条件 下载和配置了最新SSD代码 git clone https://github.com/weiliu89/caffe ...

  8. 目标检测算法SSD在window环境下GPU配置训练自己的数据集

    由于最近想试一下牛掰的目标检测算法SSD.于是乎,自己做了几千张数据(实际只有几百张,利用数据扩充算法比如镜像,噪声,切割,旋转等扩充到了几千张,其实还是很不够).于是在网上找了相关的介绍,自己处理数 ...

  9. tensorflow目标检测API之训练自己的数据集

    1.训练文件的配置 将生成的csv和record文件都放在新建的mydata文件夹下,并打开object_detection文件夹下的data文件夹,复制一个后缀为.pbtxt的文件到mtdata文件 ...

随机推荐

  1. C# 实现将listview中已经显示的数据导出到Access 数据库

    private void button1_Click(object sender, EventArgs e) { OleDbConnection dbconn = new OleDbConnectio ...

  2. SQL 之相关语法及操作符

    概述:UNION.SELECT INTO.INSERT INTO SELECT.SQL 约束. UNION操作符 UNION 操作符用于合并两个或多个 SELECT 语句的结果集. 请注意,UNION ...

  3. c#参数修饰符-out

    out 关键字通过引用传递参数. 方法定义和调用方法必须显式使用out关键字: 调用方法时参数不必初始化,方法内必须对其赋值: 参数中可以声明多个out修饰的参数. 例: public void Us ...

  4. firefox并不支持selectSingleNode和selectNodes的解决方法

    转自:http://qsrock.iteye.com/blog/209585 function test(){ var perid = document.thisForm.PerID.value; v ...

  5. Linux安装之后需要进行的一些步骤

    查看IP 首先安装后需要查看ip用SSH或者XSHELL来连接Linux,查看ip代码 ifconfig 需要执行 sudo yum install net-tools 命令安装之后 就可以看到ip了 ...

  6. 撩课-Web大前端每天5道面试题-Day13

    1.前端需要注意哪些SEO? 合理的title.description.keywords:搜索对着三项的权重逐个减小,title值强调重点即可,重要关键词出现不要超过2次,而且要靠前,不同页面titl ...

  7. 最小生成树（prim）

    里姆算法(Prim算法),图论中的一种算法,可在加权连通图里搜索最小生成树.意即由此算法搜索到的边子集所构成的树中,不但包括了连通图里的所有顶点(英语:Vertex (graph theory)),且 ...

  8. javascript中函数的写法

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  9. 【vue】混合模式

    因为工作的分配,写财务的对账部分,因为3个页面的设计和功能基本相同,都是查询筛选表格,所以用混合模式优化了部分代码.用混合把一些共用的东西抽离了出来. 具体使用方法参照文档. https://cn.v ...

  10. 通过Application存取公共数据比如登录信息等..

    Android系统在运行每一个程序应用的时候,都会创建一个Application对象,用于存储与整个应用相关的公共变量.一个Android应用只会生成一个Application对象,在不同的Activ ...