def train(stps):
import _init_paths
import caffe
from train_net import combined_roidb
from fast_rcnn.train import train_net
from fast_rcnn.config import cfg, get_output_dir
print "Train with configs:"
print cfg.TRAIN
print "Setup:"
print stps
gpu_id = stps["GPU_ID"]
solver = stps["TRAIN"]["SOLVER"]
iters = stps["TRAIN"]["ITERS"]
imdb_name = stps["TRAIN"]["IMDB"]
pretrained_model = stps["TRAIN"]["WEIGHTS"]
caffe.set_mode_gpu()
caffe.set_device(gpu_id)
imdb, roidb = combined_roidb(imdb_name)
output_dir = get_output_dir(imdb)
print '{:d} roidb entries'.format(len(roidb))
print 'Output will be saved to `{:s}`'.format(output_dir)
train_net(solver,
roidb,
output_dir,
pretrained_model=pretrained_model,
max_iters=iters)
def train(classes,
cfg_file,
solver_proto,
train_prototxt,
pretrained_model,
max_iters,
imdb_name='voc_2007_trainval',
set_cfgs=None):
if cfg_file is not None:
cfg_from_file(cfg_file)
if set_cfgs is not None:
cfg_from_list(set_cfgs)
if train_prototxt is not None:
aux_tools.change_train_prototxt(
train_prototxt,
len(classes) + 1) # add 1 -- should consider background
imdb, roidb = combined_roidb(imdb_name, classes)
print imdb.classes
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(solver_proto,
roidb,
output_dir,
pretrained_model=pretrained_model,
max_iters=max_iters)
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 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 train_rerank(imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None):
"""
Train a Region Proposal Network in a separate training process.
"""
cfg.TRAIN.PROPOSAL_METHOD = 'mat'
cfg.TRAIN.FG_THRESH = 0.7
cfg.TRAIN.BG_THRESH_HI = 0.3
cfg.TRAIN.BG_THRESH_LO = 0.0
cfg.TRAIN.SNAPSHOT_ITERS = 10000
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
mat_file = os.path.join(cfg.DATA_DIR, 'edge_boxes_data', imdb_name+'.mat')
roidb, imdb = get_roidb(imdb_name, mat_file=mat_file)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
print 'Final model: {}'.format(model_paths[-1])
def train_rpn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None):
"""Train a Region Proposal Network in a separate training process.
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
cfg.TRAIN.BBOX_REG = False # applies only to Fast R-CNN bbox regression
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rpn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
queue.put({'model_path': rpn_model_path})
def train_rpn(imdb_name=None,
init_model=None,
solver=None,
max_iters=None,
cfg=None):
"""Train a Region Proposal Network in a separate training process.
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
cfg.TRAIN.BBOX_REG = False # applies only to Fast R-CNN bbox regression
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
roidb, imdb = get_roidb(imdb_name)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver,
roidb,
output_dir,
pretrained_model=init_model,
max_iters=max_iters)
def train_rpn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None):
"""Train a Region Proposal Network in a separate training process.
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
cfg.TRAIN.BBOX_REG = False # applies only to Fast R-CNN bbox regression
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rpn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
return {'model_path': rpn_model_path}
def train_fast_rcnn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None, rpn_file=None):
"""Train a Fast R-CNN using proposals generated by an RPN.
"""
cfg.TRAIN.HAS_RPN = False # not generating prosals on-the-fly
cfg.TRAIN.PROPOSAL_METHOD = 'rpn' # use pre-computed RPN proposals instead
cfg.TRAIN.IMS_PER_BATCH = 2
print 'Init model: {}'.format(init_model)
print 'RPN proposals: {}'.format(rpn_file)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train Fast R-CNN
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
fast_rcnn_model_path = model_paths[-1]
# Send Fast R-CNN model path over the multiprocessing queue
queue.put({'model_path': fast_rcnn_model_path})
def train_fast_rcnn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None, rpn_file=None):
"""Train a Fast R-CNN using proposals generated by an RPN.
"""
cfg.TRAIN.HAS_RPN = False # not generating prosals on-the-fly
cfg.TRAIN.PROPOSAL_METHOD = 'rpn' # use pre-computed RPN proposals instead
cfg.TRAIN.IMS_PER_BATCH = 2
print 'Init model: {}'.format(init_model)
print 'RPN proposals: {}'.format(rpn_file)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train Fast R-CNN
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
fast_rcnn_model_path = model_paths[-1]
# Send Fast R-CNN model path over the multiprocessing queue
return {'model_path': fast_rcnn_model_path}
def train_plain_zf(queue=None,
imdb_name=None,
init_model=None,
solver=None,
max_iters=None,
cfg=None):
"""Train a plain ZF for face attributes prediction.
"""
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
# initialize caffe
_init_caffe(cfg.GPU_ID)
roidb, imdb = get_roidb(imdb_name)
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train plain ZF
model_paths = train_net(solver,
roidb,
output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
#for i in model_paths[:-1]:
#os.remove(i)
plain_zf_model_path = model_paths[-1]
# Send plain ZF model path over the multiprocessing queue
queue.put({'model_path': plain_zf_model_path})
def finetune(net_params, roidb, GPU_ID=1):
solver, train_pt, caffenet, bbox_pred_name, max_iters, output_dir, output_prefix = net_params
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
print 'Trained model will be saved to `{:s}`'.format(output_dir)
caffe.set_mode_gpu()
caffe.set_device(GPU_ID)
train_net(solver,
roidb,
output_dir,
output_prefix,
pretrained_model=caffenet,
max_iters=max_iters,
bbox_pred_name="bbox_pred-coco")
def train_rpn(queue=None, imdb_name=None, init_model=None, \
solver=None, max_iters=None, cfg=None):
"""
Train a Region Proposal Network in a separate training process.
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
# Applies only to Fast R-CNN bbox regression
cfg.TRAIN.BBOX_REG = False
# Roidb handler
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
# Batch size
cfg.TRAIN.IMS_PER_BATCH = cfg.TRAIN.RPN_IMS_PER_BATCH
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
# Roidb & Imdb
stage_flag = "RPN TRAIN"
roidb, imdb = get_roidb(imdb_name, stage_flag=stage_flag)
print 'roidb len: {}'.format(len(roidb))
# Output directory
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Net & Solver
# here set image_cls param to be None
# since rpn training need all images of input dataset
# but it remains the data bias
model_paths = train_net(solver,
roidb,
output_dir,
imdb.image_index,
None,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
if cfg.TRAIN.IS_RPN_REMOVE_MODEL:
for i in model_paths[:-1]:
if os.path.exists(i) and os.path.isfile(i):
os.remove(i)
rpn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
queue.put({'model_path': rpn_model_path})
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 train_fast_rcnn(queue=None, imdb_name=None, init_model=None, solver=None, \
max_iters=None, cfg=None, rpn_file=None, roidbs_cache_path=None):
"""
Train a Fast R-CNN using proposals generated by an RPN.
"""
# not generating prosals on-the-fly
cfg.TRAIN.HAS_RPN = False
# use pre-computed RPN proposals instead
if roidbs_cache_path is not None and len(roidbs_cache_path) > 0:
cfg.TRAIN.PROPOSAL_METHOD = 'cache_rpn'
else:
cfg.TRAIN.PROPOSAL_METHOD = 'rpn'
cfg.TRAIN.IMS_PER_BATCH = cfg.TRAIN.FAST_RCNN_IMS_PER_BATCH
print 'Init model: {}'.format(init_model)
print 'RPN proposals: {}'.format(rpn_file)
print 'roidbs_cache_path: {}'.format(roidbs_cache_path)
print 'Using config:'
print
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
# get roidb
stage_flag = "FAST_RCNN TRAIN"
roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file, stage_flag=stage_flag, \
roidbs_cache_path=roidbs_cache_path)
# get output
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train Fast R-CNN
model_paths = train_net(solver,
roidb,
output_dir,
imdb.image_index,
imdb.image_cls,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
if cfg.TRAIN.IS_FAST_RCNN_REMOVE_MODEL:
for i in model_paths[:-1]:
os.remove(i)
fast_rcnn_model_path = model_paths[-1]
# Send Fast R-CNN model path over the multiprocessing queue
queue.put({'model_path': fast_rcnn_model_path})
def train_rfcn(queue=None,
imdb_name=None,
init_model=None,
solver=None,
max_iters=None,
cfg=None,
rpn_file=None,
output_cache=None):
"""Train a R-FCN using proposals generated by an RPN.
"""
cfg.TRAIN.HAS_RPN = False # not generating prosals on-the-fly
cfg.TRAIN.PROPOSAL_METHOD = 'rpn' # use pre-computed RPN proposals instead
cfg.TRAIN.IMS_PER_BATCH = 1
print
'Init model: {}'.format(init_model)
print
'RPN proposals: {}'.format(rpn_file)
print('Using config:')
pprint.pprint(cfg)
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
output_dir = get_output_dir(imdb)
print
'Output will be saved to `{:s}`'.format(output_dir)
# Train R-FCN
# Send R-FCN model path over the multiprocessing queue
final_caffemodel = os.path.join(output_dir, output_cache)
if os.path.exists(final_caffemodel):
queue.put({'model_path': final_caffemodel})
else:
model_paths = train_net(solver,
roidb,
output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rfcn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
shutil.copyfile(rfcn_model_path, final_caffemodel)
queue.put({'model_path': final_caffemodel})
def train_rerank(queue=None,
imdb_names=None,
init_model=None,
solver=None,
max_iters=None,
cfg=None):
"""
Train a Region Proposal Network in a separate training process.
"""
cfg.TRAIN.RERANK_PROPOSAL = True
cfg.TRAIN.PROPOSAL_METHOD = 'mat'
cfg.TRAIN.IMS_PER_BATCH = 1
cfg.TRAIN.BATCH_SIZE = 256
cfg.TRAIN.FG_FRACTION = 0.5
cfg.TRAIN.FG_THRESH = 0.7
cfg.TRAIN.BBOX_THRESH = 0.7
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
imdb, roidb = combined_roidb(imdb_names,
mat_folder=cfg.TRAIN.RERANK_PROP_PATH)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver,
roidb,
output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rerank_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
queue.put({'model_path': rerank_model_path})
def train_roi_conv(imdb_name=None,
init_model=None,
solver=None,
max_iter=None,
cfg=None):
"""Train a Region Proposal Network in a separate training process.
"""
#imdb_name: train
_init_caffe(cfg)
import caffe
roidb, imdb = get_roidb(imdb_name)
from fast_rcnn.train import train_net
model_paths = train_net(solver,
roidb,
'./',
pretrained_model=init_model,
max_iters=max_iter)
print 'Training are finished in train process'
def train_detection(queue=None,
imdb_names=None,
init_model=None,
solver=None,
max_iters=None,
cfg=None,
pkl_folder=None):
"""Train a detection network using proposals generated by an RERANK."""
cfg.TRAIN.RERANK_PROPOSAL = False # not generating prosals on-the-fly
cfg.TRAIN.PROPOSAL_METHOD = 'pkl' # use pre-computed RERANK proposals instead
cfg.TRAIN.IMS_PER_BATCH = 1
cfg.TRAIN.BATCH_SIZE = 256
cfg.TRAIN.FG_FRACTION = 0.25
cfg.TRAIN.FG_THRESH = 0.5
cfg.TRAIN.BBOX_THRESH = 0.5
print 'Init model: {}'.format(init_model)
print 'RERANK proposals: {}'.format(pkl_folder)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
imdb, roidb = combined_roidb(imdb_names, pkl_folder=pkl_folder)
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train detection network
model_paths = train_net(solver,
roidb,
output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
detection_model_path = model_paths[-1]
# Send detection model path over the multiprocessing queue
queue.put({'model_path': detection_model_path})
def train_rpn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None, output_cache=None,model_name=None):
"""Train a Region Proposal Network in a separate training process.
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
cfg.TRAIN.BBOX_REG = False # applies only to R-FCN bbox regression
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
#final_caffemodel = os.path.join(output_dir, output_cache)
print model_name,output_cache
final_caffemodel = '/net/wujial/py-R-FCN/models/pascal_voc/ResNet-101/' + model_name + '/'+ output_cache
if os.path.exists(final_caffemodel):
queue.put({'model_path': final_caffemodel})
else:
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters,model_name = model_name)
# Cleanup all but the final model
#for i in model_paths[:-1]:
# os.remove(i)
rpn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
shutil.copyfile(rpn_model_path, final_caffemodel)
queue.put({'model_path': final_caffemodel})
def train_rfcn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None, rpn_file=None, output_cache=None):
"""Train a R-FCN using proposals generated by an RPN.
"""
cfg.TRAIN.HAS_RPN = False # not generating prosals on-the-fly
cfg.TRAIN.PROPOSAL_METHOD = 'rpn' # use pre-computed RPN proposals instead
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print 'RPN proposals: {}'.format(rpn_file)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name, rpn_file=rpn_file)
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Train R-FCN
# Send R-FCN model path over the multiprocessing queue
final_caffemodel = os.path.join(output_dir, output_cache)
if os.path.exists(final_caffemodel):
queue.put({'model_path': final_caffemodel})
else:
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rfcn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
shutil.copyfile(rfcn_model_path, final_caffemodel)
queue.put({'model_path': final_caffemodel})
def train_rpn(queue=None, imdb_name=None, init_model=None, solver=None,
max_iters=None, cfg=None):
"""Train a Region Proposal Network in a separate training process.
首先这里初始化了一些配置，比较容易忽略的的是PROPOSAL_METHOD设置成了’gt’，值得一提。
这个设定是从get_roidb然后追溯到底层数据类pascal-voc得到体现，可以看到imdb(pascal_voc的
父类)通过roidb_handler来决定用什么方式生成roidb，默认为selective_search，这里用了gt_roidb。
随后，该函数做了一些训练的准备工作，初始化模型，确定路径等，然后再开始正式训练
"""
# Not using any proposals, just ground-truth boxes
cfg.TRAIN.HAS_RPN = True
cfg.TRAIN.BBOX_REG = False # applies only to Fast R-CNN bbox regression
cfg.TRAIN.PROPOSAL_METHOD = 'gt'
cfg.TRAIN.IMS_PER_BATCH = 1
print 'Init model: {}'.format(init_model)
print('Using config:')
pprint.pprint(cfg)
import caffe
_init_caffe(cfg)
roidb, imdb = get_roidb(imdb_name)
print 'roidb len: {}'.format(len(roidb))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,
max_iters=max_iters)
# Cleanup all but the final model
for i in model_paths[:-1]:
os.remove(i)
rpn_model_path = model_paths[-1]
# Send final model path through the multiprocessing queue
queue.put({'model_path': rpn_model_path})
print pretrained_caffemodel
max_iterations = 45000
cfg_from_file(cfg_file)
cfg.GPU_ID = 0
# set up global caffe mode
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
caffe.set_mode_gpu()
caffe.set_device(0)
# set up train imdb
#imdb = pascal_voc_person('person_trainval','2007')
#imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
imdb = caltech(train = 1)
roidb = get_training_roidb(imdb)
print '{:d} roidb entries'.format(len(roidb))
# setup output result directory
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# train net
train_net(train_solver, roidb, output_dir,
pretrained_model=pretrained_caffemodel,
max_iters=max_iterations)
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)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.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,
test_during_train=args.test_during_train,
test_gpu=args.test_gpu,
test_imdb=args.test_imdb)
# 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)
print 'Use network `{:s}` in training'.format(args.network_name)
train_net(network, imdb, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
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)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.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,
previous_state=args.previous_state
)
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()
caffe.set_device(args.gpu_id)
imdb, roidb = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
# Filter out images without rois
roidb = [roi for roi in roidb if len(roi['gt_classes']) != 0]
if 'ObjectNet3D' in args.imdb_name:
db_naming = 'objectnet'
else:
db_naming = '3Dplus'
train_net(args.solver,
roidb,
output_dir,
db_naming,
args.network_specific,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
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)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
if args.debug:
caffe.SGDSolver(args.solver)
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)
if not cfg.DEBUG:
cfg.DEBUG = args.debug
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters, reload=args.reload, gpu_id = args.gpu_id)
# import pdb; pdb.set_trace()
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_device(cfg.GPU_ID)
caffe.set_mode_gpu()
# import pdb; pdb.set_trace()
# image_path_prefix = '/storage/product/detection/11st_Bag'
# loader = eleven_12cat_bag(image_path_prefix, 'train')
image_path_prefix = "/storage/product/detection/11st_All"
loader = eleven_all(image_path_prefix, "train")
output_dir = get_output_dir(loader, None)
print "Output will be saved to `{:s}`".format(output_dir)
sys.stdout.flush()
train_net(
cfg.TRAIN.SOLVER_PROTOTXT, loader, output_dir, pretrained_model=cfg.TRAIN.CAFFE_MODEL, max_iters=args.max_iters
)
#import pdb; pdb.set_trace()
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_device(cfg.GPU_ID)
caffe.set_mode_gpu()
#import pdb; pdb.set_trace()
imdb, roidb = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb))
output_dir = get_output_dir(imdb, None)
print 'Output will be saved to `{:s}`'.format(output_dir)
sys.stdout.flush()
train_net(cfg.TRAIN.SOLVER_PROTOTXT, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
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)
#imdb = get_imdb(args.imdb_name)
imdb = load_data(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)
device_name = '/{}:{:d}'.format(args.device, args.device_id)
print device_name
network = get_network(args.network_name)
print 'Use network `{:s}` in training'.format(args.network_name)
train_net(network,
imdb,
roidb,
output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
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)
# set up caffe
#caffe.set_mode_gpu()
caffe.set_mode_cpu()
# caffe.set_device(args.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)
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)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
imdbt, roidbt = combined_roidb(args.timdb_name)
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,
roidbt,
output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters,
snapshot=args.snapshot)
# 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)
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
caffe.set_mode_gpu()
caffe.set_device(0)
# setup output result directory
output_dir = get_output_dir(train_imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
# train net
train_net(train_solver, roidb, output_dir,
pretrained_model=pretrained_caffemodel,
max_iters=max_iterations,validation_cfg = (validation_network,validation_imdb))
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)
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)
train_net(args.solver, roidb, output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters,previous_state=args.previous_state)
if args.imdb_name.startswith('sz_veh') or args.imdb_name.startswith(
'sz_cyc') or args.imdb_name.startswith(
'sz_ped') or args.imdb_name.startswith('sz_lights'):
n_classes = 2
elif args.imdb_name.startswith('ksz_veh') or args.imdb_name.startswith(
'ksz_cyc') or args.imdb_name.startswith(
'ksz_ped') or args.imdb_name.startswith('ksz_lights'):
n_classes = 2
elif args.imdb_name.startswith('sz'):
n_classes = 5
elif args.imdb_name.startswith('voc'):
n_classes = 21
else:
raise Exception('Give me the correct n_classes of %s' %
(args.imdb_name))
assert len(imdb._classes) == n_classes
logging.info('----------------Use %d classes-----------------' % n_classes)
network = get_network(args.network_name, n_classes)
print 'Use network `{:s}` in training'.format(args.network_name)
train_net(network,
imdb,
roidb,
output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters,
checkpoint=args.checkpoint)
np.random.seed(cfg.RNG_SEED)
caffe.set_random_seed(cfg.RNG_SEED)
# set up caffe
caffe.set_mode_gpu()
caffe.set_device(args.gpu_id)
imdb, roidb_ori = combined_roidb(args.imdb_name)
print '{:d} roidb entries'.format(len(roidb_ori))
output_dir = get_output_dir(imdb)
print 'Output will be saved to `{:s}`'.format(output_dir)
caffemodel = train_net(args.solver,
roidb_ori,
output_dir,
pretrained_model=args.pretrained_model,
max_iters=args.max_iters)
#caffemodel = ['/home/chenyang/py-faster-rcnn/output/faster_rcnn_end2end/train/zf_faster_rcnn_iter_10000.caffemodel']
#caffemodel = ['/home/chenyang/py-faster-rcnn/output/faster_rcnn_end2end/train/zf_HNL_4cls.caffemodel']
#caffemodel = ['/home/chenyang/py-faster-rcnn/output/faster_rcnn_end2end/train/HNL_zf_iter_10000.caffemodel']
# Do hard negative learning
imgs = [
os.path.join(imdb._data_path, 'Images', x + '.jpg')
for x in imdb._image_index
]
log_file = '/home/chenyang/lib/log/result_5cls_1113_HNM.txt'
iters = 1
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__':
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)
print('Using config:')
pprint.pprint(cfg)
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(roidb, output_dir, max_iters=args.max_iters)
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__':
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)
print('Using config:')
pprint.pprint(cfg)
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(roidb, output_dir,
max_iters=args.max_iters)
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,
pretrained_model=train_cfg.common.pretrained_model,
max_iters=train_cfg.stage2.max_iters)
print 'Stage-2: training fast-rcnn finished!'
print 're-store stage-2 final model...'
dest_path = train_cfg.stage2.model_path.format(imdb.name)
os.system('cp {:s} {:s}'.format(stage2_model, dest_path))
print 'done!'
print 'stage-2 done!'
# =============== stage-3 training rpn (fc layers) with fast r-cnn parameters
if current_stage <= 3:
print 'start stage-3...'
imdb = get_imdb(args.imdb_name)
print 'Loaded dataset `{:s}` for training'.format(imdb.name)
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)
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)