def classifier_domainadaptationsvm_modular (fm_train_dna=traindna,fm_test_dna=testdna, \
label_train_dna=label_traindna, \
label_test_dna=label_testdna,fm_train_dna2=traindna2,fm_test_dna2=testdna2, \
label_train_dna2=label_traindna2,label_test_dna2=label_testdna2,C=1,degree=3):
feats_train = StringCharFeatures(fm_train_dna, DNA)
feats_test = StringCharFeatures(fm_test_dna, DNA)
kernel = WeightedDegreeStringKernel(feats_train, feats_train, degree)
labels = BinaryLabels(label_train_dna)
svm = SVMLight(C, kernel, labels)
svm.train()
#svm.io.set_loglevel(MSG_DEBUG)
#####################################
#print("obtaining DA SVM from previously trained SVM")
feats_train2 = StringCharFeatures(fm_train_dna, DNA)
feats_test2 = StringCharFeatures(fm_test_dna, DNA)
kernel2 = WeightedDegreeStringKernel(feats_train, feats_train, degree)
labels2 = BinaryLabels(label_train_dna)
# we regularize against the previously obtained solution
dasvm = DomainAdaptationSVM(C, kernel2, labels2, svm, 1.0)
dasvm.train()
out = dasvm.apply_binary(feats_test2)
return out #,dasvm TODO
def cross_validation(X, Y, d, c, K):
N = len(Y)
n = N / K
accuracy_list = []
for k in range(0, K):
print 'degree = %s\tC = %s\tcross_validation_iter = %s/%s' % (d, c,
k + 1, K)
sys.stdout.flush()
X_test = list(X[k:k + n])
Y_test = list(Y[k:k + n])
X_train = []
X_train.extend(X[:k])
X_train.extend(X[k + n:])
Y_train = []
Y_train.extend(Y[:k])
Y_train.extend(Y[k + n:])
X_train = StringCharFeatures(X_train, DNA)
X_test = StringCharFeatures(X_test, DNA)
Y_train = BinaryLabels(np.array(Y_train, dtype=np.float64))
Y_test = np.array(Y_test)
args_tuple = (X_train, Y_train, X_test, Y_test, d, c)
accuracy, Y_test_proba = svm_process(args_tuple)
accuracy_list.append(accuracy)
return np.array(accuracy_list).mean()
def classifier_featureblock_logistic_regression(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat):
from modshogun import BinaryLabels, RealFeatures, IndexBlock, IndexBlockGroup
try:
from modshogun import FeatureBlockLogisticRegression
except ImportError:
print("FeatureBlockLogisticRegression not available")
exit(0)
features = RealFeatures(hstack((traindat, traindat)))
labels = BinaryLabels(hstack((label_train, label_train)))
n_features = features.get_num_features()
block_one = IndexBlock(0, n_features // 2)
block_two = IndexBlock(n_features // 2, n_features)
block_group = IndexBlockGroup()
block_group.add_block(block_one)
block_group.add_block(block_two)
mtlr = FeatureBlockLogisticRegression(0.1, features, labels, block_group)
mtlr.set_regularization(1) # use regularization ratio
mtlr.set_tolerance(1e-2) # use 1e-2 tolerance
mtlr.train()
out = mtlr.apply().get_labels()
return out
def transfer_multitask_l12_logistic_regression(fm_train=traindat,
fm_test=testdat,
label_train=label_traindat):
from modshogun import BinaryLabels, RealFeatures, Task, TaskGroup
try:
from modshogun import MultitaskL12LogisticRegression
except ImportError:
print("MultitaskL12LogisticRegression not available")
exit(0)
features = RealFeatures(hstack((traindat, traindat)))
labels = BinaryLabels(hstack((label_train, label_train)))
n_vectors = features.get_num_vectors()
task_one = Task(0, n_vectors // 2)
task_two = Task(n_vectors // 2, n_vectors)
task_group = TaskGroup()
task_group.append_task(task_one)
task_group.append_task(task_two)
mtlr = MultitaskL12LogisticRegression(0.1, 0.1, features, labels,
task_group)
mtlr.set_tolerance(1e-2) # use 1e-2 tolerance
mtlr.set_max_iter(10)
mtlr.train()
mtlr.set_current_task(0)
out = mtlr.apply_regression().get_labels()
return out
def classifier_gpbtsvm_modular(train_fname=traindat,
test_fname=testdat,
label_fname=label_traindat,
width=2.1,
C=1,
epsilon=1e-5):
from modshogun import RealFeatures, BinaryLabels
from modshogun import GaussianKernel
from modshogun import CSVFile
try:
from modshogun import GPBTSVM
except ImportError:
print("GPBTSVM not available")
exit(0)
feats_train = RealFeatures(CSVFile(train_fname))
feats_test = RealFeatures(CSVFile(test_fname))
labels = BinaryLabels(CSVFile(label_fname))
kernel = GaussianKernel(feats_train, feats_train, width)
svm = GPBTSVM(C, kernel, labels)
svm.set_epsilon(epsilon)
svm.train()
predictions = svm.apply(feats_test)
return predictions, svm, predictions.get_labels()
def classifier_svmlight_linear_term_modular (fm_train_dna=traindna,fm_test_dna=testdna, \
label_train_dna=label_traindna,degree=3, \
C=10,epsilon=1e-5,num_threads=1):
from modshogun import StringCharFeatures, BinaryLabels, DNA
from modshogun import WeightedDegreeStringKernel
try:
from modshogun import SVMLight
except ImportError:
print("SVMLight is not available")
exit(0)
feats_train = StringCharFeatures(DNA)
feats_train.set_features(fm_train_dna)
feats_test = StringCharFeatures(DNA)
feats_test.set_features(fm_test_dna)
kernel = WeightedDegreeStringKernel(feats_train, feats_train, degree)
labels = BinaryLabels(label_train_dna)
svm = SVMLight(C, kernel, labels)
svm.set_qpsize(3)
svm.set_linear_term(
-numpy.array([1, 2, 3, 4, 5, 6, 7, 8, 7, 6], dtype=numpy.double))
svm.set_epsilon(epsilon)
svm.parallel.set_num_threads(num_threads)
svm.train()
kernel.init(feats_train, feats_test)
out = svm.apply().get_labels()
return out, kernel
def kernel_histogram_word_string_modular (fm_train_dna=traindat,fm_test_dna=testdat,label_train_dna=label_traindat,order=3,ppseudo_count=1,npseudo_count=1): from modshogun import StringCharFeatures, StringWordFeatures, DNA, BinaryLabels from modshogun import HistogramWordStringKernel, AvgDiagKernelNormalizer from modshogun import PluginEstimate#, MSG_DEBUG charfeat=StringCharFeatures(DNA) #charfeat.io.set_loglevel(MSG_DEBUG) charfeat.set_features(fm_train_dna) feats_train=StringWordFeatures(charfeat.get_alphabet()) feats_train.obtain_from_char(charfeat, order-1, order, 0, False) charfeat=StringCharFeatures(DNA) charfeat.set_features(fm_test_dna) feats_test=StringWordFeatures(charfeat.get_alphabet()) feats_test.obtain_from_char(charfeat, order-1, order, 0, False) pie=PluginEstimate(ppseudo_count,npseudo_count) labels=BinaryLabels(label_train_dna) pie.set_labels(labels) pie.set_features(feats_train) pie.train() kernel=HistogramWordStringKernel(feats_train, feats_train, pie) km_train=kernel.get_kernel_matrix() kernel.init(feats_train, feats_test) pie.set_features(feats_test) pie.apply().get_labels() km_test=kernel.get_kernel_matrix() return km_train,km_test,kernel
def modelselection_grid_search_kernel(num_subsets, num_vectors, dim_vectors):
# init seed for reproducability
Math.init_random(1)
random.seed(1)
# create some (non-sense) data
matrix = random.rand(dim_vectors, num_vectors)
# create num_feautres 2-dimensional vectors
features = RealFeatures()
features.set_feature_matrix(matrix)
# create labels, two classes
labels = BinaryLabels(num_vectors)
for i in range(num_vectors):
labels.set_label(i, 1 if i % 2 == 0 else -1)
# create svm
classifier = LibSVM()
# splitting strategy
splitting_strategy = StratifiedCrossValidationSplitting(
labels, num_subsets)
# accuracy evaluation
evaluation_criterion = ContingencyTableEvaluation(ACCURACY)
# cross validation class for evaluation in model selection
cross = CrossValidation(classifier, features, labels, splitting_strategy,
evaluation_criterion)
cross.set_num_runs(1)
# print all parameter available for modelselection
# Dont worry if yours is not included, simply write to the mailing list
#classifier.print_modsel_params()
# model parameter selection
param_tree = create_param_tree()
#param_tree.print_tree()
grid_search = GridSearchModelSelection(cross, param_tree)
print_state = False
best_combination = grid_search.select_model(print_state)
#print("best parameter(s):")
#best_combination.print_tree()
best_combination.apply_to_machine(classifier)
# larger number of runs to have tighter confidence intervals
cross.set_num_runs(10)
cross.set_conf_int_alpha(0.01)
result = cross.evaluate()
casted = CrossValidationResult.obtain_from_generic(result)
#print "result mean:", casted.mean
return classifier, result, casted.mean
def evaluation_cross_validation_mkl_weight_storage(
traindat=traindat, label_traindat=label_traindat):
from modshogun import CrossValidation, CrossValidationResult
from modshogun import CrossValidationPrintOutput
from modshogun import CrossValidationMKLStorage
from modshogun import ContingencyTableEvaluation, ACCURACY
from modshogun import StratifiedCrossValidationSplitting
from modshogun import BinaryLabels
from modshogun import RealFeatures, CombinedFeatures
from modshogun import GaussianKernel, CombinedKernel
from modshogun import LibSVM, MKLClassification
# training data, combined features all on same data
features = RealFeatures(traindat)
comb_features = CombinedFeatures()
comb_features.append_feature_obj(features)
comb_features.append_feature_obj(features)
comb_features.append_feature_obj(features)
labels = BinaryLabels(label_traindat)
# kernel, different Gaussians combined
kernel = CombinedKernel()
kernel.append_kernel(GaussianKernel(10, 0.1))
kernel.append_kernel(GaussianKernel(10, 1))
kernel.append_kernel(GaussianKernel(10, 2))
# create mkl using libsvm, due to a mem-bug, interleaved is not possible
svm = MKLClassification(LibSVM())
svm.set_interleaved_optimization_enabled(False)
svm.set_kernel(kernel)
# splitting strategy for 5 fold cross-validation (for classification its better
# to use "StratifiedCrossValidation", but the standard
# "StratifiedCrossValidationSplitting" is also available
splitting_strategy = StratifiedCrossValidationSplitting(labels, 5)
# evaluation method
evaluation_criterium = ContingencyTableEvaluation(ACCURACY)
# cross-validation instance
cross_validation = CrossValidation(svm, comb_features, labels,
splitting_strategy,
evaluation_criterium)
cross_validation.set_autolock(False)
# append cross vlaidation output classes
#cross_validation.add_cross_validation_output(CrossValidationPrintOutput())
mkl_storage = CrossValidationMKLStorage()
cross_validation.add_cross_validation_output(mkl_storage)
cross_validation.set_num_runs(3)
# perform cross-validation
result = cross_validation.evaluate()
# print mkl weights
weights = mkl_storage.get_mkl_weights()
def load_sparse_data(filename, dimension=None):
input_file = LibSVMFile(args.dataset)
sparse_feats = SparseRealFeatures()
label_array = sparse_feats.load_with_labels(input_file)
labels = BinaryLabels(label_array)
if dimension != None:
sparse_feats.set_num_features(dimension)
return {'data': sparse_feats, 'labels': labels}
