def _deploy_network(args):
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
netFn = str(args.network) # unicode->str to avoid caffe API problems
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert (batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
outDir = os.path.dirname(args.network)
if not os.path.isdir(outDir):
os.mkdir(outDir)
#----------------------------------------
# Create the Caffe network
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
phaseTest = 1 # 1 := test mode
net = caffe.Net(netFn, args.model, phaseTest)
_print_net(net)
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: loading deploy data..."
Xdeploy, Ydeploy = _load_data(args.emDeployFile, args.labelsDeployFile,
args, bs)
print "[emCNN]: tile dimension is: %d" % bs
#----------------------------------------
# Do deployment & save results
#----------------------------------------
sys.stdout.flush()
Mask = np.ones(Xdeploy.shape, dtype=np.bool)
if Ydeploy is not None:
Mask[Ydeploy < 0] = False
Prob = predict(net, Xdeploy, Mask, batchDim)
# discard mirrored edges and form class estimates
Yhat = np.argmax(Prob, 0)
Yhat[Mask == False] = -1
Prob = prune_border_4d(Prob, bs)
Yhat = prune_border_3d(Yhat, bs)
# compute some metrics
if Ydeploy is not None:
acc, precision, recall = _binary_metrics(prune_border_3d(Ydeploy, bs),
Yhat)
print('[emCNN]: Task performance:')
print(' acc=%0.2f, precision=%0.2f, recall=%0.2f' %
(acc, precision, recall))
net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'YhatDeploy.npz'), Prob)
scipy.io.savemat(os.path.join(outDir, 'YhatDeploy.mat'), {'Yhat': Prob})
print('[emCNN]: deployment complete.')
# parse information from the prototxt files
#----------------------------------------
args = get_args()
workDir, solverFn = os.path.split(args.solver)
if len(workDir):
os.chdir(workDir)
solverParam = caffe_pb2.SolverParameter()
text_format.Merge(open(solverFn).read(), solverParam)
netFn = str(solverParam.net) # unicode->str to avoid caffe API problems
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
print('[deploy]: batch shape: %s' % str(batchDim))
if len(args.outFileName):
outFileName = args.outFileName
else:
outFileName = os.path.join(os.path.split(args.dataFileName)[0], 'Yhat_' + os.path.split(args.dataFileName)[-1])
print('[deploy]: output file will be: %s' % outFileName)
#----------------------------------------
# Load and preprocess data set
#----------------------------------------
X = emlib.load_tiff_data(args.dataFileName, np.float32)
# mirror edges of images so that every pixel in the original data set can act
# as a center pixel of some tile
def _train_network(args):
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
solverParam = caffe_pb2.SolverParameter()
text_format.Merge(open(args.solver).read(), solverParam)
netFn = solverParam.net
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert (batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
outDir = str(solverParam.snapshot_prefix) # unicode -> str
if not os.path.isdir(outDir):
os.mkdir(outDir)
# choose a synthetic data generating function
if args.rotateData:
syn_func = lambda V: _xform_minibatch(V, True)
print(
'[emCNN]: WARNING: applying arbitrary rotations to data. This may degrade performance in some cases...\n'
)
else:
syn_func = lambda V: _xform_minibatch(V, False)
#----------------------------------------
# Create the Caffe solver
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
solver = caffe.SGDSolver(args.solver)
_print_net(solver.net)
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: loading training data..."
Xtrain, Ytrain = _load_data(args.emTrainFile, args.labelsTrainFile, args,
bs)
print "[emCNN]: loading validation data..."
Xvalid, Yvalid = _load_data(args.emValidFile, args.labelsValidFile, args,
bs)
print "[emCNN]: tile dimension is: %d" % bs
#----------------------------------------
# Do training; save results
#----------------------------------------
trainInfo = TrainInfo(solverParam)
sys.stdout.flush()
while trainInfo.iter < solverParam.max_iter:
print "[emCNN]: Starting epoch %d" % trainInfo.epoch
train_one_epoch(solver,
Xtrain,
Ytrain,
trainInfo,
batchDim,
outDir,
omitLabels=args.omitLabels,
data_augment=syn_func)
print "[emCNN]: Making predictions on validation data..."
Mask = np.ones(Xvalid.shape, dtype=np.bool)
Mask[Yvalid < 0] = False
Prob = predict(solver.net, Xvalid, Mask, batchDim)
# discard mirrored edges and form class estimates
Yhat = np.argmax(Prob, 0)
Yhat[Mask == False] = -1
Prob = prune_border_4d(Prob, bs)
Yhat = prune_border_3d(Yhat, bs)
# compute some metrics
acc, precision, recall = _binary_metrics(prune_border_3d(Yvalid, bs),
Yhat)
print('[emCNN]: Validation set performance:')
print(' acc=%0.2f, precision=%0.2f, recall=%0.2f' %
(acc, precision, recall))
trainInfo.epoch += 1
solver.net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'Yhat.npz'), Prob)
scipy.io.savemat(os.path.join(outDir, 'Yhat.mat'), {'Yhat': Prob})
print('[emCNN]: training complete.')
def _deploy_network(args):
""" Runs Caffe in deploy mode (where there is no solver).
"""
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
netFn = str(args.network) # unicode->str to avoid caffe API problems
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert(batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
if args.outDir:
outDir = args.outDir # overrides default
else:
# there is no snapshot dir in a network file, so default is
# to just use the location of the network file.
outDir = os.path.dirname(args.network)
# Add a timestamped subdirectory.
ts = datetime.datetime.now()
subdir = "Deploy_%s_%02d:%02d" % (ts.date(), ts.hour, ts.minute)
outDir = os.path.join(outDir, subdir)
if not os.path.isdir(outDir):
os.makedirs(outDir)
print('[emCNN]: writing results to: %s' % outDir)
# save the parameters we're using
with open(os.path.join(outDir, 'params.txt'), 'w') as f:
pprint(args, stream=f)
#----------------------------------------
# Create the Caffe network
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
phaseTest = 1 # 1 := test mode
net = caffe.Net(netFn, args.model, phaseTest)
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: loading deploy data..."
Xdeploy = _load_data(args.emDeployFile,
None,
tileRadius=bs,
onlySlices=args.deploySlices)
print "[emCNN]: tile radius is: %d" % bs
# Create a mask volume (vs list of labels to omit) due to API of emlib
if args.evalPct < 1:
Mask = np.zeros(Xdeploy.shape, dtype=np.bool)
m = Xdeploy.shape[-2]
n = Xdeploy.shape[-1]
nToEval = np.round(args.evalPct*m*n).astype(np.int32)
idx = sobol(2, nToEval ,0)
idx[0] = np.floor(m*idx[0])
idx[1] = np.floor(n*idx[1])
idx = idx.astype(np.int32)
Mask[:,idx[0], idx[1]] = True
pct = 100.*np.sum(Mask) / Mask.size
print("[emCNN]: subsampling volume...%0.2f%% remains" % pct)
else:
Mask = np.ones(Xdeploy.shape, dtype=np.bool)
#----------------------------------------
# Do deployment & save results
#----------------------------------------
sys.stdout.flush()
if args.nMC < 0:
Prob = predict(net, Xdeploy, Mask, batchDim)
else:
Prob = predict(net, Xdeploy, Mask, batchDim, nMC=args.nMC)
# discard mirrored edges
Prob = prune_border_4d(Prob, bs)
net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'YhatDeploy'), Prob)
scipy.io.savemat(os.path.join(outDir, 'YhatDeploy.mat'), {'Yhat' : Prob})
print('[emCNN]: deployment complete.')
def _train_network(args):
""" Main CNN training loop.
Creates PyCaffe objects and calls train_one_epoch until done.
"""
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
solverParam = caffe_pb2.SolverParameter()
text_format.Merge(open(args.solver).read(), solverParam)
netFn = solverParam.net
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert(batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
if args.outDir:
outDir = args.outDir # overrides snapshot prefix
else:
outDir = str(solverParam.snapshot_prefix) # unicode -> str
if not os.path.isdir(outDir):
os.mkdir(outDir)
# choose a synthetic data generating function
if args.rotateData:
syn_func = lambda V: _xform_minibatch(V, arbitraryRotation=True)
print('[emCNN]: WARNING: applying arbitrary rotations to data. This may degrade performance in some cases...\n')
else:
syn_func = lambda V: _xform_minibatch(V, arbitraryRotation=False)
#----------------------------------------
# Create the Caffe solver
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
solver = caffe.SGDSolver(args.solver)
solverMD = SGDSolverMemoryData(solver, solverParam)
solverMD.print_network()
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: tile radius is: %d" % bs
print "[emCNN]: loading training data..."
Xtrain, Ytrain = _load_data(args.emTrainFile,
args.labelsTrainFile,
tileRadius=bs,
onlySlices=args.trainSlices,
omitLabels=args.omitLabels)
print "[emCNN]: loading validation data..."
Xvalid, Yvalid = _load_data(args.emValidFile,
args.labelsValidFile,
tileRadius=bs,
onlySlices=args.validSlices,
omitLabels=args.omitLabels)
#----------------------------------------
# Do training; save results
#----------------------------------------
omitLabels = set(args.omitLabels).union([-1,]) # always omit -1
currEpoch = 1
sys.stdout.flush()
while not solverMD.is_training_complete():
print "[emCNN]: Starting epoch %d" % currEpoch
train_one_epoch(solverMD, Xtrain, Ytrain,
batchDim, outDir,
omitLabels=omitLabels,
data_augment=syn_func)
currEpoch += 1
print "[emCNN]: Making predictions on validation data..."
Mask = np.ones(Xvalid.shape, dtype=np.bool)
Mask[Yvalid<0] = False
Prob = predict(solver.net, Xvalid, Mask, batchDim)
# discard mirrored edges and form class estimates
Yhat = np.argmax(Prob, 0)
Yhat[Mask==False] = -1;
Prob = prune_border_4d(Prob, bs)
Yhat = prune_border_3d(Yhat, bs)
# compute some metrics
print('[emCNN]: Validation set performance:')
emlib.metrics(prune_border_3d(Yvalid, bs), Yhat, display=True)
solver.net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'Yhat.npz'), Prob)
scipy.io.savemat(os.path.join(outDir, 'Yhat.mat'), {'Yhat' : Prob})
print('[emCNN]: training complete.')
def _deploy_network(args):
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
netFn = str(args.network) # unicode->str to avoid caffe API problems
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert(batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
outDir = os.path.dirname(args.network)
if not os.path.isdir(outDir):
os.mkdir(outDir)
#----------------------------------------
# Create the Caffe network
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
phaseTest = 1 # 1 := test mode
net = caffe.Net(netFn, args.model, phaseTest)
_print_net(net)
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: loading deploy data..."
Xdeploy, Ydeploy = _load_data(args.emDeployFile,
args.labelsDeployFile,
args, bs)
print "[emCNN]: tile dimension is: %d" % bs
#----------------------------------------
# Do deployment & save results
#----------------------------------------
sys.stdout.flush()
Mask = np.ones(Xdeploy.shape, dtype=np.bool)
if Ydeploy is not None:
Mask[Ydeploy<0] = False
Prob = predict(net, Xdeploy, Mask, batchDim)
# discard mirrored edges and form class estimates
Yhat = np.argmax(Prob, 0)
Yhat[Mask==False] = -1;
Prob = prune_border_4d(Prob, bs)
Yhat = prune_border_3d(Yhat, bs)
# compute some metrics
if Ydeploy is not None:
acc,precision,recall = _binary_metrics(prune_border_3d(Ydeploy, bs), Yhat)
print('[emCNN]: Task performance:')
print(' acc=%0.2f, precision=%0.2f, recall=%0.2f' % (acc, precision, recall))
net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'YhatDeploy.npz'), Prob)
scipy.io.savemat(os.path.join(outDir, 'YhatDeploy.mat'), {'Yhat' : Prob})
print('[emCNN]: deployment complete.')
def _train_network(args):
#----------------------------------------
# parse information from the prototxt files
#----------------------------------------
solverParam = caffe_pb2.SolverParameter()
text_format.Merge(open(args.solver).read(), solverParam)
netFn = solverParam.net
netParam = caffe_pb2.NetParameter()
text_format.Merge(open(netFn).read(), netParam)
batchDim = emlib.infer_data_dimensions(netFn)
assert(batchDim[2] == batchDim[3]) # tiles must be square
print('[emCNN]: batch shape: %s' % str(batchDim))
outDir = str(solverParam.snapshot_prefix) # unicode -> str
if not os.path.isdir(outDir):
os.mkdir(outDir)
# choose a synthetic data generating function
if args.rotateData:
syn_func = lambda V: _xform_minibatch(V, True)
print('[emCNN]: WARNING: applying arbitrary rotations to data. This may degrade performance in some cases...\n')
else:
syn_func = lambda V: _xform_minibatch(V, False)
#----------------------------------------
# Create the Caffe solver
# Note this assumes a relatively recent PyCaffe
#----------------------------------------
solver = caffe.SGDSolver(args.solver)
_print_net(solver.net)
#----------------------------------------
# Load data
#----------------------------------------
bs = border_size(batchDim)
print "[emCNN]: loading training data..."
Xtrain, Ytrain = _load_data(args.emTrainFile,
args.labelsTrainFile,
args, bs)
print "[emCNN]: loading validation data..."
Xvalid, Yvalid = _load_data(args.emValidFile,
args.labelsValidFile,
args, bs)
print "[emCNN]: tile dimension is: %d" % bs
#----------------------------------------
# Do training; save results
#----------------------------------------
trainInfo = TrainInfo(solverParam)
sys.stdout.flush()
while trainInfo.iter < solverParam.max_iter:
print "[emCNN]: Starting epoch %d" % trainInfo.epoch
train_one_epoch(solver, Xtrain, Ytrain,
trainInfo, batchDim, outDir,
omitLabels=args.omitLabels,
data_augment=syn_func)
print "[emCNN]: Making predictions on validation data..."
Mask = np.ones(Xvalid.shape, dtype=np.bool)
Mask[Yvalid<0] = False
Prob = predict(solver.net, Xvalid, Mask, batchDim)
# discard mirrored edges and form class estimates
Yhat = np.argmax(Prob, 0)
Yhat[Mask==False] = -1;
Prob = prune_border_4d(Prob, bs)
Yhat = prune_border_3d(Yhat, bs)
# compute some metrics
acc,precision,recall = _binary_metrics(prune_border_3d(Yvalid, bs), Yhat)
print('[emCNN]: Validation set performance:')
print(' acc=%0.2f, precision=%0.2f, recall=%0.2f' % (acc, precision, recall))
trainInfo.epoch += 1
solver.net.save(str(os.path.join(outDir, 'final.caffemodel')))
np.save(os.path.join(outDir, 'Yhat.npz'), Prob)
scipy.io.savemat(os.path.join(outDir, 'Yhat.mat'), {'Yhat' : Prob})
print('[emCNN]: training complete.')