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_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_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_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_max_product_multinomial_crf():
X, Y = generate_blocks_multinomial(n_samples=1)
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]) # unary # pairwise
crf = GridCRF(inference_method="max-product")
crf.initialize(X, Y)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
def test_binary_blocks_crf_n8_lp():
X, Y = generate_blocks(n_samples=1, noise=1)
x, y = X[0], Y[0]
w = np.array([1, 0, 0, 1, 1, -1.4, 1]) # unary # pairwise
crf = GridCRF(neighborhood=8)
crf.initialize(X, Y)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
def test_max_product_binary_blocks():
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="max-product")
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_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_binary_blocks_crf_n8_lp():
X, Y = toy.generate_blocks(n_samples=1, noise=1)
x, y = X[0], Y[0]
w = np.array([1, 0, # unary
0, 1,
1, # pairwise
-1.4, 1])
crf = GridCRF(inference_method="lp", neighborhood=8)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
def test_binary_blocks_crf_n8_lp():
X, Y = generate_blocks(n_samples=1, noise=1)
x, y = X[0], Y[0]
w = np.array([1, 0, # unary
0, 1,
1, # pairwise
-1.4, 1])
crf = GridCRF(neighborhood=8)
crf.initialize(X, Y)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
def test_multinomial_grid_unaries():
# test handling on unaries for multinomial grid CRFs
# on multinomial datasets
for ds in multinomial:
X, Y = ds(n_samples=1, size_x=9)
x, y = X[0], Y[0]
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
crf.initialize(X, Y)
w_unaries_only = np.zeros(crf.size_psi)
w_unaries_only[:n_labels ** 2] = np.eye(n_labels).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))
# 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])
def test_multinomial_grid_unaries():
# test handling on unaries for multinomial grid CRFs
# on multinomial datasets
for ds in multinomial:
X, Y = ds(n_samples=1, size_x=9)
x = X[0]
n_labels = len(np.unique(Y))
crf = GridCRF(n_states=n_labels)
crf.initialize(X, Y)
w_unaries_only = np.zeros(crf.size_joint_feature)
w_unaries_only[:n_labels**2] = np.eye(n_labels).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))
# 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])
def test_multinomial_grid_unaries():
# test handling on unaries for multinomial grid CRFs
# on multinomial datasets
for ds in toy.multinomial:
X, Y = ds(n_samples=1)
x, y = X[0], Y[0]
n_labels = len(np.unique(Y))
for inference_method in ['qpbo', 'lp', 'ad3']: # dai is to expensive
crf = GridCRF(n_states=n_labels, inference_method=inference_method)
w_unaries_only = np.zeros(crf.size_psi)
w_unaries_only[:n_labels ** 2] = np.eye(n_labels).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))
# 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])
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 ['dai', 'qpbo', 'lp', 'ad3']:
crf = GridCRF(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_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_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_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_binary_crf_exhaustive():
# tests qpbo inference against brute force
# on random data / weights
np.random.seed(0)
for i in xrange(10):
x = np.random.uniform(-1, 1, size=(3, 2))
x = np.dstack([-x, np.zeros_like(x)]).copy()
crf = GridCRF(n_features=2, n_states=2)
w = np.random.uniform(-1, 1, size=7)
# check map inference
y_hat = crf.inference(x, w)
y_ex = exhaustive_inference(crf, x, w)
assert_array_equal(y_hat, y_ex)
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_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_binary_crf_exhaustive():
# tests qpbo inference against brute force
# on random data / weights
np.random.seed(0)
for i in range(10):
x = np.random.uniform(-1, 1, size=(3, 2))
x = np.dstack([-x, np.zeros_like(x)]).copy()
crf = GridCRF(n_features=2, n_states=2)
w = np.random.uniform(-1, 1, size=7)
# check map inference
y_hat = crf.inference(x, w)
y_ex = exhaustive_inference(crf, x, w)
assert_array_equal(y_hat, y_ex)
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_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_max_product_binary_blocks():
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='max-product')
crf.initialize(X, Y)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)
def test_binary_crf_exhaustive():
# tests graph cut inference against brute force
# on random data / weights
np.random.seed(0)
for i in xrange(50):
x = np.random.uniform(-1, 1, size=(3, 3))
x = np.dstack([-x, np.zeros_like(x)]).copy()
crf = GridCRF()
w = np.random.uniform(-1, 1, size=7)
# check map inference
y_hat = crf.inference(x, w)
y_ex = exhaustive_inference(crf, x, w)
#print(y_hat)
#print(y_ex)
#print("++++++++++++++++++++++")
assert_array_equal(y_hat, y_ex)
def test_binary_ssvm_repellent_potentials():
# test non-submodular problem with and without submodularity constraint
# dataset is checkerboard
X, Y = generate_checker()
crf = GridCRF(inference_method=inference_method)
clf = NSlackSSVM(model=crf, max_iter=10, C=100,
check_constraints=True)
clf.fit(X, Y)
Y_pred = clf.predict(X)
# standard crf can predict perfectly
assert_array_equal(Y, Y_pred)
submodular_clf = NSlackSSVM(model=crf, max_iter=10, C=100,
check_constraints=True,
negativity_constraint=[4, 5, 6])
submodular_clf.fit(X, Y)
Y_pred = submodular_clf.predict(X)
# submodular crf can not do better than unaries
for i, x in enumerate(X):
y_pred_unaries = crf.inference(x, np.array([1, 0, 0, 1, 0, 0, 0]))
assert_array_equal(y_pred_unaries, Y_pred[i])
def test_one_slack_repellent_potentials():
# test non-submodular learning with and without positivity constraint
# dataset is checkerboard
X, Y = toy.generate_checker()
for inference_method in ["lp", "qpbo", "ad3"]:
crf = GridCRF(inference_method=inference_method)
clf = OneSlackSSVM(model=crf, max_iter=10, C=100, verbose=0,
check_constraints=True, n_jobs=-1)
clf.fit(X, Y)
Y_pred = clf.predict(X)
# standard crf can predict perfectly
assert_array_equal(Y, Y_pred)
submodular_clf = OneSlackSSVM(model=crf, max_iter=10, C=100,
verbose=0, check_constraints=True,
positive_constraint=[4, 5, 6], n_jobs=-1)
submodular_clf.fit(X, Y)
Y_pred = submodular_clf.predict(X)
# submodular crf can not do better than unaries
for i, x in enumerate(X):
y_pred_unaries = crf.inference(x, np.array([1, 0, 0, 1, 0, 0, 0]))
assert_array_equal(y_pred_unaries, Y_pred[i])
def test_max_product_multinomial_crf():
X, Y = generate_blocks_multinomial(n_samples=1)
x, y = X[0], Y[0]
w = np.array([
1.,
0.,
0., # unary
0.,
1.,
0.,
0.,
0.,
1.,
.4, # pairwise
-.3,
.3,
-.5,
-.1,
.3
])
crf = GridCRF(inference_method='max-product')
crf.initialize(X, Y)
y_hat = crf.inference(x, w)
assert_array_equal(y, y_hat)