Python PrimalMosekSOSVM 예제들

예제 #1

def so_multiclass(fm_train_real=traindat,
                  label_train_multiclass=label_traindat):
    try:
        from shogun.Features import RealFeatures
        from shogun.Loss import HingeLoss
        from shogun.Structure import MulticlassModel, MulticlassSOLabels, PrimalMosekSOSVM, RealNumber
    except ImportError:
        print("Mosek not available")
        return

    labels = MulticlassSOLabels(label_train_multiclass)
    features = RealFeatures(fm_train_real.T)

    model = MulticlassModel(features, labels)
    loss = HingeLoss()
    sosvm = PrimalMosekSOSVM(model, loss, labels)
    sosvm.train()

    out = sosvm.apply()
    count = 0
    for i in xrange(out.get_num_labels()):
        yi_pred = RealNumber.obtain_from_generic(out.get_label(i))
        if yi_pred.value == label_train_multiclass[i]:
            count = count + 1

    print("Correct classification rate: %0.2f" %
          (100.0 * count / out.get_num_labels()))

예제 #2

파일: so_multiclass.py 프로젝트: monalisag/shogun

def so_multiclass (fm_train_real=traindat,label_train_multiclass=label_traindat):
	try:
		from shogun.Features 	import RealFeatures
		from shogun.Loss     	import HingeLoss
		from shogun.Structure	import MulticlassModel, MulticlassSOLabels, PrimalMosekSOSVM, RealNumber
	except ImportError:
		print("Mosek not available")
		return

	labels = MulticlassSOLabels(label_train_multiclass)
	features = RealFeatures(fm_train_real.T)

	model = MulticlassModel(features, labels)
	loss = HingeLoss()
	sosvm = PrimalMosekSOSVM(model, loss, labels)
	sosvm.train()

	out = sosvm.apply()
	count = 0
	for i in xrange(out.get_num_labels()):
		yi_pred = RealNumber.obtain_from_generic(out.get_label(i))
		if yi_pred.value == label_train_multiclass[i]:
			count = count + 1

	print("Correct classification rate: %0.2f" % ( 100.0*count/out.get_num_labels() ))

예제 #3

파일: structure_discrete_hmsvm_mosek.py 프로젝트: hushell/shogun

def structure_discrete_hmsvm_mosek (m_data_dict=data_dict):
	from shogun.Features   import RealMatrixFeatures
	from shogun.Structure  import SequenceLabels, HMSVMModel, Sequence, TwoStateModel, SMT_TWO_STATE
	from shogun.Evaluation import StructuredAccuracy

	try:
		from shogun.Structure import PrimalMosekSOSVM
	except ImportError:
		print("Mosek not available")
		return

	labels_array = m_data_dict['label'][0]

	idxs = numpy.nonzero(labels_array == -1)
	labels_array[idxs] = 0

	labels = SequenceLabels(labels_array, 250, 500, 2)
	features = RealMatrixFeatures(m_data_dict['signal'].astype(float), 250, 500)

	num_obs = 4	# given by the data file used
	model = HMSVMModel(features, labels, SMT_TWO_STATE, num_obs)

	sosvm = PrimalMosekSOSVM(model, labels)
	sosvm.train()
	#print(sosvm.get_w())

	predicted = sosvm.apply()
	evaluator = StructuredAccuracy()
	acc = evaluator.evaluate(predicted, labels)

예제 #4

파일: structure_hmsvm_mosek.py 프로젝트: ratschlab/shogun

def structure_hmsvm_mosek(m_data_dict=data_dict):
    from shogun.Features import RealMatrixFeatures
    from shogun.Loss import HingeLoss
    from shogun.Structure import HMSVMLabels, HMSVMModel, Sequence, TwoStateModel, SMT_TWO_STATE
    from shogun.Evaluation import StructuredAccuracy

    try:
        from shogun.Structure import PrimalMosekSOSVM
    except ImportError:
        print "Mosek not available"
        import sys
        sys.exit(0)

    labels_array = m_data_dict['label'][0]

    idxs = numpy.nonzero(labels_array == -1)
    labels_array[idxs] = 0

    labels = HMSVMLabels(labels_array, 250, 500, 2)
    features = RealMatrixFeatures(m_data_dict['signal'].astype(float), 250,
                                  500)

    loss = HingeLoss()
    model = HMSVMModel(features, labels, SMT_TWO_STATE, 4)

    sosvm = PrimalMosekSOSVM(model, loss, labels)
    sosvm.train()
    print sosvm.get_w()

    predicted = sosvm.apply()
    evaluator = StructuredAccuracy()
    acc = evaluator.evaluate(predicted, labels)

    print('Accuracy = %.4f' % acc)

예제 #5

def so_multiclass(fm_train_real=traindat,
                  label_train_multiclass=label_traindat):
    labels = MulticlassSOLabels(label_train_multiclass)
    features = RealFeatures(fm_train_real.T)

    model = MulticlassModel(features, labels)
    loss = HingeLoss()
    sosvm = PrimalMosekSOSVM(model, loss, labels)
    sosvm.train()

    out = sosvm.apply()
    count = 0
    for i in xrange(out.get_num_labels()):
        yi_pred = RealNumber.obtain_from_generic(out.get_label(i))
        if yi_pred.value == label_train_multiclass[i]:
            count = count + 1

    print "Correct classification rate: %0.2f" % (100.0 * count /
                                                  out.get_num_labels())

예제 #6

파일: structure_plif_hmsvm_mosek.py 프로젝트: hushell/shogun

def structure_plif_hmsvm_mosek (num_examples, example_length, num_features, num_noise_features):
	from shogun.Features   import RealMatrixFeatures
	from shogun.Structure  import TwoStateModel
	from shogun.Evaluation import StructuredAccuracy

	try:
		from shogun.Structure import PrimalMosekSOSVM
	except ImportError:
		print("Mosek not available")
		return

	model = TwoStateModel.simulate_data(num_examples, example_length, num_features, num_noise_features)
	sosvm = PrimalMosekSOSVM(model, model.get_labels())

	sosvm.train()
	#print(sosvm.get_w())

	predicted = sosvm.apply(model.get_features())
	evaluator = StructuredAccuracy()
	acc = evaluator.evaluate(predicted, model.get_labels())

예제 #7

파일: structure_hmsvm_mosek.py 프로젝트: vladislav-horbatiuk/shogun

def structure_hmsvm_mosek (m_data_dict=data_dict):
	from shogun.Features   import RealMatrixFeatures
	from shogun.Loss       import HingeLoss
	from shogun.Structure  import SequenceLabels, HMSVMModel, Sequence, TwoStateModel, SMT_TWO_STATE
	from shogun.Evaluation import StructuredAccuracy

	try:
		from shogun.Structure import PrimalMosekSOSVM
	except ImportError:
		print "Mosek not available"
		return

	labels_array = m_data_dict['label'][0]

	idxs = numpy.nonzero(labels_array == -1)
	labels_array[idxs] = 0

	labels = SequenceLabels(labels_array, 250, 500, 2)
	features = RealMatrixFeatures(m_data_dict['signal'].astype(float), 250, 500)

	loss = HingeLoss()
	model = HMSVMModel(features, labels, SMT_TWO_STATE, 4)

	sosvm = PrimalMosekSOSVM(model, loss, labels)
	sosvm.train()
	print sosvm.get_w()

	predicted = sosvm.apply()
	evaluator = StructuredAccuracy()
	acc = evaluator.evaluate(predicted, labels)

	print('Accuracy = %.4f' % acc)

예제 #8

파일: structure_hmsvm_mosek.py 프로젝트: luoq/shogun

#!/usr/bin/env python

import numpy
import scipy

from scipy            import io
from shogun.Features  import RealMatrixFeatures
from shogun.Loss      import HingeLoss
from shogun.Structure import HMSVMLabels, HMSVMModel, Sequence, TwoStateModel, SMT_TWO_STATE

try:
	from shogun.Structure	import PrimalMosekSOSVM
except ImportError:
	print "Mosek not available"
	import sys
	sys.exit(0)

data_dict = scipy.io.loadmat('../data/hmsvm_data_large_integer.mat')
labels_array = data_dict['label'][0]
idxs = numpy.nonzero(labels_array == -1)
labels_array[idxs] = 0
labels = HMSVMLabels(labels_array, 250, 500, 2)
features = RealMatrixFeatures(data_dict['signal'].astype(float), 250, 500)
loss   = HingeLoss()
model = HMSVMModel(features, labels, SMT_TWO_STATE, 4)
sosvm = PrimalMosekSOSVM(model, loss, labels, features)
sosvm.train()
print sosvm.get_w()

예제 #9

파일: structure_hmsvm_mosek.py 프로젝트: coodoing/shogun

import scipy

from scipy             import io
from shogun.Features   import RealMatrixFeatures
from shogun.Loss       import HingeLoss
from shogun.Structure  import HMSVMLabels, HMSVMModel, Sequence, TwoStateModel, SMT_TWO_STATE
from shogun.Evaluation import StructuredAccuracy

try:
	from shogun.Structure	import PrimalMosekSOSVM
except ImportError:
	print "Mosek not available"
	import sys
	sys.exit(0)

data_dict = scipy.io.loadmat('../data/hmsvm_data_large_integer.mat')
labels_array = data_dict['label'][0]
idxs = numpy.nonzero(labels_array == -1)
labels_array[idxs] = 0
labels = HMSVMLabels(labels_array, 250, 500, 2)
features = RealMatrixFeatures(data_dict['signal'].astype(float), 250, 500)
loss = HingeLoss()
model = HMSVMModel(features, labels, SMT_TWO_STATE, 4)
sosvm = PrimalMosekSOSVM(model, loss, labels, features)
sosvm.train()
print sosvm.get_w()
predicted = sosvm.apply()
evaluator = StructuredAccuracy()
acc = evaluator.evaluate(predicted, labels)
print('Accuracy = %.4f' % acc)

예제 #10

파일: so_multiclass.py 프로젝트: coodoing/shogun

		  np.dot(np.random.randn(N, dim), covs[1]) + np.array([-10, -10]),
		  np.dot(np.random.randn(N, dim), covs[2]) + np.array([10, -10])];
	Y = np.hstack((np.zeros(N), np.ones(N), 2*np.ones(N)))
	return X, Y

# Number of classes
M = 3
# Number of samples of each class
N = 50
# Dimension of the data
dim = 2

X, y = gen_data()

labels = MulticlassSOLabels(y)
features = RealFeatures(X.T)

model = MulticlassModel(features, labels)
loss = HingeLoss()
sosvm = PrimalMosekSOSVM(model, loss, labels, features)
sosvm.train()

out = sosvm.apply()
count = 0
for i in xrange(out.get_num_labels()):
	yi_pred = RealNumber.obtain_from_generic(out.get_label(i))
	if yi_pred.value == y[i]:
		count = count + 1

print "Correct classification rate: %0.2f" % ( 100.0*count/out.get_num_labels() )

예제 #11

파일: so_multiclass.py 프로젝트: behollis/muViewBranch

		  np.dot(np.random.randn(N, dim), covs[1]) + np.array([-10, -10]),
		  np.dot(np.random.randn(N, dim), covs[2]) + np.array([10, -10])];
	Y = np.hstack((np.zeros(N), np.ones(N), 2*np.ones(N)))
	return X, Y

# Number of classes
M = 3
# Number of samples of each class
N = 50
# Dimension of the data
dim = 2

X, y = gen_data()

labels = MulticlassSOLabels(y)
features = RealFeatures(X.T)

model = MulticlassModel(features, labels)
loss = HingeLoss()
sosvm = PrimalMosekSOSVM(model, loss, labels, features)
sosvm.train()

out = sosvm.apply()
count = 0
for i in xrange(out.get_num_labels()):
	yi_pred = RealNumber.obtain_from_generic(out.get_label(i))
	if yi_pred.value == y[i]:
		count = count + 1

print "Correct classification rate: %0.2f" % ( 100.0*count/out.get_num_labels() )