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 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 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 get_roidb(imdb_name,
rpn_file=None,
stage_flag=None,
roidbs_cache_path=None):
# Set input info
data = cfg.TRAIN.DATA
cache = cfg.TRAIN.CACHE
D_INPUT_DIR = cfg.TRAIN.D_INPUT_DIR
D_INPUT_FILE = cfg.TRAIN.D_INPUT_FILE
D_INPUT_LAB_DIR = cfg.TRAIN.D_INPUT_LAB_DIR
D_INPUT_IMG_DIR = cfg.TRAIN.D_INPUT_IMG_DIR
print
print "data:", data
print "cache:", cache
if stage_flag:
print "stage_flag:", stage_flag
print
# get imdb
imdb = get_imdb(imdb_name, D_INPUT_DIR, D_INPUT_IMG_DIR, \
D_INPUT_LAB_DIR, D_INPUT_FILE, data, cache)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# set roidb handler
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
# rpn File
if rpn_file is not None:
imdb.config['rpn_file'] = rpn_file
# get roidb
roidb = get_training_roidb(imdb, roidbs_cache_path)
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(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb)
return roidb
def get_roidb(imdb_name, devkit_path, CLASSES):
imdb = get_imdb(imdb_name, devkit_path, CLASSES)
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 train_faster_rcnn(no_pretrained, max_iters):
"""Train a Faster R-CNN network on a region of interest database."""
# Set pretrained model
if no_pretrained:
pretrained_model = None
else:
pretrained_model = osp.join(cfg.DATA_DIR, 'imagenet_models',
'{:s}.caffemodel'.format(cfg.MODEL_NAME))
check_if_exist('Pretrained model', pretrained_model)
# Change solver if OHEM is used
postfix = ''
if cfg.TRAIN.USE_OHEM:
if cfg.MODEL_NAME != 'VGG16' and \
cfg.MODEL_NAME != 'ResNet101_bn-scale-merged':
print('Faster RCNN framework with OHEM does not currently '
'support model: {:s} (supported models: VGG16, '
'ResNet101_bn-scale-merged).').format(cfg.MODEL_NAME)
sys.exit()
else:
postfix = '_ohem'
# Check if custom anchors exist and copy them to output dir
if cfg.CUSTOM_ANCHORS:
anchor_file = osp.join(cfg.DATA_DIR, cfg.DATASET_NAME,
'custom_anchor_boxes', '9_anchor_boxes.txt')
if not osp.exists(anchor_file):
print('Custom anchor boxes `{:s}` does not exist.'.format(
anchor_file))
print('Generate custom anchor boxes with '
'data/data_utils/k_means_anchor_boxes.py')
sys.exit()
copy(anchor_file, osp.join(cfg.OUTPUT_DIR, '9_anchor_boxes.txt'))
# Set solver
solver = osp.join(cfg.MODELS_DIR, cfg.DATASET_NAME, cfg.METHOD_NAME,
cfg.MODEL_NAME, 'solver{}.prototxt'.format(postfix))
check_if_exist('Solver', solver)
# Set up caffe
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
# Set imdb
imdb_name = '{:s}_train'.format(cfg.DATASET_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)
# Start training
train_net(solver,
roidb,
pretrained_model=pretrained_model,
max_iters=max_iters)
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name) # get_imdb 来自 lib/datasets/factory.py
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
imdb.set_proposal_method(
cfg.TRAIN.PROPOSAL_METHOD) #!!! 这个地方触发了野性语句, 执行了gt_roidb !!!
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb) # 从 imdb 获得 roidb
return roidb
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# set proposal method 'gt' to make this imdb load annotation
imdb.set_proposal_method('gt')
roidb = get_training_roidb(imdb)
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(
cfg.TRAIN.PROPOSAL_METHOD) # Ashu loads the ground truth
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb)
return roidb
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 get_roidb(imdb_name, flag=0):
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)
for rd in roidb:
rd['dc_label'] = flag
return roidb, imdb
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 get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
# if cfg.DEBUG:
# print(imdb.roidb_handler)
# time.sleep(10000)
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 get_roidb(imdb_name):
## return an imdb object
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)
## return list of dicts with keys ('bbox', 'gt_classes', 'gt_overlaps'\
## , 'flipped', 'seg_areas')
roidb = get_training_roidb(imdb)
return roidb
def get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
# set classes of train in interface
# no need into pascal_voc to reset self._classes
imdb.set_classes(classes)
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 get_roidb(imdb_name):
#imdb = get_imdb(imdb_name)
pos = imdb_name.rfind('_')
db_name = imdb_name[:pos]
split = imdb_name[pos + 1:]
imdb = universal(db_name=db_name, split=split, ext=ext)
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 get_roidb(imdb_name):
imdb = get_imdb(imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
print(cfg.TRAIN)
print(cfg.TRAIN['PROPOSAL_METHOD'])
#print(cfg.TEST.PROPOSAL_METHOD)
#print(cfg.TRAIN.HAS_RPN)
#print(cfg.MODELS_DIR)
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 get_roidb(imdb_name, rpn_file=None):
print 'Requiring dataset `{:s}` for training'.format(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)
if rpn_file is not None:
imdb.config['rpn_file'] = rpn_file
roidb = get_training_roidb(imdb)
num_classes = roidb[0]['gt_overlaps'].shape[1]
print "############ num class in get_roidb jg rpn train :", num_classes
return roidb, imdb
def get_roidb(imdb_name, mat_folder, pkl_folder):
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 mat_folder is not None:
mat_file = os.path.join(cfg.DATA_DIR, mat_folder,
imdb_name + '.mat')
imdb.config['mat_file'] = mat_file
if pkl_folder is not None:
pkl_file = pkl_folder + imdb_name + '_proposals.pkl'
imdb.config['pkl_file'] = pkl_file
roidb = get_training_roidb(imdb)
return roidb
def get_roidb(imdb_name, rpn_file=None):
"""
:param imdb_name: 获取roidb
:param rpn_file: 获取imdb
:return:
imdb 根据imdb_name(默认是"voc_2007_trainval")来获取，这里的imdb对象的获取采用了工厂模式，由\lib\datasets\factory.py生成，
根据年份（2007）与切分的数据集（trainval）返回pascal_voc 对象，pascal_voc与coco都继承于imdb 对象。(\lib\datasets\pascal_voc.py
+coco.py)
roidb 是通过\lib\faster_rcnn\train.py 中的get_training_roidb来获取的，这个roidb是一个imdb的成员变量，包含了训练集图片中框出的每个
区域。这个函数做了两件事情，一是将原有的roidb中的每张图片进行水平翻转然后添加回roidb中
"""
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
cache_file = os.path.join(cache_path, \
i_database_name + '_train' + '_3CL=' + str(cfg.ThreeClass) + \
'_MULTI_LABEL=' + str(cfg.MULTI_LABEL) + \
'_SOFTMAX=' + str(cfg.MULTI_LABEL_SOFTMAX) + \
'_BLC=' + str(cfg.BALANCED) + \
'_COF=' + str(cfg.BALANCED_COF) + \
'_TT1000=' + str(cfg.TESTTYPE1000) + \
'_solver_roidb.pkl')
if os.path.exists(cache_file):
with open(cache_file, 'rb') as fid:
this_dataset_roidb[i_database_name] = cPickle.load(fid)
else:
imdb = get_imdb(i_database_name + '_train')
print('No cache file spotted. Making one from the scratch')
print('Loaded dataset `{:s}`'.format(i_database_name))
this_dataset_roidb[i_database_name] = get_training_roidb(
imdb)
with open(cache_file, 'wb') as fid:
cPickle.dump(this_dataset_roidb, fid,
cPickle.HIGHEST_PROTOCOL)
print('The precomputed roidb saved to {}'.format(
cache_file))
print('The precomputed {} roidb datasets loaded'.\
format(i_database_name))
origin_roidb = []
for i_database_name in ['CFD', 'Fashionista']:
origin_roidb.extend(this_dataset_roidb[i_database_name])
print('Generating the hdf5 training data')
else:
cache_file = os.path.join(cache_path, \
if args.device_id is not None:
cfg.GPU_ID = device_id
if not args.randomize:
# fix the random seeds (numpy and caffe) for reproducibility
np.random.seed(cfg.RNG_SEED)
# the map from dataset name to the dataset is set and store in the /datasets/factory.py
# guess that factory.py should run first
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
#**************************************
# load original images and groundtruth
#**************************************
roidb = get_training_roidb(imdb)
if cfg.DEBUG:
for key in roidb[0]:
print key
# output_dir = get_output_dir(imdb, None)
output_dir = "/z/home/chsiyuan/Documents/542FinalProject/experiments/results/train"
if not os.path.exists(output_dir):
os.makedirs(output_dir)
print 'Output will be saved to `{:s}`'.format(output_dir)
device_name = '/{}:{:d}'.format(args.device,args.device_id)
print device_name
network = get_network(args.network_name)
cache_file = os.path.join(cache_path, \
i_database_name + '_train' + '_3CL=' + str(cfg.ThreeClass) + \
'_MULTI_LABEL=' + str(cfg.MULTI_LABEL) + \
'_SOFTMAX=' + str(cfg.MULTI_LABEL_SOFTMAX) + \
'_BLC=' + str(cfg.BALANCED) + \
'_COF=' + str(cfg.BALANCED_COF) + \
'_TT1000=' + str(cfg.TESTTYPE1000) + \
'_solver_roidb.pkl')
if os.path.exists(cache_file):
with open(cache_file, 'rb') as fid:
this_dataset_roidb[i_database_name] = cPickle.load(fid)
else:
imdb = get_imdb(i_database_name + '_train')
print('No cache file spotted. Making one from the scratch')
print('Loaded dataset `{:s}`'.format(i_database_name))
this_dataset_roidb[i_database_name] = get_training_roidb(imdb)
with open(cache_file, 'wb') as fid:
cPickle.dump(
this_dataset_roidb, fid, cPickle.HIGHEST_PROTOCOL)
print('The precomputed roidb saved to {}'.format(cache_file))
print('The precomputed {} roidb datasets loaded'.\
format(i_database_name))
origin_roidb = []
for i_database_name in ['CFD', 'Fashionista']:
origin_roidb.extend(this_dataset_roidb[i_database_name])
print('Generating the hdf5 training data')
else:
cache_file = os.path.join(cache_path, \
args.imdb_name + '_3CL=' + str(cfg.ThreeClass) + \
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
elif 'GOOGLENET' in model_name:
model_name = 'GOOGLENET'
elif 'INCEPTION' in model_name:
model_name = 'GOOGLENET_BN'
else:
raise Exception("This model is not supported. %s" % model_name)
cfg.MODEL_NAME = model_name
imdb = get_imdb(args.imdb_name, model_to_use, proposal, proposal_file)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# DJDJ
#imdb.rpn_train_roidb()
roidb = get_training_roidb(imdb, args.model_to_use, args.proposal_file)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(args.solver,
imdb.bbox_means,
imdb.bbox_stds,
roidb,
output_dir,
proposal_file,
pretrained_model=args.pretrained_model,
restore=args.restore,
max_iters=args.max_iters,
model_to_use=model_to_use,
proposal=proposal)
def get_roidb(dataset):
imdb = get_imdb(dataset)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
roidb = get_training_roidb(imdb)
return roidb
def setup(self, bottom, top):
"""Setup the RoIDataLayer."""
# parse the layer parameter string, which must be valid YAML
layer_params = yaml.load(self.param_str)
self._num_classes = layer_params['num_classes']
self._name_to_top_map = {}
# data blob: holds a batch of N images, each with 3 channels
idx = 0
top[idx].reshape(cfg.TRAIN.IMS_PER_BATCH, 3, max(cfg.TRAIN.SCALES),
cfg.TRAIN.MAX_SIZE)
self._name_to_top_map['data'] = idx
idx += 1
if cfg.TRAIN.HAS_RPN:
top[idx].reshape(1, 3)
self._name_to_top_map['im_info'] = idx
idx += 1
top[idx].reshape(1, 4)
self._name_to_top_map['gt_boxes'] = idx
idx += 1
else: # not using RPN
# rois blob: holds R regions of interest, each is a 5-tuple
# (n, x1, y1, x2, y2) specifying an image batch index n and a
# rectangle (x1, y1, x2, y2)
top[idx].reshape(1, 5)
self._name_to_top_map['rois'] = idx
idx += 1
# labels blob: R categorical labels in [0, ..., K] for K foreground
# classes plus background
top[idx].reshape(1)
self._name_to_top_map['labels'] = idx
idx += 1
if cfg.TRAIN.BBOX_REG:
# bbox_targets blob: R bounding-box regression targets with 4
# targets per class
top[idx].reshape(1, self._num_classes * 4)
self._name_to_top_map['bbox_targets'] = idx
idx += 1
# bbox_inside_weights blob: At most 4 targets per roi are active;
# thisbinary vector sepcifies the subset of active targets
top[idx].reshape(1, self._num_classes * 4)
self._name_to_top_map['bbox_inside_weights'] = idx
idx += 1
top[idx].reshape(1, self._num_classes * 4)
self._name_to_top_map['bbox_outside_weights'] = idx
idx += 1
print 'RoiDataLayer: name_to_top:', self._name_to_top_map
np.random.seed(cfg.RNG_SEED)
imdb = get_imdb('voc_2007_test')
roidb = get_training_roidb(imdb)
self.set_roidb(roidb)
assert len(top) == len(self._name_to_top_map)
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
os.system('cp {:s} {:s}'.format(stage1_model, dest_path))
print 'done!'
print 'stage-1 done!'
# =============== stage-2 training fast-rcnn with proposals generated by rpn
if current_stage <= 2:
print 'start stage-2...'
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# Append proposl boxes
test_rpn_net.NMS_CONFIG = train_cfg.stage1_nms
imdb = test_rpn_net.imdb_append_proposals(train_cfg.stage1.test_net,
train_cfg.stage1.model_path.format(imdb.name), imdb, anchors_file)
roidb = fast_rcnn_train.get_training_roidb(imdb)
output_dir = fast_rcnn_config.get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
### mix anothor dataset
if args.mix_imdb_name != None:
imdb_mix = get_imdb(args.mix_imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb_mix.name)
imdb_mix = test_rpn_net.imdb_append_proposals(train_cfg.stage1.test_net,
train_cfg.stage1.model_path.format(imdb.name), imdb_mix, anchors_file)
roidb_mix = fast_rcnn_train.get_training_roidb(imdb_mix)
roidb.extend(roidb_mix)
###
stage2_model = fast_rcnn_train.train_net(train_cfg.stage2.solver,
roidb, output_dir, final_name=imdb.name,
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
def rpn_evaluate(net,
imdb,
IoUThresh=0.5,
numMaxDets=[200, 500, 1000, 2000],
rpn_file=None,
score_file=None):
"""evaluate the performance of region proposals of rpn net
writen by Yali Li """
if rpn_file is not None and score_file is not None:
f_boxes = open(rpn_file, 'rb')
imdb_boxes = cPickle.load(f_boxes)
f_scores = open(rpn_file, 'rb')
imdb_scores = cPickle.load(f_scores)
else:
imdb_boxes, imdb_scores = imdb_proposals(net, imdb)
imdb.set_proposal_method('gt')
roidb = get_training_roidb(imdb)
imdb_rank_gt = [[] for _ in xrange(imdb.num_images)]
print imdb.num_images
for i in xrange(imdb.num_images):
# sort by confidence
'''
sorted_ind = np.argsort(-imdb_scores[i])
sorted_scores = np.sort(-imdb_scores[i])
BB = imdb_boxes[i][sorted_ind, :]
imdb_boxes[i] = BB
imdb_scores[i] = sorted_scores
'''
# determine if the region proposals overlaps
BBGT = roidb[i]['boxes'].reshape(-1, 4)
bb = imdb_boxes[i]
rank_gt = np.zeros(BBGT.shape[0])
for j in xrange(BBGT.shape[0]):
# compute overlaps
# intersection
ixmin = np.maximum(BBGT[j, 0], bb[:, 0])
iymin = np.maximum(BBGT[j, 1], bb[:, 1])
ixmax = np.minimum(BBGT[j, 2], bb[:, 2])
iymax = np.minimum(BBGT[j, 3], bb[:, 3])
iw = np.maximum(ixmax - ixmin + 1., 0.)
ih = np.maximum(iymax - iymin + 1., 0.)
inters = iw * ih
# union
uni = ((bb[:, 2] - bb[:, 0] + 1.) * (bb[:, 3] - bb[:, 1] + 1.) +
(BBGT[j, 2] - BBGT[j, 0] + 1.) *
(BBGT[j, 3] - BBGT[j, 1] + 1.) - inters)
overlaps = inters / uni
J = np.where(overlaps >= IoUThresh)[0]
if J.size > 0:
rank_gt[j] = np.min(J)
else:
rank_gt[j] = -1
imdb_rank_gt[i] = rank_gt
imdb_rank_gt = np.hstack(np.array(imdb_rank_gt))
num_all_gdtruths = len(imdb_rank_gt)
num_max_dets = np.max(numMaxDets, axis=0)
rec = np.zeros((num_max_dets, 1))
for k in xrange(1, num_max_dets):
inds = np.where((imdb_rank_gt >= 0) & (imdb_rank_gt < k))[0]
num_inds = len(inds)
# print float(num_inds)/num_all_gdtruths
rec[k] = float(num_inds) / num_all_gdtruths
mAR = np.zeros((len(numMaxDets), 1))
for m in xrange(len(numMaxDets)):
mAR[m] = np.mean(rec[:numMaxDets[m]], axis=0)
# print "The recall of rpn proposals: "
# print numMaxDets
# print mAR
return mAR.transpose(1, 0)
print 'done!'
print 'stage-1 done!'
# =============== stage-2 training fast-rcnn with proposals generated by rpn
if current_stage <= 2:
print 'start stage-2...'
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# Append proposl boxes
test_rpn_net.NMS_CONFIG = train_cfg.stage1_nms
imdb = test_rpn_net.imdb_append_proposals(
train_cfg.stage1.test_net,
train_cfg.stage1.model_path.format(imdb.name), imdb, anchors_file)
roidb = fast_rcnn_train.get_training_roidb(imdb)
output_dir = fast_rcnn_config.get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
### mix anothor dataset
if args.mix_imdb_name != None:
imdb_mix = get_imdb(args.mix_imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb_mix.name)
imdb_mix = test_rpn_net.imdb_append_proposals(
train_cfg.stage1.test_net,
train_cfg.stage1.model_path.format(imdb.name), imdb_mix,
anchors_file)
roidb_mix = fast_rcnn_train.get_training_roidb(imdb_mix)
roidb.extend(roidb_mix)
###
model_name = 'GOOGLENET4'
elif 'GOOGLENET5' in model_name:
model_name = 'GOOGLENET5'
elif 'GOOGLENET' in model_name:
model_name = 'GOOGLENET'
elif 'INCEPTION' in model_name:
model_name = 'GOOGLENET_BN'
else:
raise Exception("This model is not supported. %s" % model_name)
cfg.MODEL_NAME = model_name
imdb = get_imdb(args.imdb_name, model_to_use, proposal, proposal_file)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
# DJDJ
#imdb.rpn_train_roidb()
roidb = get_training_roidb(imdb, args.model_to_use, args.proposal_file)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(args.solver, imdb.bbox_means, imdb.bbox_stds, roidb, output_dir,
proposal_file,
pretrained_model=args.pretrained_model,
restore=args.restore,
max_iters=args.max_iters,
model_to_use=model_to_use,
proposal=proposal)
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)
print 'Use network `{:s}` in training'.format(args.source_network_name)
source_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES,
scope='source')
from datasets.caltech import caltech
from datasets.inria import inria
import datasets.imdb
import caffe
import numpy as np
import sys
if __name__ == '__main__':
#set up global variable 'cfg' for train
train_solver = sys.path[4] + '/' + 'models/pascal_voc_person/VGG16/solver.prototxt'
pretrained_caffemodel = sys.path[4] + '/' + 'data/imagenet_models/VGG16.caffemodel'
max_iterations = 4000
train_imdb = inria(train = 1)
roidb = get_training_roidb(train_imdb)
# set up global varibles for validation
validation_network = sys.path[4]+'/'+ 'models/pascal_voc_person/VGG16/test.prototxt'
validation_imdb = inria(test = 1)
# set up global caffe mode
cfg_file = sys.path[4] + '/' + 'models/pascal_voc_person/VGG16/vgg16_faster_rcnn.yml'
if 1:
train_solver = 'models/pascal_voc_person/VGG16/solver.prototxt'
pretrained_caffemodel = 'data/imagenet_models/VGG16.caffemodel'
validation_network = 'models/pascal_voc_person/VGG16/test.prototxt'
cfg_file = 'models/pascal_voc_person/VGG16/vgg16_faster_rcnn.yml'
cfg_from_file(cfg_file)
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)
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)
# set up caffe
caffe.set_mode_gpu()
if args.gpu_id is not None:
caffe.set_device(args.gpu_id)
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
roidb = get_training_roidb(imdb)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# roidb_s,roidb_w, = weakly_supervised_roidb(roidb)
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
caffe.set_mode_gpu()
caffe.set_device(cfg.GPU_ID)
caffe.init_glog(path_env['caffe_log'])
imdb = tsv(args.data, 'train')
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
#generate training/testing prototxt
if not args.skip_genprototxt:
gen_prototxt.generate_prototxt(path_env['basemodel'].split('_')[0],
imdb.num_images, imdb.num_classes,
path_env['output'])
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
print 'Set proposal method: {:s}'.format(cfg.TRAIN.PROPOSAL_METHOD)
roidb = get_training_roidb(imdb) #imdb.gt_roidb()
print '{:d} roidb entries'.format(len(roidb))
train_net(path_env['solver'],
roidb,
path_env['snapshot'],
pretrained_model=path_env['basemodel'],
max_iters=args.max_iters)
print 'training finished in %s seconds' % (time.time() - start)
#get final models
labelmap_src = op.join(path_env['data'], "labelmap.txt")
net_final = latest_model(path_env['model_pattern'])
labelmap_src = op.join(path_env['data'], "labelmap.txt")
proto_src = op.join(path_env['output'], "test.prototxt")
