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_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_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 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_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) 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 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_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_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_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_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_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_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_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_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 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_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_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)
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()
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)) plt.suptitle("Example digits from each of\nthe ten latent classes.") n_latent_classes = 10 n_examples = 7 for latent_class in xrange(n_latent_classes): examples = X_test[h_pred == latent_class][:n_examples] for k, example in enumerate(examples): plt.subplot(n_latent_classes, n_examples,
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("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) 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 latent")
# 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)) plt.suptitle("Example digits from each of\nthe ten latent classes.") n_latent_classes = 10 n_examples = 7 for latent_class in range(n_latent_classes): examples = X_test[h_pred == latent_class][:n_examples] for k, example in enumerate(examples): plt.subplot(n_latent_classes, n_examples,
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()
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) ax[2, 0].set_title("prediction latent")
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, force_arrays=False) 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")
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) ax[1, 1].set_title("latent final")