def test_edge_feature_latent_node_crf_no_latent():
# no latent nodes
# Test inference with different weights in different directions
X, Y = toy.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))
assert_array_almost_equal(res[1], y_pred[1])
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_multinomial_blocks():
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3, seed=0)
crf = GridCRF(n_states=X.shape[-1])
clf = StructuredPerceptron(problem=crf, max_iter=10)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_psi_continuous():
# 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]
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
crf = DirectionalGridCRF(n_states=3, inference_method='lp')
w = np.hstack([np.ones(3), -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,))
# first unary, then horizontal, then vertical
unary_psi = crf.get_unary_weights(psi_y)
pw_psi_horz, pw_psi_vert = crf.get_pairwise_weights(psi_y)
# test unary
xx, yy = np.indices(y.shape)
assert_array_almost_equal(unary_psi,
np.bincount(y.ravel(), x[xx, yy, y].ravel()))
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_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 ["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_multinomial_blocks_directional_anti_symmetric():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X_, Y_ = toy.generate_blocks_multinomial(n_samples=10, noise=0.3, seed=0)
G = [make_grid_edges(x, return_lists=True) for x in X_]
edge_features = [edge_list_to_features(edge_list) for edge_list in G]
edges = [np.vstack(g) for g in G]
X = zip([x.reshape(-1, 3) for x in X_], edges, edge_features)
Y = [y.ravel() for y in Y_]
for inference_method in ['lp', 'ad3']:
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2,
symmetric_edge_features=[0],
antisymmetric_edge_features=[1])
clf = StructuredSVM(model=crf, max_iter=20, C=1000, verbose=10,
check_constraints=False, n_jobs=-1)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
pairwise_params = clf.w[-9 * 2:].reshape(2, 3, 3)
sym = pairwise_params[0]
antisym = pairwise_params[1]
print(sym)
print(antisym)
assert_array_equal(sym, sym.T)
assert_array_equal(antisym, -antisym.T)
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]
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(n_states=3, inference_method=inference_method)
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 ["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_blocks_multinomial_crf():
X, Y = toy.generate_blocks_multinomial(n_samples=1)
x, y = X[0], Y[0]
w = np.array([1.0, 1.0, 1.0, 0.4, -0.3, 0.3, -0.5, -0.1, 0.3])
crf = GridCRF(n_states=3)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
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_multinomial_blocks_subgradient():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3,
seed=1)
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
clf = SubgradientSSVM(model=crf, max_iter=50, C=10, momentum=.98,
learning_rate=0.001)
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_multinomial_blocks_cutting_plane():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3,
seed=0)
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
clf = StructuredSVM(problem=crf, max_iter=10, C=100, verbose=0,
check_constraints=False)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_multinomial_blocks_directional():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3, seed=0)
n_labels = len(np.unique(Y))
crf = DirectionalGridCRF(n_states=n_labels)
clf = NSlackSSVM(model=crf, max_iter=100, C=100, verbose=0,
check_constraints=True, batch_size=1)
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=10, noise=0.3,
seed=0)
n_labels = len(np.unique(Y))
for inference_method in ['lp', 'qpbo', 'ad3']:
crf = GridCRF(n_states=n_labels, inference_method=inference_method)
clf = StructuredSVM(model=crf, max_iter=10, C=100, verbose=0,
check_constraints=False, n_jobs=-1)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_multinomial_blocks_one_slack():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3,
seed=0)
n_labels = len(np.unique(Y))
for inference_method in ['lp']:
crf = GridCRF(n_states=n_labels, inference_method=inference_method)
clf = OneSlackSSVM(problem=crf, max_iter=50, C=100, verbose=100,
check_constraints=True, break_on_bad=True)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_multinomial_blocks_one_slack():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.5,
seed=0)
print(np.argmax(X[0], axis=-1))
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
clf = OneSlackSSVM(model=crf, max_iter=150, C=1,
check_constraints=True, break_on_bad=True, tol=.1,
inference_cache=50)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_blocks_multinomial_crf():
X, Y = toy.generate_blocks_multinomial(n_samples=1)
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 ['dai', 'qpbo', 'lp', 'ad3']:
crf = GridCRF(n_states=3, inference_method=inference_method)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
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_averaged():
# Under a lot of noise, averaging helps. This fails with less noise.
X, Y = toy.generate_blocks_multinomial(n_samples=15, noise=2, seed=0)
X_train, Y_train = X[:10], Y[:10]
X_test, Y_test = X[10:], Y[10:]
crf = GridCRF(n_states=X.shape[-1])
clf = StructuredPerceptron(model=crf, max_iter=3)
clf.fit(X_train, Y_train)
no_avg_test = clf.score(X_test, Y_test)
clf.set_params(average=True)
clf.fit(X_train, Y_train)
avg_test = clf.score(X_test, Y_test)
assert_greater(avg_test, no_avg_test)
def test_multinomial_blocks_directional():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3,
seed=0)
n_labels = len(np.unique(Y))
for inference_method in get_installed(['lp', 'ad3']):
crf = DirectionalGridCRF(n_states=n_labels,
inference_method=inference_method)
clf = NSlackSSVM(model=crf, max_iter=10, C=100,
check_constraints=False)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def main():
X, Y = toy.generate_blocks_multinomial(noise=2, n_samples=20, seed=0)
#X, Y = toy.generate_crosses_explicit(n_samples=50, noise=10)
#X, Y = toy.generate_easy_explicit(n_samples=25, noise=10)
#X, Y = toy.generate_checker_multinomial(n_samples=20)
n_labels = len(np.unique(Y))
crf = DirectionalGridCRF(n_states=n_labels, inference_method="lp",
neighborhood=4)
clf = ssvm.OneSlackSSVM(model=crf, max_iter=1000, C=100, verbose=2,
check_constraints=True, n_jobs=-1,
inference_cache=100, inactive_window=50, tol=.1)
#clf = ssvm.StructuredSVM(model=crf, max_iter=100, C=100, verbose=3,
#check_constraints=True, n_jobs=12)
#clf = StructuredPerceptron(model=crf, max_iter=1000, verbose=10)
#clf = ssvm.SubgradientSSVM(model=crf, max_iter=50, C=100,
#verbose=10, momentum=.9,
#learning_rate=0.04,
#n_jobs=-1)
clf.fit(X, Y)
Y_pred = np.array(clf.predict(X))
np.set_printoptions(suppress=True) # suppress scientific notation
print(clf.w)
i = 0
loss = 0
for x, y, y_pred in zip(X, Y, Y_pred):
y_pred = y_pred.reshape(x.shape[:2])
loss += np.sum(y != y_pred)
#if i > 10:
#continue
fig, plots = plt.subplots(1, 4)
plots[0].matshow(y)
plots[0].set_title("gt")
plots[1].matshow(np.argmax(x, axis=-1))
plots[1].set_title("unaries only")
plots[2].matshow(y_pred)
plots[2].set_title("prediction")
loss_augmented = clf.model.loss_augmented_inference(x, y, clf.w)
loss_augmented = loss_augmented.reshape(y.shape)
plots[3].matshow(loss_augmented)
plots[3].set_title("loss augmented")
for p in plots:
p.set_xticks(())
p.set_yticks(())
fig.savefig("data_%03d.png" % i)
#plt.close(fig)
i += 1
print("loss: %f" % loss)
print("complete loss: %f" % np.sum(Y != Y_pred))
def test_multinomial_blocks_directional_simple():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X_, Y_ = toy.generate_blocks_multinomial(n_samples=10, noise=0.3, seed=0)
G = [make_grid_edges(x, return_lists=True) for x in X_]
edge_features = [edge_list_to_features(edge_list) for edge_list in G]
edges = [np.vstack(g) for g in G]
X = zip([x.reshape(-1, 3) for x in X_], edges, edge_features)
Y = [y.ravel() for y in Y_]
crf = EdgeFeatureGraphCRF(n_states=3,
n_edge_features=2)
clf = NSlackSSVM(model=crf, max_iter=10, C=1, check_constraints=False)
clf.fit(X, Y)
Y_pred = clf.predict(X)
assert_array_equal(Y, Y_pred)
def test_psi_discrete():
X, Y = toy.generate_blocks_multinomial(noise=2, n_samples=1, seed=1)
x, y = X[0], Y[0]
crf = DirectionalGridCRF(n_states=3, inference_method='lp')
psi_y = crf.psi(x, y)
assert_equal(psi_y.shape, (crf.size_psi,))
# first unary, then horizontal, then vertical
unary_psi = crf.get_unary_weights(psi_y)
pw_psi_horz, pw_psi_vert = crf.get_pairwise_weights(psi_y)
xx, yy = np.indices(y.shape)
assert_array_almost_equal(unary_psi,
np.bincount(y.ravel(), x[xx, yy, y].ravel()))
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[1, 0] = 10
vert_psi[2, 1] = 10
assert_array_equal(pw_psi_horz, vert_psi)
def test_psi_discrete():
X, Y = toy.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(n_states=3, inference_method=inference_method)
psi_y = crf.psi(x, y)
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 main():
import pystruct.toy_datasets as toy
import matplotlib.pyplot as plt
# create mrf problem:
pairwise = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])
X, Y = toy.generate_blocks_multinomial(n_samples=1, noise=.5)
x, y = X[0], Y[0]
inds = np.arange(x.shape[0] * x.shape[1]).reshape(x.shape[:2])
inds = inds.astype(np.int64)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
edges = np.vstack([horz, vert])
x = x.reshape(-1, x.shape[-1])
unary_assignment, pairwise_assignment, energy = solve_lp(
-x, edges, pairwise)
plt.matshow(np.argmax(unary_assignment, axis=1).reshape(y.shape))
plt.show()
def main():
import pystruct.toy_datasets as toy
import matplotlib.pyplot as plt
# create mrf model:
pairwise = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])
X, Y = toy.generate_blocks_multinomial(n_samples=1, noise=.5)
x, y = X[0], Y[0]
inds = np.arange(x.shape[0] * x.shape[1]).reshape(x.shape[:2])
inds = inds.astype(np.int64)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
edges = np.vstack([horz, vert])
x = x.reshape(-1, x.shape[-1])
unary_assignment, pairwise_assignment, energy = solve_lp(-x, edges,
pairwise)
plt.matshow(np.argmax(unary_assignment, axis=1).reshape(y.shape))
plt.show()
def test_objective():
# test that LatentSubgradientSSVM does the same as SubgradientSVM,
# in particular that it has the same loss, if there are no latent states.
X, Y = toy.generate_blocks_multinomial(n_samples=10)
n_labels = 3
crfl = LatentGridCRF(n_labels=n_labels, n_states_per_label=1)
clfl = LatentSubgradientSSVM(model=crfl, max_iter=50, C=10.,
learning_rate=0.001, momentum=0.98,
decay_exponent=0)
clfl.w = np.zeros(crfl.size_psi) # this disables random init
clfl.fit(X, Y)
crf = GridCRF(n_states=n_labels)
clf = SubgradientSSVM(model=crf, max_iter=50, C=10.,
learning_rate=0.001, momentum=0.98, decay_exponent=0)
clf.fit(X, Y)
assert_array_almost_equal(clf.w, clfl.w)
assert_array_equal(clf.predict(X), Y)
assert_almost_equal(clf.objective_curve_[-1], clfl.objective_curve_[-1])
def test_k_means_initialization():
n_samples = 10
X, Y = toy.generate_big_checker(n_samples=n_samples)
edges = [make_grid_edges(x, return_lists=True) for x in X]
# flatten the grid
Y = Y.reshape(Y.shape[0], -1)
X = X.reshape(X.shape[0], -1, X.shape[-1])
n_labels = len(np.unique(Y))
X = X.reshape(n_samples, -1, n_labels)
# sanity check for one state
H = kmeans_init(X, Y, edges, n_states_per_label=[1] * n_labels,
n_labels=n_labels)
H = np.vstack(H)
assert_array_equal(Y, H)
# check number of states
H = kmeans_init(X, Y, edges, n_states_per_label=[3] * n_labels,
n_labels=n_labels)
H = np.vstack(H)
assert_array_equal(np.unique(H), np.arange(6))
assert_array_equal(Y, H / 3)
# for dataset with more than two states
X, Y = toy.generate_blocks_multinomial(n_samples=10)
edges = [make_grid_edges(x, return_lists=True) for x in X]
Y = Y.reshape(Y.shape[0], -1)
X = X.reshape(X.shape[0], -1, X.shape[-1])
n_labels = len(np.unique(Y))
# sanity check for one state
H = kmeans_init(X, Y, edges, n_states_per_label=[1] * n_labels,
n_labels=n_labels)
H = np.vstack(H)
assert_array_equal(Y, H)
# check number of states
H = kmeans_init(X, Y, edges, n_states_per_label=[2] * n_labels,
n_labels=n_labels)
H = np.vstack(H)
assert_array_equal(np.unique(H), np.arange(6))
assert_array_equal(Y, H / 2)
def test_one_slack_constraint_caching():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.5,
seed=0, size_x=9)
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
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 21 constraints, which are less than the 94 iterations
# that are done
assert_equal(len(clf.inference_cache_[0]), 21)
# 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_]
assert_equal(np.max(constraints_per_sample), 21)
assert_equal(np.min(constraints_per_sample), 21)
def test_one_slack_constraint_caching():
#testing cutting plane ssvm on easy multinomial dataset
X, Y = toy.generate_blocks_multinomial(n_samples=10, noise=0.3,
seed=0)
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels, inference_method='lp')
clf = OneSlackSSVM(problem=crf, max_iter=50, C=100, verbose=100,
check_constraints=True, break_on_bad=True,
inference_cache=50)
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 9 constraints, which are less than the 16 iterations
# that are done
assert_equal(len(clf.inference_cache_[0]), 9)
# 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_]
assert_equal(np.max(constraints_per_sample), 10)
assert_equal(np.min(constraints_per_sample), 8)
