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