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 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 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])