Example #1
0
def get_model(num_exm, num_train, lens, feats, anomaly_prob=0.15):
	print('Generating {0} sequences, {1} for training, each with {2} anomaly probability.'.format(num_exm, num_train, anomaly_prob))
	mean = 0.0
	cnt = 0 
	X = [] 
	Y = []
	label = []
	for i in range(num_exm):
		(exm, lbl, marker) = ToyData.get_2state_gaussian_seq(lens,dims=feats,anom_prob=anomaly_prob)
		#if i<4:
		#	(exm,lbl) = ToyData.get_2state_gaussian_seq(LENS,dims=2,means1=[1,-3],means2=[3,7],vars1=[1,1],vars2=[1,1])
		mean += co.matrix(1.0, (1, lens))*exm.trans()
		cnt += lens
		X.append(exm)
		Y.append(lbl)
		label.append(marker)

	mean = mean / float(cnt)
	for i in range(num_exm):
		#if (i<10):
		#	pos = int(np.single(co.uniform(1))*float(LENS)*0.8 + 4.0)
		#	print pos
		#	trainX[i][1,pos] = 100.0
		for d in range(feats):
			X[i][d,:] = X[i][d,:]-mean[d]
	return (SOHMM(X[0:num_train],Y[0:num_train]), SOHMM(X[num_train:],Y[num_train:]), SOHMM(X,Y), label)
Example #2
0
def get_model(num_exm,
              num_train,
              lens,
              block_len,
              blocks=1,
              anomaly_prob=0.15):
    print(
        'Generating {0} sequences, {1} for training, each with {2} anomaly probability.'
        .format(num_exm, num_train, anomaly_prob))
    cnt = 0
    X = []
    Y = []
    label = []
    lblcnt = co.matrix(0.0, (1, lens))
    for i in range(num_exm):
        (exm, lbl,
         marker) = ToyData.get_2state_anom_seq(lens,
                                               block_len,
                                               anom_prob=anomaly_prob,
                                               num_blocks=blocks)
        cnt += lens
        X.append(exm)
        Y.append(lbl)
        label.append(marker)
        # some lbl statistics
        if i < num_train:
            lblcnt += lbl
    X = normalize_sequence_data(X)
    return (SOHMM(X[0:num_train],
                  Y[0:num_train]), SOHMM(X[num_train:],
                                         Y[num_train:]), SOHMM(X, Y), label)
def get_model(num_exm, num_train, lens, feats, anomaly_prob=0.15):
    print(
        'Generating {0} sequences, {1} for training, each with {2} anomaly probability.'
        .format(num_exm, num_train, anomaly_prob))
    mean = 0.0
    cnt = 0
    X = []
    Y = []
    label = []
    for i in range(num_exm):
        (exm, lbl,
         marker) = ToyData.get_2state_gaussian_seq(lens,
                                                   dims=feats,
                                                   anom_prob=anomaly_prob)
        #if i<4:
        #	(exm,lbl) = ToyData.get_2state_gaussian_seq(LENS,dims=2,means1=[1,-3],means2=[3,7],vars1=[1,1],vars2=[1,1])
        mean += co.matrix(1.0, (1, lens)) * exm.trans()
        cnt += lens
        X.append(exm)
        Y.append(lbl)
        label.append(marker)

    mean = mean / float(cnt)
    for i in range(num_exm):
        #if (i<10):
        #	pos = int(np.single(co.uniform(1))*float(LENS)*0.8 + 4.0)
        #	print pos
        #	trainX[i][1,pos] = 100.0
        for d in range(feats):
            X[i][d, :] = X[i][d, :] - mean[d]
    return (SOHMM(X[0:num_train],
                  Y[0:num_train]), SOHMM(X[num_train:],
                                         Y[num_train:]), SOHMM(X, Y), label)
Example #4
0
def get_model(num_exm, num_train, lens, block_len, blocks=1, anomaly_prob=0.15):
	print('Generating {0} sequences, {1} for training, each with {2} anomaly probability.'.format(num_exm, num_train, anomaly_prob))
	cnt = 0 
	X = [] 
	Y = []
	label = []
	for i in range(num_exm):
		(exm, lbl, marker) = ToyData.get_2state_anom_seq(lens, block_len, anom_prob=anomaly_prob, num_blocks=blocks)
		cnt += lens
		X.append(exm)
		Y.append(lbl)
		label.append(marker)
	X = remove_mean(X,1)
	return (SOHMM(X[0:num_train],Y[0:num_train]), SOHMM(X[num_train:],Y[num_train:]), SOHMM(X,Y), label)
Example #5
0
def plot_icml_toy_seqs():
    from toydata import ToyData
    lens = 600
    blocks = [1, 2, 5, 10, 20, 40, 60, 100]
    data = []
    lbl = []
    for i in blocks:
        (exm, label, marker) = ToyData.get_2state_anom_seq(lens,
                                                           120,
                                                           anom_prob=1.0,
                                                           num_blocks=i)
        data.append(exm)
        lbl.append(label)

    plt.figure(1)
    style = ['-', '--', '-', '.-', '--', '-', '-', '-', '-', '--']
    marker = ['D', 'o', '^', 'D', 's', '^', 'D', 's', 's', 'o']
    colors = ['r', 'b', 'm', 'm', 'm', 'c', 'c', 'c', 'g', 'g']
    alphas = [1., 0.9, .8, .6, .4, .8, .6, .4, 1., .6]
    widths = [2, 4, 1, 4, 8, 1, 4, 8, 1, 8]

    ys = []
    for i in [0, -1]:
        ys.append(i * 10)
        plt.plot(range(lens), np.array(data[i]).T + ys[-1], \
            color='r', linewidth=2, alpha=0.6, marker='')
        plt.plot(range(lens), np.array(lbl[i]).T + ys[-1], \
            color='k', linewidth=2, alpha=0.8, marker='')

    #plt.yscale('log')
    plt.xticks([0, 300, 600], ['0', '300', '600'], fontsize=16)
    plt.yticks(ys, ['0%', '100%'], fontsize=16)
    plt.ylabel('Percentage of disorganization', fontsize=18)
    plt.xlabel('Sequence position', fontsize=18)
    plt.legend(['Noisy observations', 'True state sequence'],
               fontsize=18,
               fancybox=True,
               framealpha=0.7)
    plt.show()
import cvxopt as co
import numpy as np
import pylab as pl
import matplotlib.pyplot as plt

from ssvm import SSVM
from so_multiclass import SOMultiClass
from toydata import ToyData

if __name__ == '__main__':
    NUM_CLASSES = 4

    # generate raw training data
    Dtrain1 = ToyData.get_gaussian(1000,
                                   dims=2,
                                   means=[4.0, 2.0],
                                   vars=[1.0, 0.3])
    Dtrain2 = ToyData.get_gaussian(100,
                                   dims=2,
                                   means=[-2.0, 1.0],
                                   vars=[0.3, 1.3])
    Dtrain3 = ToyData.get_gaussian(100,
                                   dims=2,
                                   means=[3.0, -1.0],
                                   vars=[0.3, 0.3])
    Dtrain4 = ToyData.get_gaussian(50,
                                   dims=2,
                                   means=[6.0, -3.0],
                                   vars=[0.2, 0.1])

    Dtrain = co.matrix([[Dtrain1], [Dtrain2], [Dtrain3], [Dtrain4]])
Example #7
0
import pylab as pl
import matplotlib.pyplot as plt

from ssvm import SSVM
from latentsvdd import LatentSVDD
from structured_ocsvm import StructuredOCSVM
from structured_pca import StructuredPCA
from so_multiclass import SOMultiClass
from toydata import ToyData


if __name__ == '__main__':
	NUM_CLASSES = 6

	# generate raw training data
	Dtrain1 = ToyData.get_gaussian(100,dims=2,means=[1.0,1.0],vars=[1.0,0.3])
	Dtrain2 = ToyData.get_gaussian(10,dims=2,means=[-2.0,1.0],vars=[0.3,1.3])
	Dtrain3 = ToyData.get_gaussian(10,dims=2,means=[3.0,-3.0],vars=[0.3,0.3])
	Dtrain4 = ToyData.get_gaussian(5,dims=2,means=[6.0,-3.0],vars=[0.2,0.1])

	Dtrain = co.matrix([[Dtrain1], [Dtrain2], [Dtrain3], [Dtrain4]])
	Dtrain = co.matrix([[Dtrain.trans()],[co.matrix(1.0,(125,1))]]).trans()
	Dy = co.matrix([co.matrix([0]*100), co.matrix([1]*10), co.matrix([2]*10), co.matrix([3]*5)])

	# generate structured object
	sobj = SOMultiClass(Dtrain, y=Dy , classes=NUM_CLASSES)

	# unsupervised methods
	lsvdd = LatentSVDD(sobj,1.0/(125.0*1.0))
	spca = StructuredPCA(sobj)
	socsvm = StructuredOCSVM(sobj,1.0/(125.0*1.0))