Merge pull request #915 from karlnapf/master

example updates in order to make test-suite work

examples/undocumented/libshogun/classifier_larank.cpp

@@ -1,3 +1,12 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Written (W) 2013 Heiko Strathmann and others
+ */
+
 #include <shogun/labels/MulticlassLabels.h>
 #include <shogun/features/DenseFeatures.h>
 #include <shogun/kernel/GaussianKernel.h>
@@ -6,28 +15,42 @@
 
 using namespace shogun;
 
-void print_message(FILE* target, const char* str)
+void test()
 {
-	fprintf(target, "%s", str);
-}
+	index_t num_vec=10;
+	index_t num_feat=3;
+	index_t num_class=num_feat; // to make data easy
+	float64_t distance=15;
 
-int main(int argc, char** argv)
-{
-	init_shogun(&print_message);
-	index_t num_vec=3;
-	index_t num_feat=2;
-	index_t num_class=2;
+	// create some linearly seperable data
+	SGMatrix<float64_t> matrix(num_class, num_vec);
+	SGMatrix<float64_t> matrix_test(num_class, num_vec);
+	CMulticlassLabels* labels=new CMulticlassLabels(num_vec);
+	CMulticlassLabels* labels_test=new CMulticlassLabels(num_vec);
+	for (index_t i=0; i<num_vec; ++i)
+	{
+		index_t label=i%num_class;
+		for (index_t j=0; j<num_feat; ++j)
+		{
+			matrix(j,i)=CMath::randn_double();
+			matrix_test(j,i)=CMath::randn_double();
+			labels->set_label(i, label);
+			labels_test->set_label(i, label);
+		}
 
-	// create some data
-	SGMatrix<float64_t> matrix(num_feat, num_vec);
-	SGVector<float64_t>::range_fill_vector(matrix.matrix, num_feat*num_vec);
+		/* make sure data is linearly seperable per class */
+		matrix(label,i)+=distance;
+		matrix_test(label,i)+=distance;
+	}
+	matrix.display_matrix("matrix");
+	labels->get_int_labels().display_vector("labels");
 
-	// create vectors
 	// shogun will now own the matrix created
 	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(matrix);
+	CDenseFeatures<float64_t>* features_test=
+			new CDenseFeatures<float64_t>(matrix_test);
 
 	// create three labels
-	CMulticlassLabels* labels=new CMulticlassLabels(num_vec);
 	for (index_t i=0; i<num_vec; ++i)
 		labels->set_label(i, i%num_class);
 
@@ -41,21 +64,39 @@ int main(int argc, char** argv)
 	svm->train();
 
 	// classify on training examples
-	CMulticlassLabels* output=CMulticlassLabels::obtain_from_generic(svm->apply());
-	SGVector<float64_t>::display_vector(output->get_labels().vector, output->get_num_labels(),
-			"batch output");
+	CMulticlassLabels* output=(CMulticlassLabels*)svm->apply();
+	output->get_labels().display_vector("batch output");
 
 	/* assert that batch apply and apply(index_t) give same result */
+	SGVector<float64_t> single_outputs(output->get_num_labels());
 	for (index_t i=0; i<output->get_num_labels(); ++i)
-	{
-		float64_t label=svm->apply_one(i);
-		SG_SPRINT("single output[%d]=%f\n", i, label);
-		ASSERT(output->get_label(i)==label);
-	}
-	SG_UNREF(output);
+		single_outputs[i]=svm->apply_one(i);
+
+	single_outputs.display_vector("single_outputs");
+
+	for (index_t i=0; i<output->get_num_labels(); ++i)
+		ASSERT(output->get_label(i)==single_outputs[i]);
+
+	CMulticlassLabels* output_test=
+			(CMulticlassLabels*)svm->apply(features_test);
+	labels_test->get_labels().display_vector("labels_test");
+	output_test->get_labels().display_vector("output_test");
+
+	for (index_t i=0; i<output->get_num_labels(); ++i)
+		ASSERT(labels_test->get_label(i)==output_test->get_label(i));
 
 	// free up memory
+	SG_UNREF(output);
+	SG_UNREF(labels_test);
+	SG_UNREF(output_test);
 	SG_UNREF(svm);
+}
+
+int main(int argc, char** argv)
+{
+	init_shogun_with_defaults();
+
+	test();
 
 	exit_shogun();
 	return 0;

examples/undocumented/python_modular/classifier_larank_modular.py

@@ -1,35 +1,42 @@
 #!/usr/bin/env python
-from tools.load import LoadMatrix
-lm=LoadMatrix()
+from numpy import *
+parameter_list = [[10,3,15,0.9,1,2000,1],[20,4,15,0.9,1,5000,2]]
 
-traindat = lm.load_numbers('../data/fm_train_real.dat')
-testdat = lm.load_numbers('../data/fm_test_real.dat')
-label_traindat = lm.load_labels('../data/label_train_multiclass.dat')
-
-parameter_list = [[traindat,testdat,label_traindat,0.9,1,2000],[traindat,testdat,label_traindat,3,1,5000]]
-
-def classifier_larank_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,C=0.9,num_threads=1,num_iter=5):
+def classifier_larank_modular (num_vec,num_class,distance,C=0.9,num_threads=1,num_iter=5,seed=1):
 	from shogun.Features import RealFeatures, MulticlassLabels
 	from shogun.Kernel import GaussianKernel
 	from shogun.Classifier import LaRank
 	from shogun.Mathematics import Math_init_random
-	Math_init_random(17)
-
-	feats_train=RealFeatures(fm_train_real)
-	feats_test=RealFeatures(fm_test_real)
+
+	# reproducible results
+	Math_init_random(seed)
+	random.seed(seed)
+
+	# generate some training data where each class pair is linearly separable
+	label_train=array([mod(x,num_class) for x in range(num_vec)],dtype="float64")
+	label_test=array([mod(x,num_class) for x in range(num_vec)],dtype="float64")
+	fm_train=array(random.randn(num_class,num_vec))
+	fm_test=array(random.randn(num_class,num_vec))
+	for i in range(len(label_train)):
+		fm_train[label_train[i],i]+=distance
+		fm_test[label_test[i],i]+=distance
+
+	feats_train=RealFeatures(fm_train)
+	feats_test=RealFeatures(fm_test)
+
 	width=2.1
 	kernel=GaussianKernel(feats_train, feats_train, width)
 
 	epsilon=1e-5
-	labels=MulticlassLabels(label_train_multiclass)
+	labels=MulticlassLabels(label_train)
 
 	svm=LaRank(C, kernel, labels)
 	#svm.set_tau(1e-3)
 	svm.set_batch_mode(False)
 	#svm.io.enable_progress()
 	svm.set_epsilon(epsilon)
 	svm.train()
-	out=svm.apply(feats_train).get_labels()
+	out=svm.apply(feats_test).get_labels()
 	predictions = svm.apply()
 	return predictions, svm, predictions.get_labels()
 

examples/undocumented/python_modular/classifier_multiclassocas_modular.py

@@ -1,24 +1,37 @@
 #!/usr/bin/env python
-from tools.multiclass_shared import prepare_data
+from numpy import *
+parameter_list = [[10,3,15,2.1,1,1e-5,1],[20,4,15,2.2,2,1e-5,2]]
 
-[traindat, label_traindat, testdat, label_testdat] = prepare_data()
-
-parameter_list = [[traindat,testdat,label_traindat,2.1,1,1e-5],[traindat,testdat,label_traindat,2.2,1,1e-5]]
-
-def classifier_multiclassocas_modular (fm_train_real=traindat,fm_test_real=testdat,label_train_multiclass=label_traindat,width=2.1,C=1,epsilon=1e-5):
+def classifier_multiclassocas_modular (num_vec=10,num_class=3,distance=15,width=2.1,C=1,epsilon=1e-5,seed=1):
 	from shogun.Features import RealFeatures, MulticlassLabels
 	from shogun.Classifier import MulticlassOCAS
+	from shogun.Mathematics import Math_init_random
+
+	# reproducible results
+	random.seed(seed)
+	Math_init_random(seed)
+
+	# generate some training data where each class pair is linearly separable
+	label_train=array([mod(x,num_class) for x in range(num_vec)],dtype="float64")
+	label_test=array([mod(x,num_class) for x in range(num_vec)],dtype="float64")
+	fm_train=array(random.randn(num_class,num_vec))
+	fm_test=array(random.randn(num_class,num_vec))
+	for i in range(len(label_train)):
+		fm_train[label_train[i],i]+=distance
+		fm_test[label_test[i],i]+=distance
 
-	feats_train=RealFeatures(fm_train_real)
-	feats_test=RealFeatures(fm_test_real)
+	feats_train=RealFeatures(fm_train)
+	feats_test=RealFeatures(fm_test)
 
-	labels=MulticlassLabels(label_train_multiclass)
+	labels=MulticlassLabels(label_train)
 
 	classifier = MulticlassOCAS(C,feats_train,labels)
 	classifier.train()
 
 	out = classifier.apply(feats_test).get_labels()
-	return out
+	#print label_test
+	#print out
+	return out,classifier
 
 if __name__=='__main__':
 	print('MulticlassOCAS')

tests/unit/multiclass/LaRank_unittest.cc

@@ -0,0 +1,87 @@
+#include <shogun/labels/MulticlassLabels.h>
+#include <shogun/features/DenseFeatures.h>
+#include <shogun/kernel/GaussianKernel.h>
+#include <shogun/multiclass/LaRank.h>
+#include <shogun/base/init.h>
+#include <gtest/gtest.h>
+
+using namespace shogun;
+
+TEST(LaRank,train)
+{
+	index_t num_vec=10;
+	index_t num_feat=3;
+	index_t num_class=num_feat; // to make data easy
+	float64_t distance=15;
+
+	// create some linearly seperable data
+	SGMatrix<float64_t> matrix(num_class, num_vec);
+	SGMatrix<float64_t> matrix_test(num_class, num_vec);
+	CMulticlassLabels* labels=new CMulticlassLabels(num_vec);
+	CMulticlassLabels* labels_test=new CMulticlassLabels(num_vec);
+	for (index_t i=0; i<num_vec; ++i)
+	{
+		index_t label=i%num_class;
+		for (index_t j=0; j<num_feat; ++j)
+		{
+			matrix(j,i)=CMath::randn_double();
+			matrix_test(j,i)=CMath::randn_double();
+			labels->set_label(i, label);
+			labels_test->set_label(i, label);
+		}
+
+		/* make sure data is linearly seperable per class */
+		matrix(label,i)+=distance;
+		matrix_test(label,i)+=distance;
+	}
+	//matrix.display_matrix("matrix");
+	//labels->get_int_labels().display_vector("labels");
+
+	// shogun will now own the matrix created
+	CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t>(matrix);
+	CDenseFeatures<float64_t>* features_test=
+			new CDenseFeatures<float64_t>(matrix_test);
+
+	// create three labels
+	for (index_t i=0; i<num_vec; ++i)
+		labels->set_label(i, i%num_class);
+
+	// create gaussian kernel with cache 10MB, width 0.5
+	CGaussianKernel* kernel = new CGaussianKernel(10, 0.5);
+	kernel->init(features, features);
+
+	// create libsvm with C=10 and train
+	CLaRank* svm = new CLaRank(10, kernel, labels);
+	svm->train();
+	svm->train();
+
+	// classify on training examples
+	CMulticlassLabels* output=(CMulticlassLabels*)svm->apply();
+	output->get_labels().display_vector("batch output");
+
+	/* assert that batch apply and apply(index_t) give same result */
+	SGVector<float64_t> single_outputs(output->get_num_labels());
+	for (index_t i=0; i<output->get_num_labels(); ++i)
+		single_outputs[i]=svm->apply_one(i);
+
+	//single_outputs.display_vector("single_outputs");
+
+	for (index_t i=0; i<output->get_num_labels(); ++i)
+		EXPECT_EQ(output->get_label(i), single_outputs[i]);
+
+	// predict test labels (since data is easy this has to be correct
+	CMulticlassLabels* output_test=
+			(CMulticlassLabels*)svm->apply(features_test);
+	//labels_test->get_labels().display_vector("labels_test");
+	//output_test->get_labels().display_vector("output_test");
+
+	for (index_t i=0; i<output->get_num_labels(); ++i)
+		EXPECT_EQ(labels_test->get_label(i), output_test->get_label(i));
+
+	// free up memory
+	SG_UNREF(output);
+	SG_UNREF(labels_test);
+	SG_UNREF(output_test);
+	SG_UNREF(svm);
+}
+