我们从Python开源项目中，提取了以下45个代码示例，用于说明如何使用caffe.SGDSolver()。
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)
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 load_nets(args, cur_gpu): # initialize solver and feature net, # RNN should be initialized before CNN, because CNN cudnn conv layers # may assume using all available memory caffe.set_mode_gpu() caffe.set_device(cur_gpu) solver = caffe.SGDSolver(args.solver) if args.snapshot: print "Restoring history from {}".format(args.snapshot) solver.restore(args.snapshot) net = solver.net if args.weights: print "Copying weights from {}".format(args.weights) net.copy_from(args.weights) return solver, net
def load_nets(args, cur_gpu): # initialize solver and feature net, # RNN should be initialized before CNN, because CNN cudnn conv layers # may assume using all available memory caffe.set_mode_gpu() caffe.set_device(cur_gpu) solver = caffe.SGDSolver(args.solver) if args.snapshot: print "Restoring history from {}".format(args.snapshot) solver.restore(args.snapshot) rnn = solver.net if args.weights: rnn.copy_from(args.weights) feature_net = caffe.Net(args.feature_net, args.feature_param, caffe.TEST) # apply bbox regression normalization on the net weights with open(args.bbox_mean, 'rb') as f: bbox_means = cPickle.load(f) with open(args.bbox_std, 'rb') as f: bbox_stds = cPickle.load(f) feature_net.params['bbox_pred_vid'][0].data[...] = \ feature_net.params['bbox_pred_vid'][0].data * bbox_stds[:, np.newaxis] feature_net.params['bbox_pred_vid'][1].data[...] = \ feature_net.params['bbox_pred_vid'][1].data * bbox_stds + bbox_means return solver, feature_net, rnn, bbox_means, bbox_stds
def main(): iter_num = process_arguments(sys.argv) solver_state = 'models/train_iter_{}.solverstate'.format(iter_num) solver = caffe.SGDSolver('solver.prototxt') solver.solve(solver_state) # load even *.caffemodel solver.net.set_mode_gpu() solver.net.set_device(0) test_interval = 1000 max_iter = 200000 FNULL = open(os.devnull, 'w') for i in xrange(max_iter): solver.step(1) if i > 0 and (i % test_interval) == 0: subprocess.call(['python', 'test_model.py', str(i)], stderr=FNULL)
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 retrain_pruned(solver, pruned_caffemodel, threshold, prune_layers): #solver = caffe.SGDSolver(solver_proto) retrain_iter = 20 accuracys = [] for i in range(retrain_iter): solver.net.copy_from(pruned_caffemodel) # solver.solve() solver.step(500) _,_,_,_,accuracy=prune(threshold, solver.test_nets[0], prune_layers) solver.test_nets[0].save(pruned_caffemodel) accuracys.append(accuracy) plt.plot(accuracys, 'r.-') plt.show() #CPU?GPU???? #caffe.set_mode_cpu()
def solve(proto, snapshot, gpus, timing, uid, rank): caffe.set_mode_gpu() caffe.set_device(gpus[rank]) caffe.set_solver_count(len(gpus)) caffe.set_solver_rank(rank) caffe.set_multiprocess(True) solver = caffe.SGDSolver(proto) if snapshot and len(snapshot) != 0: solver.restore(snapshot) nccl = caffe.NCCL(solver, uid) nccl.bcast() if timing and rank == 0: time(solver, nccl) else: solver.add_callback(nccl) if solver.param.layer_wise_reduce: solver.net.after_backward(nccl) solver.step(solver.param.max_iter)
def _load_solver(self, solver_params, model_params): """ Load solver """ solver_path = solver_params.path if model_params.max_rounds > 1: if self._cur_round > 0: solver_path = osp.join(osp.dirname(solver_path), 'round_{}'.format(self._cur_round)) else: solver_path = osp.join(solver_path, 'round_{}'.format(self._cur_round)) solver_params.set_path(solver_path) model = model_params.model if model is not None: model.to_proto(solver_path, deploy=False) model.to_proto(solver_path, deploy=True) print 'Model files saved at {}'.format(solver_path) return caffe.SGDSolver(solver_params.to_proto())
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 __init__(self, solver_prototxt, pretrained_model=None): """Initialize the SolverWrapper.""" 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.io.caffe_pb2.SolverParameter() with open(solver_prototxt, 'rt') as f: text_format.Merge(f.read(), self.solver_param) if self.solver_param.solver_mode == 1: caffe.set_mode_gpu() caffe.set_device(params.gpu_id) print 'Use GPU', params.gpu_id, 'to train' else: print 'Use CPU to train' #initial python data layer self.solver.net.layers[0].set_db()
def __init__(self, solver_prototxt, pretrained_model=None): """Initialize the SolverWrapper.""" 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.io.caffe_pb2.SolverParameter() with open(solver_prototxt, 'rt') as f: text_format.Merge(f.read(), self.solver_param) if self.solver_param.solver_mode == 1: caffe.set_mode_gpu() caffe.set_device(params.gpu_id) print 'Use GPU', params.gpu_id, 'to train' else: print 'Use CPU to train' #initial python data layer #self.solver.net.layers[0].set_db()
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 solve(proto, gpus, uid, rank, max_iter): caffe.set_mode_gpu() caffe.set_device(gpus[rank]) caffe.set_solver_count(len(gpus)) caffe.set_solver_rank(rank) caffe.set_multiprocess(True) solver = caffe.SGDSolver(proto) if rank == 0: # solver.restore(_snapshot) solver.net.copy_from(_weights) solver.net.layers[0].get_gpu_id(gpus[rank]) nccl = caffe.NCCL(solver, uid) nccl.bcast() solver.add_callback(nccl) if solver.param.layer_wise_reduce: solver.net.after_backward(nccl) for _ in range(max_iter): solver.step(1)
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)
def __init__(self, solver_prototxt, roidb, output_dir, pretrained_model=None): """Initialize the SolverWrapper.""" self.output_dir = output_dir 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): if pa.GPU==True: caffe.set_device(pa.device) caffe.set_mode_gpu() else: caffe.set_mode_cpu() self.solver=caffe.SGDSolver(pa.solver) if pa.pretrain!="": self.solver.net.copy_from(pa.pretrain) self.solver_param=caffe_pb2.SolverParameter() with open(pa.solver,'rt') as f: pb2.text_format.Merge(f.read(),self.solver_param) #self.output_dir=pa.output_dir self.solver.net.layers[0].set_queue()
def __init__(self, solver_prototxt, imdb, 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_imdb(imdb) self.solver.net.layers[0].set_roidb(roidb)
def __get_solver(self, solver_proto_path): ''' Returns a caffe.SGDSolver for the given protofile path, ignoring Caffe command line chatter if debug mode is not set to True. ''' if not self.debug_mode: # disable Caffe init chatter when not in debug with Suppressor(): return caffe.SGDSolver(solver_proto_path) else: return caffe.SGDSolver(solver_proto_path)
def __init__(self, solver_prototxt, roidb, maskdb, output_dir, imdb, pretrained_model=None): 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: if not cfg.CFM_MODE: print 'Computing bounding-box regression targets...' self.bbox_means, self.bbox_stds = add_bbox_regression_targets(roidb) print 'done' else: # Pre-defined mcg bbox_mean and bbox_std # We store them on disk to avoid disk level IO # multiple times (mcg boxes are stored on disk) mean_cache = './data/cache/mcg_bbox_mean.npy' std_cache = './data/cache/mcg_bbox_std.npy' roidb_dir = imdb._roidb_path if os.path.exists(mean_cache) and os.path.exists(std_cache): self.bbox_means = np.load(mean_cache) self.bbox_stds = np.load(std_cache) else: self.bbox_means, self.bbox_stds = compute_mcg_mean_std(roidb_dir, imdb.num_classes) 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) if not cfg.CFM_MODE: self.solver.net.layers[0].set_roidb(roidb) if cfg.MNC_MODE: self.solver.net.layers[0].set_maskdb(maskdb) else: self.solver.net.layers[0].set_image_info(imdb, self.bbox_means, self.bbox_stds)
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)
