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_edge_feature_latent_node_crf_no_latent(): # no latent nodes # Test inference with different weights in different directions X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1, size_x=10) x, y = X[0], Y[0] n_states = x.shape[-1] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) pw_horz = -1 * np.eye(n_states + 5) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states + 5) pw_vert[xx != yy] = 1 pw_vert *= 10 # generate edge weights edge_weights_horizontal = np.repeat(pw_horz[np.newaxis, :, :], edge_list[0].shape[0], axis=0) edge_weights_vertical = np.repeat(pw_vert[np.newaxis, :, :], edge_list[1].shape[0], axis=0) edge_weights = np.vstack([edge_weights_horizontal, edge_weights_vertical]) # do inference # pad x for hidden states... x_padded = -100 * np.ones((x.shape[0], x.shape[1], x.shape[2] + 5)) x_padded[:, :, :x.shape[2]] = x res = lp_general_graph(-x_padded.reshape(-1, n_states + 5), edges, edge_weights) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, n_states), edges, edge_features, 0) y = y.ravel() for inference_method in get_installed(["lp"]): # same inference through CRF inferface crf = EdgeFeatureLatentNodeCRF(n_labels=3, inference_method=inference_method, n_edge_features=2, n_hidden_states=5) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) assert_array_almost_equal(res[0], y_pred[0].reshape(-1, n_states + 5), 4) assert_array_almost_equal(res[1], y_pred[1], 4) assert_array_equal(y, np.argmax(y_pred[0], axis=-1)) for inference_method in get_installed(["lp", "ad3", "qpbo"]): # again, this time discrete predictions only crf = EdgeFeatureLatentNodeCRF(n_labels=3, inference_method=inference_method, n_edge_features=2, n_hidden_states=5) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=False) assert_array_equal(y, y_pred)
def test_switch_to_ad3(): # test if switching between qpbo and ad3 works if not get_installed(['qpbo']) or not get_installed(['ad3']): return X, Y = generate_blocks_multinomial(n_samples=5, noise=1.5, seed=0) crf = GridCRF(n_states=3, inference_method='qpbo') ssvm = NSlackSSVM(crf, max_iter=10000) ssvm_with_switch = NSlackSSVM(crf, max_iter=10000, switch_to=('ad3')) ssvm.fit(X, Y) ssvm_with_switch.fit(X, Y) assert_equal(ssvm_with_switch.model.inference_method, 'ad3') # we check that the dual is higher with ad3 inference # as it might use the relaxation, that is pretty much guraranteed assert_greater(ssvm_with_switch.objective_curve_[-1], ssvm.objective_curve_[-1]) # test that convergence also results in switch ssvm_with_switch = NSlackSSVM(crf, max_iter=10000, switch_to=('ad3'), tol=10) ssvm_with_switch.fit(X, Y) assert_equal(ssvm_with_switch.model.inference_method, 'ad3')
def test_edge_type_graph_crf(): # create two samples with different graphs # two states only, pairwise smoothing # all edges are of the first type. should do the same as GraphCRF # if we make w symmetric for inference_method in get_installed(['qpbo', 'lp', 'ad3', 'dai', 'ogm']): crf = EdgeTypeGraphCRF(n_states=2, inference_method=inference_method, n_edge_types=1) assert_array_equal(crf.inference((x_1, [g_1]), w_sym), y_1) assert_array_equal(crf.inference((x_2, [g_2]), w_sym), y_2) # same, only with two edge types and no edges of second type w_sym_ = np.array([1, 0, # unary 0, 1, .22, 0, # pairwise 0, .22, 2, -1, # second edge type, doesn't exist -1, 3]) for inference_method in get_installed(['qpbo', 'lp', 'ad3', 'dai', 'ogm']): crf = EdgeTypeGraphCRF(n_states=2, inference_method=inference_method, n_edge_types=2) assert_array_equal(crf.inference((x_1, [g_1, np.zeros((0, 2), dtype=np.int)]), w_sym_), y_1) assert_array_equal(crf.inference((x_2, [g_2, np.zeros((0, 2), dtype=np.int)]), w_sym_), y_2) print crf.get_pairwise_potentials((x_2, [g_2, np.zeros((0, 2), dtype=np.int)]), w_sym_)
def test_switch_to_ad3(): # test if switching between qpbo and ad3 works if not get_installed(['qpbo']) or not get_installed(['ad3']): return X, Y = toy.generate_blocks_multinomial(n_samples=5, noise=1.5, seed=0) crf = GridCRF(n_states=3, inference_method='qpbo') ssvm = NSlackSSVM(crf, max_iter=10000) ssvm_with_switch = NSlackSSVM(crf, max_iter=10000, switch_to=('ad3')) ssvm.fit(X, Y) ssvm_with_switch.fit(X, Y) assert_equal(ssvm_with_switch.model.inference_method, 'ad3') # we check that the dual is higher with ad3 inference # as it might use the relaxation, that is pretty much guraranteed assert_greater(ssvm_with_switch.objective_curve_[-1], ssvm.objective_curve_[-1]) print(ssvm_with_switch.objective_curve_[-1], ssvm.objective_curve_[-1]) # test that convergence also results in switch ssvm_with_switch = NSlackSSVM(crf, max_iter=10000, switch_to=('ad3'), tol=10) ssvm_with_switch.fit(X, Y) assert_equal(ssvm_with_switch.model.inference_method, 'ad3')
def test_inference(): # Test inference with different weights in different directions X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # generate edge weights edge_weights_horizontal = np.repeat(pw_horz[np.newaxis, :, :], edge_list[0].shape[0], axis=0) edge_weights_vertical = np.repeat(pw_vert[np.newaxis, :, :], edge_list[1].shape[0], axis=0) edge_weights = np.vstack([edge_weights_horizontal, edge_weights_vertical]) # do inference res = lp_general_graph(-x.reshape(-1, n_states), edges, edge_weights) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, n_states), edges, edge_features) y = y.ravel() for inference_method in get_installed(["lp", "ad3"]): # same inference through CRF inferface crf = EdgeFeatureGraphCRF(inference_method=inference_method) crf.initialize([x], [y]) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) if isinstance(y_pred, tuple): # ad3 produces an integer result if it found the exact solution assert_array_almost_equal(res[1], y_pred[1]) assert_array_almost_equal(res[0], y_pred[0].reshape(-1, n_states)) assert_array_equal(y, np.argmax(y_pred[0], axis=-1)) for inference_method in get_installed(["lp", "ad3", "qpbo"]): # again, this time discrete predictions only crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) crf.initialize([x], [y]) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=False) assert_array_equal(y, y_pred)
def test_inference(): # Test inference with different weights in different directions X, Y = toy.generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # generate edge weights edge_weights_horizontal = np.repeat(pw_horz[np.newaxis, :, :], edge_list[0].shape[0], axis=0) edge_weights_vertical = np.repeat(pw_vert[np.newaxis, :, :], edge_list[1].shape[0], axis=0) edge_weights = np.vstack([edge_weights_horizontal, edge_weights_vertical]) # do inference res = lp_general_graph(-x.reshape(-1, n_states), edges, edge_weights) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, n_states), edges, edge_features) y = y.ravel() for inference_method in get_installed(["lp", "ad3"]): # same inference through CRF inferface crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) if isinstance(y_pred, tuple): # ad3 produces an integer result if it found the exact solution assert_array_almost_equal(res[1], y_pred[1]) assert_array_almost_equal(res[0], y_pred[0].reshape(-1, n_states)) assert_array_equal(y, np.argmax(y_pred[0], axis=-1)) for inference_method in get_installed(["lp", "ad3", "qpbo"]): # again, this time discrete predictions only crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=False) assert_array_equal(y, y_pred)
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_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_joint_feature_discrete(): X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) y_flat = y.ravel() for inference_method in get_installed(["lp", "ad3", "qpbo"]): crf = EdgeFeatureGraphCRF(inference_method=inference_method) crf.initialize([x], [y_flat]) joint_feature_y = crf.joint_feature(x, y_flat) assert_equal(joint_feature_y.shape, (crf.size_joint_feature, )) # first horizontal, then vertical # we trust the unaries ;) pw_joint_feature_horz, pw_joint_feature_vert = joint_feature_y[ crf.n_states * crf.n_features:].reshape(2, crf.n_states, crf.n_states) xx, yy = np.indices(y.shape) assert_array_equal(pw_joint_feature_vert, np.diag([9 * 4, 9 * 4, 9 * 4])) vert_joint_feature = np.diag([10 * 3, 10 * 3, 10 * 3]) vert_joint_feature[0, 1] = 10 vert_joint_feature[1, 2] = 10 assert_array_equal(pw_joint_feature_horz, vert_joint_feature)
def test_binary_blocks_cutting_plane(): #testing cutting plane ssvm on easy binary dataset # generate graphs explicitly for each example for inference_method in get_installed(["lp", "qpbo", "ad3", 'ogm']): X, Y = generate_blocks(n_samples=3) crf = GraphCRF(inference_method=inference_method) 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 = list(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)
def test_binary_blocks_cutting_plane(): #testing cutting plane ssvm on easy binary dataset # generate graphs explicitly for each example for inference_method in get_installed(["dai", "lp", "qpbo", "ad3", 'ogm']): print("testing %s" % inference_method) X, Y = generate_blocks(n_samples=3) crf = GraphCRF(inference_method=inference_method) 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)
def test_energy_discrete(): for inference_method in get_installed(["qpbo", "ad3"]): crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2, n_features=3) for i in xrange(10): x = np.random.normal(size=(7, 8, 3)) edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) unary_params = np.random.normal(size=(3, 3)) pw1 = np.random.normal(size=(3, 3)) pw2 = np.random.normal(size=(3, 3)) w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()]) y_hat = crf.inference(x, w, relaxed=False) energy = compute_energy(crf._get_unary_potentials(x, w), crf._get_pairwise_potentials(x, w), edges, y_hat) joint_feature = crf.joint_feature(x, y_hat) energy_svm = np.dot(joint_feature, w) assert_almost_equal(energy, energy_svm)
def test_energy(): # make sure that energy as computed by ssvm is the same as by lp np.random.seed(0) for inference_method in get_installed(["lp", "ad3"]): found_fractional = False crf = DirectionalGridCRF(n_states=3, n_features=3, inference_method=inference_method) while not found_fractional: x = np.random.normal(size=(7, 8, 3)) unary_params = np.random.normal(size=(3, 3)) pw1 = np.random.normal(size=(3, 3)) pw2 = np.random.normal(size=(3, 3)) w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()]) res, energy = crf.inference(x, w, relaxed=True, return_energy=True) found_fractional = np.any(np.max(res[0], axis=-1) != 1) joint_feature = crf.joint_feature(x, res) energy_svm = np.dot(joint_feature, w) assert_almost_equal(energy, -energy_svm) if not found_fractional: # exact discrete labels, test non-relaxed version res, energy = crf.inference(x, w, relaxed=False, return_energy=True) joint_feature = crf.joint_feature(x, res) energy_svm = np.dot(joint_feature, w) assert_almost_equal(energy, -energy_svm)
def test_continuous_y(): for inference_method in get_installed(["lp", "ad3"]): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([1, 0, 0, 1, 0, -4, 0]) # unary # pairwise crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) joint_feature = crf.joint_feature(x, y) y_cont = np.zeros_like(x) gx, gy = np.indices(x.shape[:-1]) y_cont[gx, gy, y] = 1 # need to generate edge marginals vert = np.dot(y_cont[1:, :, :].reshape(-1, 2).T, y_cont[:-1, :, :].reshape(-1, 2)) # horizontal edges horz = np.dot(y_cont[:, 1:, :].reshape(-1, 2).T, y_cont[:, :-1, :].reshape(-1, 2)) pw = vert + horz joint_feature_cont = crf.joint_feature(x, (y_cont, pw)) assert_array_almost_equal(joint_feature, joint_feature_cont) const = find_constraint(crf, x, y, w, relaxed=False) const_cont = find_constraint(crf, x, y, w, relaxed=True) # djoint_feature and loss are equal: assert_array_almost_equal(const[1], const_cont[1], 4) assert_almost_equal(const[2], const_cont[2], 4) # returned y_hat is one-hot version of other if isinstance(const_cont[0], tuple): assert_array_equal(const[0], np.argmax(const_cont[0][0], axis=-1)) # test loss: assert_almost_equal(crf.loss(y, const[0]), crf.continuous_loss(y, const_cont[0][0]), 4)
def test_energy_continuous(): # make sure that energy as computed by ssvm is the same as by lp np.random.seed(0) for inference_method in get_installed(["lp", "ad3"]): found_fractional = False crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2, n_features=3) while not found_fractional: x = np.random.normal(size=(7, 8, 3)) edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) unary_params = np.random.normal(size=(3, 3)) pw1 = np.random.normal(size=(3, 3)) pw2 = np.random.normal(size=(3, 3)) w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()]) res, energy = crf.inference(x, w, relaxed=True, return_energy=True) found_fractional = np.any(np.max(res[0], axis=-1) != 1) joint_feature = crf.joint_feature(x, res) energy_svm = np.dot(joint_feature, w) assert_almost_equal(energy, -energy_svm)
def test_joint_feature_continuous(): # FIXME # first make perfect prediction, including pairwise part X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # create crf, assemble weight, make prediction for inference_method in get_installed(["lp", "ad3"]): crf = DirectionalGridCRF(inference_method=inference_method) crf.initialize(X, Y) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) # compute joint_feature for prediction joint_feature_y = crf.joint_feature(x, y_pred) assert_equal(joint_feature_y.shape, (crf.size_joint_feature,))
def test_psi_continuous(): # FIXME # first make perfect prediction, including pairwise part X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) y = y.ravel() pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # create crf, assemble weight, make prediction for inference_method in get_installed(["lp", "ad3"]): crf = EdgeFeatureGraphCRF(inference_method=inference_method) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) crf.initialize([x], [y]) y_pred = crf.inference(x, w, relaxed=True) # compute psi for prediction psi_y = crf.psi(x, y_pred) assert_equal(psi_y.shape, (crf.size_psi, ))
def test_one_slack_constraint_caching(): # testing cutting plane ssvm on easy multinomial dataset X, Y = generate_blocks_multinomial(n_samples=10, noise=0.5, seed=0, size_x=9) n_labels = len(np.unique(Y)) exact_inference = get_installed([('ad3', {'branch_and_bound': True}), "lp"])[0] crf = GridCRF(n_states=n_labels, inference_method=exact_inference) clf = OneSlackSSVM(model=crf, max_iter=150, C=1, check_constraints=True, break_on_bad=True, inference_cache=50, inactive_window=0) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(Y, Y_pred) assert_equal(len(clf.inference_cache_), len(X)) # there should be 13 constraints, which are less than the 94 iterations # that are done # check that we didn't change the behavior of how we construct the cache constraints_per_sample = [len(cache) for cache in clf.inference_cache_] if exact_inference == "lp": assert_equal(len(clf.inference_cache_[0]), 18) assert_equal(np.max(constraints_per_sample), 18) assert_equal(np.min(constraints_per_sample), 18) else: assert_equal(len(clf.inference_cache_[0]), 13) assert_equal(np.max(constraints_per_sample), 20) assert_equal(np.min(constraints_per_sample), 11)
def test_binary_grid_unaries(): # test handling on unaries for binary grid CRFs for ds in binary: X, Y = ds(n_samples=1) x, y = X[0], Y[0] for inference_method in get_installed(): #NOTE: ad3+ fails because it requires a different data structure if inference_method == 'ad3+': continue crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) w_unaries_only = np.zeros(7) w_unaries_only[:4] = np.eye(2).ravel() # test that inference with unaries only is the # same as argmax inf_unaries = crf.inference(x, w_unaries_only) assert_array_equal(inf_unaries, np.argmax(x, axis=2), "Wrong unary inference for %s" % inference_method) assert(np.mean(inf_unaries == y) > 0.5) # check that the right thing happens on noise-free data X, Y = ds(n_samples=1, noise=0) inf_unaries = crf.inference(X[0], w_unaries_only) assert_array_equal(inf_unaries, Y[0], "Wrong unary result for %s" % inference_method)
def test_binary_grid_unaries(): # test handling on unaries for binary grid CRFs for ds in binary: X, Y = ds(n_samples=1) x, y = X[0], Y[0] for inference_method in get_installed(): # dai is to expensive crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) w_unaries_only = np.zeros(7) w_unaries_only[:4] = np.eye(2).ravel() # test that inference with unaries only is the # same as argmax inf_unaries = crf.inference(x, w_unaries_only) assert_array_equal(inf_unaries, np.argmax(x, axis=2), "Wrong unary inference for %s" % inference_method) try: assert(np.mean(inf_unaries == y) > 0.5) except: print(ds) # check that the right thing happens on noise-free data X, Y = ds(n_samples=1, noise=0) inf_unaries = crf.inference(X[0], w_unaries_only) assert_array_equal(inf_unaries, Y[0], "Wrong unary result for %s" % inference_method)
def test_chain(): # test LP, AD3, AD3-BB and JT on a chain. # they should all be exact rnd = np.random.RandomState(0) algorithms = get_installed([('ad3', {'branch_and_bound': False}), ('ad3', {'branch_and_bound': True}), ('ogm', {'alg': 'dyn'}), ('ogm', {'alg': 'dd'}), ('ogm', {'alg': 'trw'})]) n_states = 3 n_nodes = 10 for i in xrange(10): forward = np.c_[np.arange(n_nodes - 1), np.arange(1, n_nodes)] backward = np.c_[np.arange(1, n_nodes), np.arange(n_nodes - 1)] unary_potentials = rnd.normal(size=(n_nodes, n_states)) pairwise_potentials = rnd.normal(size=(n_states, n_states)) # test that reversing edges is same as transposing pairwise potentials y_forward = inference_dispatch(unary_potentials, pairwise_potentials, forward, 'lp') y_backward = inference_dispatch(unary_potentials, pairwise_potentials.T, backward, 'lp') assert_array_equal(y_forward, y_backward) for chain in [forward, backward]: y_lp = inference_dispatch(unary_potentials, pairwise_potentials, chain, 'lp') for alg in algorithms: if chain is backward and alg[0] == 'ogm': # ogm needs sorted indices continue y = inference_dispatch(unary_potentials, pairwise_potentials, chain, alg) assert_array_equal(y, y_lp)
def test_blocks_multinomial_crf(): X, Y = generate_blocks_multinomial(n_samples=1, size_x=9, seed=0) x, y = X[0], Y[0] w = np.array([ 1., 0., 0., # unaryA 0., 1., 0., 0., 0., 1., .4, # pairwise -.3, .3, -.5, -.1, .3 ]) for inference_method in get_installed(): crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_chain(): # test LP, AD3, AD3-BB and JT on a chain. # they should all be exact rnd = np.random.RandomState(0) algorithms = get_installed([('ad3', {'branch_and_bound':False}), ('ad3', {'branch_and_bound':True}), ('dai', {'alg':'jt'})]) for i in xrange(10): forward = np.c_[np.arange(9), np.arange(1, 10)] backward = np.c_[np.arange(1, 10), np.arange(9)] unary_potentials = rnd.normal(size=(10, 3)) pairwise_potentials = rnd.normal(size=(3, 3)) # test that reversing edges is same as transposing pairwise potentials y_forward = inference_dispatch(unary_potentials, pairwise_potentials, forward, 'lp') y_backward = inference_dispatch(unary_potentials, pairwise_potentials.T, backward, 'lp') assert_array_equal(y_forward, y_backward) for chain in [forward, backward]: y_lp = inference_dispatch(unary_potentials, pairwise_potentials, chain, 'lp') for alg in algorithms: print(alg) y = inference_dispatch(unary_potentials, pairwise_potentials, chain, alg) assert_array_equal(y, y_lp)
def test_binary_grid_unaries(): # test handling on unaries for binary grid CRFs for ds in binary: X, Y = ds(n_samples=1) x, y = X[0], Y[0] for inference_method in get_installed(): # dai is to expensive crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) w_unaries_only = np.zeros(7) w_unaries_only[:4] = np.eye(2).ravel() # test that inference with unaries only is the # same as argmax inf_unaries = crf.inference(x, w_unaries_only) assert_array_equal( inf_unaries, np.argmax(x, axis=2), "Wrong unary inference for %s" % inference_method) try: assert (np.mean(inf_unaries == y) > 0.5) except: print(ds) # check that the right thing happens on noise-free data X, Y = ds(n_samples=1, noise=0) inf_unaries = crf.inference(X[0], w_unaries_only) assert_array_equal(inf_unaries, Y[0], "Wrong unary result for %s" % inference_method)
def test_psi_continuous(): # FIXME # first make perfect prediction, including pairwise part X, Y = toy.generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) y = y.ravel() pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # create crf, assemble weight, make prediction for inference_method in get_installed(["lp", "ad3"]): crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) # compute psi for prediction psi_y = crf.psi(x, y_pred) assert_equal(psi_y.shape, (crf.size_psi,))
def test_psi_discrete(): X, Y = toy.generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) y_flat = y.ravel() for inference_method in get_installed(["lp", "ad3", "qpbo"]): crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) psi_y = crf.psi(x, y_flat) assert_equal(psi_y.shape, (crf.size_psi,)) # first horizontal, then vertical # we trust the unaries ;) pw_psi_horz, pw_psi_vert = psi_y[crf.n_states * crf.n_features:].reshape( 2, crf.n_states, crf.n_states) xx, yy = np.indices(y.shape) assert_array_equal(pw_psi_vert, np.diag([9 * 4, 9 * 4, 9 * 4])) vert_psi = np.diag([10 * 3, 10 * 3, 10 * 3]) vert_psi[0, 1] = 10 vert_psi[1, 2] = 10 assert_array_equal(pw_psi_horz, vert_psi)
def test_energy_discrete(): for inference_method in get_installed(["qpbo", "ad3"]): crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) for i in xrange(10): x = np.random.normal(size=(7, 8, 3)) edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) unary_params = np.random.normal(size=(3, 3)) pw1 = np.random.normal(size=(3, 3)) pw2 = np.random.normal(size=(3, 3)) w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()]) y_hat = crf.inference(x, w, relaxed=False) energy = compute_energy(crf.get_unary_potentials(x, w), crf.get_pairwise_potentials(x, w), edges, y_hat) psi = crf.psi(x, y_hat) energy_svm = np.dot(psi, w) assert_almost_equal(energy, energy_svm)
def test_energy_continuous(): # make sure that energy as computed by ssvm is the same as by lp np.random.seed(0) for inference_method in get_installed(["lp", "ad3"]): found_fractional = False crf = EdgeFeatureGraphCRF(n_states=3, inference_method=inference_method, n_edge_features=2) while not found_fractional: x = np.random.normal(size=(7, 8, 3)) edge_list = make_grid_edges(x, 4, return_lists=True) edges = np.vstack(edge_list) edge_features = edge_list_to_features(edge_list) x = (x.reshape(-1, 3), edges, edge_features) unary_params = np.random.normal(size=(3, 3)) pw1 = np.random.normal(size=(3, 3)) pw2 = np.random.normal(size=(3, 3)) w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()]) res, energy = crf.inference(x, w, relaxed=True, return_energy=True) found_fractional = np.any(np.max(res[0], axis=-1) != 1) psi = crf.psi(x, res) energy_svm = np.dot(psi, w) assert_almost_equal(energy, -energy_svm)
def test_switch_to_ad3(): # test if switching between qpbo and ad3 works if not get_installed(["qpbo"]) or not get_installed(["ad3"]): return X, Y = generate_blocks_multinomial(n_samples=5, noise=1.5, seed=0) crf = GridCRF(n_states=3, inference_method="qpbo") ssvm = OneSlackSSVM(crf, inference_cache=50, max_iter=10000) ssvm_with_switch = OneSlackSSVM(crf, inference_cache=50, max_iter=10000, switch_to=("ad3")) ssvm.fit(X, Y) ssvm_with_switch.fit(X, Y) assert_equal(ssvm_with_switch.model.inference_method, "ad3") # we check that the dual is higher with ad3 inference # as it might use the relaxation, that is pretty much guraranteed assert_greater(ssvm_with_switch.objective_curve_[-1], ssvm.objective_curve_[-1])
def test_graph_crf_inference(): # create two samples with different graphs # two states only, pairwise smoothing for inference_method in get_installed(['qpbo', 'lp', 'ad3', 'ogm']): crf = GraphCRF(n_states=2, n_features=2, inference_method=inference_method) assert_array_equal(crf.inference((x_1, g_1), w), y_1) assert_array_equal(crf.inference((x_2, g_2), w), y_2)
def test_binary_blocks_perceptron_online(): #testing subgradient ssvm on easy binary dataset X, Y = generate_blocks(n_samples=10) inference_method = get_installed(['qpbo', 'ad3', 'lp'])[0] crf = GridCRF(inference_method=inference_method) clf = StructuredPerceptron(model=crf, max_iter=20) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(Y, Y_pred)
def test_binary_blocks_crf(): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([1, 0, 0, 1, 0, -4, 0]) # unary # pairwise for inference_method in get_installed(["dai", "qpbo", "lp", "ad3", "ogm"]): crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_blocks_multinomial_crf(): X, Y = generate_blocks_multinomial(n_samples=1, size_x=9, seed=0) x, y = X[0], Y[0] w = np.array([1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.4, -0.3, 0.3, -0.5, -0.1, 0.3]) # unaryA # pairwise for inference_method in get_installed(): crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_directed_graph_crf_inference(): # create two samples with different graphs # two states only, pairwise smoothing # same as above, only with full symmetric matrix for inference_method in get_installed(['qpbo', 'lp', 'ad3', 'ogm']): crf = GraphCRF(n_states=2, n_features=2, inference_method=inference_method, directed=True) assert_array_equal(crf.inference((x_1, g_1), w_sym), y_1) assert_array_equal(crf.inference((x_2, g_2), w_sym), y_2)
def test_binary_blocks_cutting_plane(): #testing cutting plane ssvm on easy binary dataset for inference_method in get_installed(["dai", "lp", "qpbo", "ad3"]): X, Y = toy.generate_blocks(n_samples=5) crf = GridCRF(inference_method=inference_method) clf = NSlackSSVM(model=crf, max_iter=20, C=100, check_constraints=True, break_on_bad=False) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(Y, Y_pred)
def test_multinomial_blocks_cutting_plane(): #testing cutting plane ssvm on easy multinomial dataset X, Y = toy.generate_blocks_multinomial(n_samples=40, noise=0.5, seed=0) n_labels = len(np.unique(Y)) for inference_method in get_installed(['ad3']): crf = GridCRF(n_states=n_labels, inference_method=inference_method) clf = NSlackSSVM(model=crf, max_iter=100, C=100, verbose=0, check_constraints=False, batch_size=1) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(Y, Y_pred)
def test_binary_blocks_crf(): X, Y = toy.generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([1, 0, # unary 0, 1, 0, # pairwise -4, 0]) for inference_method in get_installed(['dai', 'qpbo', 'lp', 'ad3', 'ogm']): crf = GridCRF(inference_method=inference_method) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_binary_blocks_crf(): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([1, 0, # unary 0, 1, 0, # pairwise -4, 0]) for inference_method in get_installed(['dai', 'qpbo', 'lp', 'ad3', 'ogm']): crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_energy_lp(): # make sure that energy as computed by ssvm is the same as by lp np.random.seed(0) found_fractional = False for inference_method in get_installed(["lp", "ad3"]): crf = GridCRF(n_states=3, n_features=4, inference_method=inference_method) while not found_fractional: x = np.random.normal(size=(2, 2, 4)) w = np.random.uniform(size=crf.size_joint_feature) inf_res, energy_lp = crf.inference(x, w, relaxed=True, return_energy=True) assert_almost_equal(energy_lp, -np.dot(w, crf.joint_feature(x, inf_res))) found_fractional = np.any(np.max(inf_res[0], axis=-1) != 1)
def test_blocks_multinomial_crf(): X, Y = toy.generate_blocks_multinomial(n_samples=1, size_x=9, seed=0) x, y = X[0], Y[0] w = np.array([1., 0., 0., # unaryA 0., 1., 0., 0., 0., 1., .4, # pairwise -.3, .3, -.5, -.1, .3]) for inference_method in get_installed(): crf = GridCRF(n_states=3, inference_method=inference_method) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_energy_lp(): # make sure that energy as computed by ssvm is the same as by lp np.random.seed(0) found_fractional = False for inference_method in get_installed(["lp", "ad3"]): crf = GridCRF(n_states=3, n_features=4, inference_method=inference_method) while not found_fractional: x = np.random.normal(size=(2, 2, 4)) w = np.random.uniform(size=crf.size_psi) inf_res, energy_lp = crf.inference(x, w, relaxed=True, return_energy=True) assert_almost_equal(energy_lp, -np.dot(w, crf.psi(x, inf_res))) found_fractional = np.any(np.max(inf_res[0], axis=-1) != 1)
def test_graph_crf_continuous_inference(): for inference_method in get_installed(['lp', 'ad3']): crf = GraphCRF(n_states=2, n_features=2, inference_method=inference_method) y_hat = crf.inference((x_1, g_1), w, relaxed=True) if isinstance(y_hat, tuple): assert_array_equal(np.argmax(y_hat[0], axis=-1), y_1) else: # ad3 produces integer result if it found the exact solution assert_array_equal(y_hat, y_1) y_hat = crf.inference((x_2, g_2), w, relaxed=True) if isinstance(y_hat, tuple): assert_array_equal(np.argmax(y_hat[0], axis=-1), y_2) else: assert_array_equal(y_hat, y_2)
def test_blocks_multinomial_crf(): X, Y = generate_blocks_multinomial(n_samples=1, size_x=9, seed=0) x, y = X[0], Y[0] w = np.array([1., 0., 0., # unaryA 0., 1., 0., 0., 0., 1., .4, # pairwise -.3, .3, -.5, -.1, .3]) for inference_method in get_installed(): #NOTE: ad3+ fails because it requires a different data structure if inference_method == 'ad3+': continue crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) y_hat = crf.inference(x, w) assert_array_equal(y, y_hat)
def test_continuous_y(): for inference_method in get_installed(["lp", "ad3"]): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([ 1, 0, # unary 0, 1, 0, # pairwise -4, 0 ]) crf = LatentGridCRF(n_labels=2, n_features=2, n_states_per_label=1, inference_method=inference_method) joint_feature = crf.joint_feature(x, y) y_cont = np.zeros_like(x) gx, gy = np.indices(x.shape[:-1]) y_cont[gx, gy, y] = 1 # need to generate edge marginals vert = np.dot(y_cont[1:, :, :].reshape(-1, 2).T, y_cont[:-1, :, :].reshape(-1, 2)) # horizontal edges horz = np.dot(y_cont[:, 1:, :].reshape(-1, 2).T, y_cont[:, :-1, :].reshape(-1, 2)) pw = vert + horz joint_feature_cont = crf.joint_feature(x, (y_cont, pw)) assert_array_almost_equal(joint_feature, joint_feature_cont, 4) const = find_constraint(crf, x, y, w, relaxed=False) const_cont = find_constraint(crf, x, y, w, relaxed=True) # djoint_feature and loss are equal: assert_array_almost_equal(const[1], const_cont[1], 4) assert_almost_equal(const[2], const_cont[2], 4) if isinstance(const_cont[0], tuple): # returned y_hat is one-hot version of other assert_array_equal(const[0], np.argmax(const_cont[0][0], axis=-1)) # test loss: assert_almost_equal(crf.loss(y, const[0]), crf.continuous_loss(y, const_cont[0][0]), 4)
def test_binary_crf_exhaustive_loss_augmented(): # tests qpbo inference against brute force # on random data / weights np.random.seed(0) for inference_method in get_installed(['qpbo', 'lp']): crf = GridCRF(n_states=2, n_features=2, inference_method=inference_method) for i in xrange(10): # generate data and weights y = np.random.randint(2, size=(3, 2)) x = np.random.uniform(-1, 1, size=(3, 2)) x = np.dstack([-x, np.zeros_like(x)]) w = np.random.uniform(-1, 1, size=7) # check loss augmented map inference y_hat = crf.loss_augmented_inference(x, y, w) y_ex = exhaustive_loss_augmented_inference(crf, x, y, w) assert_array_equal(y_hat, y_ex)
def test_joint_feature_discrete(): X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] for inference_method in get_installed(["lp", "ad3", "qpbo"]): crf = DirectionalGridCRF(inference_method=inference_method) crf.initialize(X, Y) joint_feature_y = crf.joint_feature(x, y) assert_equal(joint_feature_y.shape, (crf.size_joint_feature,)) # first horizontal, then vertical # we trust the unaries ;) pw_joint_feature_horz, pw_joint_feature_vert = joint_feature_y[crf.n_states * crf.n_features:].reshape( 2, crf.n_states, crf.n_states) xx, yy = np.indices(y.shape) assert_array_equal(pw_joint_feature_vert, np.diag([9 * 4, 9 * 4, 9 * 4])) vert_joint_feature = np.diag([10 * 3, 10 * 3, 10 * 3]) vert_joint_feature[0, 1] = 10 vert_joint_feature[1, 2] = 10 assert_array_equal(pw_joint_feature_horz, vert_joint_feature)
def test_continuous_y(): for inference_method in get_installed(["lp", "ad3"]): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] w = np.array([1, 0, # unary 0, 1, 0, # pairwise -4, 0]) crf = GridCRF(inference_method=inference_method) crf.initialize(X, Y) psi = crf.psi(x, y) y_cont = np.zeros_like(x) gx, gy = np.indices(x.shape[:-1]) y_cont[gx, gy, y] = 1 # need to generate edge marginals vert = np.dot(y_cont[1:, :, :].reshape(-1, 2).T, y_cont[:-1, :, :].reshape(-1, 2)) # horizontal edges horz = np.dot(y_cont[:, 1:, :].reshape(-1, 2).T, y_cont[:, :-1, :].reshape(-1, 2)) pw = vert + horz psi_cont = crf.psi(x, (y_cont, pw)) assert_array_almost_equal(psi, psi_cont) const = find_constraint(crf, x, y, w, relaxed=False) const_cont = find_constraint(crf, x, y, w, relaxed=True) # dpsi and loss are equal: assert_array_almost_equal(const[1], const_cont[1]) assert_almost_equal(const[2], const_cont[2]) # returned y_hat is one-hot version of other if isinstance(const_cont[0], tuple): assert_array_equal(const[0], np.argmax(const_cont[0][0], axis=-1)) # test loss: assert_almost_equal(crf.loss(y, const[0]), crf.continuous_loss(y, const_cont[0][0]))
def test_objective(): # test that SubgradientLatentSSVM does the same as SubgradientSVM, # in particular that it has the same loss, if there are no latent states. X, Y = generate_blocks_multinomial(n_samples=10, noise=.3, seed=1) inference_method = get_installed(["qpbo", "ad3", "lp"])[0] n_labels = 3 crfl = LatentGridCRF(n_labels=n_labels, n_states_per_label=1, inference_method=inference_method) clfl = SubgradientLatentSSVM(model=crfl, max_iter=20, C=10., learning_rate=0.001, momentum=0.98) crfl.initialize(X, Y) clfl.w = np.zeros(crfl.size_joint_feature) # this disables random init clfl.fit(X, Y) crf = GridCRF(n_states=n_labels, inference_method=inference_method) clf = SubgradientSSVM(model=crf, max_iter=20, C=10., learning_rate=0.001, momentum=0.98) clf.fit(X, Y) assert_array_almost_equal(clf.w, clfl.w) assert_almost_equal(clf.objective_curve_[-1], clfl.objective_curve_[-1]) assert_array_equal(clf.predict(X), clfl.predict(X)) assert_array_equal(clf.predict(X), Y)
import numpy as np from tempfile import mkstemp from sklearn.datasets import load_iris from sklearn.cross_validation import train_test_split from pystruct.models import GraphCRF from pystruct.learners import NSlackSSVM from pystruct.utils import SaveLogger from pystruct.inference import get_installed from nose.tools import assert_less, assert_almost_equal # we always try to get the fastest installed inference method inference_method = get_installed(["qpbo", "ad3", "max-product", "lp"])[0] def test_logging(): iris = load_iris() X, y = iris.data, iris.target X_ = [(np.atleast_2d(x), np.empty((0, 2), dtype=np.int)) for x in X] Y = y.reshape(-1, 1) X_train, X_test, y_train, y_test = train_test_split(X_, Y, random_state=1) _, file_name = mkstemp() pbl = GraphCRF(n_features=4, n_states=3, inference_method=inference_method) logger = SaveLogger(file_name) svm = NSlackSSVM(pbl, C=100, n_jobs=1, logger=logger) svm.fit(X_train, y_train)
import numpy as np from numpy.testing import assert_array_equal from nose.tools import assert_less from sklearn.datasets import load_iris from sklearn.cross_validation import train_test_split from pystruct.models import GridCRF, GraphCRF from pystruct.learners import SubgradientSSVM from pystruct.inference import get_installed from pystruct.datasets import (generate_blocks_multinomial, generate_checker_multinomial, generate_blocks) from pystruct.utils import SaveLogger inference_method = get_installed(["qpbo", "ad3", "lp"])[0] def test_multinomial_blocks_subgradient(): #testing cutting plane ssvm on easy multinomial dataset X, Y = generate_blocks_multinomial(n_samples=10, noise=0.6, seed=1) n_labels = len(np.unique(Y)) crf = GridCRF(n_states=n_labels, inference_method=inference_method) clf = SubgradientSSVM(model=crf, max_iter=50) clf.fit(X, Y) Y_pred = clf.predict(X) assert_array_equal(Y, Y_pred) def test_multinomial_checker_subgradient(): X, Y = generate_checker_multinomial(n_samples=10, noise=0.4)
def main(): print("Please be patient. Will take 5-20 minutes.") snakes = load_snakes() X_train, Y_train = snakes['X_train'], snakes['Y_train'] X_train = [one_hot_colors(x) for x in X_train] Y_train_flat = [y_.ravel() for y_ in Y_train] X_train_directions, X_train_edge_features = prepare_data(X_train) if 'ogm' in get_installed(): inference = ('ogm', {'alg': 'fm'}) else: inference = 'qpbo' # first, train on X with directions only: crf = EdgeFeatureGraphCRF(inference_method=inference) ssvm = OneSlackSSVM(crf, inference_cache=50, C=.1, tol=.1, max_iter=100, n_jobs=1) ssvm.fit(X_train_directions, Y_train_flat) # Evaluate using confusion matrix. # Clearly the middel of the snake is the hardest part. X_test, Y_test = snakes['X_test'], snakes['Y_test'] X_test = [one_hot_colors(x) for x in X_test] Y_test_flat = [y_.ravel() for y_ in Y_test] X_test_directions, X_test_edge_features = prepare_data(X_test) Y_pred = ssvm.predict(X_test_directions) print("Results using only directional features for edges") print("Test accuracy: %.3f" % accuracy_score(np.hstack(Y_test_flat), np.hstack(Y_pred))) print(confusion_matrix(np.hstack(Y_test_flat), np.hstack(Y_pred))) # now, use more informative edge features: crf = EdgeFeatureGraphCRF(inference_method=inference) ssvm = OneSlackSSVM(crf, inference_cache=50, C=.1, tol=.1, switch_to='ad3', n_jobs=1) ssvm.fit(X_train_edge_features, Y_train_flat) Y_pred2 = ssvm.predict(X_test_edge_features) print("Results using also input features for edges") print("Test accuracy: %.3f" % accuracy_score(np.hstack(Y_test_flat), np.hstack(Y_pred2))) print(confusion_matrix(np.hstack(Y_test_flat), np.hstack(Y_pred2))) # plot stuff fig, axes = plt.subplots(2, 2) axes[0, 0].imshow(snakes['X_test'][0], interpolation='nearest') axes[0, 0].set_title('Input') y = Y_test[0].astype(np.int) bg = 2 * (y != 0) # enhance contrast axes[0, 1].matshow(y + bg, cmap=plt.cm.Greys) axes[0, 1].set_title("Ground Truth") axes[1, 0].matshow(Y_pred[0].reshape(y.shape) + bg, cmap=plt.cm.Greys) axes[1, 0].set_title("Prediction w/o edge features") axes[1, 1].matshow(Y_pred2[0].reshape(y.shape) + bg, cmap=plt.cm.Greys) axes[1, 1].set_title("Prediction with edge features") for a in axes.ravel(): a.set_xticks(()) a.set_yticks(()) plt.show() from IPython.core.debugger import Tracer Tracer()()