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_blocks_crf_directional(): # test latent directional CRF on blocks # test that all results are the same as equivalent LatentGridCRF X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] pairwise_weights = np.array([0, 0, 0, -4, -4, 0, -4, -4, 0, 0]) unary_weights = np.repeat(np.eye(2), 2, axis=0) w = np.hstack([unary_weights.ravel(), pairwise_weights]) pw_directional = np.array([ 0, 0, -4, -4, 0, 0, -4, -4, -4, -4, 0, 0, -4, -4, 0, 0, 0, 0, -4, -4, 0, 0, -4, -4, -4, -4, 0, 0, -4, -4, 0, 0 ]) w_directional = np.hstack([unary_weights.ravel(), pw_directional]) crf = LatentGridCRF(n_states_per_label=2, inference_method='lp') crf.initialize(X, Y) directional_crf = LatentDirectionalGridCRF(n_states_per_label=2, inference_method='lp') directional_crf.initialize(X, Y) h_hat = crf.inference(x, w) h_hat_d = directional_crf.inference(x, w_directional) assert_array_equal(h_hat, h_hat_d) h = crf.latent(x, y, w) h_d = directional_crf.latent(x, y, w_directional) assert_array_equal(h, h_d) h_hat = crf.loss_augmented_inference(x, y, w) h_hat_d = directional_crf.loss_augmented_inference(x, y, w_directional) assert_array_equal(h_hat, h_hat_d) joint_feature = crf.joint_feature(x, h_hat) joint_feature_d = directional_crf.joint_feature(x, h_hat) assert_array_equal(np.dot(joint_feature, w), np.dot(joint_feature_d, w_directional))
def test_latent_consistency_grid(): crf = LatentGridCRF(n_labels=2, n_features=2, n_states_per_label=2) for i in xrange(10): w = np.random.normal(size=18) y = np.random.randint(2, size=(4, 4)) x = np.random.normal(size=(4, 4, 2)) h = crf.latent(x, y, w) assert_array_equal(h / 2, y)
def test_loss_augmented_inference_exhaustive_grid(): crf = LatentGridCRF(n_labels=2, n_features=2, n_states_per_label=2) for i in xrange(10): w = np.random.normal(size=18) y = np.random.randint(2, size=(2, 2)) x = np.random.normal(size=(2, 2, 2)) h_hat = crf.loss_augmented_inference(x, y * 2, w) h = exhaustive_loss_augmented_inference(crf, x, y * 2, w) assert_array_equal(h, h_hat)
def test_blocks_crf_unaries(): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] unary_weights = np.repeat(np.eye(2), 2, axis=0) pairwise_weights = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) w = np.hstack([unary_weights.ravel(), pairwise_weights]) crf = LatentGridCRF(n_states_per_label=2, n_labels=2, n_features=2) h_hat = crf.inference(x, w) assert_array_equal(h_hat / 2, np.argmax(x, axis=-1))
def test_latent_consistency_zero_pw_grid(): crf = LatentGridCRF(n_labels=2, n_features=2, n_states_per_label=2) for i in range(10): w = np.zeros(18) w[:8] = np.random.normal(size=8) y = np.random.randint(2, size=(5, 5)) x = np.random.normal(size=(5, 5, 2)) h = crf.latent(x, y, w) assert_array_equal(h // 2, y)
def test_blocks_crf(): X, Y = generate_blocks(n_samples=1) x, y = X[0], Y[0] pairwise_weights = np.array([0, 0, 0, -4, -4, 0, -4, -4, 0, 0]) unary_weights = np.repeat(np.eye(2), 2, axis=0) w = np.hstack([unary_weights.ravel(), pairwise_weights]) crf = LatentGridCRF(n_states_per_label=2, n_labels=2, n_features=2) h_hat = crf.inference(x, w) assert_array_equal(y, h_hat / 2) h = crf.latent(x, y, w) assert_equal(crf.loss(h, h_hat), 0)
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_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_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_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)
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_k_means_initialization_grid_crf(): # with only 1 state per label, nothing happends X, Y = generate_big_checker(n_samples=10) crf = LatentGridCRF(n_states_per_label=1, n_features=2, n_labels=2) H = crf.init_latent(X, Y) assert_array_equal(Y, H)
""" import numpy as np import matplotlib.pyplot as plt from sklearn.cross_validation import train_test_split 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)