def kernel_io_modular (fm_train_real=traindat,fm_test_real=testdat,width=1.9):
from shogun.Features import RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Library import AsciiFile, BinaryFile
feats_train=RealFeatures(fm_train_real)
feats_test=RealFeatures(fm_test_real)
kernel=GaussianKernel(feats_train, feats_train, width)
km_train=kernel.get_kernel_matrix()
f=AsciiFile("gaussian_train.ascii","w")
kernel.save(f)
del f
kernel.init(feats_train, feats_test)
km_test=kernel.get_kernel_matrix()
f=AsciiFile("gaussian_test.ascii","w")
kernel.save(f)
del f
#clean up
import os
os.unlink("gaussian_test.ascii")
os.unlink("gaussian_train.ascii")
return km_train, km_test, kernel
def mlprocess(task_filename, data_filename, pred_filename, verbose=True):
"""Demo of creating machine learning process."""
task_type, fidx, lidx, train_idx, test_idx = parse_task(task_filename)
outputs = init_output(task_type)
all_data = parse_data(data_filename)
train_ex, train_lab, test_ex, test_lab = split_data(all_data, fidx, lidx, train_idx, test_idx)
label_train = outputs.str2label(train_lab)
if verbose:
print 'Number of features: %d' % train_ex.shape[0]
print '%d training examples, %d test examples' % (len(train_lab), len(test_lab))
feats_train = RealFeatures(train_ex)
feats_test = RealFeatures(test_ex)
width=1.0
kernel=GaussianKernel(feats_train, feats_train, width)
labels=Labels(label_train)
svm = init_svm(task_type, kernel, labels)
svm.train()
kernel.init(feats_train, feats_test)
preds = svm.classify().get_labels()
pred_label = outputs.label2str(preds)
pf = open(pred_filename, 'w')
for pred in pred_label:
pf.write(pred+'\n')
pf.close()
def kernel_io_modular(fm_train_real=traindat, fm_test_real=testdat, width=1.9):
from shogun.Features import RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.IO import AsciiFile, BinaryFile
feats_train = RealFeatures(fm_train_real)
feats_test = RealFeatures(fm_test_real)
kernel = GaussianKernel(feats_train, feats_train, width)
km_train = kernel.get_kernel_matrix()
f = AsciiFile("gaussian_train.ascii", "w")
kernel.save(f)
del f
kernel.init(feats_train, feats_test)
km_test = kernel.get_kernel_matrix()
f = AsciiFile("gaussian_test.ascii", "w")
kernel.save(f)
del f
#clean up
import os
os.unlink("gaussian_test.ascii")
os.unlink("gaussian_train.ascii")
return km_train, km_test, kernel
def classify(classifier, features, labels, C=5, kernel_name=None, kernel_args=None):
from shogun.Features import RealFeatures
sigma = 10000
kernel = GaussianKernel(features, features, sigma)
# TODO
# kernel = LinearKernel(features, features)
# kernel = PolyKernel(features, features, 50, 2)
# kernel = kernels[kernel_name](features, features, *kernel_args)
svm = classifier(C, kernel, labels)
svm.train(features)
x_size = 640
y_size = 400
size = 100
x1 = np.linspace(0, x_size, size)
y1 = np.linspace(0, y_size, size)
x, y = np.meshgrid(x1, y1)
test = RealFeatures(np.array((np.ravel(x), np.ravel(y))))
kernel.init(features, test)
out = svm.apply(test).get_values()
if not len(out):
out = svm.apply(test).get_labels()
z = out.reshape((size, size))
z = np.transpose(z)
return x, y, z
def regression_svrlight_modular(fm_train=traindat,fm_test=testdat,label_train=label_traindat, \
width=1.2,C=1,epsilon=1e-5,tube_epsilon=1e-2,num_threads=3):
from shogun.Features import Labels, RealFeatures
from shogun.Kernel import GaussianKernel
try:
from shogun.Regression import SVRLight
except ImportError:
print 'No support for SVRLight available.'
return
feats_train = RealFeatures(fm_train)
feats_test = RealFeatures(fm_test)
kernel = GaussianKernel(feats_train, feats_train, width)
labels = Labels(label_train)
svr = SVRLight(C, epsilon, kernel, labels)
svr.set_tube_epsilon(tube_epsilon)
svr.parallel.set_num_threads(num_threads)
svr.train()
kernel.init(feats_train, feats_test)
out = svr.apply().get_labels()
return out, kernel
def classifier_libsvm_modular(fm_train_real=traindat,
fm_test_real=testdat,
label_train_twoclass=label_traindat,
width=2.1,
C=1,
epsilon=1e-5):
from shogun.Features import RealFeatures, Labels
from shogun.Kernel import GaussianKernel
from shogun.Classifier import LibSVM
feats_train = RealFeatures(fm_train_real)
feats_test = RealFeatures(fm_test_real)
kernel = GaussianKernel(feats_train, feats_train, width)
labels = Labels(label_train_twoclass)
svm = LibSVM(C, kernel, labels)
svm.set_epsilon(epsilon)
svm.train()
kernel.init(feats_train, feats_test)
labels = svm.apply().get_labels()
supportvectors = sv_idx = svm.get_support_vectors()
alphas = svm.get_alphas()
predictions = svm.apply()
return predictions, svm, predictions.get_labels()
def mlprocess(task_filename, data_filename, pred_filename, verbose=True):
"""Demo of creating machine learning process."""
task_type, fidx, lidx, train_idx, test_idx = parse_task(task_filename)
outputs = init_output(task_type)
all_data = parse_data(data_filename)
train_ex, train_lab, test_ex, test_lab = split_data(all_data, fidx, lidx, train_idx, test_idx)
label_train = outputs.str2label(train_lab)
if verbose:
print('Number of features: %d' % train_ex.shape[0])
print('%d training examples, %d test examples' % (len(train_lab), len(test_lab)))
feats_train = RealFeatures(train_ex)
feats_test = RealFeatures(test_ex)
width=1.0
kernel=GaussianKernel(feats_train, feats_train, width)
labels=Labels(label_train)
svm = init_svm(task_type, kernel, labels)
svm.train()
kernel.init(feats_train, feats_test)
preds = svm.classify().get_labels()
pred_label = outputs.label2str(preds)
pf = open(pred_filename, 'w')
for pred in pred_label:
pf.write(pred+'\n')
pf.close()
def statistics_kmm (n,d): from shogun.Features import RealFeatures from shogun.Features import DataGenerator from shogun.Kernel import GaussianKernel, MSG_DEBUG from shogun.Statistics import KernelMeanMatching from shogun.Mathematics import Math # init seed for reproducability Math.init_random(1) random.seed(1); data = random.randn(d,n) # create shogun feature representation features=RealFeatures(data) # use a kernel width of sigma=2, which is 8 in SHOGUN's parametrization # which is k(x,y)=exp(-||x-y||^2 / tau), in constrast to the standard # k(x,y)=exp(-||x-y||^2 / (2*sigma^2)), so tau=2*sigma^2 kernel=GaussianKernel(10,8) kernel.init(features,features) kmm = KernelMeanMatching(kernel,array([0,1,2,3,7,8,9],dtype=int32),array([4,5,6],dtype=int32)) w = kmm.compute_weights() #print w return w
def classifier_mpdsvm_modular(fm_train_real=traindat,
fm_test_real=testdat,
label_train_twoclass=label_traindat,
C=1,
epsilon=1e-5):
from shogun.Features import RealFeatures, BinaryLabels
from shogun.Kernel import GaussianKernel
from shogun.Classifier import MPDSVM
feats_train = RealFeatures(fm_train_real)
feats_test = RealFeatures(fm_test_real)
width = 2.1
kernel = GaussianKernel(feats_train, feats_train, width)
labels = BinaryLabels(label_train_twoclass)
svm = MPDSVM(C, kernel, labels)
svm.set_epsilon(epsilon)
svm.train()
kernel.init(feats_train, feats_test)
svm.apply().get_labels()
predictions = svm.apply()
return predictions, svm, predictions.get_labels()
def regression_svrlight_modular(fm_train=traindat,fm_test=testdat,label_train=label_traindat, \
width=1.2,C=1,epsilon=1e-5,tube_epsilon=1e-2,num_threads=3):
from shogun.Features import Labels, RealFeatures
from shogun.Kernel import GaussianKernel
try:
from shogun.Regression import SVRLight
except ImportError:
print('No support for SVRLight available.')
return
feats_train=RealFeatures(fm_train)
feats_test=RealFeatures(fm_test)
kernel=GaussianKernel(feats_train, feats_train, width)
labels=Labels(label_train)
svr=SVRLight(C, epsilon, kernel, labels)
svr.set_tube_epsilon(tube_epsilon)
svr.parallel.set_num_threads(num_threads)
svr.train()
kernel.init(feats_train, feats_test)
out = svr.apply().get_labels()
return out, kernel
def mkl_binclass_modular (train_data, testdata, train_labels, test_labels, d1, d2):
# create some Gaussian train/test matrix
tfeats = RealFeatures(train_data)
tkernel = GaussianKernel(128, d1)
tkernel.init(tfeats, tfeats)
K_train = tkernel.get_kernel_matrix()
pfeats = RealFeatures(test_data)
tkernel.init(tfeats, pfeats)
K_test = tkernel.get_kernel_matrix()
# create combined train features
feats_train = CombinedFeatures()
feats_train.append_feature_obj(RealFeatures(train_data))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_train))
kernel.append_kernel(GaussianKernel(128, d2))
kernel.init(feats_train, feats_train)
# train mkl
labels = Labels(train_labels)
mkl = MKLClassification()
# not to use svmlight
mkl.set_interleaved_optimization_enabled(0)
# which norm to use for MKL
mkl.set_mkl_norm(2)
# set cost (neg, pos)
mkl.set_C(1, 1)
# set kernel and labels
mkl.set_kernel(kernel)
mkl.set_labels(labels)
# train
mkl.train()
# test
# create combined test features
feats_pred = CombinedFeatures()
feats_pred.append_feature_obj(RealFeatures(test_data))
# and corresponding combined kernel
kernel = CombinedKernel()
kernel.append_kernel(CustomKernel(K_test))
kernel.append_kernel(GaussianKernel(128, d2))
kernel.init(feats_train, feats_pred)
# and classify
mkl.set_kernel(kernel)
output = mkl.apply().get_labels()
output = [1.0 if i>0 else -1.0 for i in output]
accu = len(where(output == test_labels)[0]) / float(len(output))
return accu
def kernel_gaussian_modular (fm_train_real=traindat,fm_test_real=testdat, width=1.3): from shogun.Features import RealFeatures from shogun.Kernel import GaussianKernel feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix() return km_train,km_test,kernel
def gaussian (): print 'Gaussian' from shogun.Features import RealFeatures from shogun.Kernel import GaussianKernel feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) width=1.9 kernel=GaussianKernel(feats_train, feats_train, width) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) km_test=kernel.get_kernel_matrix()
def classifier_libsvm_minimal_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_twoclass=label_traindat,width=2.1,C=1): from shogun.Features import RealFeatures, BinaryLabels from shogun.Classifier import LibSVM from shogun.Kernel import GaussianKernel feats_train=RealFeatures(fm_train_real); feats_test=RealFeatures(fm_test_real); kernel=GaussianKernel(feats_train, feats_train, width); labels=BinaryLabels(label_train_twoclass); svm=LibSVM(C, kernel, labels); svm.train(); kernel.init(feats_train, feats_test); out=svm.apply().get_labels(); testerr=mean(sign(out)!=label_train_twoclass)
def classifier_gmnpsvm_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import GMNPSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train_multiclass) svm=GMNPSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train(feats_train) kernel.init(feats_train, feats_test) out=svm.apply(feats_test).get_labels() return out,kernel
def classifier_multiclassmachine_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVM, KernelMulticlassMachine, ONE_VS_REST_STRATEGY feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train_multiclass) classifier = LibSVM(C, kernel, labels) classifier.set_epsilon(epsilon) mc_classifier = KernelMulticlassMachine(ONE_VS_REST_STRATEGY,kernel,classifier,labels) mc_classifier.train() kernel.init(feats_train, feats_test) out = mc_classifier.apply().get_labels() return out
def classifier_libsvmoneclass_modular (fm_train_real=traindat,fm_test_real=testdat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVMOneClass feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) svm=LibSVMOneClass(C, kernel) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) svm.apply().get_labels() predictions = svm.apply() return predictions, svm, predictions.get_labels()
def classifier_multiclasslibsvm_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import MulticlassLibSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train_multiclass) svm=MulticlassLibSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) out = svm.apply().get_labels() predictions = svm.apply() return predictions, svm, predictions.get_labels()
def regression_kernel_ridge_modular (fm_train=traindat,fm_test=testdat,label_train=label_traindat,width=0.8,tau=1e-6): from shogun.Features import Labels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import KernelRidgeRegression feats_train=RealFeatures(fm_train) feats_test=RealFeatures(fm_test) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train) krr=KernelRidgeRegression(tau, kernel, labels) krr.train(feats_train) kernel.init(feats_train, feats_test) out = krr.apply().get_labels() return out,kernel,krr
def classifier_gmnpsvm_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, MulticlassLabels from shogun.Kernel import GaussianKernel from shogun.Classifier import GMNPSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=MulticlassLabels(label_train_multiclass) svm=GMNPSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train(feats_train) kernel.init(feats_train, feats_test) out=svm.apply(feats_test).get_labels() return out,kernel
def classifier_libsvmoneclass_modular (fm_train_real=traindat,fm_test_real=testdat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVMOneClass feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) svm=LibSVMOneClass(C, kernel) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) svm.apply().get_labels() predictions = svm.apply() return predictions, svm, predictions.get_labels()
def regression_kernel_ridge_modular (n=100,n_test=100, \ x_range=6,x_range_test=10,noise_var=0.5,width=1, tau=1e-6, seed=1): from shogun.Features import RegressionLabels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import KernelRidgeRegression # reproducable results random.seed(seed) # easy regression data: one dimensional noisy sine wave n=15 n_test=100 x_range_test=10 noise_var=0.5; X=random.rand(1,n)*x_range X_test=array([[float(i)/n_test*x_range_test for i in range(n_test)]]) Y_test=sin(X_test) Y=sin(X)+random.randn(n)*noise_var # shogun representation labels=RegressionLabels(Y[0]) feats_train=RealFeatures(X) feats_test=RealFeatures(X_test) kernel=GaussianKernel(feats_train, feats_train, width) krr=KernelRidgeRegression(tau, kernel, labels) krr.train(feats_train) kernel.init(feats_train, feats_test) out = krr.apply().get_labels() # plot results #plot(X[0],Y[0],'x') # training observations #plot(X_test[0],Y_test[0],'-') # ground truth of test #plot(X_test[0],out, '-') # mean predictions of test #legend(["training", "ground truth", "mean predictions"]) #show() return out,kernel,krr
def regression_libsvr_modular (svm_c=1, svr_param=0.1, n=100,n_test=100, \ x_range=6,x_range_test=10,noise_var=0.5,width=1, seed=1): from shogun.Features import RegressionLabels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import LibSVR, LIBSVR_NU_SVR, LIBSVR_EPSILON_SVR # reproducable results random.seed(seed) # easy regression data: one dimensional noisy sine wave n=15 n_test=100 x_range_test=10 noise_var=0.5; X=random.rand(1,n)*x_range X_test=array([[float(i)/n_test*x_range_test for i in range(n_test)]]) Y_test=sin(X_test) Y=sin(X)+random.randn(n)*noise_var # shogun representation labels=RegressionLabels(Y[0]) feats_train=RealFeatures(X) feats_test=RealFeatures(X_test) kernel=GaussianKernel(feats_train, feats_train, width) # two svr models: epsilon and nu svr_epsilon=LibSVR(svm_c, svr_param, kernel, labels, LIBSVR_EPSILON_SVR) svr_epsilon.train() svr_nu=LibSVR(svm_c, svr_param, kernel, labels, LIBSVR_NU_SVR) svr_nu.train() # predictions kernel.init(feats_train, feats_test) out1_epsilon=svr_epsilon.apply().get_labels() out2_epsilon=svr_epsilon.apply(feats_test).get_labels() out1_nu=svr_epsilon.apply().get_labels() out2_nu=svr_epsilon.apply(feats_test).get_labels() return out1_epsilon,out2_epsilon,out1_nu,out2_nu ,kernel
def classifier_multiclassmachine_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, MulticlassLabels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVM, KernelMulticlassMachine, MulticlassOneVsRestStrategy feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=MulticlassLabels(label_train_multiclass) classifier = LibSVM() classifier.set_epsilon(epsilon) #print labels.get_labels() mc_classifier = KernelMulticlassMachine(MulticlassOneVsRestStrategy(),kernel,classifier,labels) mc_classifier.train() kernel.init(feats_train, feats_test) out = mc_classifier.apply().get_labels() return out
def krr (): print 'KRR' from shogun.Features import Labels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import KRR feats_train=RealFeatures(fm_train) feats_test=RealFeatures(fm_test) width=0.8 kernel=GaussianKernel(feats_train, feats_train, width) tau=1e-6 labels=Labels(label_train) krr=KRR(tau, kernel, labels) krr.train(feats_train) kernel.init(feats_train, feats_test) out = krr.classify().get_labels() return out
def classifier_multiclassmachine_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVM, KernelMulticlassMachine, MulticlassOneVsRestStrategy feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train_multiclass) classifier = LibSVM(C, kernel, labels) classifier.set_epsilon(epsilon) print labels.get_labels() mc_classifier = KernelMulticlassMachine(MulticlassOneVsRestStrategy(),kernel,classifier,labels) mc_classifier.train() kernel.init(feats_train, feats_test) out = mc_classifier.apply().get_labels() return out
def classifier_libsvm_minimal_modular(fm_train_real=traindat,
fm_test_real=testdat,
label_train_twoclass=label_traindat,
width=2.1,
C=1):
from shogun.Features import RealFeatures, BinaryLabels
from shogun.Classifier import LibSVM
from shogun.Kernel import GaussianKernel
feats_train = RealFeatures(fm_train_real)
feats_test = RealFeatures(fm_test_real)
kernel = GaussianKernel(feats_train, feats_train, width)
labels = BinaryLabels(label_train_twoclass)
svm = LibSVM(C, kernel, labels)
svm.train()
kernel.init(feats_train, feats_test)
out = svm.apply().get_labels()
testerr = mean(sign(out) != label_train_twoclass)
def libsvm_oneclass (): print 'LibSVMOneClass' from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVMOneClass feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) width=2.1 kernel=GaussianKernel(feats_train, feats_train, width) C=1 epsilon=1e-5 svm=LibSVMOneClass(C, kernel) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) svm.classify().get_labels()
def classifier_libsvm_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_twoclass=label_traindat,width=2.1,C=1,epsilon=1e-5): from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train_twoclass) svm=LibSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) labels = svm.apply().get_labels() supportvectors = sv_idx=svm.get_support_vectors() alphas=svm.get_alphas() predictions = svm.apply() return predictions, svm, predictions.get_labels()
def regression_libsvr_modular (fm_train=traindat,fm_test=testdat,label_train=label_traindat,\ width=2.1,C=1,epsilon=1e-5,tube_epsilon=1e-2): from shogun.Features import Labels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import LibSVR feats_train=RealFeatures(fm_train) feats_test=RealFeatures(fm_test) kernel=GaussianKernel(feats_train, feats_train, width) labels=Labels(label_train) svr=LibSVR(C, tube_epsilon, kernel, labels) svr.set_epsilon(epsilon) svr.train() kernel.init(feats_train, feats_test) out1=svr.apply().get_labels() out2=svr.apply(feats_test).get_labels() return out1,out2,kernel
def mpdsvm (): print 'MPDSVM' from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import MPDSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) width=2.1 kernel=GaussianKernel(feats_train, feats_train, width) C=1 epsilon=1e-5 labels=Labels(label_train_twoclass) svm=MPDSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) svm.classify().get_labels()
def regression_libsvr_modular (fm_train=traindat,fm_test=testdat,label_train=label_traindat,\
width=2.1,C=1,epsilon=1e-5,tube_epsilon=1e-2):
from shogun.Features import Labels, RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import LibSVR
feats_train = RealFeatures(fm_train)
feats_test = RealFeatures(fm_test)
kernel = GaussianKernel(feats_train, feats_train, width)
labels = Labels(label_train)
svr = LibSVR(C, tube_epsilon, kernel, labels)
svr.set_epsilon(epsilon)
svr.train()
kernel.init(feats_train, feats_test)
out1 = svr.apply().get_labels()
out2 = svr.apply(feats_test).get_labels()
return out1, out2, kernel
def regression_kernel_ridge_modular(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat,
width=0.8,
tau=1e-6):
from shogun.Features import RegressionLabels, RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import KernelRidgeRegression
feats_train = RealFeatures(fm_train)
feats_test = RealFeatures(fm_test)
kernel = GaussianKernel(feats_train, feats_train, width)
labels = RegressionLabels(label_train)
krr = KernelRidgeRegression(tau, kernel, labels)
krr.train(feats_train)
kernel.init(feats_train, feats_test)
out = krr.apply().get_labels()
return out, kernel, krr
def libsvr (): print 'LibSVR' from shogun.Features import Labels, RealFeatures from shogun.Kernel import GaussianKernel from shogun.Regression import LibSVR feats_train=RealFeatures(fm_train) feats_test=RealFeatures(fm_test) width=2.1 kernel=GaussianKernel(feats_train, feats_train, width) C=1 epsilon=1e-5 tube_epsilon=1e-2 labels=Labels(label_train) svr=LibSVR(C, epsilon, kernel, labels) svr.set_tube_epsilon(tube_epsilon) svr.train() kernel.init(feats_train, feats_test) out1=svr.classify().get_labels() out2=svr.classify(feats_test).get_labels()
def libsvm (): print 'LibSVM' from shogun.Features import RealFeatures, Labels from shogun.Kernel import GaussianKernel from shogun.Classifier import LibSVM feats_train=RealFeatures(fm_train_real) feats_test=RealFeatures(fm_test_real) width=2.1 kernel=GaussianKernel(feats_train, feats_train, width) C=1 epsilon=1e-5 labels=Labels(label_train_twoclass) svm=LibSVM(C, kernel, labels) svm.set_epsilon(epsilon) svm.train() kernel.init(feats_train, feats_test) svm.classify().get_labels() sv_idx=svm.get_support_vectors() alphas=svm.get_alphas()
def regression_gaussian_process_modelselection (n=100,n_test=100, \
x_range=6,x_range_test=10,noise_var=0.5,width=1, seed=1):
from shogun.Features import RealFeatures, RegressionLabels
from shogun.Kernel import GaussianKernel
from shogun.ModelSelection import GradientModelSelection, ModelSelectionParameters, R_LINEAR
from shogun.Regression import GaussianLikelihood, ZeroMean, \
ExactInferenceMethod, GaussianProcessRegression, GradientCriterion, \
GradientEvaluation
# Reproducable results
random.seed(seed)
# Easy regression data: one dimensional noisy sine wave
X_train=random.rand(1,n)*x_range
X_test=array([[float(i)/n_test*x_range_test for i in range(n_test)]])
Y_test=sin(X_test)
Y_train=sin(X_train)+random.randn(n)*noise_var
# shogun representation
labels=RegressionLabels(Y_train[0])
feats_train=RealFeatures(X_train)
feats_test=RealFeatures(X_test)
# GP specification
width=1
shogun_width=width*width*2
kernel=GaussianKernel(10,shogun_width)
kernel.init(feats_train,feats_train)
zmean = ZeroMean()
likelihood = GaussianLikelihood()
inf = ExactInferenceMethod(kernel, feats_train, zmean, labels, likelihood)
gp = GaussianProcessRegression(inf, feats_train, labels)
# Paramter tree for model selection
root = ModelSelectionParameters()
c1 = ModelSelectionParameters("inference_method", inf)
root.append_child(c1)
c2 = ModelSelectionParameters("scale")
c1.append_child(c2)
c2.build_values(0.01, 4.0, R_LINEAR)
c3 = ModelSelectionParameters("likelihood_model", likelihood)
c1.append_child(c3)
c4 = ModelSelectionParameters("sigma")
c3.append_child(c4)
c4.build_values(0.001, 4.0, R_LINEAR)
c5 = ModelSelectionParameters("kernel", kernel)
c1.append_child(c5)
c6 = ModelSelectionParameters("width")
c5.append_child(c6)
c6.build_values(0.001, 4.0, R_LINEAR)
# Criterion for Gradient Search
crit = GradientCriterion()
# Evaluate our inference method for its derivatives
grad = GradientEvaluation(gp, feats_train, labels, crit)
grad.set_function(inf)
gp.print_modsel_params()
root.print_tree()
# Handles all of the above structures in memory
grad_search = GradientModelSelection(root, grad)
# Set autolocking to false to get rid of warnings
grad.set_autolock(False)
# Search for best parameters
best_combination = grad_search.select_model(True)
# Outputs all result and information
best_combination.print_tree()
best_combination.apply_to_machine(gp)
result = grad.evaluate()
result.print_result()
#inference
gp.set_return_type(GaussianProcessRegression.GP_RETURN_COV)
covariance = gp.apply_regression(feats_test)
covariance = covariance.get_labels()
gp.set_return_type(GaussianProcessRegression.GP_RETURN_MEANS)
mean = gp.apply_regression(feats_test)
mean = mean.get_labels()
# some things we can do
alpha = inf.get_alpha()
diagonal = inf.get_diagonal_vector()
cholesky = inf.get_cholesky()
# plot results
plot(X_train[0],Y_train[0],'x') # training observations
plot(X_test[0],Y_test[0],'-') # ground truth of test
plot(X_test[0],mean, '-') # mean predictions of test
legend(["training", "ground truth", "mean predictions"])
show()
return gp, alpha, labels, diagonal, covariance, mean, cholesky
class SVR:
svr = None
kernel = None
feats_train = None
def __init__(self, traininput,testinput,traintarget,width=0.5,C=1,epsilon=0.1,tube_epsilon=0.1):
train = matrix(traininput, dtype=float64)
test = matrix(testinput, dtype=float64)
label_train = array(traintarget, dtype=float64)
self.feats_train=RealFeatures(train)
feats_test=RealFeatures(test)
trainstart = time.time()
self.kernel=GaussianKernel(self.feats_train, self.feats_train, width)
# self.kernel = PolyKernel(self.feats_train, self.feats_train, 2, False)
labels=Labels(label_train)
self.svr=LibSVR(C, epsilon, self.kernel, labels)
self.svr.set_tube_epsilon(tube_epsilon)
self.svr.train()
trainend = time.time()
print 'SVR train time'
print trainend-trainstart
def svr_req(self,inputs):
feat_inputs = RealFeatures(matrix(inputs, dtype=float64))
teststart = time.time()
self.kernel.init(self.feats_train, feat_inputs)
out = self.svr.classify(feat_inputs).get_labels()
# feat_input0 = RealFeatures(matrix(inputs[0], dtype=float64))
# feat_input1 = RealFeatures(matrix(inputs[1], dtype=float64))
# feat_input2 = RealFeatures(matrix(inputs[2], dtype=float64))
# feat_input3 = RealFeatures(matrix(inputs[3], dtype=float64))
#
# out.append(self.svr.classify(feat_input0).get_labels())
# out.append(self.svr.classify(feat_input1).get_labels())
# out.append(self.svr.classify(feat_input2).get_labels())
# out.append(self.svr.classify(feat_input3).get_labels())
testend = time.time()
print 'SVR query response '
print testend-teststart
return out
def calc_sme(self, testtarget, realtarget):
result = 0.0
for i in range(len(testtarget)):
result += pow((realtarget[i] - testtarget[i]),2)
result /= len(testtarget)
return result
def calc_mape(self, testtarget, realtarget):
result = 0.0
for i in range(len(testtarget)):
result = abs(testtarget[i] - realtarget[i])/testtarget[i]
return result/len(testtarget)
def calc_rsqr(self, testtarget, realtarget):
result_up = 0.0
result_down = 0.0
avg = sum(realtarget)/len(realtarget)
for i in range(len(testtarget)):
result_up += pow((realtarget[i] - testtarget[i]),2)
result_down += (realtarget[i] - avg)
return 1 - (result_up / result_down)
def calc_pred(self, testtarget, realtarget, x):
countx = 0.0
for i in range(len(testtarget)):
if ((testtarget[i]/realtarget[i]) - 1 < (realtarget[i] * (1-x))):
countx += 1
return countx / len(realtarget)
def statistics_quadratic_time_mmd (m,dim,difference): from shogun.Features import RealFeatures from shogun.Features import MeanShiftDataGenerator from shogun.Kernel import GaussianKernel, CustomKernel from shogun.Statistics import QuadraticTimeMMD from shogun.Statistics import BOOTSTRAP, MMD2_SPECTRUM, MMD2_GAMMA, BIASED, UNBIASED from shogun.Mathematics import Statistics, IntVector, RealVector, Math # init seed for reproducability Math.init_random(1) # number of examples kept low in order to make things fast # streaming data generator for mean shift distributions gen_p=MeanShiftDataGenerator(0, dim); gen_q=MeanShiftDataGenerator(difference, dim); # stream some data from generator feat_p=gen_p.get_streamed_features(m); feat_q=gen_q.get_streamed_features(m); # set kernel a-priori. usually one would do some kernel selection. See # other examples for this. width=10; kernel=GaussianKernel(10, width); # create quadratic time mmd instance. Note that this constructor # copies p and q and does not reference them mmd=QuadraticTimeMMD(kernel, feat_p, feat_q); # perform test: compute p-value and test if null-hypothesis is rejected for # a test level of 0.05 alpha=0.05; # using bootstrapping (slow, not the most reliable way. Consider pre- # computing the kernel when using it, see below). # Also, in practice, use at least 250 iterations mmd.set_null_approximation_method(BOOTSTRAP); mmd.set_bootstrap_iterations(3); p_value_boot=mmd.perform_test(); # reject if p-value is smaller than test level #print "bootstrap: p!=q: ", p_value_boot<alpha # using spectrum method. Use at least 250 samples from null. # This is consistent but sometimes breaks, always monitor type I error. # See tutorial for number of eigenvalues to use . # Only works with BIASED statistic mmd.set_statistic_type(BIASED); mmd.set_null_approximation_method(MMD2_SPECTRUM); mmd.set_num_eigenvalues_spectrum(3); mmd.set_num_samples_sepctrum(250); p_value_spectrum=mmd.perform_test(); # reject if p-value is smaller than test level #print "spectrum: p!=q: ", p_value_spectrum<alpha # using gamma method. This is a quick hack, which works most of the time # but is NOT guaranteed to. See tutorial for details. # Only works with BIASED statistic mmd.set_statistic_type(BIASED); mmd.set_null_approximation_method(MMD2_GAMMA); p_value_gamma=mmd.perform_test(); # reject if p-value is smaller than test level #print "gamma: p!=q: ", p_value_gamma<alpha # compute tpye I and II error (use many more trials in practice). # Type I error is not necessary if one uses bootstrapping. We do it here # anyway, but note that this is an efficient way of computing it. # Also note that testing has to happen on # difference data than kernel selection, but the linear time mmd does this # implicitly and we used a fixed kernel here. mmd.set_null_approximation_method(BOOTSTRAP); mmd.set_bootstrap_iterations(5); num_trials=5; type_I_errors=RealVector(num_trials); type_II_errors=RealVector(num_trials); inds=int32(array([x for x in range(2*m)])) # numpy p_and_q=mmd.get_p_and_q(); # use a precomputed kernel to be faster kernel.init(p_and_q, p_and_q); precomputed=CustomKernel(kernel); mmd.set_kernel(precomputed); for i in range(num_trials): # this effectively means that p=q - rejecting is tpye I error inds=random.permutation(inds) # numpy permutation precomputed.add_row_subset(inds); precomputed.add_col_subset(inds); type_I_errors[i]=mmd.perform_test()>alpha; precomputed.remove_row_subset(); precomputed.remove_col_subset(); # on normal data, this gives type II error type_II_errors[i]=mmd.perform_test()>alpha; return type_I_errors.get(),type_I_errors.get(),p_value_boot,p_value_spectrum,p_value_gamma,
