def test_latent_node_boxes_standard_latent(): # learn the "easy" 2x2 boxes dataset. # a 2x2 box is placed randomly in a 4x4 grid # we add a latent variable for each 2x2 patch # that should make the model fairly simple X, Y = make_simple_2x2(seed=1, n_samples=40) latent_crf = LatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1) one_slack = OneSlackSSVM(latent_crf) n_slack = NSlackSSVM(latent_crf) subgradient = SubgradientSSVM(latent_crf, max_iter=100) for base_svm in [one_slack, n_slack, subgradient]: base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] Y_flat = [y.ravel() for y in Y] X_ = list(zip(X_flat, G, [2 * 2 for x in X_flat])) latent_svm.fit(X_[:20], Y_flat[:20]) assert_array_equal(latent_svm.predict(X_[:20]), Y_flat[:20]) assert_equal(latent_svm.score(X_[:20], Y_flat[:20]), 1) # test that score is not always 1 assert_true(.98 < latent_svm.score(X_[20:], Y_flat[20:]) < 1)
def test_latent_node_boxes_edge_features(): # learn the "easy" 2x2 boxes dataset. # smoketest using a single constant edge feature X, Y = make_simple_2x2(seed=1, n_samples=40) latent_crf = EdgeFeatureLatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1) base_svm = OneSlackSSVM(latent_crf) base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] Y_flat = [y.ravel() for y in Y] #X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) # add edge features X_ = [(x, g, np.ones((len(g), 1)), 4) for x, g in zip(X_flat, G)] latent_svm.fit(X_[:20], Y_flat[:20]) assert_array_equal(latent_svm.predict(X_[:20]), Y_flat[:20]) assert_equal(latent_svm.score(X_[:20], Y_flat[:20]), 1) # test that score is not always 1 assert_true(.98 < latent_svm.score(X_[20:], Y_flat[20:]) < 1)
def test_with_crosses_bad_init(): # use less perfect initialization rnd = np.random.RandomState(0) X, Y = toy.generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2) H_init = crf.init_latent(X, Y) mask = rnd.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) one_slack = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, max_iter=10000) n_slack = NSlackSSVM(crf) subgradient = SubgradientSSVM(crf, max_iter=150, learning_rate=.01, momentum=0) for base_ssvm in [one_slack, n_slack, subgradient]: base_ssvm.C = 10. ** 2 clf = LatentSSVM(base_ssvm) clf.fit(X, Y, H_init=H_init) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(.98 < clf.score(X_test, Y_test) < 1)
def test_latent_node_boxes_edge_features(): # learn the "easy" 2x2 boxes dataset. # smoketest using a single constant edge feature X, Y = make_simple_2x2(seed=1, n_samples=40) latent_crf = EdgeFeatureLatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1) base_svm = OneSlackSSVM(latent_crf) base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] Y_flat = [y.ravel() for y in Y] #X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) # add edge features X_ = [(x, g, np.ones((len(g), 1)), 4) for x, g in zip(X_flat, G)] latent_svm.fit(X_[:20], Y_flat[:20]) assert_array_equal(latent_svm.predict(X_[:20]), Y_flat[:20]) assert_equal(latent_svm.score(X_[:20], Y_flat[:20]), 1) # test that score is not always 1 assert_true(.98 < latent_svm.score(X_[20:], Y_flat[20:]) < 1)
def test_switch_to_ad3(): # smoketest only # test if switching between qpbo and ad3 works inside latent svm # use less perfect initialization if not get_installed(['qpbo']) or not get_installed(['ad3']): return X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] crf = LatentGridCRF(n_states_per_label=2, inference_method='qpbo') crf.initialize(X, Y) H_init = crf.init_latent(X, Y) np.random.seed(0) mask = np.random.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) base_ssvm = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, max_iter=10000, switch_to=('ad3', {'branch_and_bound': True}), C=10. ** 3) clf = LatentSSVM(base_ssvm) clf.fit(X, Y, H_init=H_init) assert_equal(clf.model.inference_method[0], 'ad3') Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(.98 < clf.score(X_test, Y_test) < 1)
def test_with_crosses_bad_init(): # use less perfect initialization X, Y = toy.generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2, inference_method='lp') H_init = crf.init_latent(X, Y) mask = np.random.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) one_slack = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, max_iter=10000) n_slack = StructuredSVM(crf) subgradient = SubgradientSSVM(crf, max_iter=150, learning_rate=5) for base_ssvm in [one_slack, n_slack, subgradient]: base_ssvm.C = 10. ** 3 base_ssvm.n_jobs = -1 clf = LatentSSVM(base_ssvm) clf.fit(X, Y, H_init=H_init) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_with_crosses_bad_init(): # use less perfect initialization rnd = np.random.RandomState(0) X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] crf = LatentGridCRF(n_states_per_label=2) crf.initialize(X, Y) H_init = crf.init_latent(X, Y) mask = rnd.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) one_slack_ssvm = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, C=100) clf = LatentSSVM(one_slack_ssvm) clf.fit(X, Y, H_init=H_init) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(.98 < clf.score(X_test, Y_test) < 1)
def test_latent_node_boxes_standard_latent(): # learn the "easy" 2x2 boxes dataset. # a 2x2 box is placed randomly in a 4x4 grid # we add a latent variable for each 2x2 patch # that should make the model fairly simple X, Y = make_simple_2x2(seed=1, n_samples=40) latent_crf = LatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1) one_slack = OneSlackSSVM(latent_crf) n_slack = NSlackSSVM(latent_crf) subgradient = SubgradientSSVM(latent_crf, max_iter=100) for base_svm in [one_slack, n_slack, subgradient]: base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] Y_flat = [y.ravel() for y in Y] X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) latent_svm.fit(X_[:20], Y_flat[:20]) assert_array_equal(latent_svm.predict(X_[:20]), Y_flat[:20]) assert_equal(latent_svm.score(X_[:20], Y_flat[:20]), 1) # test that score is not always 1 assert_true(.98 < latent_svm.score(X_[20:], Y_flat[20:]) < 1)
def main(): # get some data X, Y = toy.generate_bars(n_samples=40, noise=10, total_size=10, separate_labels=False) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5) # train a latent grid crf n_labels = len(np.unique(Y_train)) crf = LatentDirectionalGridCRF(n_labels=n_labels, n_states_per_label=[1, 6], inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=50, C=10., verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=False, tol=-10, base_svm='1-slack') clf.fit(X_train, Y_train) # the rest is plotting for X_, Y_, H, name in [[X_train, Y_train, clf.H_init_, "train"], [X_test, Y_test, [None] * len(X_test), "test"]]: Y_pred = clf.predict(X_) i = 0 loss = 0 for x, y, h_init, y_pred in zip(X_, Y_, H, Y_pred): loss += np.sum(y != y_pred) fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y, vmin=0, vmax=crf.n_labels - 1) ax[0, 0].set_title("ground truth") unary_pred = np.argmax(x, axis=-1) ax[0, 1].matshow(unary_pred, vmin=0, vmax=crf.n_labels - 1) ax[0, 1].set_title("unaries only") if h_init is None: ax[1, 0].set_visible(False) else: ax[1, 0].matshow(h_init, vmin=0, vmax=crf.n_states - 1) ax[1, 0].set_title("latent initial") ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1) ax[1, 1].set_title("latent final") ax[2, 0].matshow(crf.inference(x, clf.w), vmin=0, vmax=crf.n_states - 1) ax[2, 0].set_title("prediction") ax[2, 1].matshow(y_pred, vmin=0, vmax=crf.n_labels - 1) ax[2, 1].set_title("prediction") for a in ax.ravel(): a.set_xticks(()) a.set_yticks(()) fig.savefig("data_%s_%03d.png" % (name, i), bbox_inches="tight") i += 1 print("loss %s set: %f" % (name, loss))
def test_directional_bars(): X, Y = generate_easy(n_samples=10, noise=5, box_size=2, total_size=6, seed=1) n_labels = 2 crf = LatentDirectionalGridCRF(n_labels=n_labels, n_states_per_label=[1, 4]) clf = LatentSSVM(OneSlackSSVM(model=crf, max_iter=500, C=10.0, inference_cache=50, tol=0.01)) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def main(): X, Y = toy.generate_crosses(n_samples=40, noise=8, n_crosses=2, total_size=10) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5) n_labels = len(np.unique(Y_train)) crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2, inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=50, C=1000., verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True, plot=True) clf.fit(X_train, Y_train) for X_, Y_, H, name in [[X_train, Y_train, clf.H_init_, "train"], [X_test, Y_test, [None] * len(X_test), "test"]]: Y_pred = clf.predict(X_) i = 0 loss = 0 for x, y, h_init, y_pred in zip(X_, Y_, H, Y_pred): loss += np.sum(y != y_pred / crf.n_states_per_label) fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y * crf.n_states_per_label, vmin=0, vmax=crf.n_states - 1) ax[0, 0].set_title("ground truth") unary_params = np.repeat(np.eye(2), 2, axis=1) pairwise_params = np.zeros(10) w_unaries_only = np.hstack([unary_params.ravel(), pairwise_params.ravel()]) unary_pred = crf.inference(x, w_unaries_only) ax[0, 1].matshow(unary_pred, vmin=0, vmax=crf.n_states - 1) ax[0, 1].set_title("unaries only") if h_init is None: ax[1, 0].set_visible(False) else: ax[1, 0].matshow(h_init, vmin=0, vmax=crf.n_states - 1) ax[1, 0].set_title("latent initial") ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1) ax[1, 1].set_title("latent final") ax[2, 0].matshow(y_pred, vmin=0, vmax=crf.n_states - 1) ax[2, 0].set_title("prediction") ax[2, 1].matshow((y_pred // crf.n_states_per_label) * crf.n_states_per_label, vmin=0, vmax=crf.n_states - 1) ax[2, 1].set_title("prediction") for a in ax.ravel(): a.set_xticks(()) a.set_yticks(()) fig.savefig("data_%s_%03d.png" % (name, i), bbox_inches="tight") i += 1 print("loss %s set: %f" % (name, loss)) print(clf.w)
def main(): # get some data X, Y = toy.generate_bars(n_samples=40, noise=10, total_size=10, separate_labels=False) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.5) # train a latent grid crf n_labels = len(np.unique(Y_train)) crf = LatentDirectionalGridCRF(n_labels=n_labels, n_states_per_label=[1, 6], inference_method="lp") clf = LatentSSVM( problem=crf, max_iter=50, C=10.0, verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=False, tol=-10, base_svm="1-slack", ) clf.fit(X_train, Y_train) # the rest is plotting for X_, Y_, H, name in [[X_train, Y_train, clf.H_init_, "train"], [X_test, Y_test, [None] * len(X_test), "test"]]: Y_pred = clf.predict(X_) i = 0 loss = 0 for x, y, h_init, y_pred in zip(X_, Y_, H, Y_pred): loss += np.sum(y != y_pred) fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y, vmin=0, vmax=crf.n_labels - 1) ax[0, 0].set_title("ground truth") unary_pred = np.argmax(x, axis=-1) ax[0, 1].matshow(unary_pred, vmin=0, vmax=crf.n_labels - 1) ax[0, 1].set_title("unaries only") if h_init is None: ax[1, 0].set_visible(False) else: ax[1, 0].matshow(h_init, vmin=0, vmax=crf.n_states - 1) ax[1, 0].set_title("latent initial") ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1) ax[1, 1].set_title("latent final") ax[2, 0].matshow(crf.inference(x, clf.w), vmin=0, vmax=crf.n_states - 1) ax[2, 0].set_title("prediction") ax[2, 1].matshow(y_pred, vmin=0, vmax=crf.n_labels - 1) ax[2, 1].set_title("prediction") for a in ax.ravel(): a.set_xticks(()) a.set_yticks(()) fig.savefig("data_%s_%03d.png" % (name, i), bbox_inches="tight") i += 1 print("loss %s set: %f" % (name, loss))
def test_switch_to_ad3(): # smoketest only # test if switching between qpbo and ad3 works inside latent svm # use less perfect initialization if not get_installed(["qpbo"]) or not get_installed(["ad3"]): return X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] crf = LatentGridCRF(n_states_per_label=2, inference_method="qpbo") crf.initialize(X, Y) H_init = crf.init_latent(X, Y) np.random.seed(0) mask = np.random.uniform(size=H_init.shape) > 0.7 H_init[mask] = 2 * (H_init[mask] / 2) base_ssvm = OneSlackSSVM( crf, inactive_threshold=1e-8, cache_tol=0.0001, inference_cache=50, max_iter=10000, switch_to=("ad3", {"branch_and_bound": True}), C=10.0 ** 3, ) clf = LatentSSVM(base_ssvm) # evil hackery to get rid of ad3 output try: devnull = open("/dev/null", "w") oldstdout_fno = os.dup(sys.stdout.fileno()) os.dup2(devnull.fileno(), 1) replaced_stdout = True except: replaced_stdout = False clf.fit(X, Y, H_init=H_init) if replaced_stdout: os.dup2(oldstdout_fno, 1) assert_equal(clf.model.inference_method[0], "ad3") Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(0.98 < clf.score(X_test, Y_test) < 1)
def test_with_crosses_base_svms(): # very simple dataset. k-means init is perfect for base_svm in ['1-slack', 'n-slack', 'subgradient']: X, Y = toy.generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=[1, 2], inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=150, C=10. ** 5, verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True, base_svm=base_svm, learning_rate=5) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_states(states, x, y, x_t, y_t, i, jobs): latent_pbl = GraphLDCRF(n_states_per_label=states, inference_method="qpbo") base_ssvm = NSlackSSVM(latent_pbl, C=1, tol=0.01, inactive_threshold=1e-3, batch_size=10, verbose=0, n_jobs=jobs) latent_svm = LatentSSVM(base_ssvm=base_ssvm, latent_iter=3) latent_svm.fit(x, y) test = latent_svm.score(x_t, y_t) train = latent_svm.score(x, y) plot_cm(latent_svm, y_t, x_t, str(states), i) print states, "Test:", test, "Train:", train return test, train
def test_switch_to_ad3(): # smoketest only # test if switching between qpbo and ad3 works inside latent svm # use less perfect initialization if not get_installed(['qpbo']) or not get_installed(['ad3']): return X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] crf = LatentGridCRF(n_states_per_label=2, inference_method='qpbo') crf.initialize(X, Y) H_init = crf.init_latent(X, Y) np.random.seed(0) mask = np.random.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) base_ssvm = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, max_iter=10000, switch_to=('ad3', { 'branch_and_bound': True }), C=10.**3) clf = LatentSSVM(base_ssvm) # evil hackery to get rid of ad3 output try: devnull = open('/dev/null', 'w') oldstdout_fno = os.dup(sys.stdout.fileno()) os.dup2(devnull.fileno(), 1) replaced_stdout = True except: replaced_stdout = False clf.fit(X, Y, H_init=H_init) if replaced_stdout: os.dup2(oldstdout_fno, 1) assert_equal(clf.model.inference_method[0], 'ad3') Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(.98 < clf.score(X_test, Y_test) < 1)
def test_directional_bars(): for inference_method in ['lp']: X, Y = toy.generate_easy(n_samples=10, noise=5, box_size=2, total_size=6, seed=1) n_labels = 2 crf = LatentDirectionalGridCRF(n_labels=n_labels, n_states_per_label=[1, 4], inference_method=inference_method) clf = LatentSSVM(problem=crf, max_iter=500, C=10. ** 5, verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True, base_svm='1-slack') clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_with_crosses_perfect_init(): # very simple dataset. k-means init is perfect for n_states_per_label in [2, [1, 2]]: # test with 2 states for both foreground and background, # as well as with single background state X, Y = generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=n_states_per_label) clf = LatentSSVM( OneSlackSSVM(model=crf, max_iter=500, C=10, check_constraints=False, break_on_bad=False, inference_cache=50) ) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) assert_equal(clf.score(X, Y), 1)
def test_binary_blocks_cutting_plane_latent_node(): #testing cutting plane ssvm on easy binary dataset # we use the LatentNodeCRF without latent nodes and check that it does the # same as GraphCRF X, Y = generate_blocks(n_samples=3) crf = GraphCRF() clf = NSlackSSVM(model=crf, max_iter=20, C=100, check_constraints=True, break_on_bad=False, n_jobs=1) x1, x2, x3 = X y1, y2, y3 = Y n_states = len(np.unique(Y)) # delete some rows to make it more fun x1, y1 = x1[:, :-1], y1[:, :-1] x2, y2 = x2[:-1], y2[:-1] # generate graphs X_ = [x1, x2, x3] G = [make_grid_edges(x) for x in X_] # reshape / flatten x and y X_ = [x.reshape(-1, n_states) for x in X_] Y = [y.ravel() for y in [y1, y2, y3]] X = zip(X_, G) clf.fit(X, Y) Y_pred = clf.predict(X) for y, y_pred in zip(Y, Y_pred): assert_array_equal(y, y_pred) latent_crf = LatentNodeCRF(n_labels=2, n_hidden_states=0) latent_svm = LatentSSVM(NSlackSSVM(model=latent_crf, max_iter=20, C=100, check_constraints=True, break_on_bad=False, n_jobs=1), latent_iter=3) X_latent = zip(X_, G, np.zeros(len(X_))) latent_svm.fit(X_latent, Y, H_init=Y) Y_pred = latent_svm.predict(X_latent) for y, y_pred in zip(Y, Y_pred): assert_array_equal(y, y_pred) assert_array_almost_equal(latent_svm.w, clf.w)
def test_with_crosses_base_svms(): # very simple dataset. k-means init is perfect n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=[1, 2]) one_slack = OneSlackSSVM(crf, inference_cache=50) n_slack = NSlackSSVM(crf) subgradient = SubgradientSSVM(crf, max_iter=400, learning_rate=0.01, decay_exponent=0, decay_t0=10) X, Y = generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) for base_ssvm in [one_slack, n_slack, subgradient]: base_ssvm.C = 100.0 clf = LatentSSVM(base_ssvm=base_ssvm) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) assert_equal(clf.score(X, Y), 1)
def test_with_crosses_bad_init(): # use less perfect initialization X, Y = toy.generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2, inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=50, C=10. ** 3, verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True) H_init = crf.init_latent(X, Y) mask = np.random.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) clf.fit(X, Y, H_init=H_init) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_states(states, x, y, x_t, y_t, jobs): latent_pbl = GraphLDCRF(n_states_per_label=states, inference_method='qpbo') base_ssvm = NSlackSSVM(latent_pbl, C=1, tol=.01, inactive_threshold=1e-3, batch_size=10, verbose=0, n_jobs=jobs) latent_svm = LatentSSVM(base_ssvm=base_ssvm, latent_iter=3) latent_svm.fit(x, y) test = latent_svm.score(x_t, y_t) train = latent_svm.score(x, y) print states, 'Test:', test, 'Train:', train return test, train
def test_with_crosses_base_svms(): # very simple dataset. k-means init is perfect n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=[1, 2], inference_method='lp') one_slack = OneSlackSSVM(crf) n_slack = StructuredSVM(crf) subgradient = SubgradientSSVM(crf, max_iter=150, learning_rate=5) for base_ssvm in [one_slack, n_slack, subgradient]: base_ssvm.C = 10. ** 5 base_ssvm.n_jobs = -1 X, Y = toy.generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) clf = LatentSSVM(base_ssvm=base_ssvm) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_latent_node_boxes_standard_latent_features(): # learn the "easy" 2x2 boxes dataset. # we make it even easier now by adding features that encode the correct # latent state. This basically tests that the features are actually used X, Y = make_simple_2x2(seed=1, n_samples=20, n_flips=6) latent_crf = LatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1, latent_node_features=True) one_slack = OneSlackSSVM(latent_crf) n_slack = NSlackSSVM(latent_crf) subgradient = SubgradientSSVM(latent_crf, max_iter=100, learning_rate=0.01, momentum=0) for base_svm in [one_slack, n_slack, subgradient]: base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] # augment X with the features for hidden units X_flat = [ np.vstack([x, y[::2, ::2].reshape(-1, 1)]) for x, y in zip(X_flat, Y) ] Y_flat = [y.ravel() for y in Y] X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) latent_svm.fit(X_[:10], Y_flat[:10]) assert_array_equal(latent_svm.predict(X_[:10]), Y_flat[:10]) assert_equal(latent_svm.score(X_[:10], Y_flat[:10]), 1) # we actually become prefect ^^ assert_true(.98 < latent_svm.score(X_[10:], Y_flat[10:]) <= 1)
def test_binary_blocks_cutting_plane_latent_node(): #testing cutting plane ssvm on easy binary dataset # we use the LatentNodeCRF without latent nodes and check that it does the # same as GraphCRF X, Y = toy.generate_blocks(n_samples=3) crf = GraphCRF(inference_method='lp') clf = StructuredSVM(model=crf, max_iter=20, C=100, verbose=0, check_constraints=True, break_on_bad=False, n_jobs=1) x1, x2, x3 = X y1, y2, y3 = Y n_states = len(np.unique(Y)) # delete some rows to make it more fun x1, y1 = x1[:, :-1], y1[:, :-1] x2, y2 = x2[:-1], y2[:-1] # generate graphs X_ = [x1, x2, x3] G = [make_grid_edges(x) for x in X_] # reshape / flatten x and y X_ = [x.reshape(-1, n_states) for x in X_] Y = [y.ravel() for y in [y1, y2, y3]] X = zip(X_, G) clf.fit(X, Y) Y_pred = clf.predict(X) for y, y_pred in zip(Y, Y_pred): assert_array_equal(y, y_pred) latent_crf = LatentNodeCRF(n_labels=2, inference_method='lp', n_hidden_states=0) latent_svm = LatentSSVM(StructuredSVM(model=latent_crf, max_iter=20, C=100, verbose=0, check_constraints=True, break_on_bad=False, n_jobs=1), latent_iter=3) X_latent = zip(X_, G, np.zeros(len(X_))) latent_svm.fit(X_latent, Y, H_init=Y) Y_pred = latent_svm.predict(X_latent) for y, y_pred in zip(Y, Y_pred): assert_array_equal(y, y_pred) assert_array_almost_equal(latent_svm.w, clf.w)
def main(): X, Y = toy.generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5) n_labels = len(np.unique(Y_train)) crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=[1, 2], inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=50, C=1000., verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True) clf.fit(X_train, Y_train) i = 0 for X_, Y_, H, name in [[X_train, Y_train, clf.H_init_, "train"], [X_test, Y_test, [None] * len(X_test), "test"]]: Y_pred = clf.predict(X_) score = clf.score(X_, Y_) for x, y, h_init, y_pred in zip(X_, Y_, H, Y_pred): fig, ax = plt.subplots(4, 1) ax[0].matshow(y, vmin=0, vmax=crf.n_labels - 1) ax[0].set_title("Ground truth") ax[1].matshow(np.argmax(x, axis=-1), vmin=0, vmax=crf.n_labels - 1) ax[1].set_title("Unaries only") #if h_init is None: #ax[1, 0].set_visible(False) #else: #ax[1, 0].matshow(h_init, vmin=0, vmax=crf.n_states - 1) #ax[1, 0].set_title("latent initial") #ax[2].matshow(crf.latent(x, y, clf.w), #vmin=0, vmax=crf.n_states - 1) #ax[2].set_title("latent final") ax[2].matshow(crf.inference(x, clf.w), vmin=0, vmax=crf.n_states - 1) ax[2].set_title("Prediction for h") ax[3].matshow(y_pred, vmin=0, vmax=crf.n_labels - 1) ax[3].set_title("Prediction for y") for a in ax.ravel(): a.set_xticks(()) a.set_yticks(()) plt.subplots_adjust(hspace=.5) fig.savefig("data_%s_%03d.png" % (name, i), bbox_inches="tight", dpi=400) i += 1 print("score %s set: %f" % (name, score)) print(clf.w)
def test_with_crosses(): # very simple dataset. k-means init is perfect for n_states_per_label in [2, [1, 2]]: # test with 2 states for both foreground and background, # as well as with single background state #for inference_method in ['ad3', 'qpbo', 'lp']: for inference_method in ['lp']: X, Y = toy.generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=n_states_per_label, inference_method=inference_method) clf = LatentSSVM(problem=crf, max_iter=50, C=10. ** 5, verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_directional_bars(): X, Y = generate_easy(n_samples=10, noise=5, box_size=2, total_size=6, seed=1) n_labels = 2 crf = LatentDirectionalGridCRF(n_labels=n_labels, n_states_per_label=[1, 4]) clf = LatentSSVM( OneSlackSSVM(model=crf, max_iter=500, C=10., inference_cache=50, tol=.01)) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y)
def test_with_crosses_base_svms(): # very simple dataset. k-means init is perfect n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=[1, 2]) one_slack = OneSlackSSVM(crf, inference_cache=50) n_slack = NSlackSSVM(crf) subgradient = SubgradientSSVM(crf, max_iter=400, learning_rate=.01, decay_exponent=0, decay_t0=10) X, Y = generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) for base_ssvm in [one_slack, n_slack, subgradient]: base_ssvm.C = 100. clf = LatentSSVM(base_ssvm=base_ssvm) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) assert_equal(clf.score(X, Y), 1)
def test_latent_node_boxes_standard_latent_features(): # learn the "easy" 2x2 boxes dataset. # we make it even easier now by adding features that encode the correct # latent state. This basically tests that the features are actually used X, Y = make_simple_2x2(seed=1, n_samples=20, n_flips=6) latent_crf = LatentNodeCRF(n_labels=2, n_hidden_states=2, n_features=1, latent_node_features=True) one_slack = OneSlackSSVM(latent_crf) n_slack = NSlackSSVM(latent_crf) subgradient = SubgradientSSVM(latent_crf, max_iter=100, learning_rate=0.01, momentum=0) for base_svm in [one_slack, n_slack, subgradient]: base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = make_edges_2x2() G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] # augment X with the features for hidden units X_flat = [np.vstack([x, y[::2, ::2].reshape(-1, 1)]) for x, y in zip(X_flat, Y)] Y_flat = [y.ravel() for y in Y] X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) latent_svm.fit(X_[:10], Y_flat[:10]) assert_array_equal(latent_svm.predict(X_[:10]), Y_flat[:10]) assert_equal(latent_svm.score(X_[:10], Y_flat[:10]), 1) # we actually become prefect ^^ assert_true(.98 < latent_svm.score(X_[10:], Y_flat[10:]) <= 1)
def test_with_crosses_bad_init(): # use less perfect initialization rnd = np.random.RandomState(0) X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] crf = LatentGridCRF(n_states_per_label=2) crf.initialize(X, Y) H_init = crf.init_latent(X, Y) mask = rnd.uniform(size=H_init.shape) > 0.7 H_init[mask] = 2 * (H_init[mask] / 2) one_slack_ssvm = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=0.0001, inference_cache=50, C=100) clf = LatentSSVM(one_slack_ssvm) clf.fit(X, Y, H_init=H_init) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(0.98 < clf.score(X_test, Y_test) < 1)
def test_latent_node_boxes_standard_latent(): # learn the "easy" 2x2 boxes dataset. # a 2x2 box is placed randomly in a 4x4 grid # we add a latent variable for each 2x2 patch # that should make the model fairly simple X, Y = toy.make_simple_2x2(seed=1) latent_crf = LatentNodeCRF(n_labels=2, inference_method='lp', n_hidden_states=2, n_features=1) one_slack = OneSlackSSVM(latent_crf) n_slack = StructuredSVM(latent_crf) subgradient = SubgradientSSVM(latent_crf, max_iter=100, learning_rate=0.01, momentum=0) for base_svm in [one_slack, n_slack, subgradient]: base_svm.C = 10 latent_svm = LatentSSVM(base_svm, latent_iter=10) G = [make_grid_edges(x) for x in X] # make edges for hidden states: edges = [] node_indices = np.arange(4 * 4).reshape(4, 4) for i, (x, y) in enumerate(itertools.product([0, 2], repeat=2)): for j in xrange(x, x + 2): for k in xrange(y, y + 2): edges.append([i + 4 * 4, node_indices[j, k]]) G = [np.vstack([make_grid_edges(x), edges]) for x in X] # reshape / flatten x and y X_flat = [x.reshape(-1, 1) for x in X] Y_flat = [y.ravel() for y in Y] X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) latent_svm.fit(X_, Y_flat) assert_equal(latent_svm.score(X_, Y_flat), 1)
def test_with_crosses_perfect_init(): # very simple dataset. k-means init is perfect for n_states_per_label in [2, [1, 2]]: # test with 2 states for both foreground and background, # as well as with single background state X, Y = generate_crosses(n_samples=10, noise=5, n_crosses=1, total_size=8) n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=n_states_per_label) clf = LatentSSVM( OneSlackSSVM(model=crf, max_iter=500, C=10, check_constraints=False, break_on_bad=False, inference_cache=50)) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) assert_equal(clf.score(X, Y), 1)
def test_switch_to_ad3(): # smoketest only # test if switching between qpbo and ad3 works inside latent svm # use less perfect initialization if not get_installed(['qpbo']) or not get_installed(['ad3']): return X, Y = toy.generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_test, Y_test = X[10:], Y[10:] X, Y = X[:10], Y[:10] n_labels = 2 crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2, inference_method='qpbo') H_init = crf.init_latent(X, Y) np.random.seed(0) mask = np.random.uniform(size=H_init.shape) > .7 H_init[mask] = 2 * (H_init[mask] / 2) base_ssvm = OneSlackSSVM(crf, inactive_threshold=1e-8, cache_tol=.0001, inference_cache=50, max_iter=10000, switch_to='ad3bb', C=10. ** 3) clf = LatentSSVM(base_ssvm) clf.fit(X, Y, H_init=H_init) # we actually switch back from ad3bb to the original assert_equal(clf.model.inference_method, "qpbo") # unfortunately this test only works with ad3 clf.base_ssvm.model.inference_method = 'ad3bb' Y_pred = clf.predict(X) assert_array_equal(np.array(Y_pred), Y) # test that score is not always 1 assert_true(.98 < clf.score(X_test, Y_test) < 1)
# first, do it with a standard CRF / SVM pbl = GraphCRF(n_features=2, n_states=2, inference_method='lp') svm = StructuredSVM(pbl, verbose=1, check_constraints=True, C=100, n_jobs=1) svm.fit(X_train_, y_train) y_pred = np.vstack(svm.predict(X_test_)) print("Score with pystruct crf svm: %f" % np.mean(y_pred == y_test)) # now with latent CRF SVM latent_pbl = LatentGraphCRF(n_features=2, n_labels=2, n_states_per_label=2, inference_method='lp') latent_svm = LatentSSVM(latent_pbl, verbose=1, check_constraints=True, C=100, n_jobs=1) # we explicitly initialize randomly to make it a bit more interesting latent_svm.fit(X_train_, y_train, H_init=np.random.randint(2, size=y_train.shape) + 2 * y_train) y_pred_latent = np.vstack(latent_svm.predict(X_test_)) # plot the results fig, axes = plt.subplots(1, 5, figsize=(12, 4)) cm = plt.cm.Paired axes[0].set_title("Ground truth") axes[0].scatter(X_test[:, 0], X_test[:, 1], c=y_test, s=50, cmap=cm) axes[1].set_title("SVM prediction") axes[1].scatter(X_test[:, 0], X_test[:, 1], c=y_pred, s=50, cmap=cm) axes[2].set_title("Latent SVM prediction") axes[2].scatter(X_test[:, 0], X_test[:, 1], c=y_pred_latent // 2, s=50, cmap=cm) axes[3].set_title("Latent states") axes[3].scatter(X_test[:, 0], X_test[:, 1], c=y_pred_latent, s=50, cmap=cm) axes[4].set_title("Initial states")
from pystruct.models import LatentGridCRF from pystruct.learners import LatentSSVM, OneSlackSSVM from pystruct.datasets import generate_crosses X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5) crf = LatentGridCRF(n_states_per_label=[1, 2]) base_ssvm = OneSlackSSVM(model=crf, C=10., n_jobs=-1, inference_cache=20, tol=.1) clf = LatentSSVM(base_ssvm=base_ssvm) clf.fit(X_train, Y_train) print("Score training set: %f" % clf.score(X_train, Y_train)) print("Score test set: %f" % clf.score(X_test, Y_test)) Y_pred = clf.predict(X_test) x, y, y_pred = X_test[1], Y_test[1], Y_pred[1] fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y, vmin=0, vmax=crf.n_labels - 1) ax[0, 0].set_title("ground truth") ax[0, 1].matshow(np.argmax(x, axis=-1), vmin=0, vmax=crf.n_labels - 1) ax[0, 1].set_title("unaries only") ax[1, 0].set_visible(False) ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1) ax[1, 1].set_title("latent final") ax[2, 0].matshow(crf.inference(x, clf.w), vmin=0, vmax=crf.n_states - 1)
from pystruct.models import LatentGridCRF from pystruct.learners import LatentSSVM, OneSlackSSVM from pystruct.datasets import generate_crosses X, Y = generate_crosses(n_samples=20, noise=5, n_crosses=1, total_size=8) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5, allow_nd=True) crf = LatentGridCRF(n_states_per_label=[1, 2]) base_ssvm = OneSlackSSVM(model=crf, C=10., n_jobs=-1, inference_cache=20, tol=.1) clf = LatentSSVM(base_ssvm=base_ssvm) clf.fit(X_train, Y_train) print("loss training set: %f" % clf.score(X_train, Y_train)) print("loss test set: %f" % clf.score(X_test, Y_test)) Y_pred = clf.predict(X_test) x, y, y_pred = X_test[1], Y_test[1], Y_pred[1] fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y, vmin=0, vmax=crf.n_labels - 1) ax[0, 0].set_title("ground truth") ax[0, 1].matshow(np.argmax(x, axis=-1), vmin=0, vmax=crf.n_labels - 1) ax[0, 1].set_title("unaries only") ax[1, 0].set_visible(False) ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1)
show_loss_every=10, inference_cache=50) latent_svm = LatentSSVM(ssvm) # make edges for hidden states: edges = [] node_indices = np.arange(4 * 4).reshape(4, 4) for i, (x, y) in enumerate(itertools.product([0, 2], repeat=2)): for j in xrange(x, x + 2): for k in xrange(y, y + 2): edges.append([i + 4 * 4, node_indices[j, k]]) G = [np.vstack([make_grid_edges(x), edges]) for x in X] # Random initialization H_init = [ np.hstack([y.ravel(), np.random.randint(2, 4, size=2 * 2)]) for y in Y ] plot_boxes(H_init, title="Top: Random initial hidden states. Bottom: Ground" "truth labeling.") X_ = zip(X_flat, G, [2 * 2 for x in X_flat]) latent_svm.fit(X_, Y_flat, H_init) print("Training score with latent nodes: %f " % latent_svm.score(X_, Y_flat)) H = latent_svm.predict_latent(X_) plot_boxes(H, title="Top: Hidden states after training. Bottom: Prediction.") plt.show()
def main(): X, Y = toy.generate_crosses(n_samples=40, noise=8, n_crosses=2, total_size=10) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.5) n_labels = len(np.unique(Y_train)) crf = LatentGridCRF(n_labels=n_labels, n_states_per_label=2, inference_method='lp') clf = LatentSSVM(problem=crf, max_iter=50, C=1000., verbose=2, check_constraints=True, n_jobs=-1, break_on_bad=True, plot=True) clf.fit(X_train, Y_train) for X_, Y_, H, name in [[X_train, Y_train, clf.H_init_, "train"], [X_test, Y_test, [None] * len(X_test), "test"]]: Y_pred = clf.predict(X_) i = 0 loss = 0 for x, y, h_init, y_pred in zip(X_, Y_, H, Y_pred): loss += np.sum(y != y_pred / crf.n_states_per_label) fig, ax = plt.subplots(3, 2) ax[0, 0].matshow(y * crf.n_states_per_label, vmin=0, vmax=crf.n_states - 1) ax[0, 0].set_title("ground truth") unary_params = np.repeat(np.eye(2), 2, axis=1) pairwise_params = np.zeros(10) w_unaries_only = np.hstack( [unary_params.ravel(), pairwise_params.ravel()]) unary_pred = crf.inference(x, w_unaries_only) ax[0, 1].matshow(unary_pred, vmin=0, vmax=crf.n_states - 1) ax[0, 1].set_title("unaries only") if h_init is None: ax[1, 0].set_visible(False) else: ax[1, 0].matshow(h_init, vmin=0, vmax=crf.n_states - 1) ax[1, 0].set_title("latent initial") ax[1, 1].matshow(crf.latent(x, y, clf.w), vmin=0, vmax=crf.n_states - 1) ax[1, 1].set_title("latent final") ax[2, 0].matshow(y_pred, vmin=0, vmax=crf.n_states - 1) ax[2, 0].set_title("prediction") ax[2, 1].matshow( (y_pred // crf.n_states_per_label) * crf.n_states_per_label, vmin=0, vmax=crf.n_states - 1) ax[2, 1].set_title("prediction") for a in ax.ravel(): a.set_xticks(()) a.set_yticks(()) fig.savefig("data_%s_%03d.png" % (name, i), bbox_inches="tight") i += 1 print("loss %s set: %f" % (name, loss)) print(clf.w)
pbl = GraphCRF(inference_method='unary') # We use batch_size=-1 as a binary problem can be solved in one go. svm = NSlackSSVM(pbl, C=1, batch_size=-1) svm.fit(X_train_, y_train) # Now, use a latent-variabile CRF model with SVM training. # 5 states per label is enough capacity to encode the 5 digit classes. latent_pbl = LatentGraphCRF(n_states_per_label=5, inference_method='unary') base_ssvm = NSlackSSVM(latent_pbl, C=1, tol=.01, inactive_threshold=1e-3, batch_size=10) latent_svm = LatentSSVM(base_ssvm=base_ssvm, latent_iter=2) latent_svm.fit(X_train_, y_train) print("Score with binary SVM:") print("Train: {:2.2f}".format(svm.score(X_train_, y_train))) print("Test: {:2.2f}".format(svm.score(X_test_, y_test))) print("Score with latent SVM:") print("Train: {:2.2f}".format(latent_svm.score(X_train_, y_train))) print("Test: {:2.2f}".format(latent_svm.score(X_test_, y_test))) h_pred = np.hstack(latent_svm.predict_latent(X_test_)) print("Latent class counts: %s" % repr(np.bincount(h_pred))) # plot first few digits from each latent class plt.figure(figsize=(3, 5))
def trainModel_Latent(num_iter=5, latent_iter=3, inference="qpbo", trainer="NSlack", num_train=2, num_test=1, C=0.1, edges="180x180_dist1_diag0", inputs=[1, 1, 1, 1, 1, 1], features="all", directed=False, savePred=False): padding = (30, 30, 30, 30) if directed == True: features += '+directed' resultsDir = os.getcwd() + '/CRFResults' nameLen = len(os.listdir(resultsDir)) edgeFeature = edges filename = str(nameLen) + '_CRF_iter_' + str( num_iter ) + "_" + inference + "_" + trainer + "_" + features + "_" + str( num_train) + "_" + str(num_test) + "_" + edgeFeature print "Loading training slices" start = time.clock() train = extractSlices2(train_path, num_train, padding, inputs=inputs) end = time.clock() train_load_time = (end - start) / 60.0 [trainLayers, trainTruth, sliceShape] = train print "Training slices loaded in %f" % (train_load_time) n_features = len(trainLayers[0][0, 0]) print "Layer shape is : " print trainLayers[0].shape print "Training the model" edges = np.load("/home/bmi/CRF/edges/" + edges + ".npy") G = [edges for x in trainLayers] print trainLayers[0].shape trainLayers = np.array([ x.reshape((sliceShape[0] * sliceShape[1], n_features)) for x in trainLayers ]) trainTruth = np.array([ x.reshape((sliceShape[0] * sliceShape[1], )).astype(int) for x in trainTruth ]) if inference == 'ogm': crf = GraphCRF(inference_method=('ogm', { 'alg': 'fm' }), directed=directed) else: crf = LatentGraphCRF(n_states_per_label=2, inference_method=inference) if trainer == "Frank": base_svm = FrankWolfeSSVM(model=crf, max_iter=num_iter, C=C, n_jobs=-1, verbose=1) svm = LatentSSVM(base_ssvm=base_svm) elif trainer == "NSlack": base_svm = NSlackSSVM(model=crf, max_iter=num_iter, C=C, n_jobs=-1, verbose=1) svm = LatentSSVM(base_ssvm=base_svm, latent_iter=latent_iter) else: svm = OneSlackSSVM(model=crf, max_iter=num_iter, C=C, n_jobs=-1, verbose=1) start = time.clock() asdf = zip(trainLayers, G) svm.fit(asdf, trainTruth) end = time.clock() train_time = (end - start) / 60.0 print "The training took %f" % (train_time) print "Model parameter size :" print svm.w.shape print "making predictions on train data" predTrain = svm.predict(asdf) trainDice = [] for i in range(len(trainLayers)): diceScore = accuracy(predTrain[i], trainTruth[i]) trainDice.append(diceScore) meanTrainDice = sum(trainDice) / len(trainLayers) del trainLayers, trainTruth ################################################################################################ overallDicePerPatient = [] # For overall test Dice extDicePerPatient = [] PatientTruthLayers = [] PatientPredLayers = [] PREC = [] RECALL = [] F1 = [] LayerwiseDiceTotal = [] testResultFile = open(os.getcwd() + "/CRFResults/" + filename + ".csv", 'a') testResultFile.write( "folderName,numLayers, Overall Dice, precision , recall, F1" + "\n") counter = 0 print "Loading the test slices" for folder in os.listdir(test_path): path = test_path + "/" + folder layerDiceScores = '' # print path data = extractTestSlices2(path, padding, inputs=inputs) if data != 0: [testLayers, testTruth, sliceShape, startSlice, endSlice] = data # trueTestLayers=testLayers GTest = [edges for x in testLayers] testLayers = np.array([ x.reshape((sliceShape[0] * sliceShape[1], n_features)) for x in testLayers ]) testTruth = np.array([ x.reshape((sliceShape[0] * sliceShape[1], )).astype(int) for x in testTruth ]) asdfTest = zip(testLayers, GTest) predTest = svm.predict(asdfTest) LayerwiseDice = [] for i in range(len(testLayers)): diceScore = accuracy(predTest[i], testTruth[i]) layerDiceScores += "," + str(diceScore) if math.isnan(diceScore): if sum(predTest[i]) == 0 and sum(testTruth[i]) == 0: LayerwiseDice.append(1.0) continue LayerwiseDice.append(diceScore) LayerwiseDiceTotal.append(LayerwiseDice) overallTestDice = accuracy(np.hstack(predTest), np.hstack(testTruth)) extDice = np.mean( np.array(LayerwiseDice) [range(10) + range(len(LayerwiseDice) - 10, len(LayerwiseDice))]) prec, recall, f1 = precision_score(np.hstack(testTruth), np.hstack(predTest)), recall_score( np.hstack(testTruth), np.hstack(predTest)), f1_score( np.hstack(testTruth), np.hstack(predTest)) print "Patient %d : Overall test DICE for %s is : %f and extDice is %f" % ( counter, folder, overallTestDice, extDice) print "Precision : %f Recall : %f F1 : %f " % (prec, recall, f1) print "__________________________________________" # testResultFile.write(folder+","+str(len(testLayers))+","+str(meanTestDice)+","+str(overallTestDice) ","+str(np.max(testDice)) +","+ str(np.min(testDice))+"\n" ) testResultFile.write(folder + "," + str(len(testLayers)) + "," + str(overallTestDice) + "," + str(prec) + "," + str(recall) + "," + str(extDice) + layerDiceScores + "\n") overallDicePerPatient.append(overallTestDice) extDicePerPatient.append(extDice) PREC.append(prec), RECALL.append(recall), F1.append(f1) PatientTruthLayers.append(testTruth) PatientPredLayers.append(predTest) counter += 1 if counter == num_test and num_test != -1: break ###################################################################################################### print "Done testing slices" overallDice = sum(overallDicePerPatient) / len(PatientTruthLayers) overallPrec = sum(PREC) / len(PatientTruthLayers) overallRecall = sum(RECALL) / len(PatientTruthLayers) overallExtDice = np.mean(extDicePerPatient) print "Overall DICE : %f Precision : %f Recall : %f extDice : %f " % ( overallDice, overallPrec, overallRecall, overallExtDice) print "############################################" # testOutput=np.array([PatientPredLayers,PatientTruthLayers,trueTestLayers]) testOutput = np.array([PatientPredLayers, PatientTruthLayers]) ########### Saving the models ###################################################################### # print "Saving the model" # modelDir = os.getcwd()+"/CRFModel/" # svmModel = open(modelDir+filename+"_model"+".pkl",'wb') # cPickle.dump(svm,svmModel,protocol=cPickle.HIGHEST_PROTOCOL) # svmModel.close() # # print "saving the predictions" # predFileTest = open(os.getcwd()+"/CRFPred/"+filename+"_pred.pkl",'wb') # cPickle.dump(testOutput,predFileTest,protocol=cPickle.HIGHEST_PROTOCOL) # predFileTest.close() layerDataLog = open(os.getcwd() + "/CRFModel/" + filename + "_layer.pkl", 'wb') cPickle.dump(LayerwiseDiceTotal, layerDataLog, protocol=cPickle.HIGHEST_PROTOCOL) layerDataLog.close() resultLog = os.getcwd() + "/CRFResults/TestResultFinal.csv" resultFile = open(resultLog, 'a') resultFile.write(time.ctime() + "," + str(num_iter) + "," + str(num_train) + "," + str(num_test) + "," + inference + "," + trainer + "," + str(C) + "," + str(train_time) + "," + str(meanTrainDice) + "," + str(overallDice) + "," + str(np.std(overallDicePerPatient)) + "," + edgeFeature + "," + "None" + "," + features + "," + filename + "," + str(overallPrec) + "," + str(overallRecall) + "," + str(overallExtDice) + "," + "Flair+T2Latent with 2 states" + "\n") resultFile.close() testResultFile.close() return
# We use batch_size=-1 as a binary problem can be solved in one go. svm = NSlackSSVM(pbl, C=1, batch_size=-1) svm.fit(X_train_, y_train) # Now, use a latent-variabile CRF model with SVM training. # 5 states per label is enough capacity to encode the 5 digit classes. latent_pbl = LatentGraphCRF(n_states_per_label=5, inference_method='unary') base_ssvm = NSlackSSVM(latent_pbl, C=1, tol=.01, inactive_threshold=1e-3, batch_size=10) latent_svm = LatentSSVM(base_ssvm=base_ssvm, latent_iter=2) latent_svm.fit(X_train_, y_train) print("Score with binary SVM:") print("Train: {:2.2f}".format(svm.score(X_train_, y_train))) print("Test: {:2.2f}".format(svm.score(X_test_, y_test))) print("Score with latent SVM:") print("Train: {:2.2f}".format(latent_svm.score(X_train_, y_train))) print("Test: {:2.2f}".format(latent_svm.score(X_test_, y_test))) h_pred = np.hstack(latent_svm.predict_latent(X_test_)) print("Latent class counts: %s" % repr(np.bincount(h_pred))) # plot first few digits from each latent class plt.figure(figsize=(3, 5))
inference_method='lp') ssvm = OneSlackSSVM(model=latent_crf, max_iter=200, C=100, n_jobs=-1, show_loss_every=10, inference_cache=50) latent_svm = LatentSSVM(ssvm) # make edges for hidden states: edges = [] node_indices = np.arange(4 * 4).reshape(4, 4) for i, (x, y) in enumerate(itertools.product([0, 2], repeat=2)): for j in range(x, x + 2): for k in range(y, y + 2): edges.append([i + 4 * 4, node_indices[j, k]]) G = [np.vstack([make_grid_edges(x), edges]) for x in X] # Random initialization H_init = [np.hstack([y.ravel(), np.random.randint(2, 4, size=2 * 2)]) for y in Y] plot_boxes(H_init, title="Top: Random initial hidden states. Bottom: Ground" "truth labeling.") X_ = list(zip(X_flat, G, [2 * 2 for x in X_flat])) latent_svm.fit(X_, Y_flat, H_init) print("Training score with latent nodes: %f " % latent_svm.score(X_, Y_flat)) H = latent_svm.predict_latent(X_) plot_boxes(H, title="Top: Hidden states after training. Bottom: Prediction.") plt.show()