def latent(self, x, y, w):
# augment unary potentials for latent states
x_wide = np.repeat(x, self.n_states_per_label, axis=1)
# do usual inference
unary_params = w[:self.n_states]
pairwise_flat = np.asarray(w[self.n_states:])
pairwise_params = np.zeros((self.n_states, self.n_states))
pairwise_params[np.tri(self.n_states, dtype=np.bool)] = pairwise_flat
pairwise_params = (pairwise_params + pairwise_params.T
- np.diag(np.diag(pairwise_params)))
unaries = (- 10 * unary_params * x_wide).astype(np.int32)
# forbid h that is incompoatible with y
# by modifying unary params
other_states = (np.arange(self.n_states) / self.n_states_per_label !=
y[:, np.newaxis])
unaries[other_states] = +1000000
pairwise = (-10 * pairwise_params).astype(np.int32)
h = alpha_expansion_graph(self.edges, unaries, pairwise)
if (h / self.n_states_per_label != y).any():
if np.any(w):
print("inconsistent h and y")
#tracer()
h = y * self.n_states_per_label
else:
h = y * self.n_states_per_label
return h
def _inference_qpbo(x, unary_params, pairwise_params, edges):
unaries = (-1000 * unary_params * x).astype(np.int32)
unaries = unaries.reshape(-1, x.shape[-1])
pairwise = (-1000 * pairwise_params).astype(np.int32)
edges = edges.astype(np.int32)
y = alpha_expansion_graph(edges, unaries, pairwise, random_seed=1)
return y.reshape(x.shape[:2])
def latent(self, x, y, w):
# augment unary potentials for latent states
x_wide = np.repeat(x, self.n_states_per_label, axis=1)
# do usual inference
unary_params = w[:self.n_states]
pairwise_flat = np.asarray(w[self.n_states:])
pairwise_params = np.zeros((self.n_states, self.n_states))
pairwise_params[np.tri(self.n_states, dtype=np.bool)] = pairwise_flat
pairwise_params = pairwise_params + pairwise_params.T\
- np.diag(np.diag(pairwise_params))
unaries = (- 10 * unary_params * x_wide).astype(np.int32)
# forbid h that is incompoatible with y
# by modifying unary params
other_states = (np.arange(self.n_states) / self.n_states_per_label !=
y[:, np.newaxis])
unaries[other_states] = +1000000
pairwise = (-10 * pairwise_params).astype(np.int32)
h = alpha_expansion_graph(self.edges, unaries, pairwise)
if (h / self.n_states_per_label != y).any():
if np.any(w):
print("inconsistent h and y")
#tracer()
h = y * self.n_states_per_label
else:
h = y * self.n_states_per_label
return h
def main():
X, Y = make_dataset_big_checker(n_samples=1)
size_y = Y[0].size
shape_y = Y[0].shape
n_labels = len(np.unique(Y))
inds = np.arange(size_y).reshape(shape_y)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
downleft = np.c_[inds[:-1, :-1].ravel(), inds[1:, 1:].ravel()]
downright = np.c_[inds[:-1, 1:].ravel(), inds[1:, :-1].ravel()]
edges = np.vstack([horz, vert, downleft, downright]).astype(np.int32)
graph = sparse.coo_matrix((np.ones(edges.shape[0]),
(edges[:, 0], edges[:, 1])), shape=(size_y, size_y)).tocsr()
graph = graph + graph.T
crf = MultinomialFixedGraphCRFNoBias(n_states=n_labels, graph=graph)
#crf = MultinomialGridCRF(n_labels=4)
#clf = StructuredPerceptron(problem=crf, max_iter=50)
clf = StructuredSVM(problem=crf, max_iter=20, C=1000000, verbose=20,
check_constraints=True,
positive_constraint=np.arange(crf.size_psi - 1))
#clf = SubgradientStructuredSVM(problem=crf, max_iter=100, C=10000)
X_flat = [x.reshape(-1, n_labels).copy("C") for x in X]
Y_flat = [y.ravel() for y in Y]
clf.fit(X_flat, Y_flat)
#clf.fit(X, Y)
Y_pred = clf.predict(X_flat)
#Y_pred = clf.predict(X)
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)
loss += np.sum(np.logical_xor(y, y_pred))
if i > 4:
continue
fig, plots = plt.subplots(1, 4)
plots[0].imshow(y, interpolation='nearest')
plots[0].set_title("gt")
pw_z = np.zeros((n_labels, n_labels), dtype=np.int32)
un = np.ascontiguousarray(
-1000 * x.reshape(-1, n_labels)).astype(np.int32)
unaries = alpha_expansion_graph(edges, un, pw_z)
plots[1].imshow(unaries.reshape(y.shape), interpolation='nearest')
plots[1].set_title("unaries only")
plots[2].imshow(y_pred, interpolation='nearest')
plots[2].set_title("prediction")
loss_augmented = clf.problem.loss_augmented_inference(
x.reshape(-1, n_labels), y.ravel(), clf.w)
loss_augmented = loss_augmented.reshape(y.shape)
plots[3].imshow(loss_augmented, interpolation='nearest')
plots[3].set_title("loss augmented")
fig.savefig("data_%03d.png" % i)
plt.close(fig)
i += 1
print("loss: %f" % loss)
def inference(self, x, w):
if w.shape != (self.size_psi,):
raise ValueError("Got w of wrong shape. Expected %s, got %s" %
(self.size_psi, w.shape))
self.inference_calls += 1
unary_params = w[:self.n_states]
pairwise_flat = np.asarray(w[self.n_states:])
pairwise_params = np.zeros((self.n_states, self.n_states))
pairwise_params[np.tri(self.n_states, dtype=np.bool)] = pairwise_flat
pairwise_params = pairwise_params + pairwise_params.T\
- np.diag(np.diag(pairwise_params))
unaries = (-1000 * unary_params * x).astype(np.int32)
pairwise = (-1000 * pairwise_params).astype(np.int32)
y = alpha_expansion_graph(self.edges, unaries, pairwise, random_seed=1)
return y
def inference(self, x, w):
if w.shape != (self.size_psi,):
raise ValueError("Got w of wrong shape. Expected %s, got %s" %
(self.size_psi, w.shape))
self.inference_calls += 1
pairwise_flat = np.asarray(w[:-1])
unary = w[-1]
pairwise_params = np.zeros((self.n_states, self.n_states))
pairwise_params[np.tri(self.n_states, k=-1, dtype=np.bool)] = pairwise_flat
pairwise_params = pairwise_params + pairwise_params.T\
- np.diag(np.diag(pairwise_params))
unaries = (-1000 * unary * x).astype(np.int32)
pairwise = (-1000 * pairwise_params).astype(np.int32)
y = alpha_expansion_graph(self.edges, unaries, pairwise, random_seed=1)
from pyqpbo import binary_graph
y_ = binary_graph(self.edges, unaries, pairwise)
if (y_ != y).any():
tracer()
return y
def example_multinomial_checkerboard():
# generate a checkerboard
np.random.seed(1)
x = np.zeros((12, 10, 3))
x[::2, ::2, 0] = -2
x[1::2, 1::2, 1] = -2
x[:, :, 2] = -1
x_noisy = x + np.random.normal(0, 1.0, size=x.shape)
x_org = np.argmin(x, axis=2)
# create unaries
unaries = (10 * x_noisy).astype(np.int32)
x_thresh = np.argmin(unaries, axis=2)
# as we convert to int, we need to multipy to get sensible values
# create potts pairwise
pairwise = 100 * np.eye(3, dtype=np.int32)
# do alpha expansion
result_qpbo = alpha_expansion_grid(unaries, pairwise, n_iter=4)
# use the gerneral graph algorithm
# first, we construct the grid graph
inds = np.arange(x_org.size).reshape(x_org.shape)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
edges = np.vstack([horz, vert]).astype(np.int32)
result_qpbo_graph = alpha_expansion_graph(edges,
unaries.reshape(-1, 3),
pairwise,
n_iter=4)
# plot results
plt.subplot(221, title="original")
plt.imshow(x_org, interpolation='nearest')
plt.subplot(222, title="thresholding result")
plt.imshow(x_thresh, interpolation='nearest')
plt.subplot(223, title="qpbo")
plt.imshow(result_qpbo, interpolation='nearest')
plt.subplot(224, title="qpbo graph")
plt.imshow(result_qpbo_graph.reshape(x_org.shape), interpolation='nearest')
plt.show()
def example_multinomial_checkerboard():
# generate a checkerboard
np.random.seed(1)
x = np.zeros((12, 10, 3))
x[::2, ::2, 0] = -2
x[1::2, 1::2, 1] = -2
x[:, :, 2] = -1
x_noisy = x + np.random.normal(0, 1.0, size=x.shape)
x_org = np.argmin(x, axis=2)
# create unaries
unaries = (10 * x_noisy).astype(np.int32)
x_thresh = np.argmin(unaries, axis=2)
# as we convert to int, we need to multipy to get sensible values
# create potts pairwise
pairwise = 100 * np.eye(3, dtype=np.int32)
# do alpha expansion
result_qpbo = alpha_expansion_grid(unaries, pairwise, n_iter=4)
# use the gerneral graph algorithm
# first, we construct the grid graph
inds = np.arange(x_org.size).reshape(x_org.shape)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
edges = np.vstack([horz, vert]).astype(np.int32)
result_qpbo_graph = alpha_expansion_graph(edges, unaries.reshape(-1, 3),
pairwise, n_iter=4)
# plot results
plt.subplot(221, title="original")
plt.imshow(x_org, interpolation='nearest')
plt.subplot(222, title="thresholding result")
plt.imshow(x_thresh, interpolation='nearest')
plt.subplot(223, title="qpbo")
plt.imshow(result_qpbo, interpolation='nearest')
plt.subplot(224, title="qpbo graph")
plt.imshow(result_qpbo_graph.reshape(x_org.shape), interpolation='nearest')
plt.show()
def main():
X, Y = make_dataset_big_checker(n_samples=1)
size_y = Y[0].size
shape_y = Y[0].shape
n_labels = len(np.unique(Y))
inds = np.arange(size_y).reshape(shape_y)
horz = np.c_[inds[:, :-1].ravel(), inds[:, 1:].ravel()]
vert = np.c_[inds[:-1, :].ravel(), inds[1:, :].ravel()]
downleft = np.c_[inds[:-1, :-1].ravel(), inds[1:, 1:].ravel()]
downright = np.c_[inds[:-1, 1:].ravel(), inds[1:, :-1].ravel()]
edges = np.vstack([horz, vert, downleft, downright]).astype(np.int32)
graph = sparse.coo_matrix(
(np.ones(edges.shape[0]), (edges[:, 0], edges[:, 1])),
shape=(size_y, size_y)).tocsr()
graph = graph + graph.T
crf = MultinomialFixedGraphCRFNoBias(n_states=n_labels, graph=graph)
#crf = MultinomialGridCRF(n_labels=4)
#clf = StructuredPerceptron(problem=crf, max_iter=50)
clf = StructuredSVM(problem=crf,
max_iter=20,
C=1000000,
verbose=20,
check_constraints=True,
positive_constraint=np.arange(crf.size_psi - 1))
#clf = SubgradientStructuredSVM(problem=crf, max_iter=100, C=10000)
X_flat = [x.reshape(-1, n_labels).copy("C") for x in X]
Y_flat = [y.ravel() for y in Y]
clf.fit(X_flat, Y_flat)
#clf.fit(X, Y)
Y_pred = clf.predict(X_flat)
#Y_pred = clf.predict(X)
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)
loss += np.sum(np.logical_xor(y, y_pred))
if i > 4:
continue
fig, plots = plt.subplots(1, 4)
plots[0].imshow(y, interpolation='nearest')
plots[0].set_title("gt")
pw_z = np.zeros((n_labels, n_labels), dtype=np.int32)
un = np.ascontiguousarray(-1000 * x.reshape(-1, n_labels)).astype(
np.int32)
unaries = alpha_expansion_graph(edges, un, pw_z)
plots[1].imshow(unaries.reshape(y.shape), interpolation='nearest')
plots[1].set_title("unaries only")
plots[2].imshow(y_pred, interpolation='nearest')
plots[2].set_title("prediction")
loss_augmented = clf.problem.loss_augmented_inference(
x.reshape(-1, n_labels), y.ravel(), clf.w)
loss_augmented = loss_augmented.reshape(y.shape)
plots[3].imshow(loss_augmented, interpolation='nearest')
plots[3].set_title("loss augmented")
fig.savefig("data_%03d.png" % i)
plt.close(fig)
i += 1
print("loss: %f" % loss)
