def __init__(self, solver_prototxt, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
caffe.set_mode_gpu()
caffe.set_device(0)
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
python类SolverParameter()的实例源码
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver, output_dir, pretrained_model=None, gpu_id=0, data=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
caffe.set_mode_gpu()
caffe.set_device(gpu_id)
self.solver = caffe.SGDSolver(solver)
if pretrained_model is not None:
print(('Loading pretrained model '
'weights from {:s}').format(pretrained_model))
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_data(data)
def make_solver(options):
solver = caffe_pb2.SolverParameter()
solver.train_net = options.train_net
if options.test_net is not None:
solver.test_net.append(options.test_net)
solver.test_iter.append(50)
solver.test_interval = 100
solver.base_lr = options.lr
solver.lr_policy = "step"
solver.gamma = 0.1
solver.stepsize = 100000
solver.display = 5
solver.max_iter = 400000
solver.momentum = options.momentum
solver.weight_decay = 0.0005
solver.regularization_type = 'L2'
solver.snapshot = 2000
solver.solver_mode = solver.GPU
solver.iter_size = options.iter_size
solver.snapshot_format = solver.BINARYPROTO
solver.type = 'SGD'
solver.snapshot_prefix = options.snapshot_prefix
return solver
def __init__(self, solver_prototxt, roidb, output_dir,
model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
self.solver = caffe.SGDSolver(solver_prototxt)
if model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(model)
self.solver.net.copy_from(model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def get_solver(folder):
s = caffe_pb2.SolverParameter()
s.train_net = './%s/proto_train.prototxt'%folder
s.snapshot = 10000
s.snapshot_prefix = './%s/'%folder
s.max_iter = int(config.MAX_ITERATIONS)
s.display = int(config.VALIDATE_INTERVAL)
s.type = 'Adam'
s.stepsize = int(config.MAX_ITERATIONS*0.2)
s.gamma = 0.5
s.lr_policy = "step"
s.base_lr = 0.0007
s.momentum = 0.9
s.momentum2 = 0.999
s.weight_decay = 0.000
s.clip_gradients = 10
return s
def get_solver(folder):
s = caffe_pb2.SolverParameter()
s.train_net = './%s/proto_train.prototxt'%folder
s.snapshot = int(config.VALIDATE_INTERVAL)
s.snapshot_prefix = './%s/'%folder
s.max_iter = int(config.MAX_ITERATIONS)
s.display = int(config.VALIDATE_INTERVAL)
s.type = 'Adam'
s.stepsize = int(config.MAX_ITERATIONS*0.4)
s.gamma = 0.5
s.lr_policy = "step"
s.base_lr = 0.0007
s.momentum = 0.9
s.momentum2 = 0.999
s.weight_decay = 0.000
s.clip_gradients = 10
return s
def get_solver(folder):
s = caffe_pb2.SolverParameter()
s.train_net = './%s/proto_train.prototxt'%folder
s.snapshot = 10000
s.snapshot_prefix = './%s/'%folder
s.max_iter = int(config.MAX_ITERATIONS)
s.display = int(config.VALIDATE_INTERVAL)
s.type = 'Adam'
s.stepsize = int(config.MAX_ITERATIONS*0.4)
s.gamma = 0.25
s.lr_policy = "step"
s.base_lr = 0.0007
s.momentum = 0.9
s.momentum2 = 0.999
s.weight_decay = 0.000
s.clip_gradients = 10
return s
def get_solver(folder):
s = caffe_pb2.SolverParameter()
s.train_net = './%s/proto_train.prototxt'%folder
s.snapshot = int(config.VALIDATE_INTERVAL)
s.snapshot_prefix = './%s/'%folder
s.max_iter = int(config.MAX_ITERATIONS)
s.display = int(config.VALIDATE_INTERVAL)
s.type = 'Adam'
s.stepsize = int(config.MAX_ITERATIONS*0.4)
s.gamma = 0.5
s.lr_policy = "step"
s.base_lr = 0.0007
s.momentum = 0.9
s.momentum2 = 0.999
s.weight_decay = 0.000
s.clip_gradients = 10
return s
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver, output_dir, pretrained_model=None, gpu_id=0, data=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
caffe.set_mode_gpu()
caffe.set_device(gpu_id)
self.solver = caffe.SGDSolver(solver)
if pretrained_model is not None:
print(('Loading pretrained model '
'weights from {:s}').format(pretrained_model))
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_data(data)
def __init__(self, solver_path = '', debug=False):
"""
Initialise solver params
If a file is given, SolverConfig is initialised with params from that file
"""
self.sp = caffe_pb2.SolverParameter()
#critical:
self.sp.base_lr = 0.01
self.sp.momentum = 0.9
if solver_path:
self.read(solver_path)
if debug:
self.sp.max_iter = 12
self.sp.display = 1
self.sp.type = 'SGD'
def __init__(self, solver_prototxt, roidb, output_dir, pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG:
if cfg.IS_RPN:
self.bbox_means, self.bbox_stds = gdl_roidb.add_bbox_regression_targets(roidb)
else:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def parse_solver(self):
solverPath = self.solverPath;
self.expName = os.path.split(solverPath)[-1].split('_')[0];
self.expDir = os.path.split(solverPath)[0];
self.solver_param = caffe_pb2.SolverParameter();
with open(self.solverPath, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
allLines = [x.strip() for x in open(solverPath,'r')];
snapPath = self.solver_param.snapshot_prefix;
snapExp = os.path.split(snapPath)[-1];
snapPath = os.path.split(snapPath)[0];
sg_utils.mkdir(snapPath);
assert( os.path.isdir(snapPath) ), '%s does not exist'%(snapPath);
self.snapPath = snapPath;
assert( self.snapPath == os.path.split(self.solver_param.snapshot_prefix)[0] );
def __init__(self, solver_prototxt, db, output_dir, do_flip,
snapshot_path=None):
"""Initialize the SolverWrapper."""
self._output_dir = output_dir
self._solver = caffe.SGDSolver(solver_prototxt)
self._solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self._solver_param)
infix = ('_' + cfg.TRAIN.SNAPSHOT_INFIX
if cfg.TRAIN.SNAPSHOT_INFIX != '' else '')
self._snapshot_prefix = self._solver_param.snapshot_prefix + infix + '_iter_'
if snapshot_path is not None:
print ('Loading snapshot weights from {:s}').format(snapshot_path)
self._solver.net.copy_from(snapshot_path)
snapshot_path = snapshot_path.split('/')[-1]
if snapshot_path.startswith(self._snapshot_prefix):
print 'Warning! Existing snapshots may be overriden by new snapshots!'
self._db = db
self._solver.net.layers[0].set_db(self._db, do_flip)
def make_solver():
s = caffe_pb2.SolverParameter()
s.random_seed = 0xCAFFE
s.train_net = 'train_densenet.prototxt'
s.test_net.append('test_densenet.prototxt')
s.test_interval = 800
s.test_iter.append(200)
s.max_iter = 230000
s.type = 'Nesterov'
s.display = 1
s.base_lr = 0.1
s.momentum = 0.9
s.weight_decay = 1e-4
s.lr_policy='multistep'
s.gamma = 0.1
s.stepvalue.append(int(0.5 * s.max_iter))
s.stepvalue.append(int(0.75 * s.max_iter))
s.solver_mode = caffe_pb2.SolverParameter.GPU
solver_path = 'solver.prototxt'
with open(solver_path, 'w') as f:
f.write(str(s))
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
nccl_uid, rank, bbox_means=None, bbox_stds=None,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
self.rank = rank
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = bbox_means, bbox_stds
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
self.solver = caffe.SGDSolver(solver_prototxt)
assert caffe.solver_count() * cfg.TRAIN.IMS_PER_BATCH * self.solver.param.iter_size == \
cfg.TRAIN.REAL_BATCH_SIZE, "{} vs {}". \
format(caffe.solver_count() * cfg.TRAIN.IMS_PER_BATCH * self.solver.param.iter_size, cfg.TRAIN.REAL_BATCH_SIZE)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
nccl = caffe.NCCL(self.solver, nccl_uid)
nccl.bcast()
self.solver.add_callback(nccl)
assert self.solver.param.layer_wise_reduce
if self.solver.param.layer_wise_reduce:
self.solver.net.after_backward(nccl)
self.nccl = nccl # hold the reference to nccl
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
proto_file.py 文件源码
项目：Sensor-Specific-Hyperspectral-Image-Feature-Learning
作者: MeiShaohui
项目源码
文件源码
阅读 21
收藏 0
点赞 0
评论 0
def train_solver(conf):
s = caffe_pb2.SolverParameter()
# Set a seed for reproducible experiments:
# this controls for randomization in training.
#s.random_seed = 0xCAFFE
# Specify locations of the train and (maybe) test networks.
s.train_net = conf.train_net_file
s.test_net.append(conf.test_net_file)
s.test_interval = 10000 # Test after every 500 training iterations.
s.test_iter.append(1) # Test on 100 batches each time we test.
s.max_iter = conf.max_iter # no. of times to update the net (training iterations)
# s.max_iter = 50000 # no. of times to update the net (training iterations)
s.type = "AdaGrad"
s.gamma = 0.1
s.base_lr = 0.01
s.weight_decay = 5e-4
s.lr_policy = 'multistep'
s.display = 10000
s.snapshot = 10000
s.snapshot_prefix = conf.snapshot_prefix
#s.stepvalue.append(1000000)
#s.stepvalue.append(300000)
s.solver_mode = caffe_pb2.SolverParameter.GPU
s.device_id = 1 # will use the second GPU card
s.snapshot_format = 0 # 0 is HDF5, 1 is binary
return s
def build_solver(solver_filename, **kwargs):
solver = caffe_pb2.SolverParameter()
for k, v in kwargs.iteritems():
setattr(solver, v)
with open(solver_filename, 'w') as f:
f.write(text_format.MessageToString(solver))
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def generate_solver_proto(solver_fn, model_fn, trainOpts):
from caffe.proto import caffe_pb2
solver = caffe_pb2.SolverParameter()
solver.net = model_fn
if trainOpts.num_lr_decays > 0:
solver.lr_policy = 'step'
solver.gamma = trainOpts.lr_decay_factor
solver.stepsize = int(trainOpts.iters/(trainOpts.num_lr_decays+1))
else:
solver.lr_policy = 'fixed'
solver.base_lr = trainOpts.init_lr
solver.max_iter = trainOpts.iters
solver.display = 20
solver.momentum = 0.9
solver.weight_decay = trainOpts.paramReg
solver.test_state.add()
solver.test_state.add()
solver.test_state[0].stage.append('TestRecognition')
solver.test_state[1].stage.append('TestZeroShot')
solver.test_iter.extend([20, 20])
solver.test_interval = 100
solver.snapshot = 5000
solver.snapshot_prefix = os.path.splitext(model_fn)[0]
with open(solver_fn, 'w') as f:
f.write(str(solver))
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
if (cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and
cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
# RPN can only use precomputed normalization because there are no
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
self.solver = caffe.SGDSolver(solver_prototxt)
if pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
pb2.text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
