def _train_model(self, model_file=None):
print("Creating GALA feature manager...")
fm = features.moments.Manager()
fh = features.histogram.Manager(25, 0, 1, [0.1, 0.5, 0.9]) # Recommended numbers in the repo
fg = features.graph.Manager()
fc = features.contact.Manager()
self.fm = features.base.Composite(children=[fm, fh, fg, fc])
if model_file is not None and os.path.isfile(model_file):
print('Loading model from path ...')
rf = classify.load_classifier(model_file)
else:
gt, pr, sv = (map(imio.read_h5_stack, [self.gt, self.mem, self.sp]))
print("Creating training RAG...")
g_train = agglo.Rag(sv, pr, feature_manager=self.fm)
print("Learning agglomeration...")
(X, y, w, merges) = g_train.learn_agglomerate(gt, self.fm, learning_mode='permissive',
min_num_epochs=self.min_ep)[0]
y = y[:, 0]
rf = classify.DefaultRandomForest().fit(X, y)
# Save if path requested
if model_file is not None:
classify.save_classifier(rf, model_file)
self.model = agglo.classifier_probability(self.fm, rf)
def bench_suite():
times = OrderedDict()
memory = OrderedDict()
wstr, prtr, gttr = trdata()
with timer() as t_build_rag:
g = agglo.Rag(wstr, prtr)
times['build RAG'] = t_build_rag[0]
memory['base RAG'] = asizeof(g)
with timer() as t_features:
g.set_feature_manager(em)
times['build feature caches'] = t_features[0]
memory['feature caches'] = asizeof(g) - memory['base RAG']
with timer() as t_flat:
_ignore = g.learn_flat(gttr, em)
times['learn flat'] = t_flat[0]
with timer() as t_gala:
(X, y, w, e), allepochs = g.learn_agglomerate(gttr,
em,
min_num_epochs=5)
y = y[:, 0] # ignore rand-sign and vi-sign schemes
memory['training data'] = asizeof((X, y, w, e))
times['learn agglo'] = t_gala[0]
with timer() as t_train_classifier:
cl = classify.DefaultRandomForest()
cl.fit(X, y)
times['classifier training'] = t_train_classifier[0]
memory['classifier training'] = asizeof(cl)
policy = agglo.classifier_probability(em, cl)
wsts, prts, gtts = tsdata()
gtest = agglo.Rag(wsts,
prts,
merge_priority_function=policy,
feature_manager=em)
with timer() as t_segment:
gtest.agglomerate(np.inf)
times['segment test volume'] = t_segment[0]
memory['segment test volume'] = asizeof(gtest)
return times, memory
def train(args):
gt_train, pr_train, ws_train = (map(imio.read_h5_stack,
[args.gt_file, args.prob_file,
args.ws_file]))
#['train-gt.lzf.h5', 'train-p1.lzf.h5',
# 'train-ws.lzf.h5']))
#print('training')
#gt_train = np.load(args.gt_file) #X,Y,Z
#gt_train = np.transpose(gt_train,(2,0,1)) #gala wants z,x,y?
#pr_train = np.load(args.prob_file) #X,Y,Z
#pr_train = np.transpose(np.squeeze(pr_train),(2,0,1)) #gala wants z,x,y?
#pr_train = pr_train[0:50,0:256,0:256]
#pr_train = np.around(pr_train,decimals=2)
#gt_train = gt_train[0:50,0:256,0:256]
#print('watershed')
#seeds = label(pr_train==0)[0]
#seeds_cc_threshold = args.seeds_cc_threshold
#seeds = morpho.remove_small_connected_components(seeds,
# seeds_cc_threshold)
#ws_train = skmorph.watershed(pr_train, seeds)
fm = features.moments.Manager()
fh = features.histogram.Manager()
fc = features.base.Composite(children=[fm, fh])
g_train = agglo.Rag(ws_train, pr_train, feature_manager=fc)
(X, y, w, merges) = g_train.learn_agglomerate(gt_train, fc)[0]
y = y[:, 0] # gala has 3 truth labeling schemes, pick the first one
rf = classify.DefaultRandomForest().fit(X, y)
learned_policy = agglo.classifier_probability(fc, rf)
#save learned_policy
#np.savez(args.outfile, rf=rf, fc=fc)
binary_file = open(args.outfile,mode='wb')
lp_dump = pickle.dump([fc,rf], binary_file)
binary_file.close()
imio.read_h5_stack,
['train-gt.lzf.h5', 'train-p1.lzf.h5', 'train-ws.lzf.h5']))
# create a feature manager
fm = features.moments.Manager()
fh = features.histogram.Manager()
fc = features.base.Composite(children=[fm, fh])
# create graph and obtain a training dataset
g_train = agglo.Rag(ws_train, pr_train, feature_manager=fc)
(X, y, w, merges) = g_train.learn_agglomerate(gt_train, fc)[0]
y = y[:, 0] # gala has 3 truth labeling schemes, pick the first one
print((X.shape, y.shape)) # standard scikit-learn input format
# train a classifier, scikit-learn syntax
rf = classify.DefaultRandomForest().fit(X, y)
# a policy is the composition of a feature map and a classifier
learned_policy = agglo.classifier_probability(fc, rf)
# get the test data and make a RAG with the trained policy
pr_test, ws_test = (map(imio.read_h5_stack,
['test-p1.lzf.h5', 'test-ws.lzf.h5']))
g_test = agglo.Rag(ws_test, pr_test, learned_policy, feature_manager=fc)
g_test.agglomerate(0.5) # best expected segmentation
seg_test1 = g_test.get_segmentation()
# the same approach works with a multi-channel probability map
p4_train = imio.read_h5_stack('train-p4.lzf.h5')
# note: the feature manager works transparently with multiple channels!
g_train4 = agglo.Rag(ws_train, p4_train, feature_manager=fc)
(X4, y4, w4, merges4) = g_train4.learn_agglomerate(gt_train, fc)[0]
import numpy as np
from gala import imio, classify, features, agglo, evaluate as ev
gt_train, pr_train, p4_train, ws_train = map(imio.read_h5_stack, ['example-data/train-gt.lzf.h5', 'example-data/train-p1.lzf.h5', 'example-data/train-p4.lzf.h5', 'example-data/train-ws.lzf.h5'])
gt_test, pr_test, p4_test, ws_test = map(imio.read_h5_stack, ['example-data/test-gt.lzf.h5', 'example-data/test-p1.lzf.h5', 'example-data/test-p4.lzf.h5', 'example-data/test-ws.lzf.h5'])
fm = features.moments.Manager()
fh = features.histogram.Manager()
fc = features.base.Composite(children=[fm, fh])
g_train = agglo.Rag(ws_train, pr_train, feature_manager=fc)
np.random.RandomState(0)
(X, y, w, merges) = map(np.copy, map(np.ascontiguousarray,
g_train.learn_agglomerate(gt_train, fc)[0]))
print X.shape
np.savez('example-data/train-set.npz', X=X, y=y)
y = y[:, 0]
rf = classify.DefaultRandomForest()
X.shape
np.random.RandomState(0)
rf = rf.fit(X, y)
classify.save_classifier(rf, 'example-data/rf-1.joblib')
learned_policy = agglo.classifier_probability(fc, rf)
g_test = agglo.Rag(ws_test, pr_test, learned_policy, feature_manager=fc)
g_test.agglomerate(0.5)
seg_test1 = g_test.get_segmentation()
imio.write_h5_stack(seg_test1, 'example-data/test-seg1.lzf.h5', compression='lzf')
g_train4 = agglo.Rag(ws_train, p4_train, feature_manager=fc)
np.random.RandomState(0)
(X4, y4, w4, merges4) = map(np.copy, map(np.ascontiguousarray,
g_train4.learn_agglomerate(gt_train, fc)[0]))
print X4.shape
np.savez('example-data/train-set4.npz', X=X4, y=y4)
def policy():
rf = classify.DefaultRandomForest()
cl = agglo.classifier_probability(em, rf)
return cl
def classifier():
X, y = trexamples()
rf = classify.DefaultRandomForest()
rf.fit(X, y)
return rf
