def evaluation_meansquarederror_modular(ground_truth, predicted):
from shogun.Features import RegressionLabels
from shogun.Evaluation import MeanSquaredError
ground_truth_labels = RegressionLabels(ground_truth)
predicted_labels = RegressionLabels(predicted)
evaluator = MeanSquaredError()
mse = evaluator.evaluate(predicted_labels, ground_truth_labels)
return mse
def regression_gaussian_process_modular(
traindata_real=traindat, testdata_real=testdat, trainlab=label_traindat, width=2.1
):
from numpy.random import randn
from shogun.Features import RealFeatures, RegressionLabels
from shogun.Kernel import GaussianKernel
try:
from shogun.Regression import GaussianLikelihood, ZeroMean, ExactInferenceMethod, GaussianProcessRegression
except ImportError:
print "Eigen3 needed for Gaussian Processes"
return
labels = RegressionLabels(trainlab)
feats_train = RealFeatures(traindata_real)
feats_test = RealFeatures(testdata_real)
kernel = GaussianKernel(feats_train, feats_train, width)
zmean = ZeroMean()
lik = GaussianLikelihood()
inf = ExactInferenceMethod(kernel, feats_train, zmean, labels, lik)
gp = GaussianProcessRegression(inf, feats_train, labels)
alpha = inf.get_alpha()
diagonal = inf.get_diagonal_vector()
cholesky = inf.get_cholesky()
gp.set_return_type(GaussianProcessRegression.GP_RETURN_COV)
covariance = gp.apply_regression(feats_test)
gp.set_return_type(GaussianProcessRegression.GP_RETURN_MEANS)
predictions = gp.apply_regression()
print ("Alpha Vector")
print (alpha)
print ("Labels")
print (labels.get_labels())
print ("sW Matrix")
print (diagonal)
print ("Covariances")
print (covariance.get_labels())
print ("Mean Predictions")
print (predictions.get_labels())
print ("Cholesky Matrix L")
print (cholesky)
return gp, alpha, labels, diagonal, covariance, predictions, cholesky
def regression_gaussian_process_modular (traindata_real=traindat, \
testdata_real=testdat, \
trainlab=label_traindat, width=2.1):
from numpy.random import randn
from shogun.Features import RealFeatures, RegressionLabels
from shogun.Kernel import GaussianKernel
try:
from shogun.Regression import GaussianLikelihood, ZeroMean, \
ExactInferenceMethod, GaussianProcessRegression
except ImportError:
print "Eigen3 needed for Gaussian Processes"
return
labels=RegressionLabels(trainlab)
feats_train=RealFeatures(traindata_real)
feats_test=RealFeatures(testdata_real)
kernel=GaussianKernel(feats_train, feats_train, width)
zmean = ZeroMean()
lik = GaussianLikelihood()
inf = ExactInferenceMethod(kernel, feats_train, zmean, labels, lik)
gp = GaussianProcessRegression(inf, feats_train, labels)
alpha = inf.get_alpha()
diagonal = inf.get_diagonal_vector()
cholesky = inf.get_cholesky()
gp.set_return_type(GaussianProcessRegression.GP_RETURN_COV)
covariance = gp.apply_regression(feats_test)
gp.set_return_type(GaussianProcessRegression.GP_RETURN_MEANS)
predictions = gp.apply_regression()
print("Alpha Vector")
print(alpha)
print("Labels")
print(labels.get_labels())
print("sW Matrix")
print(diagonal)
print("Covariances")
print(covariance.get_labels())
print("Mean Predictions")
print(predictions.get_labels())
print("Cholesky Matrix L")
print(cholesky)
return gp, alpha, labels, diagonal, covariance, predictions, cholesky
def regression_gaussian_process_modular (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
try:
from shogun.Regression import GaussianLikelihood, ZeroMean, \
ExactInferenceMethod, GaussianProcessRegression
except ImportError:
print("Eigen3 needed for Gaussian Processes")
return
# 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)
# GP specification
width = 1
shogun_width = width * width * 2
kernel = GaussianKernel(10, shogun_width)
zmean = ZeroMean()
lik = GaussianLikelihood()
inf = ExactInferenceMethod(kernel, feats_train, zmean, labels, lik)
gp = GaussianProcessRegression(inf, feats_train, labels)
# some things we can do
alpha = inf.get_alpha()
diagonal = inf.get_diagonal_vector()
cholesky = inf.get_cholesky()
# inference
gp.set_return_type(GaussianProcessRegression.GP_RETURN_MEANS)
mean = gp.apply_regression(feats_test)
gp.set_return_type(GaussianProcessRegression.GP_RETURN_COV)
covariance = gp.apply_regression(feats_test)
# 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],mean.get_labels(), '-') # mean predictions of test
#legend(["training", "ground truth", "mean predictions"])
#show()
return gp, alpha, labels, diagonal, covariance, mean, cholesky
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 RegressionLabels, 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 = RegressionLabels(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 RunLinearRegressionShogun(q):
totalTimer = Timer()
# Load input dataset.
# If the dataset contains two files then the second file is the responses
# file.
try:
Log.Info("Loading dataset", self.verbose)
if len(self.dataset) == 2:
X = np.genfromtxt(self.dataset[0], delimiter=',')
y = np.genfromtxt(self.dataset[1], delimiter=',')
else:
X = np.genfromtxt(self.dataset, delimiter=',')
y = X[:, (X.shape[1] - 1)]
X = X[:, :-1]
with totalTimer:
# Perform linear regression.
model = LeastSquaresRegression(RealFeatures(X.T),
RegressionLabels(y))
model.train()
b = model.get_w()
except Exception as e:
q.put(-1)
return -1
time = totalTimer.ElapsedTime()
q.put(time)
return time
def RunLARSShogun(q):
totalTimer = Timer()
# Load input dataset.
try:
Log.Info("Loading dataset", self.verbose)
inputData = np.genfromtxt(self.dataset[0], delimiter=',')
responsesData = np.genfromtxt(self.dataset[1], delimiter=',')
inputFeat = RealFeatures(inputData.T)
responsesFeat = RegressionLabels(responsesData)
# Get all the parameters.
lambda1 = re.search("-l (\d+)", options)
lambda1 = 0.0 if not lambda1 else int(lambda1.group(1))
with totalTimer:
# Perform LARS.
model = LeastAngleRegression(False)
model.set_max_l1_norm(lambda1)
model.set_labels(responsesFeat)
model.train(inputFeat)
model.get_w(model.get_path_size() - 1)
except Exception as e:
q.put(-1)
return -1
time = totalTimer.ElapsedTime()
q.put(time)
return time
def get_labels(raw=False, type='binary'): data = concatenate(array( (-ones(NUM_EXAMPLES, dtype=double), ones(NUM_EXAMPLES, dtype=double)) )) if raw: return data else: if type == 'binary': return BinaryLabels(data) if type == 'regression': return RegressionLabels(data) return None
def regression_linear_ridge_modular(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat,
tau=1e-6):
from shogun.Features import RegressionLabels, RealFeatures
from shogun.Regression import LinearRidgeRegression
rr = LinearRidgeRegression(tau, RealFeatures(traindat),
RegressionLabels(label_train))
rr.train()
out = rr.apply(RealFeatures(fm_test)).get_labels()
return out, rr
def krr_short():
print('KRR_short')
from shogun.Features import RegressionLabels, RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import KernelRidgeRegression
width = 0.8
tau = 1e-6
krr = KernelRidgeRegression(tau, GaussianKernel(0, width),
RegressionLabels(label_train))
krr.train(RealFeatures(fm_train))
out = krr.apply(RealFeatures(fm_test)).get_labels()
return krr, out
def regression_least_squares_modular(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat,
tau=1e-6):
from shogun.Features import RegressionLabels, RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import LeastSquaresRegression
ls = LeastSquaresRegression(RealFeatures(traindat),
RegressionLabels(label_train))
ls.train()
out = ls.apply(RealFeatures(fm_test)).get_labels()
return out, ls
def evaluation_cross_validation_regression(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat,
width=0.8,
tau=1e-6):
from shogun.Evaluation import CrossValidation, CrossValidationResult
from shogun.Evaluation import MeanSquaredError
from shogun.Evaluation import CrossValidationSplitting
from shogun.Features import RegressionLabels, RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import KernelRidgeRegression
# training data
features = RealFeatures(fm_train)
labels = RegressionLabels(label_train)
# kernel and predictor
kernel = GaussianKernel()
predictor = KernelRidgeRegression(tau, kernel, labels)
# splitting strategy for 5 fold cross-validation (for classification its better
# to use "StratifiedCrossValidation", but here, the std x-val is used
splitting_strategy = CrossValidationSplitting(labels, 5)
# evaluation method
evaluation_criterium = MeanSquaredError()
# cross-validation instance
cross_validation = CrossValidation(predictor, features, labels,
splitting_strategy,
evaluation_criterium)
# (optional) repeat x-val 10 times
cross_validation.set_num_runs(10)
# (optional) request 95% confidence intervals for results (not actually needed
# for this toy example)
cross_validation.set_conf_int_alpha(0.05)
# (optional) tell machine to precompute kernel matrix. speeds up. may not work
predictor.data_lock(labels, features)
# perform cross-validation and print(results)
result = cross_validation.evaluate()
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 get_labels (num, ltype='twoclass'): """Return labels used for classification. @param num Number of labels @param ltype Type of labels, either twoclass or series. @return Tuple to contain the labels as numbers in a tuple and labels as objects digestable for Shogun. """ labels=[] if ltype=='twoclass': labels.append(random.rand(num).round()*2-1) # essential to wrap in array(), will segfault sometimes otherwise labels.append(BinaryLabels(numpy.array(labels[0]))) elif ltype=='series': labels.append([numpy.double(x) for x in xrange(num)]) # essential to wrap in array(), will segfault sometimes otherwise labels.append(RegressionLabels(numpy.array(labels[0]))) else: return [None, None] return 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 RegressionLabels, 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 = RegressionLabels(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 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
prefix = 'kernel_'
feats = util.get_features(indata, prefix)
kargs = util.get_args(indata, prefix)
fun = eval(indata[prefix + 'name'] + 'Kernel')
kernel = fun(feats['train'], feats['train'], *kargs)
prefix = 'regression_'
kernel.parallel.set_num_threads(indata[prefix + 'num_threads'])
try:
rfun = eval(indata[prefix + 'name'])
except NameError, e:
print "%s is disabled/unavailable!" % indata[prefix + 'name']
return False
labels = RegressionLabels(double(indata[prefix + 'labels']))
if indata[prefix + 'type'] == 'svm':
regression = rfun(indata[prefix + 'C'], indata[prefix + 'epsilon'],
kernel, labels)
elif indata[prefix + 'type'] == 'kernelmachine':
regression = rfun(indata[prefix + 'tau'], kernel, labels)
else:
return False
regression.parallel.set_num_threads(indata[prefix + 'num_threads'])
if indata.has_key(prefix + 'tube_epsilon'):
regression.set_tube_epsilon(indata[prefix + 'tube_epsilon'])
regression.train()
alphas = 0
X = Xall[0:ntrain, :]
y = yall[0:ntrain]
Xtest = Xall[ntrain:, :]
ytest = yall[ntrain:]
# preprocess data
for i in xrange(p):
X[:, i] -= np.mean(X[:, i])
X[:, i] /= np.linalg.norm(X[:, i])
y -= np.mean(y)
# train LASSO
LeastAngleRegression = LeastAngleRegression()
LeastAngleRegression.set_labels(RegressionLabels(y))
LeastAngleRegression.train(RealFeatures(X.T))
# train ordinary LSR
if use_ridge:
lsr = LinearRidgeRegression(0.01, RealFeatures(X.T), Labels(y))
lsr.train()
else:
lsr = LeastSquaresRegression()
lsr.set_labels(RegressionLabels(y))
lsr.train(RealFeatures(X.T))
# gather LASSO path
path = np.zeros((p, LeastAngleRegression.get_path_size()))
for i in xrange(path.shape[1]):
path[:, i] = LeastAngleRegression.get_w(i)
def modelselection_grid_search_krr_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.Evaluation import CrossValidation, CrossValidationResult
from shogun.Evaluation import MeanSquaredError
from shogun.Evaluation import CrossValidationSplitting
from shogun.Features import RegressionLabels
from shogun.Features import RealFeatures
from shogun.Regression import KernelRidgeRegression
from shogun.ModelSelection import GridSearchModelSelection
from shogun.ModelSelection import ModelSelectionParameters
# training data
features_train = RealFeatures(traindat)
features_test = RealFeatures(testdat)
labels = RegressionLabels(label_traindat)
# labels
labels = RegressionLabels(label_train)
# predictor, set tau=0 here, doesnt matter
predictor = KernelRidgeRegression()
# splitting strategy for 5 fold cross-validation (for classification its better
# to use "StratifiedCrossValidation", but the standard
# "StratifiedCrossValidationSplitting" is also available
splitting_strategy = CrossValidationSplitting(labels, 5)
# evaluation method
evaluation_criterium = MeanSquaredError()
# cross-validation instance
cross_validation = CrossValidation(predictor, features_train, labels,
splitting_strategy,
evaluation_criterium)
# (optional) repeat x-val 10 times
cross_validation.set_num_runs(10)
# (optional) request 95% confidence intervals for results (not actually needed
# for this toy example)
cross_validation.set_conf_int_alpha(0.05)
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
#predictor.print_modsel_params()
# build parameter tree to select regularization parameter
param_tree_root = create_param_tree()
# model selection instance
model_selection = GridSearchModelSelection(param_tree_root,
cross_validation)
# perform model selection with selected methods
#print "performing model selection of"
#print "parameter tree:"
#param_tree_root.print_tree()
#print "starting model selection"
# print the current parameter combination, if no parameter nothing is printed
print_state = False
best_parameters = model_selection.select_model(print_state)
# print best parameters
#print "best parameters:"
#best_parameters.print_tree()
# apply them and print result
best_parameters.apply_to_machine(predictor)
result = cross_validation.evaluate()
def modelselection_grid_search_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.Evaluation import CrossValidation, CrossValidationResult
from shogun.Evaluation import MeanSquaredError
from shogun.Evaluation import CrossValidationSplitting
from shogun.Features import RegressionLabels
from shogun.Features import RealFeatures
from shogun.Kernel import GaussianKernel
from shogun.Regression import LibSVR
from shogun.ModelSelection import GridSearchModelSelection
from shogun.ModelSelection import ModelSelectionParameters, R_EXP
from shogun.ModelSelection import ParameterCombination
# training data
features_train = RealFeatures(traindat)
labels = RegressionLabels(label_traindat)
# kernel
kernel = GaussianKernel(features_train, features_train, width)
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
#kernel.print_modsel_params()
labels = RegressionLabels(label_train)
# predictor
predictor = LibSVR(C, tube_epsilon, kernel, labels)
predictor.set_epsilon(epsilon)
# splitting strategy for 5 fold cross-validation (for classification its better
# to use "StratifiedCrossValidation", but the standard
# "StratifiedCrossValidationSplitting" is also available
splitting_strategy = CrossValidationSplitting(labels, 5)
# evaluation method
evaluation_criterium = MeanSquaredError()
# cross-validation instance
cross_validation = CrossValidation(predictor, features_train, labels,
splitting_strategy,
evaluation_criterium)
# (optional) repeat x-val 10 times
cross_validation.set_num_runs(10)
# (optional) request 95% confidence intervals for results (not actually needed
# for this toy example)
cross_validation.set_conf_int_alpha(0.05)
# print all parameter available for modelselection
# Dont worry if yours is not included but, write to the mailing list
#predictor.print_modsel_params()
# build parameter tree to select C1 and C2
param_tree_root = ModelSelectionParameters()
c1 = ModelSelectionParameters("C1")
param_tree_root.append_child(c1)
c1.build_values(-2.0, 2.0, R_EXP)
c2 = ModelSelectionParameters("C2")
param_tree_root.append_child(c2)
c2.build_values(-2.0, 2.0, R_EXP)
# model selection instance
model_selection = GridSearchModelSelection(param_tree_root,
cross_validation)
# perform model selection with selected methods
#print "performing model selection of"
#print "parameter tree"
#param_tree_root.print_tree()
#print "starting model selection"
# print the current parameter combination, if no parameter nothing is printed
print_state = False
# lock data before since model selection will not change the kernel matrix
# (use with care) This avoids that the kernel matrix is recomputed in every
# iteration of the model search
predictor.data_lock(labels, features_train)
best_parameters = model_selection.select_model(print_state)
# print best parameters
#print "best parameters:"
#best_parameters.print_tree()
# apply them and print result
best_parameters.apply_to_machine(predictor)
result = cross_validation.evaluate()
X = Xall[0:ntrain, :]
y = yall[0:ntrain]
Xtest = Xall[ntrain:, :]
ytest = yall[ntrain:]
# preprocess data
for i in xrange(p):
X[:, i] -= np.mean(X[:, i])
X[:, i] /= np.linalg.norm(X[:, i])
y -= np.mean(y)
# train LASSO
LeastAngleRegression = LeastAngleRegression()
LeastAngleRegression.set_labels(RegressionLabels(y))
LeastAngleRegression.train(RealFeatures(X.T))
# train ordinary LSR
if use_ridge:
lsr = LinearRidgeRegression(0.01, RealFeatures(X.T), Labels(y))
lsr.train()
else:
lsr = LeastSquaresRegression()
lsr.set_labels(RegressionLabels(y))
lsr.train(RealFeatures(X.T))
# gather LASSO path
path = np.zeros((p, LeastAngleRegression.get_path_size()))
for i in xrange(path.shape[1]):
path[:, i] = LeastAngleRegression.get_w(i)
