def solve(proto, roidb, pretrained_model, gpus, uid, rank, output_dir,
max_iter, reload):
caffe.set_device(gpus[rank])
caffe.set_mode_gpu()
caffe.set_solver_count(len(gpus))
caffe.set_solver_rank(rank)
caffe.set_multiprocess(True)
cfg.GPU_ID = gpus[rank]
solverW = SolverWrapper(solver_prototxt=proto,
roidb=roidb,
output_dir=output_dir,
gpu_id=rank,
pretrained_model=pretrained_model,
reload=reload)
solver = solverW.get_solver()
nccl = caffe.NCCL(solver, uid)
nccl.bcast()
solver.add_callback(nccl)
if solver.param.layer_wise_reduce:
solver.net.after_backward(nccl)
while solver.iter < max_iter:
solver.step(1)
if solver.iter % cfg.TRAIN.SNAPSHOT_ITERS == 0 and rank == 0:
solverW.snapshot()
tao = 60000
beta = 1000
# updatable hypeparameters
gamma = 0.6
mylambda = np.array([-np.log(0.9)] * imdb.num_classes)
# train record
loopcounter = 0
train_iters = 0
iters_sum = train_iters
discard_num = 0
# record number for some al proportion
checkpoint = [int(x * imdb.num_images) for x in np.linspace(0.1, 1, 10)]
# get solver instance
sw = SolverWrapper(args.solver,
train_roidb,
output_dir,
pretrained_model=pretrained_model_name)
#sw.train_model(70000)
while (True):
# detact remaining samples
remaining = list(set(range(imdb.num_images)) - set(tableA.nonzero()))
# load latest trained model
pretrained_model_name = choose_model(output_dir)
modelpath = os.path.join(output_dir, pretrained_model_name)
protopath = os.path.join('models/pascal_voc/ResNet-50/rfcn_end2end',
'test_agnostic.prototxt')
print 'choose latest model:{}'.format(modelpath)
model = load_model(protopath, modelpath)
scoreMatrix, boxRecord, yVecs, eps = bulk_detect(
model, remaining, imdb, mylambda)
imdb_name = 'voc_2007_trainval'
solver = '/net/wujial/py-R-FCN/models/pascal_voc/ResNet-50/soft_rfcn_alt_opt_5step_ohem/stage1_rfcn_ohem_solver80k120k.pt'
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)
roidb = filter_roidb(roidb)
sw = SolverWrapper(solver, roidb, output_dir, init_model)
sw.solver.step(1)
net = sw.solver.net
netdata = dict()
saveto = 'test.mat'
netdata['data'] = net.blobs['data'].data
netdata['res5c'] = net.blobs['res5c'].data
sio.savemat(saveto,netdata)
if os.path.exists(final_caffemodel):
print 'has done'
else:
model_paths = train_net(solver, roidb, output_dir,
pretrained_model=init_model,