def test_energy():
# make sure that energy as computed by ssvm is the same as by lp
np.random.seed(0)
for inference_method in ["lp", "ad3"]:
found_fractional = False
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2)
while not found_fractional:
x = np.random.normal(size=(7, 8, 3))
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)
unary_params = np.random.normal(size=(3, 3))
pw1 = np.random.normal(size=(3, 3))
pw2 = np.random.normal(size=(3, 3))
w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()])
res, energy = crf.inference(x, w, relaxed=True, return_energy=True)
found_fractional = np.any(np.max(res[0], axis=-1) != 1)
psi = crf.psi(x, res)
energy_svm = np.dot(psi, w)
assert_almost_equal(energy, -energy_svm)
if not found_fractional:
# exact discrete labels, test non-relaxed version
res, energy = crf.inference(x, w, relaxed=False,
return_energy=True)
psi = crf.psi(x, res)
energy_svm = np.dot(psi, w)
assert_almost_equal(energy, -energy_svm)
def test_energy_continuous():
# make sure that energy as computed by ssvm is the same as by lp
np.random.seed(0)
for inference_method in get_installed(["lp", "ad3"]):
found_fractional = False
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2, n_features=3)
while not found_fractional:
x = np.random.normal(size=(7, 8, 3))
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)
unary_params = np.random.normal(size=(3, 3))
pw1 = np.random.normal(size=(3, 3))
pw2 = np.random.normal(size=(3, 3))
w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()])
res, energy = crf.inference(x, w, relaxed=True, return_energy=True)
found_fractional = np.any(np.max(res[0], axis=-1) != 1)
joint_feature = crf.joint_feature(x, res)
energy_svm = np.dot(joint_feature, w)
assert_almost_equal(energy, -energy_svm)
def test_initialization():
X, Y = 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, n_states), edges, edge_features)
y = y.ravel()
crf = EdgeFeatureGraphCRF()
crf.initialize([x], [y])
assert_equal(crf.n_edge_features, 2)
assert_equal(crf.n_features, 3)
assert_equal(crf.n_states, 3)
crf = EdgeFeatureGraphCRF(n_states=3,
n_features=3,
n_edge_features=2)
# no-op
crf.initialize([x], [y])
crf = EdgeFeatureGraphCRF(n_states=4,
n_edge_features=2)
# incompatible
assert_raises(ValueError, crf.initialize, X=[x], Y=[y])
def test_energy_continuous():
# make sure that energy as computed by ssvm is the same as by lp
np.random.seed(0)
for inference_method in get_installed(["lp", "ad3"]):
found_fractional = False
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2, n_features=3)
while not found_fractional:
x = np.random.normal(size=(7, 8, 3))
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)
unary_params = np.random.normal(size=(3, 3))
pw1 = np.random.normal(size=(3, 3))
pw2 = np.random.normal(size=(3, 3))
w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()])
res, energy = crf.inference(x, w, relaxed=True, return_energy=True)
found_fractional = np.any(np.max(res[0], axis=-1) != 1)
joint_feature = crf.joint_feature(x, res)
energy_svm = np.dot(joint_feature, w)
assert_almost_equal(energy, -energy_svm)
def define_model(self):
if self.models == 'GridCRF':
from pystruct.models import GridCRF
self.crf = GridCRF(
neighborhood=self.models_parameters['neighborhood'],
inference_method=self.models_parameters['inference']
)
if self.models == 'GraphCRF':
self.prepare_data_to_graph_crf()
logging.info('Class weight: ' + str([self.total_label_one_avg,1-self.total_label_one_avg]))
from pystruct.models import GraphCRF
self.crf = GraphCRF(
inference_method=self.models_parameters['inference'],
directed = self.models_parameters['directed'],
class_weight = [self.total_label_one_avg,1-self.total_label_one_avg]
# class_weight=[0.01, 0.99]
)
if self.models == 'EdgeFeatureGraphCRF':
self.prepare_data_to_edge_feature_graph_crf()
logging.info('Class weight: ' + str([self.total_label_one_avg, 1 - self.total_label_one_avg]))
from pystruct.models import EdgeFeatureGraphCRF
self.crf = EdgeFeatureGraphCRF(
inference_method=self.models_parameters['inference'],
# directed=self.models_parameters['directed'],
class_weight=[self.total_label_one_avg, 1 - self.total_label_one_avg]
# class_weight=[0.01, 0.99]
)
return
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_energy_discrete():
for inference_method in get_installed(["qpbo", "ad3"]):
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2)
for i in xrange(10):
x = np.random.normal(size=(7, 8, 3))
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)
unary_params = np.random.normal(size=(3, 3))
pw1 = np.random.normal(size=(3, 3))
pw2 = np.random.normal(size=(3, 3))
w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()])
y_hat = crf.inference(x, w, relaxed=False)
energy = compute_energy(crf.get_unary_potentials(x, w),
crf.get_pairwise_potentials(x, w), edges,
y_hat)
psi = crf.psi(x, y_hat)
energy_svm = np.dot(psi, w)
assert_almost_equal(energy, energy_svm)
def test_joint_feature_discrete():
X, Y = 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 get_installed(["lp", "ad3", "qpbo"]):
crf = EdgeFeatureGraphCRF(inference_method=inference_method)
crf.initialize([x], [y_flat])
joint_feature_y = crf.joint_feature(x, y_flat)
assert_equal(joint_feature_y.shape, (crf.size_joint_feature, ))
# first horizontal, then vertical
# we trust the unaries ;)
pw_joint_feature_horz, pw_joint_feature_vert = joint_feature_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_joint_feature_vert,
np.diag([9 * 4, 9 * 4, 9 * 4]))
vert_joint_feature = np.diag([10 * 3, 10 * 3, 10 * 3])
vert_joint_feature[0, 1] = 10
vert_joint_feature[1, 2] = 10
assert_array_equal(pw_joint_feature_horz, vert_joint_feature)
def _getCRFModel(self, clsWeights):
if self._nbClass: #should always be the case, when used from DU_CRF_Task
#if some class is not represented, we still train and do not crash
crf = EdgeFeatureGraphCRF(inference_method='ad3', class_weight=clsWeights, n_states=self._nbClass)
else:
crf = EdgeFeatureGraphCRF(inference_method='ad3', class_weight=clsWeights)
return crf
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_inference():
# Test inference with different weights in different directions
X, Y = 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(inference_method=inference_method)
crf.initialize([x], [y])
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)
crf.initialize([x], [y])
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_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 train(trainSetX, trainSetY, testSetX, testSetY):
modelLogger = SaveLogger('imagesegmentation-horse-hog_96_lbp_test.model',
save_every=1)
# Load trained CRF model
print 'Loading trained model for CRF'
#clf = modelLogger.load()
# Uncomment if we want to train from scratch first layer CRF
print 'Training CRF...'
start_time = time.time()
crf = EdgeFeatureGraphCRF() #antisymmetric_edge_features=[1,2]
clf = FrankWolfeSSVM(model=crf,
C=10.,
tol=.1,
verbose=3,
show_loss_every=1,
logger=modelLogger) # #max_iter=50
##clf = OneSlackSSVM(model=crf, verbose=1, show_loss_every=1, logger=modelLogger)
clf.fit(numpy.array(trainSetX), numpy.array(trainSetY))
print 'Training CRF took ' + str(time.time() - start_time) + ' seconds'
#print("Overall super pixelwise accuracy (training set): %f" % clf.score(numpy.array(trainSetX), numpy.array(trainSetY) ))
#print("Overall super pixelwise accuracy (test set): %f" % clf.score(numpy.array(testSetX), numpy.array(testSetY) ))
print 'SUPERPIXELWISE ACCURACY'
print '-----------------------------------------------------------------------'
print ''
print 'TRAINING SET RESULTS'
train_ypred = evaluatePerformance(clf, numpy.array(trainSetX),
numpy.array(trainSetY))
print ''
print 'TEST SET RESULTS'
evaluatePerformance(clf, numpy.array(testSetX), numpy.array(testSetY))
print '-----------------------------------------------------------------------'
def structraining(self, bags, mentions, retweets, labels):
total_datas = []
total_labels = []
print('num_user', len(bags.keys()))
for user_id, bag in bags.items():
if not user_id in labels:
continue
features = np.empty((0, self.top_seq))
edge_nodes = np.empty((0, 2))
edge_features = np.empty((0, 1))
clique_labels = np.array([labels[user_id]])
features = np.vstack([features, bag])
mentioned_ids = mentions[user_id]
cnt = 0
for mentioned_id in enumerate(mentioned_ids):
if not mentioned_id in labels:
continue
clique_labels = np.append(clique_labels,
np.array([labels[mentioned_id]]))
if mentioned_id in bags:
features = np.vstack([features, bags[mentioned_id]])
else:
features = np.vstack([features, np.zeros(self.top_seq)])
edge_nodes = np.vstack([edge_nodes, np.array([0, cnt + 1])])
edge_features = np.vstack([edge_features, np.array([[0]])])
cnt += 1
num_mentioned = edge_nodes.shape[0]
retweet_ids = retweets[user_id]
cnt = 0
for retweet_id in retweet_ids:
if not retweet_id in labels:
continue
clique_labels = np.append(clique_labels,
np.array([labels[retweet_id]]))
if retweet_id in bags:
features = np.vstack([features, bags[retweet_id]])
else:
features = np.vstack([features, np.zeros(self.top_seq)])
edge_nodes = np.vstack(
[edge_nodes,
np.array([0, cnt + 1 + num_mentioned])])
edge_features = np.vstack([edge_features, np.array([[1]])])
cnt += 1
total_datas.append(
(features, edge_nodes.astype(int), edge_features))
total_labels.append(clique_labels)
ratio = len(total_datas) * 0.7
ratio = int(ratio)
print(ratio)
X_train, y_train = total_datas[:ratio], total_labels[:ratio]
X_test, y_test = total_datas[ratio:], total_labels[ratio:]
model = EdgeFeatureGraphCRF(inference_method="max-product")
ssvm = FrankWolfeSSVM(model=model, C=0.1, max_iter=10)
ssvm.fit(X_train, y_train)
result = ssvm.score(X_test, y_test)
print(result)
def __init__(self,
prob_estimator,
C_ssvm=1.,
inference='ad3',
inference_cache=50,
tol=1.,
max_iter=200,
n_jobs=1):
"""
Called when initializing the classifier
"""
#self.C_logreg = C_logreg
self.C_ssvm = C_ssvm
self.inference = inference
self.inference_cache = inference_cache
self.tol = tol
self.max_iter = max_iter
self.n_jobs = n_jobs
self.prob_estimator = prob_estimator
self.crf = EdgeFeatureGraphCRF(inference_method=inference)
self.ssvm = OneSlackSSVM(self.crf,
inference_cache=inference_cache,
C=C_ssvm,
tol=tol,
max_iter=max_iter,
n_jobs=n_jobs)
def fresh_train(self, x, y, iterations=10):
self.model = EdgeFeatureGraphCRF(inference_method="max-product")
self.learner = SubgradientSSVM(
model=self.model,
max_iter=iterations,
logger=SaveLogger(model_file.format(self.userId + "-learner")))
self.learner.fit(x, y, warm_start=False)
self.save()
def test_initialization():
X, Y = 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, n_states), edges, edge_features)
y = y.ravel()
crf = EdgeFeatureGraphCRF()
crf.initialize([x], [y])
assert_equal(crf.n_edge_features, 2)
assert_equal(crf.n_features, 3)
assert_equal(crf.n_states, 3)
crf = EdgeFeatureGraphCRF(n_states=3,
n_features=3,
n_edge_features=2)
# no-op
crf.initialize([x], [y])
crf = EdgeFeatureGraphCRF(n_states=4,
n_edge_features=2)
# incompatible
assert_raises(ValueError, crf.initialize, X=[x], Y=[y])
def model_test(k, head, tail):
"""
CRF训练和预测
"""
each_fold_time = time.time() #开始计时
#divide train set and test set
train_id = dataId[head:tail]
test_id = dataId[:head] + dataId[tail:]
X_train = X_arr[train_id, :]
Y_train = Y_arr[train_id]
X_test = X_arr[test_id, :]
Y_test = Y_arr[test_id]
campTest = Camp_arr[test_id]
#ends divide train set and test set
if len(X_train) > 0:
#实例化CRF
EFGCRF = EdgeFeatureGraphCRF(inference_method='qpbo',
class_weight=CLASS_WEIGHT)
if LEARNER == "OneSlackSSVM":
#利用OneSlackSSVM训练模型参数
ssvm = OneSlackSSVM(EFGCRF,
C=.1,
tol=.1,
max_iter=100,
switch_to='ad3')
elif LEARNER == "FrankWolfeSSVM":
#利用FrankWolfeSSVM训练模型参数
ssvm = FrankWolfeSSVM(EFGCRF, C=.1, tol=.1, max_iter=100)
else:
#没有选择分类器退出
pass
ssvm.fit(X_train, Y_train)
Y_pred = ssvm.predict(X_test)
df_result = statistic_result(Y_pred, Y_test, campTest)
V_precision = precision_score(df_result["label"], df_result["pred"])
V_recall = recall_score(df_result["label"], df_result["pred"])
V_f1 = f1_score(df_result["label"], df_result["pred"])
camps_pred, camps_lbl = statistic_campaign_result(Y_pred, Y_test)
C_precision = precision_score(camps_lbl, camps_pred)
C_recall = recall_score(camps_lbl, camps_pred)
C_f1 = f1_score(camps_lbl, camps_pred)
result_Queue.put(
[V_precision, V_recall, V_f1, C_precision, C_recall, C_f1])
else:
print("TRAIN SET is NULL")
print("the {}th fold using time: {:.4f} min".format(
k + 1, (time.time() - each_fold_time) / 60))
del X_train, Y_train, X_test, Y_test, Y_pred, campTest
def train(X,y):
X_train_directions = make_directions(X)
Y_train_flat = [y.ravel()]
inference = 'qpbo'
# first, train on X with directions only:
crf = EdgeFeatureGraphCRF(inference_method=inference)
ssvm = OneSlackSSVM(crf, inference_cache=50, C=.1, tol=.1, max_iter=10,
n_jobs=1,show_loss_every=1)
ssvm.fit(X_train_directions, Y_train_flat, warm_start=False)
return ssvm
def fresh_train(self, x, y, iterations=10, decay_rate=1):
self.model = EdgeFeatureGraphCRF(inference_method="max-product")
self.learner = SubgradientSSVM(
model=self.model,
max_iter=iterations,
logger=SaveLogger(
MODEL_PATH_TEMPLATE.format(self.userId + "-learner")),
show_loss_every=50,
decay_exponent=decay_rate)
self.learner.fit(x, y, warm_start=False)
self.save()
def test_joint_feature_continuous():
# FIXME
# first make perfect prediction, including pairwise part
X, Y = 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 get_installed(["lp", "ad3"]):
crf = EdgeFeatureGraphCRF(inference_method=inference_method)
w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()])
crf.initialize([x], [y])
y_pred = crf.inference(x, w, relaxed=True)
# compute joint_feature for prediction
joint_feature_y = crf.joint_feature(x, y_pred)
assert_equal(joint_feature_y.shape, (crf.size_joint_feature,))
def test_unary_potentials():
#print "---SIMPLE---------------------------------------------------------------------"
#g, (node_f, edges, edge_f) = get_simple_graph_structure(), get_simple_graph()
g = NodeTypeEdgeFeatureGraphCRF(
1 #how many node type?
, [4] #how many labels per node type?
, [3] #how many features per node type?
, np.array([[3]]) #how many features per node type X node type?
)
node_f = [ np.array([[1,1,1],
[2,2,2]])
]
edges = [ np.array([[0,1]])
] #an edge from 0 to 1
edge_f = [ np.array([[3,3,3]])
]
x = (node_f, edges, edge_f)
#print "- - - - - - - - - - - - - - - - - - - - - - - - - - - "
y = np.hstack([ np.array([1,2])])
# y = np.array([1,0])
#print y
g.initialize(x, y)
gref = EdgeFeatureGraphCRF(4,3,3)
xref = (node_f[0], edges[0], edge_f[0])
wref = np.arange(gref.size_joint_feature)
potref = gref._get_unary_potentials(xref, wref)
#print `potref`
w = np.arange(g.size_joint_feature)
pot = g._get_unary_potentials(x, w)
#print `pot`
assert_array_equal(pot, [potref])
pwpotref = gref._get_pairwise_potentials(xref, wref)
#print `pwpotref`
pwpot = g._get_pairwise_potentials(x, w)
#print `pwpot`
assert_array_equal(pwpot, [pwpotref])
def test_energy_discrete():
for inference_method in get_installed(["qpbo", "ad3"]):
crf = EdgeFeatureGraphCRF(n_states=3,
inference_method=inference_method,
n_edge_features=2, n_features=3)
for i in xrange(10):
x = np.random.normal(size=(7, 8, 3))
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)
unary_params = np.random.normal(size=(3, 3))
pw1 = np.random.normal(size=(3, 3))
pw2 = np.random.normal(size=(3, 3))
w = np.hstack([unary_params.ravel(), pw1.ravel(), pw2.ravel()])
y_hat = crf.inference(x, w, relaxed=False)
energy = compute_energy(crf._get_unary_potentials(x, w),
crf._get_pairwise_potentials(x, w), edges,
y_hat)
joint_feature = crf.joint_feature(x, y_hat)
energy_svm = np.dot(joint_feature, w)
assert_almost_equal(energy, energy_svm)
def test_joint_feature_discrete():
X, Y = 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 get_installed(["lp", "ad3", "qpbo"]):
crf = EdgeFeatureGraphCRF(inference_method=inference_method)
crf.initialize([x], [y_flat])
joint_feature_y = crf.joint_feature(x, y_flat)
assert_equal(joint_feature_y.shape, (crf.size_joint_feature,))
# first horizontal, then vertical
# we trust the unaries ;)
pw_joint_feature_horz, pw_joint_feature_vert = joint_feature_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_joint_feature_vert, np.diag([9 * 4, 9 * 4, 9 * 4]))
vert_joint_feature = np.diag([10 * 3, 10 * 3, 10 * 3])
vert_joint_feature[0, 1] = 10
vert_joint_feature[1, 2] = 10
assert_array_equal(pw_joint_feature_horz, vert_joint_feature)
def fit_crf(self):
for C in self.C_range:
print("Testing C value: {}".format(C))
model = EdgeFeatureGraphCRF(inference_method="ad3")
ssvm = OneSlackSSVM(model,
inference_cache=50,
C=C,
tol=self.tol,
max_iter=self.max_iter,
n_jobs=4,
verbose=False)
ssvm.fit(self.X_train, self.y_train)
predictions = [x for x in ssvm.predict(self.X_dev)]
self.evaluate_predictions(predictions, self.y_dev)
# Fit against the whole dataset except test
# Is this approach correct?
model = EdgeFeatureGraphCRF(inference_method="ad3")
ssvm = OneSlackSSVM(model,
inference_cache=50,
C=0.03,
tol=self.tol,
max_iter=self.max_iter,
n_jobs=4,
verbose=False)
X_train_dev = np.concatenate([self.X_train, self.X_dev])
y_train_dev = np.concatenate([self.y_train, self.y_dev])
ssvm.fit(X_train_dev, y_train_dev)
if self.eval_against_test:
predictions = [x for x in ssvm.predict(self.X_test)]
print("Test set evaluation")
self.evaluate_predictions(predictions, self.y_test)
self.model = ssvm
return ssvm
def test_multinomial_blocks_directional_simple():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X_, Y_ = 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_multinomial_blocks_directional_anti_symmetric():
# testing cutting plane ssvm with directional CRF on easy multinomial
# dataset
X_, Y_ = 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(symmetric_edge_features=[0],
antisymmetric_edge_features=[1])
clf = NSlackSSVM(model=crf, C=100)
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]
assert_array_equal(sym, sym.T)
assert_array_equal(antisym, -antisym.T)
def svm_on_segments(C=.1, learning_rate=.001, subgradient=True):
# load and prepare data
lateral = True
latent = True
test = False
#data_train = load_data(which="piecewise")
#data_train = add_edges(data_train, independent=False)
#data_train = add_kraehenbuehl_features(data_train, which="train_30px")
#data_train = add_kraehenbuehl_features(data_train, which="train")
#if lateral:
#data_train = add_edge_features(data_train)
data_train = load_data_global_probs(latent=latent)
X_org_ = data_train.X
#data_train = make_hierarchical_data(data_train, lateral=lateral,
#latent=latent, latent_lateral=True)
data_train = discard_void(data_train, 21, latent_features=True)
X_, Y_ = data_train.X, data_train.Y
# remove edges
if not lateral:
X_org_ = [(x[0], np.zeros((0, 2), dtype=np.int)) for x in X_org_]
if test:
data_val = load_data('val', which="piecewise")
data_val = add_edges(data_val, independent=False)
data_val = add_kraehenbuehl_features(data_val)
data_val = make_hierarchical_data(data_val,
lateral=lateral,
latent=latent)
data_val = discard_void(data_val, 21)
X_.extend(data_val.X)
Y_.extend(data_val.Y)
n_states = 21
class_weights = 1. / np.bincount(np.hstack(Y_))
class_weights *= 21. / np.sum(class_weights)
experiment_name = ("latent5_features_C%f_top_node" % C)
logger = SaveLogger(experiment_name + ".pickle", save_every=10)
if latent:
model = LatentNodeCRF(n_labels=n_states,
n_features=data_train.X[0][0].shape[1],
n_hidden_states=5,
inference_method='qpbo' if lateral else 'dai',
class_weight=class_weights,
latent_node_features=True)
if subgradient:
ssvm = learners.LatentSubgradientSSVM(model,
C=C,
verbose=1,
show_loss_every=10,
logger=logger,
n_jobs=-1,
learning_rate=learning_rate,
decay_exponent=1,
momentum=0.,
max_iter=100000)
else:
latent_logger = SaveLogger("lssvm_" + experiment_name +
"_%d.pickle",
save_every=1)
base_ssvm = learners.OneSlackSSVM(model,
verbose=2,
C=C,
max_iter=100000,
n_jobs=-1,
tol=0.001,
show_loss_every=200,
inference_cache=50,
logger=logger,
cache_tol='auto',
inactive_threshold=1e-5,
break_on_bad=False,
switch_to_ad3=True)
ssvm = learners.LatentSSVM(base_ssvm, logger=latent_logger)
warm_start = False
if warm_start:
ssvm = logger.load()
ssvm.logger = SaveLogger(experiment_name + "_retrain.pickle",
save_every=10)
ssvm.max_iter = 100000
ssvm.learning_rate = 0.00001
ssvm.momentum = 0
else:
#model = GraphCRF(n_states=n_states,
#n_features=data_train.X[0][0].shape[1],
#inference_method='qpbo' if lateral else 'dai',
#class_weight=class_weights)
model = EdgeFeatureGraphCRF(
n_states=n_states,
n_features=data_train.X[0][0].shape[1],
inference_method='qpbo' if lateral else 'dai',
class_weight=class_weights,
n_edge_features=4,
symmetric_edge_features=[0, 1],
antisymmetric_edge_features=[2])
ssvm = learners.OneSlackSSVM(model,
verbose=2,
C=C,
max_iter=100000,
n_jobs=-1,
tol=0.0001,
show_loss_every=200,
inference_cache=50,
logger=logger,
cache_tol='auto',
inactive_threshold=1e-5,
break_on_bad=False)
#ssvm = logger.load()
X_, Y_ = shuffle(X_, Y_)
#ssvm.fit(data_train.X, data_train.Y)
#ssvm.fit(X_, Y_, warm_start=warm_start)
ssvm.fit(X_, Y_)
print("fit finished!")
def main(usePopularity, useMap, defaultValue, learner):
#list of most popular heroes
most_popular_heroes = [
14, # pudge
26, # lion
74, # invoker,
84, # ogre_magi
41, # faceless_void
21, # windrunner / windranger
7, # earthshaker
104, # legion_commander
9, # mirana
44, # phantom_assassin
22, # zeus
93, # slark
5, # crystal_maiden
8, # juggernaut
86, # rubick
35, # sniper
6, # drow_ranger
101, # skywrath_mage
25, # lina
2, # axe
114, # monkey king
27, # shadow shaman
23, # kunkka
99, # bristleback
30, # witch_doctor
32, # riki
34, # tinker
75, # silencer
1, # anti mage
42, # skeletonking/wraithking
50, # dazzle
90, # keeper of the light
106, # ember spirit
62, # bounty hunter
60, # night stalker
54, # life stealer
17, # storm spirit
3, # bane
37, # warlock
47, # viper
113, # arc warden
64, # jakiro
72, # gyro
81 # chaos knight
]
#load data
with open('data/popularityDict.pkl', 'rb') as f:
popularityDict = pickle.load(f)
with open('data/hero_win_percentage.pkl', 'rb') as f:
hero_win_percentage = pickle.load(f)
with open('data/X_no_features_df.pkl', 'rb') as f:
X_no_features_df = pickle.load(f)
with open('data/Y_df.pkl', 'rb') as f:
Y_df = pickle.load(f)
with open('data/filtered_matches.pkl', 'rb') as f:
filtered_matches = pickle.load(f)
#featurize
X_features = get_X_features(X_no_features_df,
most_popular_heroes,
popularityDict,
hero_win_percentage,
filtered_matches,
use_popularity=usePopularity,
use_map=useMap,
default_value=defaultValue)
edges, X_edge_features = get_edge_features(X_features)
X_train_edge_features = np.array( [(np.array(X_features[i]), np.array(edges), np.array(X_edge_features[i]) ) \
for i in range(len(X_no_features_df))] )
print(X_train_edge_features[0][0].shape)
print(X_train_edge_features[0][1].shape)
print(X_train_edge_features[0][2].shape)
Y = [[most_popular_heroes.index(i) for i in y] for y in Y_df]
#train model
inference = 'qpbo'
crf = EdgeFeatureGraphCRF(inference_method=inference)
#ssvm = learner(crf, inference_cache=50, C=0.01, tol=.01, max_iter=100)
ssvm = learner(crf)
X_train = X_train_edge_features[:1800]
Y_train = Y[:1800]
X_test = X_train_edge_features[1800:]
Y_test = Y[1800:]
ssvm.fit(X_train, np.array(Y_train))
#evaluate
Y_train_pred = ssvm.predict(X_train)
accuracy = lambda Y_predicted, Y_actual: np.average([sum(Y_predicted[i] == Y_actual[i])/5 \
for i in range(len(Y_predicted))])
print("Train accuracy: ", accuracy(Y_train_pred, Y_train))
Y_test_pred = ssvm.predict(X_test)
print("Test accuracy: ", accuracy(Y_test_pred, Y_test))
trainFilename = "data/Y_train_predictions_popularity_" + str(usePopularity) \
+ "_default_" + str(defaultValue) + ".pkl"
testFilename = "data/Y_test_predictions_popularity_" + str(usePopularity) \
+ "_default_" + str(defaultValue) + ".pkl"
with open(trainFilename, 'wb') as f:
pickle.dump(Y_train_pred, f)
with open(testFilename, 'wb') as f:
pickle.dump(Y_test_pred, f)
for j in np.unique(labels):
this_sp_mask = np.where(labels == j)
this_gt_sp = gt_imgs[i][this_sp_mask[0], this_sp_mask[1]]
#this_y = np.asarray([hp.value_to_class(this_gt_sp,foreground_threshold) for j in range(len(gt_patches[i]))]).reshape(int(gt_imgs[0].shape[0]/grid_step),int(gt_imgs[0].shape[0]/grid_step)).ravel()
this_y.append(hp.value_to_class(this_gt_sp, foreground_threshold))
Y.append(np.asarray(this_y))
# train a logistic regression classifier
from sklearn import (linear_model, svm, preprocessing)
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
print("Training SSVM")
inference = 'qpbo'
# first, train on X with directions only:
crf = EdgeFeatureGraphCRF(inference_method=inference)
ssvm = OneSlackSSVM(crf,
inference_cache=50,
C=1.,
tol=.1,
max_iter=500,
n_jobs=4)
Y_flat = [y_.ravel() for y_ in Y]
Y_flat = np.asarray(
[Y_flat[i][j] for i in range(len(Y_flat)) for j in range(len(Y_flat[i]))])
ssvm.fit(X, Y)
Z_bin = ssvm.predict(X)
Z_flat = np.asarray(
[Z_bin[i][j] for i in range(len(Z_bin)) for j in range(len(Z_bin[i]))])
f1_score = metrics.f1_score(Y_flat, Z_flat, average='weighted')
class Model:
def __init__(self, X, y, learners, learners_parameters, models, models_parameters, total_label_one_avg, row_threshold):
saved_args = locals()
del saved_args['X'] # preventing from logging
del saved_args['y'] # preventing from logging
Arguments.logArguments('Model', saved_args)
self.X = X
self.y = y
self.learners = learners
self.learners_parameters = learners_parameters
self.models = models
self.models_parameters = models_parameters
self.total_label_one_avg = total_label_one_avg
self.row_threshold = row_threshold # needed to define graph model
self.total_accuracy_list = list() # each image and relevance accuracy
return
def run(self):
self.check_input()
self.define_model()
self.define_learners()
self.fit_model()
# self.inference()
# self.train_accuracy()
return
def check_input(self):
if self.learners not in ['OneSlackSSVM', 'SubgradientSSVM', 'StructuredPerceptron']:
raise('learners is not supported: ' + str(self.learners))
if self.models not in ['GraphCRF', 'GridCRF', 'EdgeFeatureGraphCRF']:
raise ('learners is not supported: ' + str(self.learners))
if self.models_parameters['neighborhood'] not in [4,8]:
raise ('neighborhood number must be 4/8')
return
def define_model(self):
if self.models == 'GridCRF':
from pystruct.models import GridCRF
self.crf = GridCRF(
neighborhood=self.models_parameters['neighborhood'],
inference_method=self.models_parameters['inference']
)
if self.models == 'GraphCRF':
self.prepare_data_to_graph_crf()
logging.info('Class weight: ' + str([self.total_label_one_avg,1-self.total_label_one_avg]))
from pystruct.models import GraphCRF
self.crf = GraphCRF(
inference_method=self.models_parameters['inference'],
directed = self.models_parameters['directed'],
class_weight = [self.total_label_one_avg,1-self.total_label_one_avg]
# class_weight=[0.01, 0.99]
)
if self.models == 'EdgeFeatureGraphCRF':
self.prepare_data_to_edge_feature_graph_crf()
logging.info('Class weight: ' + str([self.total_label_one_avg, 1 - self.total_label_one_avg]))
from pystruct.models import EdgeFeatureGraphCRF
self.crf = EdgeFeatureGraphCRF(
inference_method=self.models_parameters['inference'],
# directed=self.models_parameters['directed'],
class_weight=[self.total_label_one_avg, 1 - self.total_label_one_avg]
# class_weight=[0.01, 0.99]
)
return
def define_learners(self):
if self.learners == 'OneSlackSSVM':
import pystruct.learners as ssvm
self.clf = ssvm.OneSlackSSVM(
model=self.crf,
# C=100,
# inference_cache=100,
# tol=.1,
verbose=self.learners_parameters['verbose'],
max_iter=self.learners_parameters['max_iter'],
n_jobs=self.learners_parameters['n_jobs']
)
if self.learners == 'SubgradientSSVM':
import pystruct.learners as ssvm
self.clf = ssvm.OneSlackSSVM(
model=self.crf,
# C=100,
# inference_cache=100,
# tol=.1,
verbose=self.learners_parameters['verbose'],
max_iter=self.learners_parameters['max_iter'],
n_jobs=self.learners_parameters['n_jobs'],
show_loss_every = self.learners_parameters['show_loss_every']
)
if self.learners == 'StructuredPerceptron':
import pystruct.learners as structured_perceptron
self.clf = structured_perceptron.StructuredPerceptron(
model=self.crf,
# C=100,
# inference_cache=100,
# tol=.1,
verbose=self.learners_parameters['verbose'],
max_iter=self.learners_parameters['max_iter'],
n_jobs=self.learners_parameters['n_jobs'],
# show_loss_every=self.learners_parameters['show_loss_every']
)
return
def fit_model(self):
logging.info("Start fit model")
self.clf.fit(self.X, self.y)
self.w = self.clf.w
# self.objective_curve_ = self.clf.objective_curve_
# self.training_timestamps = self.clf.timestamps_
# self.loss_curve_ = self.clf.loss_curve_
logging.info('weight after fit:')
logging.info(self.w)
# logging.info('objective curve: (cutting plane objective)')
# logging.info(self.objective_curve_)
# logging.info('loss curve: (current loss)')
# logging.info(self.loss_curve_)
logging.info('training time each iteration:')
# logging.info(self.training_timestamps)
# logging.info("Finish fit model")
return
# not in use (in eval class we use inference)
def inference(self):
logging.info("Start inference - crf.inference")
for index, cur_nd_array in enumerate(self.X):
predict_picture = self.crf.inference(cur_nd_array, self.w)
logging.info('inference result number: ' + str(index))
# logging.info(predict_picture)
# logging.info(self.y[index])
accuracy = self.calculate_metrics(predict_picture, self.y[index])
self.total_accuracy_list.append(accuracy)
logging.info('accuracy: ' + str(accuracy))
# logging.info('F1 macro: ' + str(f1_score(predict_picture, self.y[index], average='macro')))
# logging.info('F1 micro: ' + str(f1_score(predict_picture, self.y[index], average='micro')))
logging.info('Total accuracy: ' + str(sum(self.total_accuracy_list)/len(self.total_accuracy_list)))
logging.info("Finish inference")
return
def calculate_metrics(self, predict_picture, real_picture):
row_loss = list()
for i, c_list in enumerate(predict_picture):
row_loss.append(zero_one_loss(c_list, real_picture[i]))
return 1- sum(row_loss)/len(row_loss)
def prepare_data_to_graph_crf(self):
from pystruct.utils import make_grid_edges, edge_list_to_features
self.X_flatten = []
self.y_flatten = []
for pic_i, pic_nd_array in enumerate(self.X):
pic_item = list()
cell_index_place = 0
for row_i, row_val in enumerate(pic_nd_array): # pic item
for col_i, cell_features in enumerate(row_val): # pic row iteration cell by cell
pic_item.append(cell_features)
if self.models_parameters['neighborhood'] == 4:
right, down = make_grid_edges(pic_nd_array, neighborhood=4, return_lists=True)
# right, down, upright, downright = make_grid_edges(pic_nd_array, neighborhood=8, return_lists=True)
edges = np.vstack([right, down])
elif self.models_parameters['neighborhood'] == 8:
right, down, upright, downright = make_grid_edges(pic_nd_array, neighborhood=8, return_lists=True)
edges = np.vstack([right, down, upright, downright])
# for val in range
# Guy version - old
# edges_item = list()
# max_cell_index = self.row_threshold * self.row_threshold
# last_row_first_index = max_cell_index - self.row_threshold # e.g. 36-6
# for i in range(0, max_cell_index):
# if i<last_row_first_index: # except last row
# edges_item.append(np.array([i, i + self.row_threshold]))
#
# if (i+1)%self.row_threshold != 0: # except last col
# edges_item.append(np.array([i, i + 1]))
# finish iterate picture
self.X_flatten.append((np.array(pic_item), edges))
for pic_i, pic_nd_array in enumerate(self.y):
pic_item = list()
for row_i, row_val in enumerate(pic_nd_array): # pic item
for col_i, cell_features in enumerate(row_val): # pic row iteration cell by cell
pic_item.append(cell_features)
self.y_flatten.append(pic_item)
self.X = np.array(self.X_flatten)
self.y = np.array(self.y_flatten)
return
def prepare_data_to_edge_feature_graph_crf(self):
from pystruct.utils import make_grid_edges, edge_list_to_features
self.X_flatten = []
self.y_flatten = []
for pic_i, pic_nd_array in enumerate(self.X):
pic_item = list()
for row_i, row_val in enumerate(pic_nd_array): # pic item
for col_i, cell_features in enumerate(row_val): # pic row iteration cell by cell
pic_item.append(cell_features)
if self.models_parameters['neighborhood'] == 4:
# 4 neigh and cross type
if 'type' in self.models_parameters and self.models_parameters['type'] == 'cross_edge':
upright, downright = self.cross_make_grid_edges(pic_nd_array, neighborhood=4, return_lists=True)
edges = np.vstack([upright, downright])
edge_features_directions = self.edge_list_to_features([upright, downright], 4)
else: # regular
right, down = make_grid_edges(pic_nd_array, neighborhood=4, return_lists=True)
edges = np.vstack([right, down])
edge_features_directions = self.edge_list_to_features([right, down], 4)
elif self.models_parameters['neighborhood'] == 8:
right, down, upright, downright = make_grid_edges(pic_nd_array, neighborhood=8, return_lists=True)
edges = np.vstack([right, down, upright, downright])
edge_features_directions = self.edge_list_to_features([right, down, upright, downright], 8)
# finish iterate picture - (pixel feature (list), edge (pixel-pixel) list)
self.X_flatten.append((np.array(pic_item), edges, edge_features_directions))
for pic_i, pic_nd_array in enumerate(self.y):
pic_item = list()
for row_i, row_val in enumerate(pic_nd_array): # pic item
for col_i, cell_features in enumerate(row_val): # pic row iteration cell by cell
pic_item.append(cell_features)
self.y_flatten.append(pic_item)
self.X = np.array(self.X_flatten)
self.y = np.array(self.y_flatten)
return
# add direction feature to each edge
def edge_list_to_features(self, edge_list, neighborhood):
edges = np.vstack(edge_list)
if neighborhood == 4:
edge_features = np.zeros((edges.shape[0], 2))
edge_features[:len(edge_list[0]), 0] = 1
edge_features[len(edge_list[0]):, 1] = 1
elif neighborhood == 8:
limit_0 = len(edge_list[0])
limit_1 = len(edge_list[0]) + len(edge_list[1])
limit_2 = len(edge_list[0]) + len(edge_list[1]) + len(edge_list[2])
limit_3 = len(edge_list[0]) + len(edge_list[1]) + len(edge_list[2]) + + len(edge_list[3])
edge_features = np.zeros((edges.shape[0], 4))
edge_features[:limit_0, 0] = 1
edge_features[limit_0:limit_1, 1] = 1
edge_features[limit_1:limit_2, 2] = 1
edge_features[limit_2:limit_3, 3] = 1
else:
raise('number neighborhood is not supported 4/8')
return edge_features
def cross_make_grid_edges(self, x, neighborhood=4, return_lists=False):
if neighborhood not in [4]:
raise ValueError("neighborhood can only be '4', got %s" %
repr(neighborhood))
inds = np.arange(x.shape[0] * x.shape[1]).reshape(x.shape[:2])
inds = inds.astype(np.int64)
upright = np.c_[inds[1:, :-1].ravel(), inds[:-1, 1:].ravel()]
downright = np.c_[inds[:-1, :-1].ravel(), inds[1:, 1:].ravel()]
edges = [upright, downright]
if return_lists:
return edges
return np.vstack(edges)
print str(end - start)
########################################################################
import time
start = time.time()
from sklearn.preprocessing import label_binarize
from sklearn.metrics import confusion_matrix, accuracy_score
from pystruct.learners import OneSlackSSVM
from pystruct.datasets import load_snakes
from pystruct.utils import make_grid_edges, edge_list_to_features
from pystruct.models import EdgeFeatureGraphCRF
inference = 'ad3'
# first, train on X with directions only:
crf = EdgeFeatureGraphCRF(inference_method=inference,
class_weight=np.array([
1.0, 1, 1, 1, 1
])) #class_weight=np.array([0.15,0.1,0.05,0.05,0.65]
ssvm = OneSlackSSVM(crf,
inference_cache=50,
C=.1,
tol=.1,
max_iter=200,
n_jobs=1,
show_loss_every=0)
ssvm.fit(X_train, Y_train)
end = time.time()
print str(end - start)
####################################################################
import time
train_inds = []
test_inds = []
for i in range(len(X)):
if i % 2 == 0:
test_inds.append(i)
else:
train_inds.append(i)
train_inds = np.array(train_inds)
test_inds = np.array(test_inds)
X_train, X_test = X[train_inds], X[test_inds]
Y_train, Y_test = Y[train_inds], Y[test_inds]
crf = EdgeFeatureGraphCRF()
ssvm = NSlackSSVM(crf,
check_constraints=False,
max_iter=50,
batch_size=1,
tol=0.1,
n_jobs=-1,
verbose=3)
print("Training started")
start = time.time()
ssvm.fit(X_train, Y_train)
train_time = time.time() - start
print("Training completed and testing started")
Y.append(thread.getLabel())
nodeList = []
nodeList.append(node)
preID = node.id
line = fin_data.readline().strip()
thread = Thread(preID, nodeList)
thread.setNodeFeatures(node_features)
thread.setEdgeFeatures(edge_features)
thread.extractFeatures()
threads.append(thread)
X.append(thread.getInstance(addVec=True))
Y.append(thread.getLabel())
print len(threads)
folds.append({'threads': threads, 'X': X, 'Y': Y})
crf = EdgeFeatureGraphCRF(n_states=3, n_features=len(node_features) + dictLength,
n_edge_features=len(edge_features), class_weight=[1.3, 0.8, 1.0])
ssvm = OneSlackSSVM(crf, inference_cache=100, C=.1, tol=.2, max_iter=2000, n_jobs=3)
accuracy = 0.0
total_correct = 0
total = 0
precision = {0: [0, 0], 1: [0, 0], 2: [0, 0]}
recall = {0: [0, 0], 1: [0, 0], 2: [0, 0]}
for fold in range(5):
print 'fold ' + str(fold) + "--------------------------"
X = []
Y = []
for i in range(5):
if i == fold:
continue
X.extend(folds[i]['X'])
def main():
print("Please be patient. Will take 5-20 minutes.")
snakes = load_snakes()
X_train, Y_train = snakes['X_train'], snakes['Y_train']
X_train = [one_hot_colors(x) for x in X_train]
Y_train_flat = [y_.ravel() for y_ in Y_train]
X_train_directions, X_train_edge_features = prepare_data(X_train)
if 'ogm' in get_installed():
inference = ('ogm', {'alg': 'fm'})
else:
inference = 'qpbo'
# first, train on X with directions only:
crf = EdgeFeatureGraphCRF(inference_method=inference)
ssvm = OneSlackSSVM(crf,
inference_cache=50,
C=.1,
tol=.1,
max_iter=100,
n_jobs=1)
ssvm.fit(X_train_directions, Y_train_flat)
# Evaluate using confusion matrix.
# Clearly the middel of the snake is the hardest part.
X_test, Y_test = snakes['X_test'], snakes['Y_test']
X_test = [one_hot_colors(x) for x in X_test]
Y_test_flat = [y_.ravel() for y_ in Y_test]
X_test_directions, X_test_edge_features = prepare_data(X_test)
Y_pred = ssvm.predict(X_test_directions)
print("Results using only directional features for edges")
print("Test accuracy: %.3f" %
accuracy_score(np.hstack(Y_test_flat), np.hstack(Y_pred)))
print(confusion_matrix(np.hstack(Y_test_flat), np.hstack(Y_pred)))
# now, use more informative edge features:
crf = EdgeFeatureGraphCRF(inference_method=inference)
ssvm = OneSlackSSVM(crf,
inference_cache=50,
C=.1,
tol=.1,
switch_to='ad3',
n_jobs=1)
ssvm.fit(X_train_edge_features, Y_train_flat)
Y_pred2 = ssvm.predict(X_test_edge_features)
print("Results using also input features for edges")
print("Test accuracy: %.3f" %
accuracy_score(np.hstack(Y_test_flat), np.hstack(Y_pred2)))
print(confusion_matrix(np.hstack(Y_test_flat), np.hstack(Y_pred2)))
# plot stuff
fig, axes = plt.subplots(2, 2)
axes[0, 0].imshow(snakes['X_test'][0], interpolation='nearest')
axes[0, 0].set_title('Input')
y = Y_test[0].astype(np.int)
bg = 2 * (y != 0) # enhance contrast
axes[0, 1].matshow(y + bg, cmap=plt.cm.Greys)
axes[0, 1].set_title("Ground Truth")
axes[1, 0].matshow(Y_pred[0].reshape(y.shape) + bg, cmap=plt.cm.Greys)
axes[1, 0].set_title("Prediction w/o edge features")
axes[1, 1].matshow(Y_pred2[0].reshape(y.shape) + bg, cmap=plt.cm.Greys)
axes[1, 1].set_title("Prediction with edge features")
for a in axes.ravel():
a.set_xticks(())
a.set_yticks(())
plt.show()
from IPython.core.debugger import Tracer
Tracer()()
from pystruct.models import GraphCRF, EdgeFeatureGraphCRF
def make_edges(n_nodes):
return np.c_[np.arange(n_nodes - 1), np.arange(1, n_nodes)]
X_graph = np.array([(x, make_edges(len(x))) for x in X])
X_graph_train, X_graph_test = X_graph[folds == 1], X_graph[folds != 1]
graph_model = GraphCRF(inference_method="max-product", directed=True)
ssvm = FrankWolfeSSVM(model=graph_model, C=.1, max_iter=11)
ssvm.fit(X_graph_train, y_train)
print("score with GraphCRF %f" % ssvm.score(X_graph_test, y_test))
X_edge_features = np.array([(x, make_edges(len(x)), np.ones(len(x)) - 1)[:, np.newaxis] for x in X])
X_edge_features_train, X_edge_features_test = X_edge_features[folds == 1], X_edge_features[folds != 1]
edge_feature_model = EdgeFeatureGraphCRF(inference_method="max-product")
ssvm = FrankWolfeSSVM(model=edge_feature_model, C=.1, max_iter=11)
ssvm.fit(X_edge_features_train, y_train)
print("score with GraphCRF %f" % ssvm.score(X_edge_features_test, y_test))
def main():
default_train = \
scriptdir+'/../../../data/compression/googlecomp100.train.lbl'
default_test = \
scriptdir+'/../../../data/compression/googlecomp.dev.lbl'
parser = argparse.ArgumentParser()
parser.add_argument('--threshold',
'-t',
type=float,
help='Threshold for predicting 0/1. ')
parser.add_argument('--iterations',
'-i',
type=int,
default=50,
help='Training iterations.')
parser.add_argument('--data',
'-d',
default=default_train,
help='Features and labels')
parser.add_argument('--testdata',
default=default_test,
help='Test data (not needed for crossval).')
parser.add_argument('--verbose',
'-v',
dest='verbose',
action='store_true',
help='Print avg. loss at every iter.')
parser.add_argument('--output', '-o', help="Output file")
parser.add_argument('--features',
'-f',
dest='features',
default=[],
type=str,
nargs='+',
help='Used feature types')
parser.add_argument('--train',
action='store_true',
help='If set, will train the model')
args = parser.parse_args()
featurizer = edge_featurize.Featurizer(args.features)
X, y = featurizer.fit_transform(default_train)
crf = EdgeFeatureGraphCRF(inference_method="max-product")
model = FrankWolfeSSVM(model=crf, C=.1, max_iter=args.iterations)
model.fit(X, y)
if args.testdata:
X_te, y_te = featurizer.transform(args.testdata)
pred = model.predict(X_te)
pred_flat = [item for sublist in pred for item in sublist]
y_te_flat = [item for sublist in y_te for item in sublist]
if args.output:
with open(args.output, 'w') as of:
for sent_pred in pred:
for lid in sent_pred:
# print(lid)
of.write('%s\n' % featurizer.mapper.id2label[lid])
of.write('\n')
res = evaluate(pred_flat, y_te_flat)
resout = "F1: %f, R: %f, A: %f, P: %f\n" % res
print(resout)
test = indices[i][1]
mean_cac = np.array(map(np.mean, labels))
# sure there's a more efficient way to do this
# --- Test/train split --- #
X_train = [examples[j] for j in train]
Y_train = [labels[j] for j in train]
X_test = [examples[j] for j in test]
Y_test = [labels[j] for j in test]
# if verbose:
# print np.mean(map(np.mean,Y_train)), 'pm',np.var(map(np.mean,Y_train))
# print np.mean(map(np.mean,Y_test)), 'pm',np.var(map(np.mean,Y_test))
# --- Train model --- #
model = EdgeFeatureGraphCRF(n_states, n_features, n_edge_features)
ssvm = NSlackSSVM(model=model,
C=0.1,
tol=0.001,
verbose=0,
show_loss_every=10)
# ssvm = OneSlackSSVM(model=model, C=.1, inference_cache=50, tol=0.1, verbose=0,show_loss_every=10)
ssvm.fit(X_train, Y_train)
# --- Test with pystruct --- #
# print("Test score with graph CRF: %f" % ssvm.score(X_test, Y_test))
# --- Test manually - get contingency tables --- #
prediction = ssvm.predict(X_test)
contingency = np.array([0, 0, 0, 0])
