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)
