def main(): network_generators = { 'ZF': ZFGenerator } args = parse_args(network_generators.keys()) if args.cfg is not None: cfg_from_file(args.cfg) apollocaffe.set_random_seed(cfg.RNG_SEED) np.random.seed(cfg.RNG_SEED) if args.gpu_id >= 0: apollocaffe.set_device(args.gpu_id) apollocaffe.set_cpp_loglevel(3) train_roidb = None if args.train_imdb is not None: train_imdb = get_imdb(args.train_imdb) train_imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD) train_roidb = get_training_roidb(train_imdb) test_roidb = None if args.test_imdb is not None: test_imdb = get_imdb(args.test_imdb) test_imdb.set_proposal_method('gt') prepare_roidb(test_imdb) test_roidb = test_imdb.roidb faster_rcnn = FasterRCNN(args, network_generators, train_roidb=train_roidb, test_roidb=test_roidb) faster_rcnn.train() return 0
def main(args_list): args = parse_args(args_list) print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.GPU_ID = args.gpu_id print('Using config:') pprint.pprint(cfg) while not os.path.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST) net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] imdb = get_imdb(args.imdb_name) imdb.competition_mode(args.comp_mode) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) test_net(net, imdb, max_per_image=args.max_per_image, vis=args.vis)
def main(args_list): args = parse_args(args_list) print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.GPU_ID = args.GPU_ID print('Using config:') pprint.pprint(cfg) if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) print 'Setting GPU device %d for training' % cfg.GPU_ID caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) imdb, roidb = combined_roidb(args.imdb_name) print '{:d} roidb entries'.format(len(roidb)) output_dir = get_output_dir(imdb) print 'Output will be saved to `{:s}`'.format(output_dir) train_net(args.solver, roidb, output_dir, pretrained_model=args.pretrained_model, max_iters=args.max_iters)
def __init__(self, _yaml_file=None, _gpu_id=None): assert(_yaml_file) self.yaml_file = _yaml_file self.mean_value = np.zeros((1, 1, 3)).astype(np.float32) self.mean_value[0,0,0] = 102.9801 self.mean_value[0,0,1] = 115.9465 self.mean_value[0,0,2] = 122.7717 if _gpu_id == None: self.use_gpu = False self.gpu_id = -1 else: self.use_gpu = True self.gpu_id = _gpu_id cfg_from_file(self.yaml_file) cfg.USE_GPU= self.use_gpu cfg.GPU_ID = self.gpu_id """ cfg.CLASSES = ('__background__', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor') """ """ cfg.CLASSES = ('__background__', # always index 0 'pant', 'leggings/stocking', 'hat/cap', 'shoe', 'blouse', 'jumper', 'panty', 'knit', 'swimsuit', 'shirt', 'coat', 'one-piece', 'tshirt', 'cardigan', 'skirt', 'jacket') """ cfg.CLASSES = ('__background__', # always index 0 'bag', 'bra', 'jacket_coat', 'onepiece', 'pants', 'panty', 'shoes', 'skirt', 'swimwear', 'tshirts_shirts_blouse_hoody', 'vest', 'knit_cardigan') """
def main(): parser = argparse.ArgumentParser("Traing ALISC Clasification Network") parser.add_argument('--network_type', help='VGG16 or ZF', required=True) parser.add_argument('--model', help="Pretrained Model, could be empty") parser.add_argument('--gpu', help="GPU ID to use for training", default=0) c = vars(parser.parse_args()) network_type = c['network_type'] print("Loading Configuration File...") cfg = cfg_from_file(osp.join( ROOT_DIR, 'experiments', 'cfgs', 'alisc_classification.yml')) solver_fn = osp.join( ROOT_DIR, 'models', 'alisc', network_type, 'solver.pt') caffe.set_mode_gpu() caffe.set_device(int(c['gpu'])) solver = caffe.SGDSolver(solver_fn) if c['model']: weights_fn = c['model'] else: weights_fn = osp.join( ROOT_DIR, 'data', 'faster_rcnn_models', '{}_faster_rcnn_final.caffemodel'.format(network_type)) if not osp.exists(weights_fn): print("Pretrained Model {} does not exists".format(weights_fn)) raise print("Loading pretrained model from {}".format(weights_fn)) solver.net.copy_from(weights_fn) if DEBUG: code.interact(local=locals()) print('Start Solving...') solver.solve()
def main(): args = parse_args() print('Called with args:') print(args) cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) netdir,net_name = os.path.split(args.net) # -------------------------------------------------------------------------- # Pycaffe doesn't reliably free GPU memory when instantiated nets are # discarded (e.g. "del net" in Python code). To work around this issue, each # training stage is executed in a separate process using # multiprocessing.Process. # -------------------------------------------------------------------------- # queue for communicated results between processes mp_queue = mp.Queue() # solves, iters, etc. for each training stage solvers, max_iters, rpn_test_prototxt = get_solvers(args.net) print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 RPN, init from ImageNet model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' cfg.TRAIN.SNAPSHOT_INFIX = 'stage1' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, init_model=args.pretrained_model, solver=solvers[0], max_iters=max_iters[0], cfg=cfg) p = mp.Process(target=train_rpn, kwargs=mp_kwargs) p.start() rpn_stage1_out = mp_queue.get() p.join() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 RPN, generate proposals' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, rpn_model_path=str(rpn_stage1_out['model_path']), cfg=cfg, rpn_test_prototxt=rpn_test_prototxt) p = mp.Process(target=rpn_generate, kwargs=mp_kwargs) p.start() rpn_stage1_out['proposal_path'] = mp_queue.get()['proposal_path'] p.join() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 Fast R-CNN using RPN proposals, init from ImageNet model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' cfg.TRAIN.SNAPSHOT_INFIX = 'stage1' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, init_model=args.pretrained_model, solver=solvers[1], max_iters=max_iters[1], cfg=cfg, rpn_file=rpn_stage1_out['proposal_path']) p = mp.Process(target=train_fast_rcnn, kwargs=mp_kwargs) p.start() fast_rcnn_stage1_out = mp_queue.get() p.join() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 2 RPN, init from stage 1 Fast R-CNN model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' cfg.TRAIN.SNAPSHOT_INFIX = 'stage2' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, init_model=str(fast_rcnn_stage1_out['model_path']), solver=solvers[2], max_iters=max_iters[2], cfg=cfg) p = mp.Process(target=train_rpn, kwargs=mp_kwargs) p.start() rpn_stage2_out = mp_queue.get() p.join() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 2 RPN, generate proposals' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, rpn_model_path=str(rpn_stage2_out['model_path']), cfg=cfg, rpn_test_prototxt=rpn_test_prototxt) p = mp.Process(target=rpn_generate, kwargs=mp_kwargs) p.start() rpn_stage2_out['proposal_path'] = mp_queue.get()['proposal_path'] p.join() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 2 Fast R-CNN, init from stage 2 RPN R-CNN model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' cfg.TRAIN.SNAPSHOT_INFIX = 'stage2' mp_kwargs = dict( queue=mp_queue, imdb_name=args.imdb_name, init_model=str(rpn_stage2_out['model_path']), solver=solvers[3], max_iters=max_iters[3], cfg=cfg, rpn_file=rpn_stage2_out['proposal_path']) p = mp.Process(target=train_fast_rcnn, kwargs=mp_kwargs) p.start() fast_rcnn_stage2_out = mp_queue.get() p.join() # Create final model (just a copy of the last stage) final_path = os.path.join( os.path.dirname(fast_rcnn_stage2_out['model_path']), net_name + '_faster_rcnn_final.caffemodel') print 'cp {} -> {}'.format( fast_rcnn_stage2_out['model_path'], final_path) shutil.copy(fast_rcnn_stage2_out['model_path'], final_path) print 'Final model: {}'.format(final_path)
textdetector = TextDetector() boxes = textdetector.detect(boxes, scores[:, np.newaxis], img.shape[:2]) draw_boxes(img, image_name, boxes, scale) timer.toc() print(('Detection took {:.3f}s for ' '{:d} object proposals').format(timer.total_time, boxes.shape[0])) if __name__ == '__main__': if os.path.exists("data/results/"): shutil.rmtree("data/results/") os.makedirs("data/results/") cfg_from_file('ctpn/text.yml') # init session print ('Begin') config = tf.ConfigProto(allow_soft_placement=True) sess = tf.Session(config=config) print ('aaaaaaaaaaaaa') # load network net = get_network("VGGnet_test") print ('bbbbbbbbbbbbb') # load model print(('Loading network {:s}... '.format("VGGnet_test")), end=' ') saver = tf.train.Saver() try: ckpt = tf.train.get_checkpoint_state(cfg.TEST.checkpoints_path)
(i[2] - i[0]) / im_scale, (i[3] - i[1]) / im_scale, scores[id])) return [i + '\n' for i in lines] if __name__ == '__main__': args = parse_args() caffemodel = caffe_model_dir if not os.path.isfile(caffemodel): raise IOError(('{:s} not found.').format(caffemodel)) if cfg_file is not None: cfg_from_file(os.path.join(cfg.ROOT_DIR, cfg_file)) cfg.GPU_ID = args.gpu_id if cpu: caffe.set_mode_cpu() else: caffe.set_mode_gpu() caffe.set_device(args.gpu_id) cfg.GPU_ID = args.gpu_id print prototxt net = caffe.Net(prototxt, caffemodel, caffe.TEST) print '\n\nLoaded network {:s}'.format(caffemodel) fold_num=0
# set up caffe caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) if __name__ == '__main__': print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 Fast R-CNN using RPN proposals, init from ImageNet model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' os.chdir(_init_paths.faster_rcnn_root) args = parse_args() scenario = Scenario().load(args.scenario_file) if scenario.config_path is not None: print 'loading config from ', scenario.config_path cfg_from_file(scenario.config_path) cfg.GPU_ID = scenario.gpu_id cfg.TRAIN.SNAPSHOT_INFIX = 'stage1' _init_caffe(cfg) output_dir = os.path.join(scenario.scen_dir, 'output') dir_exists_or_create(output_dir) train_fast_rcnn(imdb_name=scenario.train_imdb, init_model=args.weights, solver=scenario.models['stage1_fast_rcnn_solver'], cfg=cfg, rpn_file=args.roi_pkl, output_dir=output_dir, max_iters=scenario.max_iters[1])
print 'Please the config file for training! (--cfg)' sys.exit() # load trainging config file train_cfg = parse_cfg_file(args.cfg_file) print('Using config:') pprint.pprint(train_cfg) # set conf if train_cfg.common.rpn_cfg: rpn_config.cfg_from_file(train_cfg.common.rpn_cfg) print('RPN using config:') pprint.pprint(rpn_config.cfg) if train_cfg.common.fast_rcnn_cfg: fast_rcnn_config.cfg_from_file(train_cfg.common.fast_rcnn_cfg) print('Fast-RCNN using config:') pprint.pprint(fast_rcnn_config.cfg) # set up caffe if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(rpn_config.cfg.RNG_SEED) caffe.set_random_seed(rpn_config.cfg.RNG_SEED) if args.cpu_mode: caffe.set_mode_cpu() else: caffe.set_mode_gpu() caffe.set_device(args.gpu_id)
dropout_lstm=_CONFIG['dropout_lstm'], dropout_word_embedding=_CONFIG['dropout_word_embedding'], l2_weight=_CONFIG['l2_weight'], block_unnecessary_tokens=_CONFIG['block_unnecessary_tokens'], device=_CONFIG['device']) if _CONFIG['load_path_cg'] is not None: print("Starting from PATH", _CONFIG['load_path_cg']) cg.load(checkpoint_path=_CONFIG['load_path_cg'], load_optimizer=_CONFIG['load_cg_optimizer']) return cg if __name__ == '__main__': _CONFIG = parse_parameters(sys.argv[1:]) # Load the Bottom-Up net cfg_from_file(_CONFIG['bunet_config_path']) bunet = BottomUp() bunet.load_net(layout_path=_CONFIG['bunet_layout_path'], weights_path=_CONFIG['bunet_weights_path'], device=_CONFIG['device']) batch = bunet.preprocess_inputs(examples_dir=_CONFIG['examples_dir']) cg = _create_caption_generator() cg.set_mode(mode='inference') generate_captions(caption_generator=cg, batch=batch)
def test(args=None): parser = argparse.ArgumentParser(description='Simple testing script.') parser.add_argument('--net_final', help='the pretrained model', type=str, default='../output/faster_rcnn_end2end/voc_2007_trainval+voc_2012_trainval/VGGnet_wt_context/VGGnet_wt_context.ckpt') parser.add_argument('--net_name', help='net_name', type=str, default="VGGnet") parser.add_argument('--test_set', help='train set', type=str, default="voc_2007_test") parser = parser.parse_args(args) test_data = parser.test_set net_name = parser.net_name net_final = parser.net_final # get dataset extra_config = "../experiments/cfgs/faster_rcnn_end2end.yml" cfg_from_file(extra_config) imdb = get_imdb(test_data) imdb.competition_mode(True) # use_salt: False; cleanup: False weights_filename = os.path.splitext(os.path.basename(net_final))[0] output_dir = get_output_dir(imdb,weights_filename) # start a session net = get_network(net_name+"_test") saver = tf.train.Saver() config = tf.ConfigProto(allow_soft_placement=True) sess = tf.Session(config=config) saver.restore(sess, net_final) print('Loading model weights from {:s}'.format(net_final)) fetch_list = [net.get_output('cls_prob'), net.get_output('bbox_pred'), net.get_output('rois')] assert len(cfg.TEST.SCALES) == 1 target_size = cfg.TEST.SCALES[0] max_per_image = 300 thresh = 0.05 num_images = len(imdb.image_index) all_boxes = [[[] for _ in xrange(num_images)] for _ in xrange(imdb.num_classes)] # all detections are collected into: # all_boxes[cls][image] = N*5 (x1,y1,x2,y2,score) _t = {'im_detect':Timer(), 'misc':Timer()} for i in xrange(num_images): im_cv = cv2.imread(imdb.image_path_at(i)) im = im_cv.astype(np.float32, copy=True) im -= cfg.PIXEL_MEANS im_size_min = np.min(im.shape[0:2]) im_size_max = np.max(im.shape[0:2]) im_scale = min([float(target_size) / im_size_min, float(cfg.TEST.MAX_SIZE) / im_size_max]) # the biggest axis should not be more than MAX_SIZE im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) im_info = np.array([im.shape[0],im.shape[1],im_scale], dtype=np.float32) _t['im_detect'].tic() feed_dict = {net.data: np.expand_dims(im, axis=0), net.im_info: np.expand_dims(im_info, axis=0), #net.keep_prob: 1.0} net.appearance_drop_rate: 0.0000000001} cls_prob, box_deltas, rois = sess.run(fetch_list, feed_dict=feed_dict) scores = cls_prob boxes = rois[:,1:5] / im_scale # scale first?? boxes = bbox_transform_inv(boxes, box_deltas) boxes = clip_boxes(boxes, im_cv.shape) _t['im_detect'].toc() _t['misc'].tic() # skip j = 0, since it is the background class for j in xrange(1, imdb.num_classes): inds = np.where(scores[:,j] > thresh)[0] # which boxes has object belongs to class j cls_scores = scores[inds,j] # [num_box] cls_boxes = boxes[inds,j*4:(j+1)*4] # [num_box,4] cls_dets = np.hstack( (cls_boxes, cls_scores[:,np.newaxis])) \ .astype(np.float32, copy=False) #[num_box, 4 + score] keep = nms(cls_dets, cfg.TEST.NMS) cls_dets = cls_dets[keep,:] all_boxes[j][i] = cls_dets # j class, exists on image i, and have one or more boxes # limt to max_per_image detection *over all classes* image_scores = np.hstack([all_boxes[j][i][:,-1] for j in xrange(1, imdb.num_classes)]) if len(image_scores) > max_per_image: image_thresh = np.sort(image_scores)[-max_per_image] for j in xrange(1, imdb.num_classes): keep = np.where(all_boxes[j][i][:,-1] >= image_thresh)[0] all_boxes[j][i] = all_boxes[j][i][keep,:] _t['misc'].toc() print('im_detect: {:d}/{:d} {:.3f}s {:.3f}s'\ .format(i+1, num_images, _t['im_detect'].average_time, _t['misc'].average_time)) det_file = os.path.join(output_dir, "detections.pkl") with open(det_file, 'wb') as f: cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL) print 'Evaluating detections' imdb.evaluate_detections(all_boxes, output_dir) print(net_final)
return roidb roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) imdb = datasets.imdb.imdb(imdb_names) else: imdb = get_imdb(imdb_names) return imdb, roidb if __name__ == '__main__': if CFG_FILE is not None: cfg_from_file(CFG_FILE) if SET_CFGS is not None: cfg_from_list(SET_CFGS) print('Using config:') pprint.pprint(cfg) if not RANDOMIZE: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) # set up caffe caffe.set_mode_cpu() imdb, roidb = combined_roidb(IMDB_NAME)
def train(args=None): parser = argparse.ArgumentParser(description='Simple training script.') parser.add_argument('--net_name', help='net_name', type=str, default="VGGnet_wo_context") parser.add_argument('--train_set', help='train set', type=str, default="voc_2007_trainval+voc_2012_trainval") parser.add_argument('--net_pretrained', help='the pretrained model', type=str, default='../data/pretrain_model/VGG_imagenet.npy') parser.add_argument( '--iter_start', help='skip the first few iterations, relates to checkpoint', type=int, default=0) parser.add_argument('--max_iters', help='max number of iterations to run', type=int, default=350000) parser = parser.parse_args(args) train_set = parser.train_set net_name = parser.net_name net_pretrained = parser.net_pretrained iter_start = parser.iter_start max_iters = parser.max_iters # some configuration extra_config = "../experiments/cfgs/faster_rcnn_end2end.yml" cfg_from_file(extra_config) np.random.seed(cfg.RNG_SEED) print("[preparing the dataset...]") cache_path = './db_cache/' + train_set if not os.path.exists(cache_path): os.makedirs(cache_path) cache_file_1 = os.path.join(cache_path, 'roidb.pkl') if os.path.exists(cache_file_1): with open(cache_file_1, 'rb') as fid: roidb = cPickle.load(fid) print 'roidb loaded from {}'.format(cache_file_1) imdb = datasets.imdb(train_set) else: imdb, roidb = combined_roidb(train_set) """ each entry rois[index] = {image: image_path, width: scaler height: scaler boxes: [num_box, 4], absolute pixel, 0-based ! no background boxes gt_classes: [num_box], the ground-truth class for each box gt_overlaps: [num_box, num_class] one-hot verson of gt_classes flipped: True/False max_classes: exactly the gt_class [num_box] why we have this? max_overlaps: all one vector [num_box] why we have this? } """ roidb = filter_roidb(roidb) with open(cache_file_1, 'wb') as fid: cPickle.dump(roidb, fid, cPickle.HIGHEST_PROTOCOL) print 'wrote roidb to {}'.format(cache_file_1) if 'coco' in train_set: num_classes = 81 elif 'voc' in train_set: num_classes = 21 if cfg.TRAIN.BBOX_REG: # calculate roidb.roidb[im_id].['bbox_target'] [label, tx, ty, tw, th] # calculate mean and std, and apply on (tx, ty, tw, th) print(" computing bounding-box regression targets ...") bbox_means, bbox_stds = add_bbox_regression_targets(roidb) print("Done") data_layer = get_data_layer(roidb, num_classes) # for db+db, num_class=0! # a layer used to get next mini batch print("[build the graph...]") net = get_network(net_name + "_train") # chang n_classes at VGGnet_train.py saver = tf.train.Saver(max_to_keep=10, write_version=saver_pb2.SaverDef.V2) rpn_cls_loss = get_rpn_cls_loss(net) rpn_box_loss = get_rpn_box_loss(net) RCNN_cls_loss = get_RCNN_cls_loss(net) RCNN_box_loss = get_RCNN_box_loss(net) loss = rpn_cls_loss + rpn_box_loss + RCNN_cls_loss + RCNN_box_loss global_step = tf.Variable(iter_start, trainable=False) lr = tf.train.exponential_decay(cfg.TRAIN.LEARNING_RATE, global_step, cfg.TRAIN.STEPSIZE, 0.1, staircase=True) # /2 change momentum = cfg.TRAIN.MOMENTUM optimizer = tf.train.MomentumOptimizer(lr, momentum) train_op = optimizer.minimize(loss, global_step=global_step) fetch_list = [ lr, rpn_cls_loss, rpn_box_loss, RCNN_cls_loss, RCNN_box_loss, train_op ] gvs = optimizer.compute_gradients(loss) summary_op = summary(gvs, loss, RCNN_cls_loss, RCNN_box_loss, rpn_cls_loss, rpn_box_loss) print("trainable variables are:") for var in tf.trainable_variables(): print(var) print("[build the session and set model&summary save helper]") config = tf.ConfigProto(allow_soft_placement=True) sess = tf.Session(config=config) output_dir = get_output_dir(imdb, net_name) tb_dir = get_output_tb_dir(imdb, net_name) train_writer = tf.summary.FileWriter(tb_dir, sess.graph) print("[initalize the graph paremater & restore from pre-trained file") sess.run(tf.global_variables_initializer()) if net_pretrained is not None: print( 'loding pretrained model weights from {:s}'.format(net_pretrained)) try: net.load(net_pretrained, sess, saver, True) except: optimistic_restore(sess, net_pretrained) """ print("variables in the pretrained file are:") print_tensors_in_checkpoint_file(file_name=net_pretrained, tensor_name='', all_tensors = False, all_tensor_names = True) #saver.restore(sess, net_pretrained) """ for iter in xrange(iter_start, max_iters): try: blobs = data_layer.forward() feed_dict = { net.data: blobs['data'], # [num_image, max_height, max_width, 3] net.im_info: blobs['im_info'], # [height, width, im_scale] net.gt_boxes: blobs['gt_boxes'] } # [x1, y1, x2, y2, cls] if (iter + 1) % 1000 == 0: summary_w = sess.run(summary_op, feed_dict) train_writer.add_summary(summary_w, iter) filename = (net_name + '_iter_{:d}'.format(iter + 1) + '.ckpt') filename = os.path.join(output_dir, filename) snapshot(sess, saver, filename, net, bbox_means, bbox_stds) print("Wrote snapshot to: {:s}".format(filename)) cur_lr, rpn_cls_loss_value, rpn_box_loss_value, RCNN_cls_loss_value, RCNN_box_loss_value, _ = \ sess.run(fetch_list, feed_dict=feed_dict) total_loss = rpn_cls_loss_value + rpn_box_loss_value + RCNN_cls_loss_value + RCNN_box_loss_value if (iter + 1) % cfg.TRAIN.DISPLAY == 0: print(('iter %d/%d with lr %.6f: total loss is %.4f. (rpn_cls_loss: %.4f, rpn_box_loss: %.4f, ' + 'RCNN_cls_loss: %.4f, RCNN_box_loss: %.4f)') % (iter + 1, max_iters, cur_lr, total_loss, \ rpn_cls_loss_value, rpn_box_loss_value, RCNN_cls_loss_value, RCNN_box_loss_value)) except: # ZeroDivisionError as err: # print('Handling run-time error:', err) print('ignore current iteration')
args = parser.parse_args() return args if __name__ == '__main__': cfg.TEST.HAS_RPN = True # Use RPN for proposals args = parse_args() import glob cfg_file = glob.glob('*.yml') assert len(cfg_file) == 1, 'Too many .cfg files.' cfg_from_file(cfg_file[0]) CLASSES = cfg.CLASSES print 'Classes: ', CLASSES prototxt = args.demo_net caffemodels = glob.glob('snapshots/*.caffemodel') import re try: caffemodel = [ model for model in caffemodels if int(re.search('iter_(\d+).caffemodel', model).group(1)) == args.demo_iter ]
def load_net(cfg_file, net_pt, net_weight): cfg_from_file(cfg_file) net = caffe.Net(net_pt, net_weight, caffe.TEST) return net
def main(params): sys.path.insert(0, os.path.join(params.bottomup_path, 'lib')) from fast_rcnn.config import cfg, cfg_from_file from fast_rcnn.test import im_detect, _get_blobs from fast_rcnn.nms_wrapper import nms ########################### # CNN : Faster-RCNN setting data_path = os.path.join(params.bottomup_path, 'data/genome/1600-400-20') # Load classes classes = ['__background__'] with open(os.path.join(data_path, 'objects_vocab.txt')) as f: for object in f.readlines(): classes.append(object.split(',')[0].lower().strip()) # Load attributes attributes = ['__no_attribute__'] with open(os.path.join(data_path, 'attributes_vocab.txt')) as f: for att in f.readlines(): attributes.append(att.split(',')[0].lower().strip()) GPU_ID = params.gpu_id # if we have multiple GPUs, pick one caffe.init_log() caffe.set_device(GPU_ID) caffe.set_mode_gpu() net = None cfg_from_file( os.path.join(params.bottomup_path, 'experiments/cfgs/faster_rcnn_end2end_resnet.yml')) weights = os.path.join( params.bottomup_path, 'data/faster_rcnn_models/resnet101_faster_rcnn_final.caffemodel') prototxt = os.path.join( params.bottomup_path, 'models/vg/ResNet-101/faster_rcnn_end2end_final/test.prototxt') net = caffe.Net(prototxt, caffe.TEST, weights=weights) conf_thresh = 0.4 min_boxes = params.num_objects max_boxes = params.num_objects ########################### ########################### # RNN : Caption generation setting # load json file label_info = json.load(open(params.input_labels)) word_to_idx = label_info['word_to_idx'] # load h5 file caps_info = h5py.File(params.input_caps, 'r', driver='core') seq_length = caps_info['labels'].shape[1] # GPU options config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth = True # build a graph to sample captions graph_gen_cap = tf.Graph() sess_gen_cap = tf.Session(graph=graph_gen_cap, config=config) with graph_gen_cap.as_default(): model = CaptionGenerator(word_to_idx, num_features=params.num_objects, dim_feature=params.dim_features, dim_embed=params.dim_word_emb, dim_hidden=params.rnn_hid_size, dim_attention=params.att_hid_size, n_time_step=seq_length - 1) alphas, sampled_captions = model.build_sampler(max_len=params.max_len) saver1 = tf.train.Saver() saver1.restore(sess_gen_cap, params.test_model) tf.reset_default_graph() ############################ ########################### # Face : Replacer name_replacer = NameReplacer(model.idx_to_word, params.score_thr) ############################ ########################### # Run Image Captioning with face detection while True: full_fname = raw_input("Enter the image path and name:") if full_fname == 'Exit': break if not os.path.exists(full_fname): print("Not Exist File : {}".format(full_fname)) continue ########################### # Object Detection im = cv2.imread(full_fname) scores, boxes, attr_scores, rel_scores = im_detect(net, im) # Keep the original boxes, don't worry about the regression bbox outputs rois = net.blobs['rois'].data.copy() # unscale back to raw image space blobs, im_scales = _get_blobs(im, None) cls_boxes = rois[:, 1:5] / im_scales[0] cls_prob = net.blobs['cls_prob'].data attr_prob = net.blobs['attr_prob'].data pool5 = net.blobs['pool5_flat'].data # Keep only the best detections max_conf = np.zeros((rois.shape[0])) for cls_ind in range(1, cls_prob.shape[1]): cls_scores = scores[:, cls_ind] dets = np.hstack( (cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32) keep = np.array(nms(dets, cfg.TEST.NMS)) max_conf[keep] = np.where(cls_scores[keep] > max_conf[keep], cls_scores[keep], max_conf[keep]) keep_boxes = np.where(max_conf >= conf_thresh)[0] if len(keep_boxes) < min_boxes: keep_boxes = np.argsort(max_conf)[::-1][:min_boxes] elif len(keep_boxes) > max_boxes: keep_boxes = np.argsort(max_conf)[::-1][:max_boxes] feats = pool5[keep_boxes] ############################ ########################### # Caption generation using CNN features feed_dict = {model.features: [feats]} alps, sam_cap = sess_gen_cap.run([alphas, sampled_captions], feed_dict) decoded = decode_captions(sam_cap, model.idx_to_word) ############################ ########################### # Name replacer name_list, conf_list, roi_list = vtt_face_recognize( full_fname, params.url, params.post_data) replace_decoded, words = name_replacer.name_replace_caps( sam_cap, alps, cls_boxes, name_list, conf_list, roi_list) print("Original caption : %s" % decoded[0]) print("Replaced caption : %s" % replace_decoded[0]) ############################ ########################### # Showing img = skimage.io.imread(full_fname) img = skimage.img_as_float(img) boxes = cls_boxes[keep_boxes] boxes = boxes.astype(int) # draw attention map fig = plt.figure(figsize=(16, 8)) ax = fig.add_subplot(3, 6, 1) ax.imshow(img) plt.axis('off') # Plot images with attention weights words = words[0] for t in range(len(words)): if t > 16: break if words[t] == '<BLANK>': continue alphamap = np.zeros((img.shape[0], img.shape[1])) for b in range(boxes.shape[0]): alphamap[boxes[b, 1]:boxes[b, 3], boxes[b, 0]:boxes[b, 2]] += alps[0, t, b] max_idx = np.argmax(alps[0, t, :]) att_img = np.dstack((img, alphamap)) ax = fig.add_subplot(3, 6, t + 2) plt.text(0, 1, '%s' % (words[t]), color='black', backgroundcolor='white', fontsize=8) ax.imshow(att_img) ax.add_patch( patches.Rectangle((boxes[max_idx, 0], boxes[max_idx, 1]), boxes[max_idx, 2] - boxes[max_idx, 0], boxes[max_idx, 3] - boxes[max_idx, 1], linewidth=1, edgecolor='r', facecolor='none')) plt.axis('off') fig.tight_layout() plt.show()
def get_p_set(im_set, im_list, save_dir, attack_type='miscls', net_name="VGGnet_wo_context"): if not os.path.isdir(save_dir): os.makedirs(save_dir) if attack_type == 'appear': perturbation_name = '/'.join([ save_dir, 'im{:d}_box({:1.0f}-{:1.0f}-{:1.0f}-{:1.0f})_iou{:1.3f}_t{:d}' ]) else: perturbation_name = '/'.join([save_dir, 'im{:d}_box{:d}_f{:d}_t{:d}']) # some configuration extra_config = "../experiments/cfgs/faster_rcnn_end2end.yml" cfg_from_file(extra_config) # prepare data imdb = prepare_dataset(im_set, cfg) # prepare graph and sess sess, net, grad = build_digital_adv_graph(net_name, im_set) num_images = len(im_list) _t = Timer() for idx, i in enumerate(im_list): im_cv, im, im_info, gt_boxes = get_image_prepared(cfg, imdb.roidb[idx]) num_gt_boxes = len(gt_boxes) _t.tic() for box_id in range(num_gt_boxes): valid = is_valid_wo_context( im_cv, im, im_info, gt_boxes[box_id], f_id=int(gt_boxes[box_id][-1])) # changed here if not valid: break if not valid: print( "ignore the image since at least one object is not detected correctly" ) continue if attack_type == 'appear': ori_gt_boxes = gt_boxes new_gt_boxes, iou_list = generate_appear_box( im_info, gt_boxes) # (x1, y1, x2, y2, gt_cls=0) num_iter = len(new_gt_boxes) else: num_iter = num_gt_boxes for box_id in range(num_iter): new_box_id = box_id if attack_type == 'appear': box_id = -1 gt_boxes = np.concatenate([ ori_gt_boxes, np.expand_dims(new_gt_boxes[new_box_id], axis=0) ]) gt_cls = int(gt_boxes[box_id, -1]) gt_cls_name = imdb._classes[gt_cls] for target_cls, target_cls_name in enumerate(imdb._classes): if attack_type == 'hiding' and target_cls != 0: continue elif target_cls == int(gt_boxes[box_id, -1]): continue elif attack_type != 'hiding' and target_cls == 0: continue mask = create_mask(im_info[:2], gt_boxes[box_id, :4]) original_id = gt_boxes[box_id, -1] gt_boxes[box_id, -1] = target_cls p = get_p_box_IFGSM(net, im_cv, im, im_info, gt_boxes, original_id, box_id, mask, sess, grad) # p = get_p_box_FGSM(net,im_cv, im, im_info, gt_boxes, original_id, box_id, mask, sess, grad) gt_boxes[box_id, -1] = gt_cls if p is not None: if attack_type == 'appear': save_name = perturbation_name.format( i, gt_boxes[box_id, 0], gt_boxes[box_id, 1], gt_boxes[box_id, 2], gt_boxes[box_id, 3], iou_list[box_id], target_cls) else: save_name = perturbation_name.format( i, box_id, gt_cls, target_cls) p = np.int32(p) block_matrix.save(save_name, p, im_info[:2], gt_boxes[box_id, :4]) print("{:s} --> {:s} succeed." \ .format(gt_cls_name, imdb._classes[target_cls])) else: print("{:s} --> {:s} failed." \ .format(gt_cls_name, imdb._classes[target_cls])) _t.toc() print('perturbation_generation: {:d}/{:d} {:.3f}s' \ .format(idx + 1, num_images, _t.average_time))
attributes = ['__no_attribute__'] with open(os.path.join(data_path, 'attributes_vocab.txt')) as f: for att in f.readlines(): attributes.append(att.split(',')[0].lower().strip()) # Check object extraction from fast_rcnn.config import cfg, cfg_from_file from fast_rcnn.test import im_detect, _get_blobs from fast_rcnn.nms_wrapper import nms import cv2 GPU_ID = 0 # if we have multiple GPUs, pick one caffe.set_device(GPU_ID) caffe.set_mode_gpu() net = None cfg_from_file('experiments/cfgs/faster_rcnn_end2end_resnet.yml') weights = 'data/faster_rcnn_models/resnet101_faster_rcnn_final.caffemodel' prototxt = 'models/vg/ResNet-101/faster_rcnn_end2end_final/test.prototxt' net = caffe.Net(prototxt, caffe.TEST, weights=weights) conf_thresh = 0.4 min_boxes = 16 max_boxes = 16 data_dir = '../data/test' data_classes = ['test'] save_dir = data_dir + '_new_attentions' #im_file = 'data/group/pos_34.jpg'
dest='cfg_path', help='config file to use for demo', default='../experiments/cfgs/faster_rcnn_end2end.yml') args = parser.parse_args() return args if __name__ == '__main__': cfg.TEST.HAS_RPN = True # Use RPN for proposals args = parse_args() # Load config file cfg_from_file(args.cfg_path) # Load category IDs from the config file category_ids = cfg.TRAIN.CAT_IDS # Amount of random test images per category sample_img_count = 3 # list up all classes that you want the demo run on. Do not forget to include __background__ as additional class. # If you do not know the correct string of your categories, check data/MSCOCO_API_categories.py or better # use create_class_tuple() from tools/customToolbox.py # CLASSES = ('__background__', 'person', 'car', 'dog', 'horse') CLASSES = customToolbox.create_class_tuple(category_ids) print "Classes: " + str(CLASSES)
parser.add_argument("--snapshot_dir", help="caffe model params file", type=str) parser.add_argument("--save_dir", help="location to save weight files", type=str) args = parser.parse_args() os.chdir(args.snapshot_dir) if not osp.exists(args.save_dir): os.makedirs(args.save_dir) # Objects for logging solver training _train_loss = [] _weight_params = {} start = args.start stop = args.stop timestr = 'snaps_{0}_{1}'.format(start, stop) cfg_from_file('/ltmp/gustavo-2951t/dd_cv/py-faster-rcnn/experiments/cfgs/faster_rcnn_end2end.yml') if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and cfg.TRAIN.BBOX_NORMALIZE_TARGETS): # RPN can only use precomputed normalization because there are n # fixed statistics to compute a priori assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED import numpy as np import matplotlib.pyplot as plt imdb, roidb = combined_roidb('voc_2007_test') for itt in range(start, stop+1, args.iter): # TODO: change this to the name of your default solver file and shapshot file if(cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
def getDetectionData(self, modelName, prototxtName, cls_order, cls_mapper, gpu_id, testSets, datasetName="openImages_v4"): imgIdx = [] GT = [] CLASSES = self.processClass(cls_order, cls_mapper) name = "eval" for target in testSets: dataset = openImageData(name, cls_order, cls_mapper, sets=target) for i in dataset._image_index: target_img = "/root/data/data-{}/{}/{}.jpg".format( datasetName, target, i) imgIdx += [target_img] label = dataset._load_boxes(i)['gt_classes'] bbox = dataset._load_boxes(i)['boxes'] for j, k in zip(label, bbox): GT.append( ([target_img, k[0], k[1], k[2], k[3], CLASSES[j]])) GTdata = {} gtCounterPerCls = {} for re in GT: if gtCounterPerCls.has_key(re[5]): gtCounterPerCls[re[5]] += 1 else: gtCounterPerCls[re[5]] = 1 hit = {"label": re[5], "bbox": [x for x in re[1:5]], "used": False} if GTdata.has_key(re[0]): GTdata.get(re[0]).append(hit) else: GTdata[re[0]] = [] GTdata.get(re[0]).append(hit) weightPath = modelName #"/root/pva-faster-rcnn/models/output/{}/{}_iter_{}.caffemodel".format(modelName,modelName,str(iteration)) modelPath = prototxtName #"/root/pva-faster-rcnn/models/pvanet/lite/{}_test.prototxt".format(modelName) print weightPath print modelPath caffe.set_mode_gpu() caffe.set_device(gpu_id) cfg_from_file("models/pvanet/cfgs/submit_0716.yml") cfg.GPU_ID = gpu_id det = {} totalImg = len(imgIdx) if not os.path.isfile(weightPath): raise IOError(('Caffemodel: {:s} not found').format(weightPath)) net = caffe.Net(modelPath, weightPath, caffe.TEST) print '\n\nLoaded network {:s}'.format(modelPath) print "Total testing images: {}".format(len(imgIdx)) for idx, targetImg in enumerate(imgIdx): timer = Timer() timer.tic() _t = { 'im_preproc': Timer(), 'im_net': Timer(), 'im_postproc': Timer(), 'misc': Timer() } res = self.detect(CLASSES, net, targetImg, 15) timer.toc() print "Processing: {}/{},time usage is {:.3f}s".format( idx, totalImg, timer.average_time) for re in res: hit = { "confidence": re[5], "fileName": re[0], "bbox": [x for x in re[1:5]] } if det.has_key(re[6]): det.get(re[6]).append(hit) else: det[re[6]] = [] det.get(re[6]).append(hit) for i in CLASSES: if det.has_key(i) == False: det[i] = [] return det, GTdata, gtCounterPerCls
import time, os, sys, pprint, cPickle from unrealcv import unrealcv __sets = dict() for el in range(0, 61, 30): for az in range(90, 271, 45): __sets['unrealcv_%d_%d' % (el, az)] = (lambda el=el, az=az: unrealcv('RealisticRendering', '%d_%d' % (el, az))) def get_imdb(name): """Get an imdb (image database) by name.""" if not __sets.has_key(name): raise KeyError('Unknown dataset: {}'.format(name)) return __sets[name]() cfg_file = '../experiments/cfgs/faster_rcnn_alt_opt.yml' cfg_from_file(cfg_file) cfg.GPU_ID = 0 max_per_image = 100 print('Using config:') pprint.pprint(cfg) caffemodel = '../data/faster_rcnn_models/VGG16_faster_rcnn_final.caffemodel' wait = 1 while not os.path.exists(caffemodel) and wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10)
parser.add_argument('--cpu', dest='cpu_mode', help='Use CPU mode (overrides --gpu)', action='store_true') args = parser.parse_args() return args if __name__ == '__main__': cfg.TEST.HAS_RPN = True # Use RPN for proposals args = parse_args() net = None cfg_from_file( '/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/bottom-up-attention/experiments/cfgs/faster_rcnn_end2end_resnet.yml' ) caffemodel = '/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/bottom-up-attention/data/faster_rcnn_models/resnet101_faster_rcnn_final.caffemodel' prototxt = '/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/bottom-up-attention/models/vg/ResNet-101/faster_rcnn_end2end_final/test.prototxt' if not os.path.isfile(caffemodel): raise IOError(('{:s} not found.\nDid you run ./data/script/' 'fetch_faster_rcnn_models.sh?').format(caffemodel)) if args.cpu_mode: caffe.set_mode_cpu() else: caffe.set_mode_gpu() caffe.set_device(args.gpu_id) cfg.GPU_ID = args.gpu_id
def __load_net(net_path): global model_path, cfg_path cfg_from_file(cfg_path) caffe.set_mode_gpu() caffe.set_device(0) return caffe.Net(str(net_path), str(model_path), caffe.TEST)
args = parser.parse_args() return args if __name__ == '__main__': cfg.TEST.HAS_RPN = True # Use RPN for proposals args = parse_args() prototxt = args.test_prototxt caffemodel = args.demo_net cfg_path = args.cfg_path if cfg_path is not None: cfg_from_file(cfg_path) if not os.path.isfile(caffemodel): raise IOError(('{:s} not found.\nDid you run ./data/script/' 'fetch_faster_rcnn_models.sh?').format(caffemodel)) if args.cpu_mode: caffe.set_mode_cpu() else: caffe.set_mode_gpu() # caffe.set_device(args.gpu_id) # cfg.GPU_ID = args.gpu_id net = caffe.Net(prototxt, caffemodel, caffe.TEST) print '\n\nLoaded network {:s}'.format(caffemodel)
rand_seed = 1024 save_name = '{}_{}' max_per_image = 300 thresh = 0.0001 visualize = False # ------------ if rand_seed is not None: np.random.seed(rand_seed) if rand_seed is not None: np.random.seed(rand_seed) # load config cfg_from_file(cfg_file) def vis_detections(im, class_name, dets, thresh=0.1): """Visual debugging of detections.""" for i in range(np.minimum(10, dets.shape[0])): bbox = tuple(int(np.round(x)) for x in dets[i, :4]) score = dets[i, -1] if score > thresh: cv2.rectangle(im, bbox[0:2], bbox[2:4], (0, 204, 0), 2) cv2.putText(im, '%s: %.3f' % (class_name, score), (bbox[0], bbox[1] + 15), cv2.FONT_HERSHEY_PLAIN, 1.0, (0, 0, 255), thickness=1)
def main(args): if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # Setup caffe if args.gpu >= 0: caffe.mpi_init() caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) else: caffe.mpi_init() caffe.set_mode_cpu() # Get query image and roi query_img = 'demo/query.jpg' query_roi = [0, 0, 466, 943] # [x1, y1, x2, y2] # Extract feature of the query person net = caffe.Net(args.probe_def, args.caffemodel, caffe.TEST) query_feat = demo_exfeat(net, query_img, query_roi) del net # Necessary to release cuDNN conv static workspace # Get gallery images gallery_imgs = sorted(glob('demo/gallery*.jpg')) # Detect and extract feature of persons in each gallery image net = caffe.Net(args.gallery_def, args.caffemodel, caffe.TEST) # Necessary to warm-up the net, otherwise the first image results are wrong # Don't know why. Possibly a bug in caffe's memory optimization. # Nevertheless, the results are correct after this warm-up. demo_detect(net, query_img) for gallery_img in gallery_imgs: print gallery_img, '...' boxes, features = demo_detect(net, gallery_img, threshold=args.det_thresh) if boxes is None: print gallery_img, 'no detections' continue # Compute pairwise cosine similarities, # equals to inner-products, as features are already L2-normed similarities = features.dot(query_feat) # Visualize the results fig, ax = plt.subplots(figsize=(16, 9)) ax.imshow(plt.imread(gallery_img)) plt.axis('off') for box, sim in zip(boxes, similarities): x1, y1, x2, y2, _ = box ax.add_patch( plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='#4CAF50', linewidth=3.5)) ax.add_patch( plt.Rectangle((x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor='white', linewidth=1)) ax.text(x1 + 5, y1 - 18, '{:.2f}'.format(sim), bbox=dict(facecolor='#4CAF50', linewidth=0), fontsize=20, color='white') plt.tight_layout() fig.savefig(gallery_img.replace('gallery', 'result')) plt.show() plt.close(fig) del net
import pprint gpu_id = 0 solver = '/home/zyb/VirtualDisk500/exhdd/Recognition-master/models/UniqueDET/solver_debug.prototxt' max_iters = 100000 size = 224 imdb_name = 'UniqueDET' out = 'out' cfg = '/home/zyb/VirtualDisk500/exhdd/Recognition-master/experiments/cfgs/faster_rcnn_end2end.yml' pretrained_model = '/home/zyb/VirtualDisk500/exhdd/Recognition-master/pretrained_models/VGG_CNN_M_1024.v2.caffemodel' if __name__ == '__main__': def_cfg('UDET') cfg_from_file(cfg) pprint.pprint(fconfig.cfg) caffe.set_mode_gpu() caffe.set_device(gpu_id) # setup the dataset's path dataset = os.path.join('..', 'data', imdb_name) # load pixel mean pixel_means = None if os.path.exists(os.path.join(dataset, 'mean.npy')): pixel_means = np.load(os.path.join(dataset, 'mean.npy')) fconfig.cfg.PIXEL_MEANS = pixel_means print 'Loaded mean.npy: {}'.format(pixel_means) else: print 'Cannot find mean.npy and we will use default mean.'
args = parser.parse_args() return args if __name__ == '__main__': #args = parse_args() # print('Called with args:') # print(args) # if args.cfg_file is not None: # cfg_from_file(args.cfg_file) # if args.set_cfgs is not None: # cfg_from_list(args.set_cfgs) cfg_from_file("models/pvanet/cfgs/submit_160715.yml") cfg.GPU_ID = 0 print('Using config:') pprint.pprint(cfg) # while not os.path.exists(args.caffemodel) and args.wait: # print('Waiting for {} to exist...'.format(args.caffemodel)) # time.sleep(10) caffe.set_mode_gpu() caffe.set_device(0) net = caffe.Net("output/test_traffic_light.prototxt", "rcnn/traf/pvanet_frcnn_384_iter_190000.caffemodel", caffe.TEST)
def main(): args = parse_args() ins_id = args.id instance = getTrainingInstance(ins_id) assert instance != None generateCFG(instance) cfg_from_file(instance.cfg_file) if instance.set_cfgs is not None: cfg_from_list(instance.set_cfgs) #generate model if it not exists yet if instance.net == '': instance.setDefaultNet() models_path = os.path.join(instance.devkit, 'models') if os.path.exists(models_path): os.popen('rm -rf {}'.format(models_path)) print 'Generating model ' + models_path generate_custom_net.main(instance.cls_num,models_path,instance.steps,instance.lr) #if not os.path.exists(instance.net): # generate_custom_net.main(instance.cls_num,instance.netdir,instance.steps,instance.lr) #copy net_def to devkit net_src = os.path.join(instance.devkit,instance.net, "faster_rcnn_alt_opt", \ "faster_rcnn_test.pt") net_dst = os.path.join(instance.devkit, "results") if (not os.path.exists(net_dst)): os.makedirs(net_dst) print 'Copying {} to {}'.format(net_src, net_dst) shutil.copy(net_src, net_dst) #generate factory.py generateFactory(instance) #generate train.sh import generate_train_sh generate_train_sh.main(instance) #make symbolic link to VOCCode generateVOCCode(instance.devkit) if instance.validate() == False: print 'Error in training instance.' exit(1) dbconn = sql.MySQLConnection('192.168.1.90','test','test','zb_label') dbconn.connect() sqlstr = 'update zb_train set status = 2 where id = {}'.format(ins_id) dbconn.query(sqlstr) dbconn.commit() dbconn.close() #start training try: os.system('experiments/scripts/train.sh') acc_rate = getAccuracy(ins_id) acc_str = json.dumps(acc_rate) #sqlstr = 'update zb_train set status = 3 , accuracy = {} where id = {}'.format(json.dumps(acc_str), ins_id) #prev dbconn may be time-out and closed by the server. sqlstr = 'update zb_train set status = 3 where id = {}'.format( ins_id) dbconn = sql.MySQLConnection('192.168.1.90','test','test','zb_label') dbconn.connect() dbconn.query(sqlstr) dbconn.commit() dbconn.close() except Exception,e: sqlerrstr = 'update zb_train set status = -1 where id = {}'.format(ins_id) dbconn = sql.MySQLConnection('192.168.1.90','test','test','zb_label') dbconn.connect() dbconn.query(sqlstr) dbconn.commit() dbconn.close() print e
""" import caffe # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) # set up caffe caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) if __name__ == '__main__': args = parse_args() if args.path_cfg is not None: cfg_from_file(args.path_cfg) cfg.GPU_ID = args.gpu_id print 'RPN model: {}'.format(args.path_net_weights) print('Using config:') pprint.pprint(cfg) import caffe _init_caffe(cfg) imdb = get_imdb(args.imdb_name) print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name) # Load RPN and configure output directory rpn_net = caffe.Net(args.path_net_proto, args.path_net_weights, caffe.TEST) output_dir = get_output_dir(imdb)
MODEL = '/home/ryan/vision/py-faster-rcnn/output/faster_rcnn_end2end/ir_train/vgg16_faster_rcnn_iter_40000.caffemodel' CFG = './experiments/cfgs/faster_rcnn_end2end.yml' GPU = 0 PROTOTXT = './models/imagenet/VGG16/faster_rcnn_end2end/test.prototxt' WAIT = True DATASET = 'ir' COMP = True VIS = False NUM_DETS = 100 IMDB = 'ir_test' if __name__ == '__main__': # Set config and caffe parameters cfg_from_file(CFG) cfg.GPU_ID = GPU caffe.set_mode_gpu() caffe.set_device(GPU) # Initialize net net = caffe.Net(PROTOTXT, MODEL, caffe.TEST) net.name = os.path.splitext(os.path.basename(MODEL))[0] # Get the dataset imdb = get_imdb(IMDB) imdb.competition_mode(True) if not cfg.TEST.HAS_RPN: imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD) # Call test function
def _unmap(data, count, inds, fill=0): """ Unmap a subset of item (data) back to the original set of items (of size count) """ if len(data.shape) == 1: ret = np.empty((count, ), dtype=np.float32) ret.fill(fill) ret[inds] = data else: ret = np.empty((count, ) + data.shape[1:], dtype=np.float32) ret.fill(fill) ret[inds, :] = data return ret if __name__ == '__main__': cfg_from_file('experiments/cfgs/faster_rcnn_end2end_kitti.yml') # Load dataset from datasets.kitti import kitti imdb = kitti('train', '2012') roidb = imdb.roidb im_scale = float(576) / float(375) # Load anchors from rpn.generate_anchors import generate_anchors anchors = generate_anchors(scales=np.array(range(1,10)), ratios=[0.5, 1., 1.5, 2., 2.5, 3.]) anchors = anchors * im_scale num_anchors = anchors.shape[0]
def __init__(self, args): logging.info('Loading net and associated files...') gpu_id = args['gpu_id'] if gpu_id < 0: caffe.set_mode_cpu() print "use cpu mode" else: caffe.set_mode_gpu() caffe.set_device(gpu_id) cfg.GPU_ID = gpu_id print "use gpu mode" self.gpu_id = gpu_id logging.info('\n\ngpu id: {:s}'.format(str(gpu_id))) time.sleep(1) cfg_file = args['cfg_file'].strip() if os.path.exists(cfg_file) and os.path.isfile(cfg_file): cfg_from_file(cfg_file) logging.info('\n\ncfg_file: {:s}'.format(cfg_file)) cls_filepath = args['cls_filepath'].strip() if not os.path.exists(cls_filepath) or not os.path.isfile( cls_filepath): raise IOError(('{:s} not found.\n').format(cls_filepath)) with open(cls_filepath) as f: classes = [x.strip().lower() for x in f.readlines()] self.classes = tuple(classes) logging.info('\n\cls_filepath: {:s}'.format(cls_filepath)) logging.info('\n\nclasses: {:s}'.format(",".join(classes))) pt_cls = args['pt_cls'].strip().split(",") self.pt_cls = [cls.strip() for cls in pt_cls] logging.info('\n\pt_cls: {:s}'.format(pt_cls)) self.pt_choice = args['pt_choice'] logging.info('\n\pt_choice: {:s}'.format(str(self.pt_choice))) pt_def = args['pt_def'].strip() if not os.path.exists(pt_def) or not os.path.isfile(pt_def): raise IOError(('{:s} not found.\n').format(pt_def)) logging.info('\n\nLoaded pt_def: {:s}'.format(pt_def)) person_caffemodel = args['person_caffemodel'].strip() if not os.path.exists(person_caffemodel) or not os.path.isfile( person_caffemodel): raise IOError(('{:s} not found.\n').format(person_caffemodel)) self.person_caffemodel = caffe.Net(pt_def, person_caffemodel, caffe.TEST) logging.info( '\n\nLoaded person network: {:s}'.format(person_caffemodel)) torso_caffemodel = args['torso_caffemodel'].strip() if not os.path.exists(torso_caffemodel) or not os.path.isfile( torso_caffemodel): raise IOError(('{:s} not found.\n').format(torso_caffemodel)) self.torso_caffemodel = caffe.Net(pt_def, torso_caffemodel, caffe.TEST) logging.info('\n\nLoaded torso network: {:s}'.format(torso_caffemodel)) init_net(self.person_caffemodel, self.torso_caffemodel) logging.info('\n\ninit_net of pt done!') time.sleep(1)
def main(): args = parse_args() print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.GPU_ID = args.gpu_id # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) caffe.set_random_seed(cfg.RNG_SEED) # set up caffe caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) # queue for communicated results between processes mp_queue = mp.Queue() print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 RPN, init from ImageNet model' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' cfg.TRAIN.SNAPSHOT_INFIX = 'stage1' rpn_stage1_out = train_rpn(imdb_names=args.imdb_name, init_model=args.pretrained_model, solver=args.solver, max_iters=args.max_iters, cfg=cfg) # mp_kwargs = dict( # queue=mp_queue, # imdb_names=args.imdb_name, # init_model=args.pretrained_model, # solver=args.solver, # max_iters=args.max_iters, # cfg=cfg) # p = mp.Process(target=train_rpn, kwargs=mp_kwargs) # p.start() # rpn_stage1_out = mp_queue.get() # p.join() # rpn_stage1_out = \ # {'model_path': '/home/leoyolo/research/py-faster-rcnn-another/output/rpn_small_obj/voc_2007_trainval/vgg_cnn_m_1024_rpn_small_obj_stage1_iter_80000.caffemodel'} print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 RPN, generate proposals for the test set' print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' rpn_stage1_out['proposal_path'] = \ rpn_generate(imdb_name=args.test_imdb_name, rpn_model_path=str(rpn_stage1_out['model_path']), cfg=cfg, rpn_test_prototxt=args.rpn_test_prototxt )['proposal_path'] # mp_kwargs = dict( # queue=mp_queue, # imdb_name=args.test_imdb_name, # rpn_model_path=str(rpn_stage1_out['model_path']), # cfg=cfg, # rpn_test_prototxt=args.rpn_test_prototxt) # p = mp.Process(target=rpn_generate, kwargs=mp_kwargs) # p.start() # rpn_stage1_out['proposal_path'] = mp_queue.get()['proposal_path'] # p.join() for area in ['all', 'small', 'medium', 'large']: print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' print 'Stage 1 RPN, eval recall with area {}'.format(area) print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' rpn_test(imdb_name=args.test_imdb_name, rpn_proposal_path=rpn_stage1_out['proposal_path'], area=area)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD) roidb = get_training_roidb(imdb) return roidb roidbs = [get_roidb(s) for s in imdb_names.split('+')] roidb = roidbs[0] if len(roidbs) > 1: for r in roidbs[1:]: roidb.extend(r) imdb = datasets.imdb.imdb(imdb_names) else: imdb = get_imdb(imdb_names) return imdb, roidb cfg_from_file('experiments/cfgs/rfcn_end2end.yml') imdb, roidb = combined_roidb('voc_0712_test') import cv2 ann = roidb[9] im = cv2.imread(ann['image']) idx = 0 for bb in ann['boxes']: cv2.rectangle(im,(bb[0],bb[1]),(bb[2],bb[3]),(0,255,0),1) cv2.imwrite('/home/zawlin/data/all.jpg',im) cv2.imshow('im2',im) #cv2.waitKey(0) #cv2.destroyAllWindows()
for j in xrange(0, 28, 2)] ploygon_test = Polygon(pts) if not ploygon_test.is_valid: print('non-ploygon detected') delete_inds.append(i) if int(ploygon_test.area) < 10: print('neg-ploygon') delete_inds.append(i) dets = np.delete(dets, delete_inds, 0) cdets = np.delete(cdets, delete_inds, 0) return dets, cdets if __name__ == "__main__": cfg_from_file(cofig_file) net = caffe.Net(net_prototxt, model, caffe.TEST) for image in images: im = cv2.imread(image) scores, boxes, infos_h, infos_w = im_detect(net, im, None) assert (scores.shape[0] == infos_h.shape[0] == infos_w.shape[0]), 'length mismatch' inds = np.where(scores[:, 1] > 0.5)[0] cls_scores = scores[inds, 1] cls_boxes = boxes[inds, 4:8] ## curve cls_infos_h = infos_h[inds, :14]
performance['rocauc'] += [obj['rocauc']] performance['recs'] += [obj['rec']] performance['precs'] += [obj['prec']] performance['prauc'] += [obj['prauc']] return (classes, performance) if __name__ == '__main__': DEBUG = 0 args = parse_args() print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) cfg.GPU_ID = args.gpu_id print('Using config:') pprint.pprint(cfg) #while not os.path.exists(args.caffemodel) and args.wait: # print('Waiting for {} to exist...'.format(args.caffemodel)) # time.sleep(10) caffe.set_mode_gpu() caffe.set_device(args.gpu_id) print "TEST NET creation parameters:"
return imdb, roidb def latest_model(model_pattern): searchedfile = glob.glob(model_pattern) assert (len(searchedfile) > 0), "0 file matched by %s!" % (model_pattern) files = sorted(searchedfile, key=lambda file: os.path.getmtime(file)) return files[-1] if __name__ == "__main__": args = parse_args() path_env = setup_paths(args.net, args.data, args.expid) # Get model train config copy it to the output path. cfg_config = args.model_config or path_env["cfg"] cfg_from_file(cfg_config) copyfile(cfg_config, os.path.join(path_env["output"], "config.yml")) cfg.GPU_ID = args.GPU_ID cfg.DATA_DIR = path_env['data_root'] cfg.TRAIN.SCALES = args.train_sizes[:-1] cfg.TRAIN.MAX_SIZE = args.train_sizes[-1] # fix the random seeds (numpy and caffe) for reproducibility #np.random.seed(cfg.RNG_SEED) #caffe.set_random_seed(cfg.RNG_SEED) # redirect output to the LOG file print 'Logging output to %s' % path_env['log'] start = time.time() with open(path_env['log'], 'w') as pylog, PyTee(pylog, 'stdout'): print 'Setting GPU device %d for training' % cfg.GPU_ID
def main(args): if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) # parse gpus gpus = map(int, args.gpus.split(',')) assert len(gpus) >= mpi_size, "Number of GPUs must be >= MPI size" cfg.GPU_ID = gpus[mpi_rank] # parse feature blob names blob_names = args.blob_names.split(',') print('Using config:') pprint.pprint(cfg) while not osp.exists(args.caffemodel) and args.wait: print('Waiting for {} to exist...'.format(args.caffemodel)) time.sleep(10) # load imdb imdb = get_imdb(args.imdb_name) root_dir = imdb._root_dir images_dir = imdb._data_path output_dir = get_output_dir(imdb.name, osp.splitext(osp.basename(args.caffemodel))[0]) if args.eval_only: def _load(fname): fpath = osp.join(output_dir, fname) assert osp.isfile(fpath), "Must have extracted detections and " \ "features first before evaluation" return unpickle(fpath) if mpi_rank == 0: gboxes = _load('gallery_detections.pkl') gfeatures = _load('gallery_features.pkl') pfeatures = _load('probe_features.pkl') else: # setup caffe caffe.mpi_init() caffe.set_mode_gpu() caffe.set_device(cfg.GPU_ID) # 1. Detect and extract features from all the gallery images in the imdb start, end = mpi_dispatch(len(imdb.image_index), mpi_size, mpi_rank) if args.use_gt: net = caffe.Net(args.probe_def, args.caffemodel, caffe.TEST) gboxes, gfeatures = usegt_and_exfeat(net, imdb, start=start, end=end, blob_names=blob_names) else: net = caffe.Net(args.gallery_def, args.caffemodel, caffe.TEST) gboxes, gfeatures = detect_and_exfeat(net, imdb, start=start, end=end, blob_names=blob_names) gboxes = mpi_collect(mpi_comm, mpi_rank, gboxes) gfeatures = mpi_collect(mpi_comm, mpi_rank, gfeatures) del net # to release the cudnn conv static workspace # 2. Only extract features from given probe rois start, end = mpi_dispatch(len(imdb.probes), mpi_size, mpi_rank) net = caffe.Net(args.probe_def, args.caffemodel, caffe.TEST) pfeatures = exfeat(net, imdb.probes, start=start, end=end, blob_names=blob_names) pfeatures = mpi_collect(mpi_comm, mpi_rank, pfeatures) del net # Save if mpi_rank == 0: pickle(gboxes, osp.join(output_dir, 'gallery_detections.pkl')) pickle(gfeatures, osp.join(output_dir, 'gallery_features.pkl')) pickle(pfeatures, osp.join(output_dir, 'probe_features.pkl')) # Evaluate if mpi_rank == 0: imdb.evaluate_detections(gboxes, det_thresh=args.det_thresh) imdb.evaluate_detections(gboxes, det_thresh=args.det_thresh, labeled_only=True) imdb.evaluate_search(gboxes, gfeatures['feat'], pfeatures['feat'], det_thresh=args.det_thresh, gallery_size=args.gallery_size, dump_json=osp.join(output_dir, 'results.json'))
if __name__ == '__main__': args = parse_args() comm = MPI.COMM_WORLD mpi_rank = comm.Get_rank() pool_size = comm.Get_size() # TODO: wheather to check caffe.set_parallel() # load config file with open(args.val_cfg) as f: config = yaml.load(f.read()) print "Config:\n{}".format(config) if args.rcnn_cfg is not None: cfg_from_file(args.rcnn_cfg) # load data provider = load_data(args.val_cfg) # get gpu id gpus = args.device_id assert len(gpus) >= pool_size cur_gpu = gpus[mpi_rank] cfg.GPU_ID = cur_gpu # load solver and nets net = load_nets(args, cur_gpu) # start training iter = mpi_rank
print(args) assert os.path.exists(args.outdir), 'SVM path does not exist' sigmoid_cfg = get_sigmoid_configuration() #write configuration file to dir out_dir = args.outdir writeDict(sigmoid_cfg, '{}/sigmoid_cfg.txt'.format(out_dir)) # Must turn this off to prevent issues when digging into the net blobs to # pull out features (tricky!) cfg.DEDUP_BOXES = 0 # Must turn this on because we use the test im_detect() method to harvest # hard negatives cfg.TEST.SVM = True cfg.TRAIN.USE_FLIPPED = sigmoid_cfg.USE_FLIPPED if args.cfg_file is not None: cfg_from_file(args.cfg_file) print('Using config:') pprint.pprint(cfg) # set up caffe caffe.set_mode_gpu() if args.gpu_id is not None: caffe.set_device(args.gpu_id) net = caffe.Net(args.prototxt, args.caffemodel, caffe.TEST) net.name = os.path.splitext(os.path.basename(args.caffemodel))[0] #load dataset imdb_name = args.imdb_name + '.' + args.image_set imdb = get_imdb(imdb_name) print 'Loaded dataset `{:s}` for training'.format(imdb.name) if args.k_fold: imdb.gen_k_fold(args.k_fold)
#encoding:utf-8 import numpy as np import cv2 from rotation.data_extractor import get_rroidb from rotation.r_roidb import add_rbbox_regression_targets from rotation.r_minibatch import r_get_minibatch from fast_rcnn.config import cfg, cfg_from_file, cfg_from_list, get_output_dir from rotation.rt_train import filter_roidb cfg_from_file('../../experiments/cfgs/faster_rcnn_end2end.yml') for c in cfg: print c,':',cfg[c] roidb = get_rroidb() print 'len',len(roidb) #print roidb[0] roidb = filter_roidb(roidb) print 'len_after',len(roidb) print roidb[0] bbox_means,bbox_stds = add_rbbox_regression_targets(roidb)#To test #print roidb[0] #print 'bbox_means',bbox_means #print 'bbox_stds',bbox_stds blobs = r_get_minibatch(roidb, 2) im = blobs['data'].transpose(0, 2, 3, 1)[0] gt_boxes = blobs['gt_boxes'] info = blobs['im_info']