def __init__(self, solver_prototxt, output_dir, pretrained_model=None): """ Initialize the SolverWrapper. dataset must be a imdb type """ self.output_dir = output_dir self.solver_param = caffe_pb2.SolverParameter() with open(solver_prototxt, 'rt') as f: text_format.Merge(f.read(), self.solver_param) if self.solver_param.solver_type == \ caffe_pb2.SolverParameter.SolverType.Value('SGD'): self.solver = caffe.SGDSolver(solver_prototxt) elif self.solver_param.solver_type == \ caffe_pb2.SolverParameter.SolverType.Value('NESTEROV'): self.solver = caffe.NesterovSolver(solver_prototxt) elif self.solver_param.solver_type == \ caffe_pb2.SolverParameter.SolverType.Value('ADAGRAD'): self.solver = caffe.AdaGradSolver(solver_prototxt) elif self.solver_param.solver_type == \ caffe_pb2.SolverParameter.SolverType.Value('ADAM'): self.solver = caffe.AdamSolver(solver_prototxt) else: raise NotImplementedError('Solver type not defined') if pretrained_model is not None: print('Loading pretrained model ' 'weights from {:s}').format(pretrained_model) self.solver.net.copy_from(pretrained_model)
def __init__(self, train_idx, valid_idx): cnas.write_nets(train_idx, valid_idx) cnas.write_solver( display="1", test_iter="100", test_interval="25000", base_lr="0.001", momentum="0.9", momentum2="0.999", lr_policy="\"step\"", gamma="0.1", stepsize="10000", max_iter="100000", weight_decay="0.0005", snapshot="2500", type="\"Adam\"" ) self.solver = caffe.AdamSolver(osp.join(workdir, 'solver.prototxt')) # solver.net.copy_from(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel') self.solver.test_nets[0].share_with(self.solver.net) # for itt in range(6): # solver.step(100) # print('itt:{:3d}'.format((itt + 1) * 100), 'accuracy:{0:.4f}'.format(check_accuracy(solver.test_nets[0], 50))) print([(k, v.data.shape) for k, v in self.solver.net.blobs.items()]) print([(k, v[0].data.shape) for k, v in self.solver.net.params.items()])
def train_seg(): #subprocess.Popen('top') solver = caffe.AdamSolver('solver/seg_solver.prototxt') # 等价于solver文件中的max_iter,即最大解算次数 niter = 10000 # 每隔100次收集一次数据 display = 50 display_ = 622 #初始化 train_loss = np.zeros(niter / display) #是每50次的均值loss train_loss_ = np.zeros(niter / display_) #是每622次的均值loss solver.step(1) # 辅助变量 _train_loss = 0 # _test_loss = 0; _accuracy = 0 _all_loss = 0 # 进行解算 #loss_meter = tnt.meter.AverageValueMeter() #loss_meter.reset() #10000次以循环的方式 一步步进行 for it in range(niter): #import ipdb;ipdb.set_trace() # 进行一次解算 并获得loss数据 solver.step(1) now_loss = solver.net.blobs["loss"].data #loss_meter.add(now_loss[0]) # 每迭代一次,训练batch_size张图片 #对loss进行累加 _前缀的都是累加值 _train_loss += now_loss _all_loss += now_loss #print "setp: ",it,"time: ",time.strftime('%m-%d %H:%M:%S') ," train_loss average:",_all_loss/(it%display_+1) if os.path.exists("/tmp/debug"): import ipdb ipdb.set_trace() #训练每622次之后输出一次平均损失 all loss进行归零 train_loss_all_average 是每622次输出的平均损失 if it % display_ == 0: train_loss_[it // display_] = _all_loss / display_ print "step 622: %s train_loss average:" % ( time.strftime('%m-%d %H:%M:%S')), train_loss_[it // display_] _all_loss = 0 #loss_meter.reset() #训练每50次之后输出一次平均损失 train loss进行归零 train_loss 是每次50输出的平均损失 if it % display == 0: # 计算平均train loss train_loss[it // display] = _train_loss / display print psutil.cpu_percent(percpu=True), psutil.virtual_memory() print "step 50: %s train_loss average:" % ( time.strftime('%m-%d %H:%M:%S')), train_loss[it // display] _train_loss = 0 #保存每50次的均值loss np.save("train_loss.npy", train_loss) del solver
def initCaffe(self, solver, model_snapshot=''): caffe.set_device(self.gpu_id) caffe.set_mode_gpu() if self.solver == None: s_type = solver.split('.')[0].split('_')[-1] if s_type == "adadelta": self.solver = caffe.AdaDeltaSolver(solver) elif s_type == "rmsprop": self.solver = caffe.RMSPropSolver(solver) elif s_type == "adam": self.solver = caffe.AdamSolver(solver) elif s_type == "adagrad": self.solver = caffe.AdaGradSolver(solver) elif s_type == "nesterov": self.solver = caffe.NesterovSolver(solver) else: self.solver = caffe.SGDSolver(solver) self.log("used: " + s_type) self.solver_param = caffe.proto.caffe_pb2.SolverParameter() with open(solver, 'rt') as fd: pb2.text_format.Merge(fd.read(), self.solver_param) # restore the snapshot or model if model_snapshot: fsuffix = model_snapshot.split(".") m_name, s_name, crr_iter = self.modelName(model_snapshot) if os.path.exists(s_name): self.solver.restore(s_name) else: self.solver.net.copy_from(m_name) # init the batch size self.train_batch_size = self.solver.net.blobs['data'].data.shape[0] return
def __init__(self, solver_prototxt, all_fc6, all_target_sent_reshaped, all_input_sent_reshaped, all_cont_sent_reshaped, output_dir, pretrained_model=None): """Initialize the SolverWrapper.""" self.output_dir = output_dir self.solver = caffe.AdamSolver(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.TRAIN.CINPUT: self.solver.net.layers[0].set_roidb(all_fc6, all_target_sent_reshaped, all_input_sent_reshaped, all_cont_sent_reshaped)
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.AdamSolver(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 train(self, restore = False): caffe.set_device(0) caffe.set_mode_gpu() if self.config.recognise_solver_type == "SGD": self.solver = caffe.SGDSolver(self.config.recognise_solver_file) elif self.config.recognise_solver_type == "Adam": self.solver = caffe.AdamSolver(self.config.recognise_solver_file) else: print "unknow solver type" signal.signal(signal.SIGINT, self.sig_handler) if restore: self.solver.solve(self.config.recognise_restore_state) else: if self.config.recognise_copy_weight != "" : self.solver.net.copy_from(self.config.recognise_copy_weight) print 'copy net' while self.config.recognise_niter != 0: #self.print_weights('lstm2', True) self.solver.step(1) #self.print_diff('lstm2', True) #self.show_data('conv4_1', 64) self.config.recognise_niter -= 1 self.terminate()
def train_model(self, X, y): solver = caffe.AdamSolver(self.solver_prototxt_path) solver.net.blobs['data'].reshape(*X.shape) solver.net.blobs['label'].reshape(X.shape[0]) solver.net.blobs['data'].data[...] = X solver.net.blobs['label'].data[...] = y solver.solve() self.model = solver.net
def train_cls(): #subprocess.Popen('top') solver = caffe.AdamSolver('solver/cls_solver.prototxt') if cls_model_path is not None: print "loading pre-model.",cls_model_path solver.net.copy_from(cls_model_path) niter = 100000 # 每隔100次收集一次数据 display= 480 if opt.online==False else 20 # 每次测试进行100次解算,10000/100 #test_iter = 60 # 每500次训练进行一次测试(100次解算),60000/64 #test_interval =240 #初始化 train_loss = np.zeros(niter / display) train_acc=np.zeros(niter / display) #test_loss = np.zeros(niter / test_interval) #test_acc = np.zeros(niter / test_interval) # iteration 0,不计入 solver.step(1) # 辅助变量 _train_loss = 0;_test_loss = 0; _accuracy = 0 # 进行解算 #loss_meter = tnt.meter.AverageValueMeter() #loss_meter.reset() confusem = ConfusionMeter(2) confusem.reset() for it in range(niter): #import ipdb;ipdb.set_trace() # 进行一次解算 solver.step(1) now_loss=solver.net.blobs["loss"].data score=solver.net.blobs["score"].data target=solver.net.blobs["label"].data confusem.add(score, target) # 每迭代一次,训练batch_size张图片 _train_loss += now_loss _accuracy += solver.net.blobs['Accuracy1'].data if os.path.exists("/tmp/debug"): import ipdb; ipdb.set_trace() if it%5==0: print('cm:%s' % (str(confusem.value))) if it % display == 0: # 计算平均train loss train_loss[it // display] = _train_loss / display print "step_display : %s train_loss average:"%(time.strftime('%m-%d %H:%M:%S')) , train_loss[it // display] _train_loss = 0 train_acc[it // display] = _accuracy / display print "step_acc : %s train_acc average:"%(time.strftime('%m-%d %H:%M:%S')) , train_acc[it // display] _accuracy=0 confusem.reset() del solver
def train_chenyun_cls(): max_epoch = 100 sample_list = open("/home/x/dcsb/Tianchi_caffe/train_cls.txt", 'r').read().splitlines() nodule_list = [r[:-2] for r in sample_list if r[-1] == '1'] background_list = [r[:-2] for r in sample_list if r[-1] == '0'] #ration=1 # dataset=BoostDataset(nodule_list,background_list,ratio=1,augument=True,phase="train",crop_size=[16,16,16]) # dataloader = DataLoader(dataset,batch_size=32, # num_workers=1, # shuffle=True, # drop_last=True # ) solver = caffe.AdamSolver('solver/boost.prototxt') if cls_model_path is not None: print "loading pre-model.", cls_model_path solver.restore(cls_model_path) #solver.net.copy_from(cls_model_path) confusem = ConfusionMeter(2) boost_cm = ConfusionMeter(2) for it in range(max_epoch): if os.path.exists("/tmp/debug"): import ipdb ipdb.set_trace() confusem.reset() _train_loss = 0 _accuracy = 0 display = 120 # for ii, (input, label,pre_prob) in tqdm(enumerate(dataloader)): for ii in tqdm(range(10)): solver.net.blobs["data"].data[...] = np.ones([4, 1, 32, 32, 32]) solver.net.blobs["label"].data[...] = np.ones([4, 1]) solver.net.blobs['pre_prob'].data[...] = np.zeros([4, 2]) solver.step(1) now_loss = solver.net.blobs["loss"].data prob = solver.net.blobs["prob"].data bprob = solver.net.blobs['bprob'].data target = label confusem.add(prob, target) boost_cm.add(bprob, target) _train_loss += now_loss if ii % 5 == 0: print "------------cm---------------" print('cm:%s' % (str(confusem.value))) print('boostcm:%s' % (str(boost_cm.value))) if ii % 120 == 0: # 计算平均train loss train_loss = _train_loss / 120 print "step_display : %s train_loss_1 average:" % ( time.strftime('%m-%d %H:%M:%S')), train_loss _train_loss = 0 del solver
def TrainLowDoseChallenge( indices, depth, outputPath, max_iter=55000, nChannel=1, patchSize=40, patchPath='/home/data0/dufan/MedicalCNNDenoising/data/40x40_Res_Full/' ): # make working directory if not os.path.exists(outputPath): os.makedirs(outputPath) # Path names tlPath = os.path.join(outputPath, 'trainingList.txt') trainPath = os.path.join(outputPath, 'DnCNN_Train.prototxt') testPath = os.path.join(outputPath, 'DnCNN_Test.prototxt') solverPath = os.path.join(outputPath, 'DnCNN_Solver.prototxt') # Generate trainingList with open(tlPath, 'w') as f: for i in indices: f.write( os.path.join(patchPath, 'trainingData_' + str(i) + '.h5') + '\n') f.close() # Generate training prototxt GenerateNetwork.GenerateNetPrototxt(trainPath, tlPath, depth, caffe.TRAIN, 100, dim2=patchSize, nChannel=nChannel) GenerateNetwork.GenerateNetPrototxt(testPath, tlPath, depth, caffe.TEST, 20, dim2=patchSize, nChannel=nChannel) # Generate solver prototxt GenerateNetwork.GenerateADAMSolverPrototxt(solverPath, trainPath, os.path.join( outputPath, 'DnCNN'), max_iter, snapshot=10000) # Train solver = caffe.AdamSolver(solverPath) solver.solve() solver.net.save(os.path.join(outputPath, 'DnCNN.caffemodel'))
def train(initmodel, gpu): """ Train the net. """ caffe.set_mode_gpu() caffe.set_device(gpu) solver = caffe.AdamSolver('solver.prototxt') if initmodel: solver.net.copy_from(initmodel) solver.step(solver.param.max_iter)
def train_chenyun_cls(): max_epoch = 100 sample_list = open("/home/x/dcsb/Tianchi_caffe/train_cls.txt", 'r').read().splitlines() nodule_list = [r[:-2] for r in sample_list if r[-1] == '1'] background_list = [r[:-2] for r in sample_list if r[-1] == '0'] dataset = ClsDataset(nodule_list, background_list, ratio=2, augument=True, phase="train", crop_size=[16, 16, 16]) dataloader = DataLoader(dataset, batch_size=32, num_workers=1, shuffle=True, drop_last=True) solver = caffe.AdamSolver('solver/chenyun.prototxt') if cls_model_path is not None: print "loading pre-model.", cls_model_path solver.restore(cls_model_path) #solver.net.copy_from(cls_model_path) confusem = ConfusionMeter(2) for it in range(max_epoch): if os.path.exists("/tmp/debug"): import ipdb ipdb.set_trace() confusem.reset() _train_loss = 0 _accuracy = 0 display = 120 for ii, (input, label) in tqdm(enumerate(dataloader)): solver.net.blobs["data"].data[...] = input[:, np.newaxis, :, :, :] solver.net.blobs["label"].data[...] = label solver.step(1) now_loss = solver.net.blobs["loss"].data score = solver.net.blobs["cls"].data target = label confusem.add(score, target) _train_loss += now_loss if ii % 5 == 0: print "------------cm---------------" print('cm:%s' % (str(confusem.value))) if ii % 120 == 0: # 计算平均train loss train_loss = _train_loss / 120 print "step_display : %s train_loss_1 average:" % ( time.strftime('%m-%d %H:%M:%S')), train_loss _train_loss = 0 del solver
def train(initmodel, gpu): """ Train the net. """ caffe.set_mode_gpu() caffe.set_device(gpu) solver = caffe.AdamSolver('solver.prototxt') if initmodel: solver.net.copy_from(initmodel) interp_layers = [k for k in solver.net.params.keys() if 'up' in k] interp(solver.net, interp_layers) solver.step(solver.param.max_iter)
def __init__(self, model=None): solver_file = 'dqn_solver.prototxt' self.solver = caffe.AdamSolver(solver_file) # self.solver = caffe.SGDSolver(solver_file) self.net = self.solver.net self.target = caffe.Net('dqn.prototxt', caffe.TEST) if model: self.net.copy_from(model) self.epsilon = EPSILON_BEGIN self.steps = 0 self.experience_replay = deque()
def main(): args = parse_args() sys.path.insert(0, os.path.abspath('../../python/caffe/')) sys.path.insert(0, os.path.abspath('../../python/')) import caffe caffe.set_mode_gpu() caffe.set_device(args.gpu) solver = caffe.AdamSolver('solver.prototxt') if args.weights is not None: solver.net.copy_from(args.weights) solver.step(args.steps)
def Train(fold): caffe.set_device(0) caffe.set_mode_gpu() solver1 = caffe.AdamSolver('./Model/solver_DFCN.prototxt') print "start training" deviate = 0 minLoss = 10000 solver1.step(1) for i in range(10000): loss = 0 for j in range(10): solver1.step(100) if (i % 10 == 0): solver1.net.save("./Model/Deploy/Fold" + str(fold) + "/DFCN_" + str(i + 1) + ".caffemodel") loss = 0 solver1.test_nets[0].share_with(solver1.net) for j in range(1000): solver1.test_nets[0].forward() loss = loss + solver1.test_nets[0].blobs['loss'].data if (i >= 0): print loss print minLoss print deviate if (loss <= minLoss + 0.1 * minLoss): if (loss <= minLoss): minLoss = copy.deepcopy(loss) deviate = 0 print "best is" print i print "min loss is", minLoss solver1.net.save("./Model/Deploy/Fold" + str(fold) + "/DFCN_" + str(i + 1) + ".caffemodel") else: deviate = deviate + 1 if (deviate == 3000): solver1.net.save("./Model/Deploy/Fold" + str(fold) + "/DFCN_" + str(i + 1) + ".caffemodel") break return
def train_r2d2_text(config='msr-vtt-v0', start_with=None): configuration = get_configuration(config) prefix = 'char_r2d2_' + config train_net_str = the_whole_shabang(caffe.TRAIN, configuration) test_net_str = the_whole_shabang(caffe.TEST, configuration) solver_file_name = write_solver(prefix, configuration, train_net_str, test_net_str, init_test=start_with_ is not None) solver = caffe.AdamSolver(solver_file_name) # "warm start" with weight (caffemodel) file if start_with is not None: glog.info("\n", "-" * 50) glog.info("warm start. loading {}".format(start_with)) glog.info("-" * 50, "\n") if start_with.endswith('solverstate'): solver.restore(start_with) else: solver.net.copy_from(start_with) # set recurrence handler # solver.net.layers[list(solver.net._layer_names).index('recurrence_handler')].set_net(solver.net, train_hidden_out) # solver.test_nets[0].layers[list(solver.test_nets[0]._layer_names).index('recurrence_handler')].set_net(solver.test_nets[0], test_hidden_outs) # some statistics train_np = count_net_params(solver.net) test_np = count_net_params(solver.test_nets[0]) glog.info( '\nStarting training.\nTrain net has {} params\nValidationnet has {} params\n' .format(train_np, test_np)) # run solver try: solver.solve() except KeyboardInterrupt: glog.info('stopped by KeyboardInterrupt at iter {}'.format( solver.iter)) finally: # save final result solver.net.save('./{}_final_{}.caffemodel'.format(prefix, solver.iter))
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.AdamSolver(solver_prototxt) # 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 # 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'] ## vgg_layers = ['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 train_seg(): max_epoch=100 #sample_list=open("/home/x/data/dataset/tianchi/train.txt", 'r').read().splitlines() dataset=Dataset('/mnt/7/train_nodule/',augment=True) dataloader = DataLoader(dataset,batch_size=4, num_workers=1, shuffle=True, drop_last=True ) solver = caffe.AdamSolver('solver/seg_chenyun.prototxt') if seg_model_path is not None: print "loading pre-model.",seg_model_path #solver.restore(seg_model_path) solver.net.copy_from(seg_model_path) confusem = ConfusionMeter(2) _train_loss=0 #loss_meter = tnt.meter.AverageValueMeter() #loss_meter.reset() for it in range(max_epoch): confusem.reset() _accuracy=0 display=120 # for ii, (input, label) in enumerate(dataloader): import tqdm for i in tqdm.tqdm(range(10)): if os.path.exists("/tmp/debug"): import ipdb; ipdb.set_trace() # solver.net.blobs["data"].data[...]=input[:,np.newaxis,:,:,:] # solver.net.blobs["label"].data[...]=label[:,np.newaxis,:,:,:] solver.net.blobs["data"].data[...]=np.ones([4,1,64,64,64]) solver.net.blobs["label"].data[...]=np.ones([4,1,64,64,64]) solver.step(1) now_loss=solver.net.blobs["loss"].data # # 每迭代一次,训练batch_size张图片 # _train_loss += now_loss # if ii % 120 == 0: # # 计算平均train loss # train_loss = _train_loss / 120 # print "step_display : %s train_loss average:"%(time.strftime('%m-%d %H:%M:%S')) , train_loss # _train_loss = 0 del solver
def __init__(self, solver_prototxt, 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 #self.solver = caffe.SGDSolver(solver_prototxt) self.solver = caffe.AdamSolver(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)
def train(self): caffe.set_mode_gpu() caffe.set_device(0) solver = caffe.AdamSolver(osp.join(self.workdir, 'solver.prototxt')) print('Adam Solver finished------------------------') # 如果模型定义时有区分training和validation的不同phase,那么在solver中实际上是存在 # 两个表示网络的成员变量:solver.net和solver.test_nets,注意,前者直接就是一个Net的对象, # 而后者是Net对象的列表,如果像GoogleNet那样,存在一个training和一个testing(validation # 而不是真正的testing,做测试的文件其实是deploy.prototxt),那么应该通过solver.test_nets[0] # 来引用这个测试网络;另外,测试网络和训练网络应该是共享中间的特征网络层权重, # 只有那些标出include { phase: TRAIN }或者include { phase: TEST }的网络层有区分; # 训练数据train_X, train_Y必须是numpy中的float32浮点矩阵, # train_X维度是sample_num*channels*height*width, # train_Y是sample_num维度的label向量, # 这里sample_num必须是trainning输入batch_size的整数倍, # 为了方便,我在实际使用时每次迭代只在整个训练集中随机选取一个batch_size的图片数据放进去; solver.net.set_input_arrays(self.Xtrain, self.Ytrain) solver.test_nets[0].set_input_arrays(self.Xvalid, self.Yvalid) # solver.step(1)即迭代一次,包括了forward和backward,solver.iter标识了当前的迭代次数; solver.step(1)
def train_seg(): max_epoch = 100 #sample_list=open("/home/x/data/dataset/tianchi/train.txt", 'r').read().splitlines() # dataset=Dataset('/mnt/7/train_nodule_cubic/',augment=True) # dataloader = DataLoader(dataset,batch_size=4, # num_workers=1, # shuffle=True, # drop_last=True # ) solver = caffe.AdamSolver('solver/seg_chenyun.prototxt') if seg_model_path is not None: print "loading pre-model.", seg_model_path #solver.restore(seg_model_path) solver.net.copy_from(seg_model_path) confusem = ConfusionMeter(2) _train_loss = 0 #loss_meter = tnt.meter.AverageValueMeter() #loss_meter.reset() for it in range(max_epoch): confusem.reset() _accuracy = 0 display = 120 for ii in tqdm(range(10)): if os.path.exists("/tmp/debug"): import ipdb ipdb.set_trace() data_ = np.random.randn(4, 1, 64, 64, 64) solver.net.blobs["data"].data[...] = data_ solver.net.blobs["label"].data[...] = np.zeros_like(data_) solver.step(1) now_loss = solver.net.blobs["loss"].data # 每迭代一次,训练batch_size张图片 _train_loss += now_loss if ii % 120 == 0: # 计算平均train loss train_loss = _train_loss / 120 print "step_display : %s train_loss average:" % ( time.strftime('%m-%d %H:%M:%S')), train_loss _train_loss = 0 del solver
def start(self, rank): self.rank = rank if len(self.gpus) > 0: self.device = self.gpus[rank] if debug: s = 'solver gpu %d' % self.gpus[self.rank] + \ ' pid %d' % os.getpid() + ' size %d' % self.size + \ ' rank %d' % self.rank print(s, file = sys.stderr) caffe.set_mode_gpu() caffe.set_device(self.device) caffe.set_solver_count(self.size) caffe.set_solver_rank(self.rank) caffe.set_multiprocess(True) else: print('solver cpu', file = sys.stderr) caffe.set_mode_cpu() if self.cmd.graph.endswith('.json'): with open(self.cmd.graph, mode = 'r') as f: graph = caffe_pb2.SolverParameter() text_format.Merge(f.read(), graph) self.graph = graph else: self.graph = self.solver_graph() import tempfile with tempfile.NamedTemporaryFile(mode = 'w+', delete = False) as f: text_format.PrintMessage(self.graph, f) tmp = f.name self.caffe = caffe.AdamSolver(tmp) if self.uid: self.nccl = caffe.NCCL(self.caffe, self.uid) self.nccl.bcast() self.caffe.add_callback(self.nccl) if self.caffe.param.layer_wise_reduce: self.caffe.net.after_backward(self.nccl)
# In[ ]: import caffe import numpy as np import sys caffe_root = './caffe_VSPV/' sys.path.append(caffe_root + 'python') sys.path.append("./model/python_layers/") caffe.set_mode_gpu() # read solver solver = caffe.AdamSolver('./solver/mySolver_FlowNet.prototxt') solver.restore('./snapshot/FN/iter_iter_124000.solverstate') # small model # L1 flow loss + 0.01 L1 img loss flowL1Loss_sum=0 imgLoss_sum=0 for iter in range(10000): solver.step(1) flowL1Loss_sum=flowL1Loss_sum+solver.net.blobs['flowL1Loss'].data[0,0,0,0] imgLoss_sum=imgLoss_sum+solver.net.blobs['imgLoss'].data[0,0,0,0] if iter%10 == 0: FN_loss=open('FN_loss.txt','a') FN_loss_sum=open('FN_loss_sum.txt','a') # print ("{} {} {}".format(solver.iter,solver.net.blobs['flowL1Loss'].data[0,0,0,0],solver.net.blobs['imgLoss'].data[0,0,0,0]))
import numpy as np import caffe import os import sys #net = caffe.Net('./examples/cifar10/cifar10_full_train_test.prototxt', weights='./examples/cifar10/cifar10_2_full_iter_60000.caffemodel.h5') solver = caffe.AdamSolver('./examples/cifar10/cifar10_full_solver.prototxt') solver_com = caffe.AdamSolver( './examples/cifar10/cifar10_comp_solver.prototxt') solver.net.copy_from( './examples/cifar10/cifar10_full_iter_60000.caffemodel.h5') prev = 0 for i in solver.net.params: if (i[0:4] == "conv"): #print(i) solver_com.net.params[i][0].data[...] = solver.net.params[i][0].data[ solver.net.params[i][0].shape[0] // 32 * 20:, prev:, :, :] solver_com.net.params[i][1].data[...] = solver.net.params[i][1].data[ solver.net.params[i][1].shape[0] // 32 * 20:] #for j in solver.net.params[i]: # print(j.data) prev = solver.net.params[i][0].shape[0] // 32 * 20 if (i[0:2] == "ip"): solver_com.net.params[i][0].data[...] = solver.net.params[i][ 0].data[:, solver.net.params[i][0].shape[1] // 32 * 20:] solver_com.net.params[i][1].data[...] = solver.net.params[i][1].data[ ...]
import caffe import numpy as np caffe.set_mode_cpu() #caffe.set_device(0) #caffe.set_mode_gpu() #net = caffe.Net("models/train.proto", caffe.TEST) #solver = caffe.SGDSolver("models/solver.proto") solver = caffe.AdamSolver("models/solver.proto") net = solver.net print net.blobs["data"].data.shape print net.blobs["conv"].data.shape while solver.iter < 10000: net.blobs["data"].data[...] = np.zeros(net.blobs["data"].data.shape, dtype=np.float32) net.blobs["label"].data[...] = np.ones(net.blobs["conv"].data.shape, dtype=np.float32) print "------- data --------" print net.blobs["data"].data print "------- label --------" print net.blobs["label"].data solver.step(1) #solver.solve() print "------- loss --------" print net.blobs["loss"].data print "------- conv --------"
wget.download(url, filepath) print(' Downloaded') else: print('\nfile ' + str(filepath)[-8:] + ' already exists.') print('\n' + '*' * 10 + 'Downloading Done' + '*' * 10 + '\n\n') ###########################CAFFE EXECUTION # ADD SUDO CHMOD FOR LMDB #print os.getcwd() # /home/ubuntu/Deep-Learning/DL_Project/svhn_data caffe.set_mode_gpu() solver = caffe.AdamSolver('svhn_solver.prototxt') niter = 30000 test_interval = 1000 train_loss = np.zeros(niter) test_acc = np.zeros(int(np.ceil(niter / test_interval))) # the main solver loop for it in range(niter): solver.step(1) # SGD by Caffe # store the train loss train_loss[it] = solver.net.blobs['loss'].data solver.test_nets[0].forward() if it % test_interval == 0: loss = solver.test_nets[0].blobs['loss'].data # print 'Iteration', it, 'testing loss is :',loss acc = solver.test_nets[0].blobs['accuracy'].data
import sys import os import numpy as np import caffe from caffe import layers as L, params as P from DeepAlignmentNetwork import DeepAlignmentNetwork import tools import os.path as osp caffe_root = '../' # this file is expected to be in {caffe_root}/DAN-caffe sys.path.append(caffe_root + 'python/DesignLayer') caffe.set_mode_gpu() caffe.set_device(0) workdir = './' solverprototxt = tools.CaffeSolver( trainnet_prototxt_path=osp.join(workdir, "trainnet.prototxt"), testnet_prototxt_path=osp.join(workdir, "valnet.prototxt")) solverprototxt.sp['base_lr'] = "0.05" solverprototxt.write(osp.join(workdir, 'solver.prototxt')) training = DeepAlignmentNetwork() # write train net. with open(osp.join(workdir, 'trainnet.prototxt'), 'w') as f: f.write(training.createCNN(2)) solver = caffe.AdamSolver(osp.join(workdir, 'solver.prototxt'))
import caffe import numpy as np import os if __name__ == '__main__': gpu_id = 1 caffe.set_device(gpu_id) caffe.set_mode_gpu() solver = caffe.AdamSolver('./model/lossless_adam_solver.prototxt') #solver.restore('./model/save/ls_14_iter_40000.solverstate') iters = 100000 for i in range(iters): solver.step(10) print 'gpu_id:%d, entropy:%.3f' % (gpu_id, solver.net.blobs['ent_loss'].data)