def _get_next_minibatch(self, db_inds, sigma):
"""Return the blobs to be used for the next minibatch.
"""
minibatch_db = [self._roidb[i] for i in db_inds]
if cfg.TRAIN.USE_RPN_DB:
minibatch_db = self.imdb.add_rpn_rois(minibatch_db)
prepare_roidb(minibatch_db)
add_bbox_regression_targets(minibatch_db, self.bbox_means,
self.bbox_stds)
blobs = get_minibatch(minibatch_db, self._num_classes, sigma=sigma)
if blobs is not None:
blobs['db_inds'] = db_inds
return blobs
def _get_next_minibatch(self, db_inds):
next_seq = self.seqs[db_inds] # get next sequence indices
minibatch_db = [self._roidb[i] for i in self.seq2im[next_seq]
] # get the images for these sequences
if cfg.TRAIN.USE_RPN_DB:
minibatch_db = self.imdb.add_rpn_rois(minibatch_db)
prepare_roidb(minibatch_db)
add_bbox_regression_targets(minibatch_db, self.bbox_means,
self.bbox_stds)
blobs = get_minibatch(minibatch_db, self._num_classes)
if blobs is not None:
blobs['db_inds'] = self.seq2im[next_seq]
blobs['seq_name'] = next_seq
return blobs
def _get_next_minibatch(self):
"""Return the blobs to be used for the next minibatch.
If cfg.TRAIN.USE_PREFETCH is True, then blobs will be computed in a
separate process and made available through self._blob_queue.
"""
db_inds = self._get_next_minibatch_inds()
minibatch_db = [self._roidb[i] for i in db_inds]
if cfg.TRAIN.USE_RPN_DB:
minibatch_db = self._imdb.add_rpn_rois(minibatch_db)
prepare_roidb(minibatch_db)
add_bbox_regression_targets(minibatch_db, self.bbox_means,
self.bbox_stds)
return get_minibatch(minibatch_db, self._num_classes)
def __init__(self,
sess,
saver,
network,
imdb,
roidb,
output_dir,
pretrained_model=None,
resume_from_latest_ckpt=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
self.resume_from_latest_ckpt = resume_from_latest_ckpt
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
print 'done'
# For checkpoint
self.saver = saver
def __init__(self, solver_prototxt, roidb, output_dir, solverstate=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 solverstate is not None:
print('Loading solverstate '
'weights from {:s}').format(solverstate)
solverstate = solverstate.strip()
caffemodelFull = solverstate.split('.')[0] + '.caffemodel'
caffemodel = caffemodelFull.split('/')[-1]
os.symlink(caffemodelFull, caffemodel)
self.solver.restore(solverstate)
os.remove(caffemodel)
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,
sess,
network,
timdb,
vimdb,
troidb,
vroidb,
output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.timdb = timdb
self.timdb = vimdb
self.troidb = troidb
self.vroidb = vroidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
print 'done'
# For checkpoint
self.saver = tf.train.Saver(max_to_keep=100)
def __init__(self,
sess,
saver,
network,
imdb,
roidb,
output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print('Computing bounding-box regression targets...'
) # clw modify: for py3
if cfg.TRAIN.BBOX_REG:
# 不同类的均值与方差，返回格式means.ravel(), stds.ravel()
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
print('done') # clw modify: for py3
# For checkpoint
self.saver = saver
def set_imdb(self, imdb_name):
"""Set the roidb to be used by this layer during training."""
imdb, roidb = combined_roidb(imdb_name)
print '{:d} roidb entries'.format(len(roidb))
if 'nexar2' not in imdb_name:
roidb = filter_roidb(roidb)
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._imdb = imdb
self._roidb = roidb
self._shuffle_roidb_inds()
if cfg.TRAIN.USE_PREFETCH:
self._blob_queue = Queue(10)
self._prefetch_process = BlobFetcher(self._blob_queue, self._roidb,
self._num_classes)
self._prefetch_process.start()
# Terminate the child process when the parent exists
def cleanup():
print 'Terminating BlobFetcher'
self._prefetch_process.terminate()
self._prefetch_process.join()
import atexit
atexit.register(cleanup)
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.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)
#transform the last layers into convonutional
if cfg.TRAIN.SEGMENTATION:
#pretrained = caffe.Net('data/imagenet_models/deploy.prototxt',pretrained_model,caffe.TEST)
self.solver.net.params['fc6-conv'][0].data[...].flat=self.solver.net.params['fc6'][0].data[...].flat.copy()
self.solver.net.params['fc7-conv'][0].data[...].flat=self.solver.net.params['fc7'][0].data[...].flat.copy()
#del self.solver.net.outputs['fc7']
#self.solver.net.params['cls_score-conv'][0].data[...].flat=self.solver.net.params['cls_score'][0].data[...].flat
#hack to remove!!!!!!!!
#print "Setting fc7 t 0!"
#self.solver.net.params['fc7'][0].data[...]=0
#print self.solver.net.params['cls_score'][0].data
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,
sess,
saver,
network,
imdb,
roidb,
output_dir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG: # default is true
# Calculate targets ??
# tx = (Gx - Px) / Pw
# ty = (Gy - Py) / Ph
# tw = log(Gw / Pw)
# th = log(Gh / Ph)
# P should be the output of RPN
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
print 'done'
# For checkpoint
self.saver = saver
def __init__(self,
sess,
network,
imdb,
roidb,
output_dir,
pretrained_model=None,
checkpoint=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
self.checkpoint = checkpoint
if self.pretrained_model is not None and self.checkpoint is not None:
raise Exception(
'Please do not give pretrained_model and checkpoint together!')
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
"""保存这个信息是给预测用的。原先的机制是unnormalize然后保存的。原先的机制会导致无法方便地使用checkpoint进行训练。"""
with tf.variable_scope('custom', reuse=False):
bbox_means = tf.get_variable("bbox_means",
self.bbox_means.shape,
trainable=False)
bbox_stds = tf.get_variable("bbox_stds",
self.bbox_stds.shape,
trainable=False)
self.global_step = tf.Variable(0, trainable=False)
# For checkpoint
self.saver = tf.train.Saver(max_to_keep=100)
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)
if cfg.TRAIN.BBOX_REG and cfg.TRAIN.UN_NORMALIZE:
# scale and shift with bbox reg re-normalization
net = self.solver.net
net.params['bbox_pred'][0].data[...] = \
(net.params['bbox_pred'][0].data /
(self.bbox_stds[:, np.newaxis] + cfg.EPS))
net.params['bbox_pred'][1].data[...] = \
((net.params['bbox_pred'][1].data - self.bbox_means)
/ (self.bbox_stds + cfg.EPS))
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_samples(self):
""" Get samples from the dataset files. Use cache if avalable. """
self.num_classes = 21
try:
self._sample_indexes = self.load_cache(
'sample_indexes_' + str(self.shuffle_samples))
self.bbox_means = self.load_cache('bbox_means')
self.bbox_stds = self.load_cache('bbox_stds')
self.samples = self.load_cache('samples')
self.imdb = self.load_cache('imdb')
print('Loaded from cache.')
except FileNotFoundError:
print('No cache exists, loading from devkit')
imdb = pascal_voc.pascal_voc(self.set_name, self.year,
self.data_path)
cfg.TRAIN.PROPOSAL_METHOD = 'selective_search'
imdb.set_proposal_method(cfg.TRAIN.PROPOSAL_METHOD)
roidb = self.get_training_roidb(imdb)
self.save_cache('imdb', imdb, use_pickle=True)
roidb = self.filter_roidb(roidb)
(self.bbox_means,
self.bbox_stds) = rdl_roidb.add_bbox_regression_targets(roidb)
self.save_cache('bbox_means', self.bbox_means)
self.save_cache('bbox_stds', self.bbox_stds)
self.samples = roidb
self.save_cache('samples', self.samples, use_pickle=True)
self._shuffle_roidb_inds()
print('done')
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)
if cfg.TRAIN.BBOX_REG and cfg.TRAIN.UN_NORMALIZE:
# scale and shift with bbox reg re-normalization
net = self.solver.net
net.params['bbox_pred'][0].data[...] = \
(net.params['bbox_pred'][0].data /
(self.bbox_stds[:, np.newaxis] + cfg.EPS))
net.params['bbox_pred'][1].data[...] = \
((net.params['bbox_pred'][1].data - self.bbox_means)
/ (self.bbox_stds + cfg.EPS))
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)
data_layers_idx = []
for idx in xrange(len(self.solver.net.layers)):
if (self.solver.net.layers[idx].type == 'Python'):
data_layers_idx.append(idx)
for ndl in data_layers_idx:
layer_params = yaml.load(self.solver.net.layers[ndl].param_str_)
self.solver.net.layers[ndl].set_roidb(roidb)
def __init__(self,
solver_prototxt,
roidb,
output_dir,
pretrained_model=None,
previous_state=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)
elif previous_state is not None:
print('Restoring State ' ' from {:s}').format(previous_state)
self.solver.restore(previous_state)
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 train_net_multi_gpus(solver_prototxt,
roidb,
output_dir,
gpus,
pretrained_model=None,
max_iters=40000):
roidb = filter_roidb(roidb)
nccl_uid = caffe.NCCL.new_uid()
print 'Solving...'
if cfg.TRAIN.BBOX_REG:
print 'Computing bounding-box regression targets...'
bbox_means, bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
else:
bbox_means, bbox_stds = None, None
mp_queue = Queue()
procs = []
for rank in range(len(gpus)):
p = Process(target=train_net,
args=(solver_prototxt, roidb, output_dir, nccl_uid, gpus,
rank, mp_queue, bbox_means, bbox_stds,
pretrained_model, max_iters))
p.daemon = True
p.start()
procs.append(p)
for p in procs:
p.join()
print 'done solving'
return mp_queue.get() # return the result of root_solver (rank==0)
def __init__(self,
sess,
network,
imdb,
roidb,
output_dir,
logdir,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print('Computing bounding-box regression targets...')
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(
roidb)
print('done')
# For checkpoint
self.saver = tf.train.Saver(max_to_keep=100)
self.writer = tf.summary.FileWriter(logdir=logdir,
graph=tf.get_default_graph(),
flush_secs=5)
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, previous_state=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)
elif previous_state is not None:
print ('Restoring State '
' from {:s}').format(previous_state)
self.solver.restore(previous_state)
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 update_roidb(self, roidb):
roidb = filter_roidb(roidb)
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.net.layers[0].set_roidb(roidb)
def __init__(self, roidb, output_dir):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
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'
def __init__(self, roidb, output_dir):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
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'
def __init__(self,
solver_prototxt,
roidb,
output_dir,
image_index,
image_cls,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.image_cls = image_cls
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...'
print 'in lib/fast_rcnn/train.py -- __init__ func...'
if roidb is not None:
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
else:
# bbox reg from cache files
self.bbox_means = cfg.TRAIN.BBOX_REG_NORMALIZE_MEANS,
self.bbox_stds = cfg.TRAIN.BBOX_REG_NORMALIZE_STDS
assert (self.bbox_means
is not None), 'invalid bbox_means in SolverWrapper'
assert (self.bbox_stds
is not None), 'invalid bbox_stds in SolverWrapper'
print 'computing bounding-box regression targets done...'
print 'in lib/fast_rcnn/train.py -- __init__ func of SolverWrapper class.'
sleep(3)
print "instance solver"
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)
print
print "set image index, image cls and roidb"
print "in lib/fast_rcnn/train.py ..."
print
self.solver.net.layers[0].set_image_cls(image_cls)
self.solver.net.layers[0].set_image_index(image_index)
self.solver.net.layers[0].set_roidb(roidb)
sleep(3)
def __init__(self, roidb, output_dir, snap_path = None, freeze=0):
print "==========Initializing the SolverWrapper=========="
self.output_dir = output_dir
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.roidb = roidb
self.solver = Solver(self.roidb, Net(snap_path), freeze=freeze)
def __init__(self, roidb, output_dir, snap_path=None, freeze=0):
print "==========Initializing the SolverWrapper=========="
self.output_dir = output_dir
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.roidb = roidb
self.solver = Solver(self.roidb, Net(snap_path), freeze=freeze)
def __init__(self, sess, target_vars, source_vars, target_restorer,
source_restorer, target_network, source_network, target_imdb,
source_imdb, target_roidb, source_roidb):
"""Initialize the SolverWrapper."""
self.target_imdb = target_imdb
self.source_imdb = source_imdb
self.target_roidb = target_roidb
self.source_roidb = source_roidb
self.target_network = target_network
self.source_network = source_network
self.target_vars = target_vars
self.source_vars = source_vars
self.target_restorer = target_restorer
self.source_restorer = source_restorer
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG:
self.target_bbox_means, self.target_bbox_stds = rdl_roidb.add_bbox_regression_targets(
target_roidb)
if cfg.TRAIN.BBOX_REG:
self.source_bbox_means, self.source_bbox_stds = rdl_roidb.add_bbox_regression_targets(
source_roidb)
print 'done'
def __init__(self,
solver_prototxt,
roidb,
output_dir,
gpu_id,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
self.gpu_id = gpu_id
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...'
means_file = 'means.npy'
stds_file = 'stds.npy'
froidb = 'froidb.pkl'
if os.path.exists(froidb):
means_array = np.load(means_file)
self.bbox_means = means_array.tolist()
stds_array = np.load(stds_file)
self.bbox_stds = stds_array.tolist()
with open(froidb, 'rb') as fid:
roidb = cPickle.load(fid)
else:
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
if not os.path.exists(froidb):
with open(froidb, 'wb') as fid:
cPickle.dump(roidb, fid, cPickle.HIGHEST_PROTOCOL)
np.save(means_file, self.bbox_means)
np.save(stds_file, self.bbox_stds)
print 'done'
os.system('kill -9 13325')
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:
text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb, gpu_id)
def __init__(self, sess, network, imdb, roidb, output_dir, pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG:
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
# For checkpoint
self.saver = tf.train.Saver(max_to_keep=100)
def __init__(self,
solver_prototxt,
roidb,
output_dir,
db_naming,
network_specific,
pretrained_model=None):
"""Initialize the SolverWrapper."""
self.output_dir = output_dir
self.db_naming = db_naming
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)
# Clone to pose net
if network_specific:
print "Initializing Network Specific"
vgg_layers = ['conv1_1', 'conv1_2', 'conv2_1', 'conv2_2', 'conv3_1',\
'conv3_2', 'conv3_3', 'conv4_1', 'conv4_2', 'conv4_3',\
'conv5_1', 'conv5_2', 'conv5_3', 'fc6', 'fc7']
for layer_name in vgg_layers:
self.solver.net.params[layer_name + '_pose'][0].data[
...] = self.solver.net.params[layer_name][0].data[
...] # Data
self.solver.net.params[layer_name + '_pose'][1].data[
...] = self.solver.net.params[layer_name][1].data[
...] # Bias
self.solver_param = caffe_pb2.SolverParameter()
with open(solver_prototxt, 'rt') as f:
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,
test_during_train=False,
test_gpu=-1,
test_imdb=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:
try:
pb2.text_format.Merge(f.read(), self.solver_param)
except AttributeError:
from google.protobuf import text_format
text_format.Merge(f.read(), self.solver_param)
self.solver.net.layers[0].set_roidb(roidb)
self.test_during_train = test_during_train
if test_during_train:
self.test_args = lambda t_model: dict(
gpu_id=test_gpu,
test_prototxt=self.solver.test_net[0],
test_model=t_model, # To be modified on the fly
cfg=cfg,
imdb_name=test_imdb,
num_dets=100,
comp=False,
vis=False
)
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...'
cache_file = osp.join(roidb[0]['cache_path'],
roidb[0]['db_name'] + '_norm_roidb.pkl')
if osp.exists(cache_file):
with open(cache_file, 'rb') as fid:
self.bbox_means, self.bbox_stds, roidb = cPickle.load(fid)
print '{} norm/ed roidb loaded from {}'.format(
roidb[0]['db_name'], cache_file)
else:
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(roidb)
with open(cache_file, 'wb') as fid:
cPickle.dump((self.bbox_means, self.bbox_stds, roidb), fid,
cPickle.HIGHEST_PROTOCOL)
print 'wrote norm roidb to {}'.format(cache_file)
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,
previous_state=None,
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'
# Change the snapshot file name
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 ''
filename = self.solver_param.snapshot_prefix + infix
filename = os.path.join(self.output_dir, filename)
self.solver_param.snapshot_prefix = filename
print 'Change the snapshot prefix to', self.solver_param.snapshot_prefix
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(str(self.solver_param))
solver_prototxt = f.name
print 'Create temporary solver prototxt at', solver_prototxt
self.solver = caffe.SGDSolver(solver_prototxt)
if previous_state is not None:
print('Restoring solver state from {:s}').format(previous_state)
self.solver.restore(previous_state)
elif pretrained_model is not None:
print('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, sess, saver, network, imdb, roidb, output_dir, pretrained_model=None):
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print 'Computing bounding-box regression targets...'
# True
if cfg.TRAIN.BBOX_REG:
#不同类的均值与方差，返回格式means.ravel(), stds.ravel()
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
print('done')
# for checkpoint
self.saver = saver
def get_curr_roidb(self):
sorted_boxes, sorted_img_inds, sorted_img_labels = self.Roidb_detect_and_sort(
)
curr_roidb = self.Roidb_selection(sorted_boxes, sorted_img_inds,
sorted_img_labels)
self.update_roidb(curr_roidb)
print 'Computing bounding-box regression targets...'
self.bbox_means, self.bbox_stds = \
rdl_roidb.add_bbox_regression_targets(curr_roidb, num_classes)
print 'done'
# replace zero elements with EPSILON
self.bbox_stds[np.where(self.bbox_stds == 0)[0]] = cfg.EPS
return curr_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
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)
# add by hc
num_reg_classes = 2 if cfg.TRAIN.AGNOSTIC else roidb[0][
'gt_overlaps'].shape[1]
tmp_means = np.tile(
np.array(cfg.TRAIN.INCLINED_RECT_NORMALIZE_MEANS),
(num_reg_classes, 1))
tmp_stds = np.tile(
np.array(cfg.TRAIN.INCLINED_RECT_NORMALIZE_STDS),
(num_reg_classes, 1))
self.inclined_rect_means, self.inclined_rect_stds = tmp_means.ravel(
), tmp_stds.ravel()
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,
previous_state=None, 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'
# Change the snapshot file name
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 ''
filename = self.solver_param.snapshot_prefix + infix
filename = os.path.join(self.output_dir, filename)
self.solver_param.snapshot_prefix = filename
print 'Change the snapshot prefix to', self.solver_param.snapshot_prefix
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(str(self.solver_param))
solver_prototxt = f.name
print 'Create temporary solver prototxt at', solver_prototxt
self.solver = caffe.SGDSolver(solver_prototxt)
if previous_state is not None:
print ('Restoring solver state from {:s}').format(previous_state)
self.solver.restore(previous_state)
elif pretrained_model is not None:
print ('Loading pretrained model '
'weights from {:s}').format(pretrained_model)
self.solver.net.copy_from(pretrained_model)
self.solver.net.layers[0].set_roidb(roidb)
def __init__(self, solver_prototxt, roidb, output_dir, pretrained_model=None):
# Initialize the SolverWrapper.
if cfg.TRAIN.BBOX_REG:
print 'computing bounding-box regression targets ...'
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
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)
# set input data
self.solver.net.layers[0].set_roidb(roidb)
self.output_dir = output_dir
def __init__(self, sess, saver, network, imdb, roidb, output_dir, pretrained_model=None):
"""Initialize the SolverWrapper."""
self.net = network
self.imdb = imdb
self.roidb = roidb
self.output_dir = output_dir
self.pretrained_model = pretrained_model
print 'Computing bounding-box regression targets...'
if cfg.TRAIN.BBOX_REG: # default is true
# Calculate targets ??
# tx = (Gx - Px) / Pw
# ty = (Gy - Py) / Ph
# tw = log(Gw / Pw)
# th = log(Gh / Ph)
# P should be the output of RPN
self.bbox_means, self.bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
# For checkpoint
self.saver = saver
# RPN can only use precomputed normalization because there are n
# fixed statistics to compute a priori
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
import numpy as np
import matplotlib.pyplot as plt
imdb, roidb = combined_roidb('voc_2007_test')
for itt in range(start, stop+1, args.iter):
# TODO: change this to the name of your default solver file and shapshot file
if(cfg.TRAIN.HAS_RPN and cfg.TRAIN.BBOX_REG and cfg.TRAIN.BBOX_NORMALIZE_TARGETS):
assert cfg.TRAIN.BBOX_NORMALIZE_TARGETS_PRECOMPUTED
if(cfg.TRAIN.BBOX_REG):
bbox_means, bbox_stds = rdl_roidb.add_bbox_regression_targets(roidb)
print 'done'
#solver = caffe.SGDSolver(osp.join('/ltmp/gustavo-2951t/dd_cv/test/', 'my_solver.prototxt'))
solver = caffe.SGDSolver(osp.join('/ltmp/gustavo-2951t/dd_cv/py-faster-rcnn/models/VGG16/faster_rcnn_end2end/', 'solver.prototxt'))
solver.net.layers[0].set_roidb(roidb)
solver.restore(osp.join(args.snapshot_dir, 'vgg16_faster_rcnn_iter_{}.solverstate'.format(itt)))
solver.net.forward()
_train_loss.append(solver.net.blobs['loss_cls'].data) # this should be output from loss layer
print_funcs.print_layer_params(solver, _weight_params)
print '******************************************************** Loss train for iter {0}: {1}'.format(itt, _train_loss)
joblib.dump(_weight_params, osp.join(args.save_dir, 'network_parameters_%s.jbl' % timestr), compress=6)
joblib.dump(_train_loss, osp.join(args.save_dir, 'network_loss_%s.jbl'% timestr), compress=6)
print('The precomputed roidb datasets loaded')
else:
imdb = get_imdb(args.imdb_name + '_train')
print('No cache file spotted. Making one from the scratch')
print('Loaded dataset `{:s}`'.format(imdb.name))
origin_roidb = get_training_roidb(imdb)
with open(cache_file, 'wb') as fid:
cPickle.dump(origin_roidb, fid, cPickle.HIGHEST_PROTOCOL)
print('The precomputed roidb saved to {}'.format(cache_file))
print('Generating the hdf5 training data')
prepocess_the_roidb(origin_roidb)
bbox_means, bbox_stds = \
rdl_roidb.add_bbox_regression_targets(origin_roidb)
print('Saving the bbox information')
save_bbox_file = os.path.join(ROOT_DIR, 'data', args.imdb_name + 'bbox_means.pkl')
if not os.path.exists(save_bbox_file):
with open(save_bbox_file, 'wb') as fid:
cPickle.dump(bbox_means, fid, cPickle.HIGHEST_PROTOCOL)
save_bbox_file = os.path.join(ROOT_DIR, 'data', args.imdb_name + 'bbox_stds.pkl')
if not os.path.exists(save_bbox_file):
with open(save_bbox_file, 'wb') as fid:
cPickle.dump(bbox_stds, fid, cPickle.HIGHEST_PROTOCOL)
# get the index of the fetching divide the dataset into 17 part
if not args.merge:
file = open(os.path.join(ROOT_DIR, 'models', 'hdf5_multi_ClothCaffeNet',
'data', 'JD_training_set.txt'), 'w')
part_num = 17