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=('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 = 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 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(model=crf, max_iter=500, C=1000., verbose=2,
#check_constraints=True, n_jobs=-1, break_on_bad=True,
#base_svm='1-slack', inference_cache=20, tol=.1)
clf = LatentSubgradientSSVM(
model=crf, max_iter=500, C=1000., verbose=2,
n_jobs=-1, learning_rate=0.1, show_loss_every=10)
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"]]:
for X_, Y_, H, name in [[X_train, Y_train, [None] * len(X_test), "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")
ax[0, 1].matshow(np.argmax(x, axis=-1),
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 latent")
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))
print(clf.w)
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 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_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_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_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 = 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)
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 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_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 = LatentSubgradientSSVM(model=crf, max_iter=250, C=10. ** 5,
verbose=20, learning_rate=0.0001,
show_loss_every=10, momentum=0.98,
decay_exponent=0)
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)
an additional state with different interactions, that maps to the same
state (the cross) in the ground truth.
"""
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
import pystruct.toy_datasets as toy
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')
base_ssvm = OneSlackSSVM(model=crf, max_iter=500, C=10., verbose=0,
check_constraints=True, n_jobs=-1,
break_on_bad=True, 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]
