Esempio n. 1
0
def experiment_anomaly_detection(train, test, comb, num_train, anom_prob, labels):
	phi = calc_feature_vecs(comb.X)
	print phi.size

	# bayes classifier
	(DIMS, N) = phi.size
	w_bayes = co.matrix(1.0, (DIMS, 1))
	pred = w_bayes.trans()*phi[:,num_train:]
	(fpr, tpr, thres) = metric.roc_curve(labels[num_train:], pred.trans())
	bayes_auc = metric.auc(fpr, tpr)

	# train one-class svm
	kern = Kernel.get_kernel(phi[:,0:num_train], phi[:,0:num_train])
	ocsvm = OCSVM(kern, C=1.0/(num_train*anom_prob))
	ocsvm.train_dual()
	kern = Kernel.get_kernel(phi, phi)
	(oc_as, foo) = ocsvm.apply_dual(kern[num_train:,ocsvm.get_support_dual()])
	(fpr, tpr, thres) = metric.roc_curve(labels[num_train:], oc_as)
	base_auc = metric.auc(fpr, tpr)
	if (base_auc<0.5):
	    base_auc = 1.0-base_auc

	# train structured anomaly detection
	#sad = StructuredOCSVM(train, C=1.0/(num_train*anom_prob))
	sad = StructuredOCSVM(train, C=1.0/(num_train*0.5))
	(lsol, lats, thres) = sad.train_dc(max_iter=50)
	(pred_vals, pred_lats) = sad.apply(test)
	(fpr, tpr, thres) = metric.roc_curve(labels[num_train:], pred_vals)
	auc = metric.auc(fpr, tpr)
	if (auc<0.5):
	    auc = 1.0-auc

	return (auc, base_auc, bayes_auc)
Esempio n. 2
0
def experiment_anomaly_segmentation(train, test, comb, num_train, anom_prob, labels):

	# transductive train/pred for structured anomaly detection
	sad = StructuredOCSVM(comb, C=1.0/(num_train*0.5))
	(lsol, lats, thres) = sad.train_dc(max_iter=40)
	(cont, cont_exm) = test.evaluate(lats[num_train:])

	# train structured svm
	ssvm = SSVM(train)
	(sol, slacks) = ssvm.train()
	(vals, preds) = ssvm.apply(test)
	(base_cont, base_cont_exm) = test.evaluate(preds)

	return (cont, base_cont)
Esempio n. 3
0
def experiment_anomaly_segmentation(train, test, comb, num_train, anom_prob,
                                    labels):

    # transductive train/pred for structured anomaly detection
    sad = StructuredOCSVM(comb, C=1.0 / (num_train * 0.5))
    (lsol, lats, thres) = sad.train_dc(max_iter=40)
    (cont, cont_exm) = test.evaluate(lats[num_train:])

    # train structured svm
    ssvm = SSVM(train)
    (sol, slacks) = ssvm.train()
    (vals, preds) = ssvm.apply(test)
    (base_cont, base_cont_exm) = test.evaluate(preds)

    return (cont, base_cont)
Esempio n. 4
0
def experiment_anomaly_detection(train, test, comb, num_train, anom_prob, labels):
	# train one-class svm
	phi = calc_feature_vecs(comb.X)
	kern = Kernel.get_kernel(phi[:,0:num_train], phi[:,0:num_train])
	ocsvm = OCSVM(kern, C=1.0/(num_train*anom_prob))
	ocsvm.train_dual()
	kern = Kernel.get_kernel(phi, phi)
	(oc_as, foo) = ocsvm.apply_dual(kern[num_train:,ocsvm.get_support_dual()])
	(fpr, tpr, thres) = metric.roc_curve(labels[num_train:], oc_as)
	base_auc = metric.auc(fpr, tpr)

	# train structured anomaly detection
	sad = StructuredOCSVM(train, C=1.0/(num_train*anom_prob))
	(lsol, lats, thres) = sad.train_dc(max_iter=40)
	(pred_vals, pred_lats) = sad.apply(test)
	(fpr, tpr, thres) = metric.roc_curve(labels[num_train:], pred_vals)
	auc = metric.auc(fpr, tpr)

	return (auc, base_auc)
Esempio n. 5
0
def experiment_anomaly_detection(train, test, comb, num_train, anom_prob,
                                 labels):
    # train one-class svm
    phi = calc_feature_vecs(comb.X)
    kern = Kernel.get_kernel(phi[:, 0:num_train], phi[:, 0:num_train])
    ocsvm = OCSVM(kern, C=1.0 / (num_train * anom_prob))
    ocsvm.train_dual()
    kern = Kernel.get_kernel(phi, phi)
    (oc_as, foo) = ocsvm.apply_dual(kern[num_train:, ocsvm.get_support_dual()])
    (fpr, tpr, thres) = metric.roc_curve(labels[num_train:], oc_as)
    base_auc = metric.auc(fpr, tpr)

    # train structured anomaly detection
    sad = StructuredOCSVM(train, C=1.0 / (num_train * anom_prob))
    (lsol, lats, thres) = sad.train_dc(max_iter=40)
    (pred_vals, pred_lats) = sad.apply(test)
    (fpr, tpr, thres) = metric.roc_curve(labels[num_train:], pred_vals)
    auc = metric.auc(fpr, tpr)

    return (auc, base_auc)
Esempio n. 6
0
		lens = len(X[i][0,:])
		cnt += lens
		tst_mean += co.matrix(1.0, (1, lens))*X[i].trans()
	print tst_mean/float(cnt)

	return X


if __name__ == '__main__':
	EXMS_TRAIN = 80
	EXMS_TEST = 100
	EXMS_COMB = EXMS_TRAIN+EXMS_TEST

	(train, test, comb, label, phi) = get_model(EXMS_COMB, EXMS_TRAIN)
	lsvm = StructuredOCSVM(train, C=1.0/(train.samples*0.5))
	(lsol, lats, thres) = lsvm.train_dc(max_iter=100)
	(err, err_exm) = train.evaluate(lats)
	print err

	plt.figure()
	scores = []
	for i in range(train.samples):
	 	LENS = len(train.y[i])
	 	(anom_score, scores_exm) = train.get_scores(lsol, i, lats[i])
	 	scores.append(anom_score)
	 	plt.plot(range(LENS),scores_exm.trans() + i*8,'-g')

	 	plt.plot(range(LENS),train.y[i].trans() + i*8,'-b')
	 	plt.plot(range(LENS),lats[i].trans() + i*8,'-r')

	 	if i==0:
Esempio n. 7
0
	# for all methods
	fig = plt.figure()
	for i in xrange(4):
		plt.subplot(2,4,i+1)
		
		if i==0:
			plt.title("LatentSVDD")
			lsvdd.train_dc()
			(scores,lats) = lsvdd.apply(predsobj)
		if i==1:
			plt.title("StructPCA")
			spca.train_dc()
			(scores,lats) = spca.apply(predsobj)
		if i==2:
			plt.title("StructOCSVM")
			socsvm.train_dc()
			(scores,lats) = socsvm.apply(predsobj)
		if i==3:
			plt.title("SSVM")
			ssvm.train()
			(scores,lats) = ssvm.apply(predsobj)

		# plot scores
		Z = np.reshape(scores,(sx,sy))
		plt.contourf(X, Y, Z)
		plt.scatter(Dtrain[0,:],Dtrain[1,:],10)

		# plot latent variable
		Z = np.reshape(lats,(sx,sy))
		plt.subplot(2,4,i+4+1)
		plt.contourf(X, Y, Z)
Esempio n. 8
0
    # for all methods
    fig = plt.figure()
    for i in xrange(4):
        plt.subplot(2, 4, i + 1)

        if i == 0:
            plt.title("LatentSVDD")
            lsvdd.train_dc()
            (scores, lats) = lsvdd.apply(predsobj)
        if i == 1:
            plt.title("StructPCA")
            spca.train_dc()
            (scores, lats) = spca.apply(predsobj)
        if i == 2:
            plt.title("StructOCSVM")
            socsvm.train_dc()
            (scores, lats) = socsvm.apply(predsobj)
        if i == 3:
            plt.title("SSVM")
            ssvm.train()
            (scores, lats) = ssvm.apply(predsobj)

        # plot scores
        Z = np.reshape(scores, (sx, sy))
        plt.contourf(X, Y, Z)
        plt.scatter(Dtrain[0, :], Dtrain[1, :], 10)

        # plot latent variable
        Z = np.reshape(lats, (sx, sy))
        plt.subplot(2, 4, i + 4 + 1)
        plt.contourf(X, Y, Z)