remove LibSVM, LibLinear, LibSVR from SWIG (shogun-toolbox#4494)

examples/meta/generator/translate.py

@@ -412,6 +412,12 @@ def getIncludePathForClass(self, type_):
                                      uniqueCandidates[0]))
             return uniqueCandidates[0]
 
+        # hack since ctags cannot find include paths for preprocessor
+        # macros generated names that use the concat (##) operator
+        # which is used from factory.h to generated methods: as_svm, etc
+        if translatedType.startswith("as_"):
+            return "shogun/util/factory.h"
+
         raise TranslationFailure('Failed to obtain include path for %s' %
                                  (' or '.join(variants)))
 

examples/meta/src/base_api/factory.sg

@@ -1,10 +1,11 @@
 RealMatrix real_matrix(2,2)
 
 Machine lib_svm = machine("LibSVM")
+SVM svm_from_machine = as_svm(lib_svm)
 Machine lda = machine("LDA")
 Kernel kernel_gaussian = kernel("GaussianKernel")
 Kernel kernel_linear = kernel("LinearKernel")
-Kernel kernel_from_object = kernel(kernel_gaussian)
+Kernel kernel_from_any_other_object = as_kernel(kernel_gaussian)
 Kernel kernel_custom_from_matrix = kernel(real_matrix)
 
 Features features_from_matrix = features(real_matrix)

examples/meta/src/base_api/put_get_add.sg

@@ -1,4 +1,4 @@
-KNN knn()
+Machine knn = machine("KNN")
 knn.put("k", 2)
 
 Kernel k = kernel("GaussianKernel")
@@ -29,9 +29,9 @@ matrix[1,1] = 0.4
 Distance dist = distance("EuclideanDistance")
 knn.put("distance", dist)
 
-LibSVM svm()
+Machine svm = machine("LibSVM")
 svm.put("kernel", k)
-Kernel k2 = kernel(svm.get("kernel"))
+Kernel k2 = as_kernel(svm.get("kernel"))
 svm.put("kernel", k2)
 
 CSVFile f_feats("../../data/regression_1d_sinc_features_train.dat")

examples/meta/src/binary/linear_support_vector_machine.sg

@@ -21,7 +21,7 @@ Machine svm = machine("LibLinear", C1=C, C2=C, labels=labels_train, epsilon=epsi
 
 #![train_and_apply]
 svm.train(features_train)
-BinaryLabels labels_predict = svm.apply_binary(features_test)
+Labels labels_predict = svm.apply(features_test)
 #![train_and_apply]
 
 #![extract_weights_bias]
@@ -35,4 +35,4 @@ real accuracy = eval.evaluate(labels_predict, labels_test)
 #![evaluate_accuracy]
 
 # additional integration testing variables
-RealVector output = labels_predict.get_labels()
+RealVector output = labels_predict.get_real_vector("labels")

examples/meta/src/evaluation/cross_validation.sg

@@ -17,7 +17,7 @@ real epsilon = 0.001
 #![set_parameters]
 
 #![create_instance]
-Machine svm = machine("LibLinear", labels=labels_train, epsilon=epsilon, C1=C, liblinear_solver_type=enum LIBLINEAR_SOLVER_TYPE.L2R_L2LOSS_SVC)
+Machine svm = machine("LibLinear", labels=labels_train, epsilon=epsilon, C1=C, C2=C, liblinear_solver_type=enum LIBLINEAR_SOLVER_TYPE.L2R_L2LOSS_SVC)
 #![create_instance]
 
 #![create_cross_validation]

examples/meta/src/evaluation/cross_validation_multiple_kernel_learning_weights_storage.sg

@@ -21,7 +21,7 @@ combined_kernel.add("kernel_array", k_3)
 #![create_kernels]
 
 #![create_classifier]
-Machine libsvm = machine("LibSVM")
+SVM libsvm = as_svm(machine("LibSVM"))
 Machine svm = machine("MKLClassification", kernel=combined_kernel, interleaved_optimization=False, svm=libsvm)
 #![create_classifier]
 
@@ -50,11 +50,11 @@ real stddev = result.get_real("std_dev")
 #![get_fold_machine]
 CrossValidationStorage obs = mkl_obs.get_observation(0)
 CrossValidationFoldStorage fold = obs.get_fold(0)
-Machine machine_mkl = machine(fold.get_trained_machine())
+Machine machine_mkl = as_machine(fold.get_trained_machine())
 
 #![get_fold_machine]
 
 #![get_weights]
-Kernel k = kernel(machine_mkl.get("kernel"))
+Kernel k = as_kernel(machine_mkl.get("kernel"))
 RealVector w = k.get_subkernel_weights()
 #![get_weights]

examples/meta/src/evaluation/cross_validation_pipeline.sg

@@ -24,7 +24,8 @@ Pipeline pipeline = builder.then(svm)
 #![create_cross_validation]
 SplittingStrategy strategy = splitting_strategy("StratifiedCrossValidationSplitting", labels=labels_train, num_subsets=2)
 Evaluation evaluation_criterion = evaluation("AccuracyMeasure")
-MachineEvaluation cross = machine_evaluation("CrossValidation", machine=machine(pipeline), features=feats_train, labels=labels_train, splitting_strategy=strategy, evaluation_criterion=evaluation_criterion, autolock=False, num_runs=2)
+Machine pipeline_as_machine = as_machine(pipeline)
+MachineEvaluation cross = machine_evaluation("CrossValidation", machine=pipeline_as_machine, features=feats_train, labels=labels_train, splitting_strategy=strategy, evaluation_criterion=evaluation_criterion, autolock=False, num_runs=2)
 #![create_cross_validation]
 
 #![evaluate_and_get_result]

examples/meta/src/evaluation/cross_validation_support_vector_machine.sg

@@ -4,8 +4,7 @@ File f_labels = csv_file("../../data/label_train_twoclass.dat")
 Features feats = features(f_feats)
 Labels labs = labels(f_labels)
 
-Machine svm = machine("LibLinear")
-svm.put("liblinear_solver_type", enum LIBLINEAR_SOLVER_TYPE.L2R_L2LOSS_SVC)
+Machine svm = machine("LibLinear", liblinear_solver_type=enum LIBLINEAR_SOLVER_TYPE.L2R_L2LOSS_SVC)
 
 StratifiedCrossValidationSplitting splitting_strategy(labs, 5)
 Evaluation evaluation_criterion = evaluation("AccuracyMeasure")

examples/meta/src/gaussian_process/regression.sg

@@ -46,4 +46,4 @@ real marg_ll = inference_method.get_negative_log_marginal_likelihood()
 #![evaluate_error_and_marginal_likelihood]
 
 # integration testing variables
-RealVector output = labels_test.get_labels()
+RealVector output = labels_test.get_real_vector("labels")

examples/meta/src/meta_api/enums.sg

@@ -1,3 +1,2 @@
-Machine m = machine("LibLinear")
-m.put("liblinear_solver_type", enum LIBLINEAR_SOLVER_TYPE.L2R_LR)
+Machine m = machine("LibLinear", liblinear_solver_type=enum LIBLINEAR_SOLVER_TYPE.L2R_LR)
 m.put("liblinear_solver_type", enum LIBLINEAR_SOLVER_TYPE.L2R_L2LOSS_SVC_DUAL)

examples/meta/src/multiclass/relaxed_tree.sg

@@ -11,7 +11,7 @@ MulticlassLabels labels_test(f_labels_test)
 #![create_features]
 
 #![set_parameters]
-MulticlassLibLinear mll()
+Machine mll = machine("MulticlassLibLinear")
 Kernel k = kernel("GaussianKernel")
 #![set_parameters]
 

examples/meta/src/multiclass/support_vector_machine.sg

@@ -6,24 +6,22 @@ CSVFile f_labels_test("../../data/classifier_4class_2d_linear_labels_test.dat")
 #![create_features]
 Features features_train = features(f_feats_train)
 Features features_test = features(f_feats_test)
-MulticlassLabels labels_train(f_labels_train)
-MulticlassLabels labels_test(f_labels_test)
+Labels labels_train = labels(f_labels_train)
+Labels labels_test = labels(f_labels_test)
 #![create_features]
 
 #![set_parameters]
 real C = 1.0
-real epsilon = 0.0001
 Kernel gauss_kernel = kernel("GaussianKernel", log_width=0.0)
 #![set_parameters]
 
 #![create_instance]
-MulticlassLibSVM svm(C, gauss_kernel, labels_train)
-svm.set_epsilon(epsilon)
+Machine svm = machine("MulticlassLibSVM", C=C, kernel=gauss_kernel, labels=labels_train)
 #![create_instance]
 
 #![train_and_apply]
 svm.train(features_train)
-MulticlassLabels labels_predict = svm.apply_multiclass(features_test)
+Labels labels_predict = svm.apply(features_test)
 #![train_and_apply]
 
 #![evaluate_accuracy]
@@ -32,4 +30,4 @@ real accuracy = accu.evaluate(labels_predict, labels_test)
 #![evaluate_accuracy]
 
 # additional integration testing variables
-RealVector output = labels_predict.get_labels()
+RealVector output = labels_predict.get_real_vector("labels")

examples/meta/src/regression/multiple_kernel_learning.sg

@@ -25,7 +25,7 @@ combined_kernel.init(features_train, features_train)
 #![create_combined_train]
 
 #![train_mkl]
-Machine binary_svm_solver = machine("SVRLight")
+SVM binary_svm_solver = as_svm(machine("SVRLight"))
 Machine mkl = machine("MKLRegression", svm=binary_svm_solver, kernel=combined_kernel, labels=labels_train)
 mkl.train()
 #![train_mkl]

examples/undocumented/python/classifier_libsvmoneclass.py

@@ -5,20 +5,19 @@
 parameter_list = [[traindat,testdat,2.2,1,1e-7],[traindat,testdat,2.1,1,1e-5]]
 
 def classifier_libsvmoneclass (train_fname=traindat,test_fname=testdat,width=2.1,C=1,epsilon=1e-5):
-	from shogun import RealFeatures, LibSVMOneClass, CSVFile
+	from shogun import RealFeatures, CSVFile
 	import shogun as sg
 
 	feats_train=RealFeatures(CSVFile(train_fname))
 	feats_test=RealFeatures(CSVFile(test_fname))
 
 	kernel=sg.kernel("GaussianKernel", log_width=width)
 
-	svm=LibSVMOneClass(C, kernel)
-	svm.set_epsilon(epsilon)
+	svm=sg.machine("LibSVMOneClass", C1=C, C2=C, kernel=kernel, epsilon=epsilon)
 	svm.train(feats_train)
 
 	predictions = svm.apply(feats_test)
-	return predictions, svm, predictions.get_labels()
+	return predictions, svm, predictions.get("labels")
 
 if __name__=='__main__':
 	print('LibSVMOneClass')

examples/undocumented/python/classifier_multiclass_ecoc.py

@@ -13,9 +13,10 @@
 def classifier_multiclass_ecoc (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,label_test_multiclass=label_testdat,lawidth=2.1,C=1,epsilon=1e-5):
 
 	import shogun
-	from shogun import ECOCStrategy, LibLinear, L2R_L2LOSS_SVC, LinearMulticlassMachine
+	from shogun import ECOCStrategy, L2R_L2LOSS_SVC, LinearMulticlassMachine
 	from shogun import MulticlassAccuracy
 	from shogun import RealFeatures, MulticlassLabels
+	import shogun as sg
 
 	def nonabstract_class(name):
 		try:
@@ -37,8 +38,9 @@ def nonabstract_class(name):
 	else:
 		gnd_test = MulticlassLabels(label_test_multiclass)
 
-	base_classifier = LibLinear(L2R_L2LOSS_SVC)
-	base_classifier.set_bias_enabled(True)
+	base_classifier = sg.machine("LibLinear",
+								liblinear_solver_type=L2R_L2LOSS_SVC,
+								use_bias=True)
 
 	#print('Testing with %d encoders and %d decoders' % (len(encoders), len(decoders)))
 	#print('-' * 70)

examples/undocumented/python/classifier_multiclassliblinear.py

@@ -7,18 +7,18 @@
 
 def classifier_multiclassliblinear (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,label_test_multiclass=label_testdat,width=2.1,C=1,epsilon=1e-5):
 	from shogun import RealFeatures, MulticlassLabels
-	from shogun import MulticlassLibLinear
+	import shogun as sg
 
 	feats_train=RealFeatures(fm_train_real)
 	feats_test=RealFeatures(fm_test_real)
 
 	labels=MulticlassLabels(label_train_multiclass)
 
-	classifier = MulticlassLibLinear(C,feats_train,labels)
-	classifier.train()
+	classifier = sg.machine("MulticlassLibLinear", C=C, labels=labels)
+	classifier.train(feats_train)
 
 	label_pred = classifier.apply(feats_test)
-	out = label_pred.get_labels()
+	out = label_pred.get("labels")
 
 	if label_test_multiclass is not None:
 		from shogun import MulticlassAccuracy

examples/undocumented/python/classifier_multiclassmachine.py

@@ -7,7 +7,7 @@
 
 def classifier_multiclassmachine (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5):
 	from shogun import RealFeatures, MulticlassLabels
-	from shogun import LibSVM, KernelMulticlassMachine, MulticlassOneVsRestStrategy
+	from shogun import KernelMulticlassMachine, MulticlassOneVsRestStrategy
 	import shogun as sg
 
 	feats_train=RealFeatures(fm_train_real)
@@ -16,8 +16,7 @@ def classifier_multiclassmachine (fm_train_real=traindat,fm_test_real=testdat,la
 
 	labels=MulticlassLabels(label_train_multiclass)
 
-	classifier = LibSVM()
-	classifier.set_epsilon(epsilon)
+	classifier = sg.machine("LibSVM", epsilon=epsilon)
 	#print labels.get_labels()
 	mc_classifier = KernelMulticlassMachine(MulticlassOneVsRestStrategy(),kernel,classifier,labels)
 	mc_classifier.train(feats_train)

examples/undocumented/python/classifier_multilabeloutputliblinear.py

@@ -7,20 +7,21 @@
 
 def classifier_multilabeloutputliblinear (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,label_test_multiclass=label_testdat,width=2.1,C=1,epsilon=1e-5):
 	from shogun import RealFeatures, MulticlassLabels, MultilabelLabels
-	from shogun import MulticlassLibLinear
-
+	import shogun as sg
+	
 	feats_train=RealFeatures(fm_train_real)
 	feats_test=RealFeatures(fm_test_real)
 
 	labels=MulticlassLabels(label_train_multiclass)
 
-	classifier = MulticlassLibLinear(C,feats_train,labels)
-	classifier.train()
+	classifier = sg.machine("MulticlassLibLinear", C=C, labels=labels)
+	classifier.train(feats_train)
 
-	label_pred = classifier.apply_multilabel_output(feats_test,2)
-	out = label_pred.get_labels()
+	# TODO: figure out the new style API for the below call, disabling for now
+	#label_pred = classifier.apply_multilabel_output(feats_test,2)
+	#out = label_pred.get_labels()
 	#print out
-	return out
+	#return out
 
 if __name__=='__main__':
 	print('MultilabelOutputLibLinear')

examples/undocumented/python/classifier_ssk.py

@@ -15,15 +15,16 @@
 def classifier_ssk (fm_train_dna=traindat,fm_test_dna=testdat,
 		label_train_dna=label_traindat,C=1,maxlen=1,decay=1):
 	from shogun import StringCharFeatures, BinaryLabels
-	from shogun import LibSVM, SubsequenceStringKernel, DNA
+	from shogun import SubsequenceStringKernel, DNA
 	from shogun import ErrorRateMeasure
+	import shogun as sg
 
 	feats_train=StringCharFeatures(fm_train_dna, DNA)
 	feats_test=StringCharFeatures(fm_test_dna, DNA)
 	labels=BinaryLabels(label_train_dna)
 	kernel=SubsequenceStringKernel(feats_train, feats_train, maxlen, decay);
 
-	svm=LibSVM(C, kernel, labels);
+	svm=sg.machine("LibSVM", C1=C, C2=C, kernel=kernel, labels=labels);
 	svm.train();
 
 	out=svm.apply(feats_train);
@@ -32,7 +33,7 @@ def classifier_ssk (fm_train_dna=traindat,fm_test_dna=testdat,
 	# print(trainerr)
 
 	kernel.init(feats_train, feats_test)
-	predicted_labels=svm.apply(feats_test).get_labels()
+	predicted_labels=svm.apply(feats_test).get("labels")
 	# print predicted_labels
 
 	return predicted_labels

examples/undocumented/python/evaluation_cross_validation_mkl_weight_storage.py

@@ -24,7 +24,7 @@ def evaluation_cross_validation_mkl_weight_storage(traindat=traindat, label_trai
     from shogun import BinaryLabels
     from shogun import RealFeatures, CombinedFeatures
     from shogun import CombinedKernel
-    from shogun import LibSVM, MKLClassification
+    from shogun import MKLClassification
     import shogun as sg
     import numpy as np
 
@@ -43,7 +43,8 @@ def evaluation_cross_validation_mkl_weight_storage(traindat=traindat, label_trai
     kernel.append_kernel(sg.kernel("GaussianKernel", log_width=np.log(2)))
 
     # create mkl using libsvm, due to a mem-bug, interleaved is not possible
-    svm=MKLClassification(LibSVM());
+    svm=MKLClassification();
+    svm.put("svm", sg.as_svm(sg.machine("LibSVM")))
     svm.set_interleaved_optimization_enabled(False);
     svm.set_kernel(kernel);
 

examples/undocumented/python/evaluation_multiclassovrevaluation.py

@@ -6,14 +6,16 @@
 
 def evaluation_multiclassovrevaluation(train_fname=traindat, label_fname=label_traindat):
 	from shogun import MulticlassOVREvaluation,ROCEvaluation
-	from shogun import MulticlassLibLinear,RealFeatures,ContingencyTableEvaluation,ACCURACY
+	from shogun import RealFeatures,ContingencyTableEvaluation,ACCURACY
 	from shogun import MulticlassLabels, Math, CSVFile
+	import shogun as sg
 
 	Math.init_random(1)
 	ground_truth_labels = MulticlassLabels(CSVFile(label_fname))
-	svm = MulticlassLibLinear(1.0,RealFeatures(CSVFile(train_fname)),ground_truth_labels)
+	svm = sg.machine("MulticlassLibLinear", C=1.0,
+					labels=ground_truth_labels)
 	svm.parallel.set_num_threads(1)
-	svm.train()
+	svm.train(RealFeatures(CSVFile(train_fname)))
 	predicted_labels = svm.apply()
 
 	binary_evaluator = ROCEvaluation()

examples/undocumented/python/kernel_combined_custom_poly.py

@@ -10,7 +10,8 @@
 def kernel_combined_custom_poly (train_fname = traindat,test_fname = testdat,train_label_fname=label_traindat):
     from shogun import CombinedFeatures, RealFeatures, BinaryLabels
     from shogun import CombinedKernel, PolyKernel, CustomKernel
-    from shogun import LibSVM, CSVFile
+    from shogun import CSVFile
+    import shogun as sg
 
     kernel = CombinedKernel()
     feats_train = CombinedFeatures()
@@ -29,7 +30,7 @@ def kernel_combined_custom_poly (train_fname = traindat,test_fname = testdat,tra
     kernel.init(feats_train, feats_train)
 
     labels = BinaryLabels(CSVFile(train_label_fname))
-    svm = LibSVM(1.0, kernel, labels)
+    svm = sg.machine("LibSVM", C1=1.0, C2=1.0, kernel=kernel, labels=labels)
     svm.train()
 
     kernel = CombinedKernel()
@@ -47,7 +48,7 @@ def kernel_combined_custom_poly (train_fname = traindat,test_fname = testdat,tra
     kernel.append_kernel(subkernel)
     kernel.init(feats_train, feats_pred)
 
-    svm.set_kernel(kernel)
+    svm.put("kernel", kernel)
     svm.apply()
     km_train=kernel.get_kernel_matrix()
     return km_train,kernel