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 __init__(self, name, eval_root=None, det_times_file=None,
imdb_name=None):
"""
:name: name of the detector, used to extract some of the paths
"""
self._name = name
if imdb_name is None:
self._imdb_name = 'voc_2007_test'
else:
self._imdb_name = imdb_name
self._imdb = get_imdb(self._imdb_name)
self._data_dir = os.path.join(DATA_ROOT_DIR, self._name,
self._imdb_name)
if eval_root is None:
self._eval_root = self._data_dir
else:
self._eval_root = eval_root
if det_times_file is None:
self._det_times_file = os.path.join(self._data_dir,
'detections_times.pkl')
else:
self._det_times_file = det_times_file
self.det_cls_img_eval = {}
self._conf = None
self._tp = None
self._fp = None
self._npos = None
self._allnpos = {}
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb)
return roidb
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 combined_roidb(imdb_names, rpn_files=None):
def get_roidb(imdb_name, rpn_file=None):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
if rpn_file is not None:
imdb.config['rpn_file'] = rpn_file
roidb = get_training_roidb(imdb)
return roidb
if '+' in imdb_names: # Multiple databases e.g. voc_2007_trainval+voc_2012_trainval
imdbs_list = imdb_names.split('+')
imdb = datasets.imdb.imdb(imdb_names)
if rpn_files is None:
rpn_files = [None] * len(imdbs_list)
assert(len(imdbs_list) == len(rpn_files))
for i, imdb_name in enumerate(imdbs_list):
if i == 0:
roidb = get_roidb(imdb_name, rpn_files[i])
else:
roidb.extend( get_roidb(imdb_name, rpn_files[i]) )
else: # Single database case e.g. voc_2007_trainval
roidb = get_roidb(imdb_names, rpn_files)
imdb= get_imdb(imdb_names)
return roidb, imdb
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method('gt')
print 'Set proposal method: {:s}'.format('gt')
roidb = get_training_roidb(imdb)
return roidb
def test(dataset, output_file):
"""
Create a pickle file from relations according to annotations in a dataset (VOC 2007)
"""
imdb = get_imdb(dataset)
db_relations = {}
rcc_detector = RCC8()
for n, image_index in enumerate(imdb.image_index):
if n % 10 == 0:
print u'Processed: {} / {}'.format(n, len(imdb.image_index))
impath = imdb.image_path_from_index(image_index)
# read image
img = caffe.io.load_image(impath)
# read annotations
annotations = imdb._load_pascal_annotation(image_index)
# compute RCC8 relation
hist, relations, pairs = rcc_detector.get_relations(img,
annotations=annotations['gt_classes'],
objects=annotations['boxes'])
db_relations[image_index] = (hist, relations, pairs)
if db_relations:
with open(output_file, 'wb') as handle:
pickle.dump(db_relations, handle)
else:
print u'Relations not found!'
def rpn_generate(queue=None, imdb_name=None, rpn_model_path=None, cfg=None,
rpn_test_prototxt=None):
"""Use a trained RPN to generate proposals.
"""
cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering
cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS
print 'RPN model: {}'.format(rpn_model_path)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
# NOTE: the matlab implementation computes proposals on flipped images, too.
# We compute them on the image once and then flip the already computed
# proposals. This might cause a minor loss in mAP (less proposal jittering).
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name)
# Load RPN and configure output directory
rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Generate proposals on the imdb
rpn_proposals = imdb_proposals(rpn_net, imdb)
# Write proposals to disk and send the proposal file path through the
# multiprocessing queue
rpn_net_name = os.path.splitext(os.path.basename(rpn_model_path))[0]
rpn_proposals_path = os.path.join(
output_dir, rpn_net_name + '_proposals.pkl')
with open(rpn_proposals_path, 'wb') as f:
cPickle.dump(rpn_proposals, f, cPickle.HIGHEST_PROTOCOL)
print 'Wrote RPN proposals to {}'.format(rpn_proposals_path)
return {'proposal_path': rpn_proposals_path}
def from_dets(imdb_name, output_dir, args):
imdb = get_imdb(imdb_name)
imdb.competition_mode(args.comp_mode)
imdb.config['matlab_eval'] = args.matlab_eval
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = cPickle.load(f)
#pose_file = os.path.join(output_dir, 'detections_pose.txt')
#with open(pose_file, 'w') as f:
# for i in xrange(0, len(dets[0])):
# for j in xrange(1, len(dets)):
# det = dets[j][i]
# for d in det:
# f.write("{:d} {:d} {:.1f} {:.1f} {:.1f} {:.1f} {:.3f} {:.3f} {:.3f}\n".format(i, j,
# d[0], d[1], d[2], d[3], 15.0*d[4], 15.0*d[5], d[6]))
#matlab_cmd = "test_pose_avp('%s');" % (pose_file)
#print matlab_cmd
#os.system('matlab -nodisplay -r "addpath(\'tools\');%s;quit"' % (matlab_cmd))
if args.apply_nms:
print 'Applying NMS to all detections'
nms_dets = apply_nms(dets, cfg.TEST.NMS)
else:
nms_dets = dets
print 'Evaluating detections'
imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names, training=True):
"""
Combine multiple roidbs
"""
def get_training_roidb(imdb):
"""Returns a roidb (Region of Interest database) for use in training."""
if cfg.TRAIN.USE_FLIPPED:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images()
print('done')
print('Preparing training data...')
prepare_roidb(imdb)
#ratio_index = rank_roidb_ratio(imdb)
print('done')
return imdb.roidb
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
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)
tmp = get_imdb(imdb_names.split('+')[1])
imdb = datasets.imdb.imdb(imdb_names, tmp.classes)
else:
imdb = get_imdb(imdb_names)
if training:
roidb = filter_roidb(roidb)
ratio_list, ratio_index = rank_roidb_ratio(roidb)
return imdb, roidb, ratio_list, ratio_index
def __init__(self, gts):
# DATA_ROOT_PATH = '/home/hinami/rcnn/savedata/frcnn_fc6/caffenet_finetuned/PASCAL2007_trainval'
self.DATA_ROOT_PATH = '/home/hinami/work/rcnn/savedata/frcnn_fc6/caffenet_finetuned/PASCAL2007'
self.imdb = get_imdb('voc_2007_test')
self.svm = LinearSVC(C=0.001, class_weight={1: 2, -1: 1},
intercept_scaling=10.0, verbose=1,
penalty='l2', loss='l1',
random_state=3, dual=True)
self.gts = gts
def get_roidb(imdb_name, rpn_file=None):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
if rpn_file is not None:
imdb.config['rpn_file'] = rpn_file
roidb = get_training_roidb(imdb)
return roidb, imdb
def rpn_generate(queue=None, imdb_name=None, rpn_model_path=None, cfg=None,
rpn_test_prototxt=None):
"""Use a trained RPN to generate proposals.
"""
cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering
cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS
print 'RPN model: {}'.format(rpn_model_path)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
if '+' in imdb_name:
imdbs_list = imdb_name.split('+')
imdb = datasets.imdb.imdb(imdb_name)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
else:
imdbs_list = [imdb_name]
output_dir = None # Gets set later for single database case
rpn_proposals_path = [None] * len(imdbs_list)
for i, imdb_name in enumerate(imdbs_list):
# NOTE: the matlab implementation computes proposals on flipped images, too.
# We compute them on the image once and then flip the already computed
# proposals. This might cause a minor loss in mAP (less proposal jittering).
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for proposal generation'.format(imdb.name)
if output_dir is None:
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Load RPN and configure output directory
rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST)
rpn_net_name = os.path.splitext(os.path.basename(rpn_model_path))[0]
rpn_proposals_path[i] = os.path.join(
output_dir, rpn_net_name + '_' + imdb_name + '_proposals.pkl')
# Check if rpn proposals have already been computed
# If so, don't recompute
if not os.path.isfile(rpn_proposals_path[i]):
# Generate proposals on the imdb
rpn_proposals = imdb_proposals(rpn_net, imdb)
# Write proposals to disk
with open(rpn_proposals_path[i], 'wb') as f:
cPickle.dump(rpn_proposals, f, cPickle.HIGHEST_PROTOCOL)
print 'Wrote RPN proposals to {}'.format(rpn_proposals_path[i])
else:
print "Proposals for " + imdb_name + " exist already."
if len(rpn_proposals_path) == 1:
rpn_proposals_path = rpn_proposals_path[0]
# Send the proposal file path through the
# multiprocessing queue
queue.put({'proposal_path': rpn_proposals_path})
def from_dets(imdb_name, output_dir, comp_mode):
imdb = get_imdb(imdb_name)
imdb.competition_mode(comp_mode)
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = cPickle.load(f)
print 'Applying NMS to all detections'
nms_dets = apply_nms(dets, cfg.TEST.NMS)
print 'Evaluating detections'
imdb.evaluate_detections(nms_dets, output_dir)
def rcnn_demo(i):
imdb = get_imdb('voc_2007_test')
img = cv2.imread(imdb.image_path_at(i))
rcnn_model = np.load('rcnn_model2.npy').all()
rcnn_load_model(rcnn_model, False)
# rcnn_model = np.load('rcnn_model.npz')['rcnn_model'].all()
# thresh = -1
dets = rcnn_detect(imdb.image_index[i], imdb, rcnn_model)
for i in xrange(len(dets)):
if isinstance(dets[i], list):
continue
vis_detections(img, rcnn_model.classes[i], dets[i])
def from_dets(imdb_name, output_dir, args):
imdb = get_imdb(imdb_name)
imdb.competition_mode(args.comp_mode)
imdb.config['matlab_eval'] = args.matlab_eval
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = cPickle.load(f)
print 'Applying NMS to all detections'
cfg.USE_GPU_NMS = False # much faster than GPU NMS for small number of dets
nms_dets = apply_nms(dets, cfg.TEST.NMS)
print 'Evaluating detections'
imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names):
"""
Combine multiple roidbs
"""
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
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)
tmp = get_imdb(imdb_names.split('+')[1])
imdb = datasets.imdb.imdb(imdb_names, tmp.classes)
else:
imdb = get_imdb(imdb_names)
return imdb, roidb
def from_dets(imdb_name, output_dir, args):
imdb = get_imdb(imdb_name)
imdb.competition_mode(args.comp_mode)
imdb.config['matlab_eval'] = args.matlab_eval
with open(os.path.join(output_dir, 'detections.pkl'), 'rb') as f:
dets = cPickle.load(f)
if args.apply_nms:
print('Applying NMS to all detections')
nms_dets = apply_nms(dets, cfg.TEST.NMS)
else:
nms_dets = dets
print('Evaluating detections')
imdb.evaluate_detections(nms_dets, output_dir)
def combined_roidb(imdb_names):
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
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_names)
else:
imdb = get_imdb(imdb_names)
return imdb, roidb
def extractFeatureImdb(self, imdb_name=None, im_list=None):
"""extracts features of a image database able to do for sublist of
images
:imdb_name: name of image database, the same as girschick's
implementation, to be used with datasets.factory.get_imdb
:im_list: gives features with the same order of im_list, if None, then
assumes the default order
:returns: ndarray of im_list*feature_vector
"""
if imdb_name is None:
imdb_name = self.config['IMDB_NAME']
imdb = get_imdb(imdb_name)
self.config['IMDB_NAME'] = imdb_name
if im_list is None:
im_list = imdb.image_index
# check if file already exists, debugging purposes, should add a rerun
# feature to it
features_file = os.path.join(self.path, imdb_name + '.pkl')
self._feature_file = features_file
if os.path.exists(features_file):
print 'Reading features from file {}'.format(features_file)
with open(features_file, 'rb') as f:
features = cPickle.load(f)
return features
print 'computing features for {}'.format(imdb_name)
num_images = len(im_list)
reporting_freq = np.floor(num_images/10)
# extract first image's feature vector to learn more about the
# dimensions and then proceed
im = imdb.image_path_from_index(im_list[0])
feat = self._extractFeatureImage(im)
feat_dimension = len(feat)
features = np.empty((len(im_list),feat_dimension))
features[0,:] = feat
for i, imindex in enumerate(im_list[1:]):
if (i+1)%reporting_freq == 0:
print 'computing features for image {}/{}'.format(i+2, num_images)
im = imdb.image_path_from_index(imindex)
features[i+1, :] = self._extractFeatureImage(im)
# save intermediate files
print 'saving features to {}'.format(features_file)
with open(features_file, 'wb') as f:
cPickle.dump(features, f)
return features
def combined_roidb(imdb_names):
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print "Loaded dataset `{:s}` for training".format(imdb.name)
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
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
def combined_roidb(imdb_names):
def get_roidb(imdb):
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb)
return roidb
imdb = get_imdb(imdb_names)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
roidb = get_roidb(imdb)
# 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
def from_mats(imdb_name, output_dir):
import scipy.io as sio
imdb = get_imdb(imdb_name)
aps = []
for i, cls in enumerate(imdb.classes[1:]):
mat = sio.loadmat(os.path.join(output_dir, cls + '_pr.mat'))
ap = mat['ap'][0, 0] * 100
apAuC = mat['ap_auc'][0, 0] * 100
print '!!! {} : {:.1f} {:.1f}'.format(cls, ap, apAuC)
aps.append(ap)
print '~~~~~~~~~~~~~~~~~~~'
print 'Results (from mat files):'
for ap in aps:
print '{:.1f}'.format(ap)
print '{:.1f}'.format(np.array(aps).mean())
print '~~~~~~~~~~~~~~~~~~~'
def combined_roidb(imdb_names):
print('===> Start compined_roidb in train_net.py')
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
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_names)
else:
imdb = get_imdb(imdb_names)
print('===> Start compined_roidb in train_net.py. done')
return imdb, roidb
def main(args):
# Combine the default config with
# the external config file and the set command
if args.cfg is not None:
cfg_from_file(args.cfg)
if args.set_cfgs is not None:
cfg_from_list(args.set_cfgs)
cfg.DEBUG = args.debug
cfg.GPU_ID = args.gpu_id
cfg_print(cfg)
# Loading the network
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
net = caffe.Net(args.prototxt, args.model, caffe.TEST)
# Create the imdb
imdb = get_imdb(args.db_name)
# Set the network name
net.name = args.net_name
# Evaluate the network
test_net(net, imdb, visualize=args.visualize, no_cache=args.no_cache, output_path=args.out_path)
if args.set_cfgs:
cfg_from_list(args.set_cfgs)
# Record logs into cfg
cfg.LOG.CMD = ' '.join(sys.argv)
cfg.LOG.TIME = datetime.datetime.now().strftime('%Y_%m_%d_%H_%M_%S')
np.random.seed(int(cfg.RNG_SEED))
if cfg.TENSORBOARD.ENABLE:
tb.client = Tensorboard(hostname=cfg.TENSORBOARD.HOSTNAME,
port=cfg.TENSORBOARD.PORT)
tb.sess = tb.client.create_experiment(cfg.NAME + '_' + cfg.LOG.TIME)
if args.train == 'true' or args.train == 'True': # the training entrance
# Get training imdb
imdb = get_imdb(cfg.TRAIN.DB)
roidb = get_training_roidb(imdb)
# Redirect stderr
output_dir = get_output_dir(imdb.name, cfg.NAME + '_' + cfg.LOG.TIME)
f = open(osp.join(output_dir, 'stderr.log'), 'w', 0)
os.dup2(f.fileno(), sys.stderr.fileno())
os.dup2(sys.stderr.fileno(), sys.stderr.fileno())
# Edit solver and train prototxts
target_sw = osp.join(output_dir, 'solver.prototxt')
target_train = osp.join(output_dir, 'train.prototxt')
manipulate_solver(cfg.TRAIN.SOLVER, target_sw, train_net=target_train)
manipulate_train(cfg.TRAIN.PROTOTXT, target_train)
def combined_roidb(imdb_names, training=True): #dataset name
"""
Combine multiple roidbs 融合多个roidbs
"""
def get_training_roidb(imdb):
"""Returns a roidb (Region of Interest database) for use in training."""
# 如果使用翻转,数据增广 2975张 -> 5950张
if cfg.TRAIN.USE_FLIPPED:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images() # data augment
print('done')
print('Preparing training data...')
# 准备imdb
prepare_roidb(imdb)
#ratio_index = rank_roidb_ratio(imdb)
print('done')
return imdb.roidb
# 如imdb_name="cityscape_2007_train_s"
def get_roidb(imdb_name):
# get_imdb 在 factory.py中定义,通过名称获取imdb(image database)
# imdb 是数据集标注的实例化对象( !! 例如 imdb = cityscape(train_s, 2007))
imdb = get_imdb(
imdb_name
) # return a pascal_voc dataset object get_imdb is from factory which contain all legal dataset object
print('Loaded dataset `{:s}` for training'.format(
imdb.name)) # 打印数据集的名字 !! 例如 'cityscape_2007_train_s'
# cfg.TRAIN.PROPOSAL_METHOD = 'gt' --> 训练方法??
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print('Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD))
# 由imdb变为roidb
roidb = get_training_roidb(imdb)
return roidb
# 对字符串进行分割，有的数据集中是多个数据集名用‘+’相连，先分开处理。
# 最终返回GT的roidbs,形式[ 第一种数据集->[{ 第一张图片的字典 },{ 第二张图片的字典 },{...}],第二种数据集-> [{},...],[...]]
roidbs = [get_roidb(s) for s in imdb_names.split('+')]
roidb = roidbs[0] # 这里因为只有一个数据集,即cityscapes
# 如果数据集的个数 > 1
if len(roidbs) > 1:
# r是每个roidb列表
for r in roidbs[1:]:
# 在第一个数据集的列表中追加(后面数据集的图片标注)字典
roidb.extend(r)
tmp = get_imdb(imdb_names.split('+')[1]) # 对第一个数据集????
imdb = datasets.imdb.imdb(imdb_names, tmp.classes) # 数据集合并
else:
imdb = get_imdb(imdb_names)
# 如果是在训练过程
if training:
# 过滤没有目标框的目标 !!对cityscape : 5950张 -> 5932张
roidb = filter_roidb(roidb) # filter samples without bbox
ratio_list, ratio_index = rank_roidb_ratio(
roidb) # 进行长宽比的排列,排列后的长宽比列表ratio_list & 长宽比的次序ratio_index
return imdb, roidb, ratio_list, ratio_index # dataset, roidb dict,ratio_list(0.5,0.5,0.5......2,2,2,), ratio_increase_index(4518,6421,.....)
def get_Imdbs(imdb_names):
imdbs = [get_imdb(s) for s in imdb_names.split('+')]
for im in imdbs:
im.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
return datasets.imdb.Imdbs(imdbs)
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()
print('Called with args:')
print(args)
if args.cfg_file is not None:
cfg_from_file(args.cfg_file)
print('Using config:')
pprint.pprint(cfg)
weights_filename = os.path.splitext(os.path.basename(args.model))[0]
imdb = get_imdb(args.imdb_name)
# construct the filenames
root = 'data/demo_images/'
num = 5
rgb_filenames = []
depth_filenames = []
for i in xrange(num):
filename = root + '{:06d}-color.png'.format(i + 1)
print filename
rgb_filenames.append(filename)
filename = root + '{:06d}-depth.png'.format(i + 1)
print filename
depth_filenames.append(filename)
# construct meta data
print('Using config:')
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)
label_set = args.label_set
print label_set
if label_set != None:
label_set = label_set.split(',')
imdb = get_imdb(args.imdb_name,
dict(label_set = label_set, num_selected = 2))
imdb.competition_mode(args.comp_mode)
if not cfg.TEST.HAS_RPN:
imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD)
proto_file = args.prototxt
with open(proto_file, 'r') as fp:
all_content = fp.read()
net_proto = caffe.proto.caffe_pb2.NetParameter()
text_format.Merge(all_content, net_proto)
all_finded = [layer for layer in net_proto.layer \
if layer.name == 'cls_score']
assert len(all_finded) == 1
all_finded[0].inner_product_param.num_output = len(imdb.classes)
all_finded = [layer for layer in net_proto.layer \
if layer.name == 'bbox_pred']
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
roidb = get_training_roidb(imdb)
return roidb
exp_name = None # the previous experiment name in TensorBoard
# ------------
if rand_seed is not None:
np.random.seed(rand_seed)
# load config file and get hyperparameters
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
test_imdb = get_imdb(test_imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
print(net)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
pkl.dump(pret_net, open('pretrained_alexnet.pkl', 'wb'),
def main():
np.random.seed(5)
global args, best_prec1
args = parser.parse_args()
args.distributed = args.world_size > 1
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch == 'localizer_alexnet':
model = localizer_alexnet(pretrained=args.pretrained)
criterion = multilabel_loss
elif args.arch == 'localizer_alexnet_robust':
model = localizer_alexnet_robust(pretrained=args.pretrained)
criterion = multilabel_loss_robust
print(model)
model.features = torch.nn.DataParallel(model.features)
model.cuda()
# TODO:
# define loss function (criterion) and optimizer
# criterion = multilabel_loss
params = list(model.parameters())
# optimizer = torch.optim.SGD(params[2:], args.lr,
# momentum=args.momentum,
# weight_decay=args.weight_decay)
optimizer = torch.optim.Adam(params[10:],
args.lr,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
# TODO: Write code for IMDBDataset in custom.py
trainval_imdb = get_imdb('voc_2007_trainval')
test_imdb = get_imdb('voc_2007_test')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = IMDBDataset(
trainval_imdb,
transforms.Compose([
transforms.Resize((512, 512)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(IMDBDataset(
test_imdb,
transforms.Compose([
transforms.Resize((384, 384)),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
logger = Logger('./tfboard2', name='freeloc_robust')
if args.evaluate:
validate(val_loader, model, criterion, logger, 0)
return
# TODO: Create loggers for visdom and tboard
# TODO: You can pass the logger objects to train(), make appropriate
# modifications to train()
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, logger)
# evaluate on validation set
if epoch % args.eval_freq == 0 or epoch == args.epochs - 1:
m1, m2 = validate(val_loader, model, criterion, logger, epoch)
score = m1 * m2
# remember best prec@1 and save checkpoint
is_best = score > best_prec1
best_prec1 = max(score, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best)
scale = blobs['im_info'][0, 2]
boxes = blobs_out['rois'][:, 1:].copy()
scores = blobs_out['scores'].copy()
return boxes, scores
cfg.TEST.RPN_PRE_NMS_TOP_N = -1 # no pre NMS filtering
cfg.TEST.RPN_POST_NMS_TOP_N = 2000 # limit top boxes after NMS
import caffe
_init_caffe(cfg)
imdb = get_imdb('compcars_trainval')
rpn_test_prototxt = os.path.join(cfg.MODELS_DIR, 'ZF', 'faster_rcnn_alt_opt',
'rpn_test.pt')
rpn_model_path = './output/faster_rcnn_alt_opt/compcars_trainval/zf_rpn_stage1_iter_80000.caffemodel'
# Load RPN and configure output directory
rpn_net = caffe.Net(rpn_test_prototxt, rpn_model_path, caffe.TEST)
nums = 10
boxes = [[] for _ in xrange(nums)]
for i in xrange(nums):
im = cv2.imread(imdb.image_path_at(i))
boxes[i], scores = im_proposals(rpn_net, im)
im = Image.open(imdb.image_path_at(i))
current_frames)
if __name__ == '__main__':
cfg_from_file("models/pvanet/cfgs/submit_1019.yml")
output_name = "hierarchy"
data_name = "tanktruck"
classes = CLASS_SETS["coco"]
sub_classes = CLASS_SETS["vehicle-types"]
prototxt = "models/pvanet/lite/hierachy/v1_test.prototxt"
caffemodel = "models/hierarchy/v2/v1_iter_10000.caffemodel"
FPS_rate = 1
GPU_ID = 0
imdb = get_imdb(data_name, classes)
OUTPUT_DIR = os.path.join(imdb._data_path, "res", output_name)
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
if not os.path.isfile(caffemodel):
raise IOError(('Caffemodel: {:s} not found').format(caffemodel))
caffe.set_device(GPU_ID)
cfg.GPU_ID = GPU_ID
net = caffe.Net(prototxt, caffemodel, caffe.TEST)
print '\n\nLoaded network {:s}'.format(caffemodel)
print("PVANET Loaded")
print("Start Detecting")
write_testing_results_file(net, imdb, FPS_rate, OUTPUT_DIR, classes)
return sub_cls, sub_score, sub_ind
if __name__ == '__main__':
cfg_from_file("models/pvanet/cfgs/submit_1019.yml")
output_name = "v13-100k"
data_name = "Thailand"
CLASSES_main = CLASS_SETS["coco"]
CLASSES_sub = CLASS_SETS['vehicle-types']
prototxt = "/root/pva-faster-rcnn/models/pvanet/lite/hierachy/v1_test.prototxt"
caffemodel = "/root/pva-faster-rcnn/models/hierarchy/v13/v13_iter_100000.caffemodel"
FPS_rate = 1
GPU_ID = 2
imdb = get_imdb(data_name, CLASSES_main)
OUTPUT_DIR = os.path.join(imdb._data_path, "res", output_name)
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
if not os.path.isfile(caffemodel):
raise IOError(('Caffemodel: {:s} not found').format(caffemodel))
caffe.set_mode_gpu()
caffe.set_device(GPU_ID)
cfg.GPU_ID = GPU_ID
net = caffe.Net(prototxt, caffemodel, caffe.TEST)
print '\n\nLoaded network {:s}'.format(caffemodel)
print("PVANET Loaded")
print("Start Detecting")
single_scale = True # True: sinle scale test; False: multi scale test
test_set = 'coco_2017_val' # 'voc_2007_test' or 'voc_2012_test' or 'coco_2014_minival' or 'coco_2015_test-dev'
coco_path = 'models/ResNet/coco/refinedet_resnet101_512x512/'
cfg.single_scale_test = single_scale
path = coco_path
if '320' in path:
input_size = 320
else:
input_size = 512
caffe.set_mode_gpu()
caffe.set_device(GPU_ID)
imdb = get_imdb(test_set)
imdb.competition_mode(False)
if 'coco' in test_set:
if single_scale is True:
prototxt = path + 'deploy.prototxt'
else:
prototxt = path + 'multi_test_deploy.prototxt'
f = open(prototxt, 'r')
for line in f:
if 'confidence_threshold' in line:
line = line[:-1]
cfg.confidence_threshold = float(line.split(' ')[-1])
else:
prototxt = path + 'deploy.prototxt'
models = ['coco_refinedet_resnet101_512x512_final.caffemodel']
pprint.pprint(cfg)
if not args.randomize:
# fix the random seeds (numpy) for reproducibility
np.random.seed(cfg.RNG_SEED)
if args.multi_label == 1:
imdb = get_imdb_multi(args.roidb,
args.imdb,
args.rpndb,
args.data_dir,
split=0)
else:
imdb = get_imdb(args.roidb,
args.imdb,
args.rpndb,
args.data_dir,
split=0)
print 'Loaded imdb `{:s}` for training'.format(args.imdb)
print 'Loaded roidb `{:s}` for training'.format(args.roidb)
print 'Loaded rpndb `{:s}` for training'.format(args.rpndb)
if cfg.TRAIN.USE_FLIPPED:
print('appending flipped images')
imdb.append_flipped_images()
roidb = imdb.roidb
print('roidb loaded')
# compute bbox target mean and stds if not precomputed
if False:
print('precomputing target means...')
imdb.add_rpn_rois(roidb, make_copy=False)
prepare_roidb(roidb)
import os,sys
#add library to the system path
lib_path = os.path.abspath(os.path.join('lib'))
sys.path.append(lib_path)
lib_path = os.path.abspath(os.path.join('tools'))
sys.path.append(lib_path)
import numpy as np
import cv2
from utils.transform import calib_to_P,clip3DwithinImage,projectToImage,lidar_to_camera
import time
from datasets.factory import get_imdb
imdb = get_imdb('kitti_trainval')
import read_lidar_VOXEL_test as rl
root_dir = '/data/RPN/mscnn-master/data/testing'#'/data/RPN/mscnn-master/data/training'
velodyne = os.path.join(root_dir, "velodyne/")
bird = os.path.join(root_dir, "lidar_pc/")
if not os.path.exists(bird)::
os.mkdir(bird)
t0 = time.time()
for ind in xrange(imdb.num_images):
filename = velodyne + str(ind).zfill(6) + ".bin"
scan = np.fromfile(filename, dtype=np.float32)
scan = scan.reshape((-1, 4))
im = cv2.imread(imdb.image_path_at(ind))
img_size = np.array([im.shape[1],im.shape[0]])
calib = imdb.calib_at(ind)
return xset
xset = xset + vs[0]
if __name__ == '__main__':
cfg.TEST.HAS_RPN = True # Use RPN for proposals
args = parse_args()
if args.model == ' ':
raise IOError(('Error: Model not found.\n'))
if args.jpg == '':
raise IOError(('Error: No image for detection'))
imdb = get_imdb(args.imdb)
# init session
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# load network
net = get_network(args.demo_net, len(CLASSES))
# load model
saver = tf.train.Saver(write_version=tf.train.SaverDef.V1)
saver.restore(sess, args.model)
#sess.run(tf.initialize_all_variables())
print '\n\nLoaded network {:s}'.format(args.model)
# Warmup on a dummy image
im = 128 * np.ones((300, 300, 3), dtype=np.uint8)
def main():
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
global args, best_prec1
args = parser.parse_args()
args.distributed = args.world_size > 1
# create model
print("=> creating model '{}'".format(args.arch))
if args.arch == 'localizer_alexnet':
model = localizer_alexnet(pretrained=args.pretrained)
elif args.arch == 'localizer_alexnet_robust':
model = localizer_alexnet_robust(pretrained=args.pretrained)
model.features = torch.nn.DataParallel(model.features)
model.cuda()
# TODO:
# define loss function (criterion) and optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
criterion = nn.BCEWithLogitsLoss()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
# TODO: Write code for IMDBDataset in custom.py
trainval_imdb = get_imdb('voc_2007_trainval')
test_imdb = get_imdb('voc_2007_test')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = IMDBDataset(
trainval_imdb,
transforms.Compose([
transforms.Resize((512, 512)),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(
IMDBDataset(
test_imdb,
transforms.Compose([
# transforms.Resize((384, 384)),
transforms.Resize((512, 512)),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion)
return
# TODO: Create loggers for visdom and tboard
# TODO: You can pass the logger objects to train(), make appropriate
# modifications to train()
import visdom
vis = visdom.Visdom(server='http://localhost', port='8097')
from tensorboardX import SummaryWriter
logger = SummaryWriter('./runs/q3')
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, logger, vis)
# evaluate on validation set
if epoch % args.eval_freq == 0 or epoch == args.epochs - 1:
m1, m2 = validate(val_loader, model, criterion, epoch, logger, vis)
score = m1 * m2
# remember best prec@1 and save checkpoint
is_best = score > best_prec1
best_prec1 = max(score, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best)
def run_single(imid):
caffe.set_mode_gpu()
caffe.set_device(0)
m = h5py.File('/home/zawlin/Dropbox/proj/sg_vrd_meta.h5', 'r', 'core')
net = caffe.Net(
'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt',
'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_iter_80000.caffemodel',
caffe.TEST)
net2 = caffe.Net(
'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt',
'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_finetune_iter_95000.caffemodel',
caffe.TEST)
# net.name = os.path.splitext(os.path.basename(args.caffemodel))[0]
net.name = 'sgvrd'
imdb = get_imdb('sg_vrd_2016_test')
imdb.competition_mode(0)
if not cfg.TEST.HAS_RPN:
imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD)
"""Test a Fast R-CNN network on an image database."""
num_images = len(imdb.image_index)
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
root = 'data/sg_vrd_2016/Data/sg_test_images/'
cnt = 0
fpath = root + imid + '.jpg'
im_orig = cv2.imread(fpath)
if im_orig == None:
print fpath
cv2.namedWindow('ctrl')
cv2.createTrackbar('t1', 'ctrl', 200, 1000, nothing)
cv2.createTrackbar('t2', 'ctrl', 200, 1000, nothing)
dets1 = detect(im_orig, net, 0.1, imid, m)
dets2 = detect(im_orig, net2, 0.1, imid, m)
print_text = True
while True:
im = im_orig.copy()
t1 = cv2.getTrackbarPos('t1', 'ctrl') / 1000.
t2 = cv2.getTrackbarPos('t2', 'ctrl') / 1000.
# t1idx = []
# t2idx = []
t1idx = [2, 10]
t2idx = [1, 9]
for i in xrange(len(dets1)):
#if t1idx != -1 and t1idx!=i: continue
if len(t1idx) > 0 and i not in t1idx: continue
d = dets1[i]
score = d['score']
if score < t1: continue
cls_name = d['cls_name'] + '.' + str(i)
di = [d['x1'], d['y1'], d['x2'], d['y2']]
x, y = int(di[0]), int(di[1])
if x < 10:
x = 15
if y < 10:
y = 15
if print_text:
cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1,
(0, 0, 255), 1)
cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 0, 255), 1)
#print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3])
for i in xrange(len(dets2)):
if len(t2idx) > 0 and i not in t2idx: continue
d = dets2[i]
score = d['score']
if score < t2: continue
cls_name = d['cls_name'] + '.' + str(i)
di = [d['x1'], d['y1'], d['x2'], d['y2']]
x, y = int(di[0]), int(di[1])
if x < 10:
x = 15
if y < 10:
y = 15
if print_text:
cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1,
(0, 0, 255), 1)
cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 255, 0), 1)
#print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3])
cv2.imshow('im', im)
c = cv2.waitKey(100) & 0xFF
if c == ord('s'):
cv2.imwrite('output/results/' + imid + '.jpg', im)
print 'written'
elif c == ord('b'):
print_text = not print_text
elif c == ord(' '):
break
elif c == 27:
exit(0)
def combined_roidb(imdb_names, training=True, seen=1):
"""
Combine multiple roidbs
"""
def get_training_roidb(imdb, training):
"""Returns a roidb (Region of Interest database) for use in training."""
if cfg.TRAIN.USE_FLIPPED and training:
print('Appending horizontally-flipped training examples...')
imdb.append_flipped_images()
print('done')
print('Preparing training data...')
prepare_roidb(imdb)
#ratio_index = rank_roidb_ratio(imdb)
print('done')
return imdb.roidb
def get_roidb(imdb_name, training):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print('Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD))
imdb.filter(seen)
roidb = get_training_roidb(imdb, training)
return imdb, roidb, imdb.cat_data, imdb.inverse_list
imdbs = []
roidbs = []
querys = []
for s in imdb_names.split('+'):
imdb, roidb, query, reserved = get_roidb(s, training)
imdbs.append(imdb)
roidbs.append(roidb)
querys.append(query)
imdb = imdbs[0]
roidb = roidbs[0]
query = querys[0]
if len(roidbs) > 1 and training:
for r in roidbs[1:]:
roidb.extend(r)
for r in range(len(querys[0])):
query[r].extend(querys[1][r])
tmp = get_imdb(imdb_names.split('+')[1])
imdb = datasets.imdb.imdb(imdb_names, tmp.classes)
if training:
roidb = filter_roidb(roidb)
ratio_list, ratio_index = rank_roidb_ratio(roidb)
else:
# Generate testing image, an image testing frequency(time) according to the reserved category
ratio_list, ratio_index = test_rank_roidb_ratio(roidb, reserved)
return imdb, roidb, ratio_list, ratio_index, query
exp_name = None # the previous experiment name in TensorBoard
# ------------
if rand_seed is not None:
np.random.seed(rand_seed)
# load config file and get hyperparameters
cfg_from_file(cfg_file)
lr = cfg.TRAIN.LEARNING_RATE
momentum = cfg.TRAIN.MOMENTUM
weight_decay = cfg.TRAIN.WEIGHT_DECAY
disp_interval = cfg.TRAIN.DISPLAY
log_interval = cfg.TRAIN.LOG_IMAGE_ITERS
# load imdb and create data later
imdb = get_imdb(imdb_name)
rdl_roidb.prepare_roidb(imdb)
roidb = imdb.roidb
data_layer = RoIDataLayer(roidb, imdb.num_classes)
imdb_test = get_imdb(imdb_test_name)
# Create network and initialize
net = WSDDN(classes=imdb.classes, debug=_DEBUG)
print(net)
network.weights_normal_init(net, dev=0.001)
if os.path.exists('pretrained_alexnet.pkl'):
pret_net = pkl.load(open('pretrained_alexnet.pkl', 'rb'))
else:
pret_net = model_zoo.load_url(
'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth')
im2show = cv2.cvtColor(im2show, cv2.COLOR_BGR2RGB)
im2show = im2show.transpose((2, 0, 1))
logger.add_image('test/image_with_box/' + str(step),
im2show / 255., i)
with open(det_file, 'wb') as f:
cPickle.dump(all_boxes, f, cPickle.HIGHEST_PROTOCOL)
print('Evaluating detections')
aps = imdb.evaluate_detections(all_boxes, output_dir)
return aps
if __name__ == '__main__':
# load data
imdb = get_imdb(imdb_name)
imdb.competition_mode(on=True)
# load net
net = WSDDN(classes=imdb.classes, debug=False)
trained_model = trained_model_fmt.format(cfg.TRAIN.SNAPSHOT_PREFIX, 30000)
print('Loading {}'.format(trained_model))
network.load_net(trained_model, net)
print('load model successfully!')
net.cuda()
net.eval()
# evaluation
aps = test_net(save_name,
net,
print('Using config:')
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)
label_set = args.label_set
print label_set
if label_set != None:
label_set = label_set.split(',')
imdb = get_imdb(args.imdb_name, dict(label_set=label_set, num_selected=10))
imdb.competition_mode(args.comp_mode)
proto_file = args.prototxt
with open(proto_file, 'r') as fp:
all_content = fp.read()
net_proto = caffe.proto.caffe_pb2.NetParameter()
text_format.Merge(all_content, net_proto)
all_finded = [layer for layer in net_proto.layer \
if layer.name == 'cls_score']
assert len(all_finded) == 1
all_finded[0].inner_product_param.num_output = len(imdb.classes)
all_finded = [layer for layer in net_proto.layer \
if layer.name == 'bbox_pred']
assert len(all_finded) == 1
all_finded[0].inner_product_param.num_output = 4 * len(imdb.classes)
def run_test_visualize():
caffe.set_mode_gpu()
caffe.set_device(0)
m = h5py.File('/home/zawlin/Dropbox/proj/sg_vrd_meta.h5', 'r', 'core')
net = caffe.Net(
'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt',
'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_iter_80000.caffemodel',
caffe.TEST)
net2 = caffe.Net(
'models/sg_vrd/vgg16/faster_rcnn_end2end/test.prototxt',
'output/faster_rcnn_end2end/sg_vrd_2016_train/vgg16_faster_rcnn_finetune_iter_95000.caffemodel',
caffe.TEST)
# net.name = os.path.splitext(os.path.basename(args.caffemodel))[0]
net.name = 'sgvrd'
imdb = get_imdb('sg_vrd_2016_test')
imdb.competition_mode(0)
if not cfg.TEST.HAS_RPN:
imdb.set_proposal_method(cfg.TEST.PROPOSAL_METHOD)
"""Test a Fast R-CNN network on an image database."""
num_images = len(imdb.image_index)
# all detections are collected into:
# all_boxes[cls][image] = N x 5 array of detections in
# (x1, y1, x2, y2, score)
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(imdb.num_classes)]
root = 'data/sg_vrd_2016/Data/sg_test_images/'
cnt = 0
cv2.namedWindow('ctrl')
cv2.createTrackbar('t1', 'ctrl', 200, 1000, nothing)
cv2.createTrackbar('t2', 'ctrl', 200, 1000, nothing)
images = []
for path, subdirs, files in os.walk(root):
for name in files:
cnt += 1
imid = name.split('.')[0]
fpath = os.path.join(path, name)
images.append(fpath)
random.shuffle(images)
for fpath in images:
print fpath
imorig = cv2.imread(fpath)
dets1 = detect(imorig, net, 0.01, imid, m)
dets2 = detect(imorig, net2, 0.01, imid, m)
while True:
im = imorig.copy()
t1 = cv2.getTrackbarPos('t1', 'ctrl') / 1000.
t2 = cv2.getTrackbarPos('t2', 'ctrl') / 1000.
for i in xrange(len(dets1)):
d = dets1[i]
score = d['score']
if score < t1: continue
cls_name = d['cls_name'] + '.' + str(i)
di = [d['x1'], d['y1'], d['x2'], d['y2']]
x, y = int(di[0]), int(di[1])
if x < 10:
x = 15
if y < 10:
y = 15
cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1,
(0, 0, 255), 1)
cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (255, 0, 0),
2)
#print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3])
for i in xrange(len(dets2)):
d = dets2[i]
score = d['score']
if score < t2: continue
cls_name = d['cls_name'] + '.' + str(i)
di = [d['x1'], d['y1'], d['x2'], d['y2']]
x, y = int(di[0]), int(di[1])
if x < 10:
x = 15
if y < 10:
y = 15
cv2.putText(im, cls_name, (x, y), cv2.FONT_HERSHEY_COMPLEX, 1,
(0, 0, 255), 1)
cv2.rectangle(im, (di[0], di[1]), (di[2], di[3]), (0, 255, 0),
2)
#print '%s %f %d %d %d %f\n' % (imid, score, di[0], di[1], di[2], di[3])
cv2.imshow('im', im)
c = cv2.waitKey(100) & 0xFF
if c == ord('s'):
pass
elif c == ord(' '):
break
elif c == 27:
exit(0)
def gogo():
print 'starting ensemble'
thresh = 0.01
#data_type = 'val'
data_type = 'test'
exclude_worst = True
num_classes = 201
imdb_name = 'imagenet_' + data_type
base_dir = '/home/dj/big/workspace/fast-rcnn/output/ensemble/'
data = []
result = []
# 1. vgg16 frcnn
data.append('vgg16_imagenet_fast_rcnn_with_ss_iter_500000')
result.append('result_comp4-1648.txt')
# 2. vgg16 step 2_1
#data.append('vgg16_imagenet_fast_rcnn_step2_with_rpn_iter_520000')
#result.append('result_comp4-13436.txt')
# 3. vgg16 step 2_2
#data.append('vgg16_imagenet_fast_rcnn2_step2_with_rpn_iter_520000')
#result.append('result_comp4-31392.txt')
# (2, 3) vgg16 avg (step 2_1, step 2_2)
data.append('vgg16_imagenet_fast_rcnn_avg_2_3')
result.append('result_comp4-3153.txt')
# (2, 3, 5) vgg16 avg (step 2_1, step 2_2, step 2_4)
#data.append('vgg16_imagenet_fast_rcnn_with_rpn_avg_2_3_5')
#result.append('result_comp4-33831.txt')
# (2, 3, 6) vgg16 avg (step 2_1, step 2_2, step 4)
#data.append('vgg16_imagenet_fast_rcnn_avg_2_3_6')
#result.append('result_comp4-22284.txt')
# (2, 3, 4, 5) vgg16 avg (step 2_1, step 2_2, step 2_3, step 2_4)
#data.append('vgg16_imagenet_fast_rcnn_with_rpn_avg_2_3_4_5')
#result.append('result_comp4-6730.txt')
# (2, 3, 5, 6) vgg16 avg (step 2_1, step 2_2, step 2_4, step 4)
#data.append('vgg16_imagenet_fast_rcnn_avg_2_3_5_6')
#result.append('result_comp4-6456.txt')
# 6. vgg16 step 4
data.append('vgg16_imagenet_fast_rcnn_step4_with_rpn_iter_360000')
result.append('result_comp4-16205.txt')
# 7. vgg19 frcnn
data.append('vgg19_imagenet_fast_rcnn_with_ss_iter_470000')
result.append('result_comp4-37160.txt')
# 8. googlenet frcnn
#data.append('googlenet_imagenet_fast_rcnn_with_ss_iter_480000')
#result.append('result_comp4-42391.txt')
# 9. vgg16 step 3
#data.append('vgg16_imagenet_fast_rcnn_step2_with_rpn_step3_iter_520000')
#result.append('result_comp4-25665.txt')
output_dir = '%s/results' % base_dir
all_boxes = None
total_result = np.zeros((num_classes, len(data)))
data_no = 0
for one_result, one_data in zip(result, data):
result_file = base_dir + one_data + '/val/' + one_result
with open(result_file, 'rt') as f:
line_no = 0
for one_line in f.readlines():
try:
one_number = float(one_line.rstrip())
except:
continue
line_no += 1
total_result[line_no, data_no] = one_number
if line_no >= num_classes - 1:
break
data_no += 1
min_data_index_per_class = np.argmin(total_result, axis=1)
data_no = 0
for one_data in data:
det_file = base_dir + one_data + '/' + data_type + '/detections.pkl'
if data_type == 'test':
submission_file = base_dir + one_data + '/' + data_type + '/submission.txt'
else:
submission_file = ''
print '[%s] processing %s' % (data_no + 1, one_data)
with open(det_file, 'rb') as f:
det = cPickle.load(f)
num_images = len(det[0])
# all_boxes[cls][image] = N x 5 array of detections in (x1, y1, x2, y2, score)
if all_boxes == None:
all_boxes = [[[] for _ in xrange(num_images)]
for _ in xrange(num_classes)]
for cls_no in xrange(num_classes):
if exclude_worst and cls_no > 0 and min_data_index_per_class[cls_no] == data_no:
continue
for img_no in xrange(num_images):
det_value = det[cls_no][img_no]
if len(det_value) > 0:
inds = np.where((det_value[:, 4] >= thresh))[0]
det_value = det_value[inds]
if len(all_boxes[cls_no][img_no]) == 0:
all_boxes[cls_no][img_no] = det_value
else:
all_boxes[cls_no][img_no] = np.vstack((all_boxes[cls_no][img_no], det_value))
data_no += 1
print ''
print 'Applying NMS to all detections'
nms_dets = apply_nms(all_boxes, cfg.TEST.NMS)
all_boxes = None
print 'Evaluating detections'
imdb = get_imdb(imdb_name)
imdb.evaluate_detections(nms_dets, output_dir, submission_file)
cfg_from_list(args.set_cfgs)
print('Using config:')
pprint.pprint(cfg)
device_name = '/{}:{:d}'.format(args.device, args.device_id)
print device_name
if args.device == 'gpu':
cfg.USE_GPU_NMS = True
cfg.GPU_ID = args.device_id
else:
cfg.USE_GPU_NMS = False
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
target_imdb = get_imdb(args.target_imdb_name)
target_imdb.competition_mode(args.comp_mode)
print 'Loaded dataset `{:s}` for training'.format(target_imdb.name)
target_roidb = get_training_roidb(target_imdb)
source_imdb = get_imdb(args.source_imdb_name)
source_imdb.competition_mode(args.comp_mode)
print 'Loaded dataset `{:s}` for training'.format(source_imdb.name)
source_roidb = get_training_roidb(source_imdb)
target_network = get_network(args.target_network_name)
print 'Use network `{:s}` in training'.format(args.target_network_name)
target_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='target')
source_network = get_network(args.source_network_name)
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print('Loaded dataset `{:s}` for training'.format(imdb.name))
imdb.set_proposal_method('gt')
roidb = get_training_roidb(imdb)
return roidb
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)
import pdb; pdb.set_trace()
test_net(net, imdb)
else:
filename = os.path.splitext(os.path.basename(args.weight))[0]
tag = args.tag
tag = tag if tag else 'default'
filename = tag + '/' + filename
# This extra_string used by me (Aleksis) when running code on two
# different machines, for convenience
extra_string = ''
print(args.imdb_name)
if args.imdb_name == 'voc_2012_test':
extra_string += '_test'
#print(args.imdb_name + extra_string)
#sleep(100)
imdb = get_imdb(args.imdb_name + extra_string)
imdb.competition_mode(args.comp_mode)
# Set class names in config file based on IMDB
class_names = imdb.classes
cfg_from_list(['CLASS_NAMES', [class_names]])
# Update config depending on if class-specific history used or not
if not args.use_hist:
cfg_from_list(['DRL_RPN.USE_HIST', False])
cfg_from_list(['DIMS_TOT', cfg.DIMS_NONHIST])
cfg_from_list(['DIMS_AUX', 2 * cfg.NBR_ANCHORS])
elif args.use_post > 0:
cfg_from_list(['DRL_RPN.USE_POST', True])
# Specify if run drl-RPN in auto mode or a fix number of iterations
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)
#set classes to train
classes_to_train = range(args.first_class,min(args.first_class+args.class_num,imdb.num_classes))
# enhance roidb to contain flipped examples
if cfg.TRAIN.USE_FLIPPED:
print 'Appending horizontally-flipped training examples...'
imdb.append_flipped_images()
print 'done'
#train folds
if args.k_fold:
print 'Training with {:d} folds'.format(args.k_fold)
for k in range(args.k_fold):
parser.add_argument('--data_dir', dest='data_dir',
type=str)
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
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)
cfg.TEST.INFERENCE_ITER = args.inference_iter
print('Using config:')
pprint.pprint(cfg)
cfg.GPU_ID = args.gpu_id
config = tf.ConfigProto()
config.allow_soft_placement=True
imdb = get_imdb(args.roidb, args.imdb, args.rpndb, args.data_dir, split=1, num_im=args.test_size)
merge_late(args.load_score, imdb, args.test_mode, args.write_rel_f)
