Relaxed Tree

.gitignore

@@ -23,6 +23,7 @@ configure.log
 *.swo
 *.mex*
 *.oct
+.localvimrc
 
 # /doc/
 /doc/html

examples/undocumented/libshogun/classifier_multiclass_relaxedtree.cpp

@@ -0,0 +1,100 @@
+#include <algorithm>
+
+#include <shogun/labels/MulticlassLabels.h>
+#include <shogun/io/streaming/StreamingAsciiFile.h>
+#include <shogun/io/SGIO.h>
+#include <shogun/features/streaming/StreamingDenseFeatures.h>
+#include <shogun/features/DenseFeatures.h>
+#include <shogun/features/DenseSubsetFeatures.h>
+#include <shogun/base/init.h>
+#include <shogun/multiclass/tree/RelaxedTree.h>
+#include <shogun/multiclass/MulticlassLibLinear.h>
+#include <shogun/evaluation/MulticlassAccuracy.h>
+#include <shogun/kernel/GaussianKernel.h>
+
+#define  EPSILON  1e-5
+
+using namespace shogun;
+
+int main(int argc, char** argv)
+{
+	int32_t num_vectors = 0;
+	int32_t num_feats   = 0;
+
+	init_shogun_with_defaults();
+
+	const char*fname_train = "../data/7class_example4_train.dense";
+	CStreamingAsciiFile *train_file = new CStreamingAsciiFile(fname_train);
+	SG_REF(train_file);
+
+	CStreamingDenseFeatures<float64_t> *stream_features = new CStreamingDenseFeatures<float64_t>(train_file, true, 1024);
+	SG_REF(stream_features);
+
+	SGMatrix<float64_t> mat;
+	SGVector<float64_t> labvec(1000);
+
+	stream_features->start_parser();
+	SGVector< float64_t > vec;
+	int32_t num_vec=0;
+	while (stream_features->get_next_example())
+	{
+		vec = stream_features->get_vector();
+		if (num_feats == 0)
+		{
+			num_feats = vec.vlen;
+			mat = SGMatrix<float64_t>(num_feats, 1000);
+		}
+		std::copy(vec.vector, vec.vector+vec.vlen, mat.get_column_vector(num_vectors));
+		labvec[num_vectors] = stream_features->get_label();
+		num_vectors++;
+		stream_features->release_example();
+		num_vec++;
+
+		if (num_vec > 20000)
+			break;
+	}
+	stream_features->end_parser();
+	mat.num_cols = num_vectors;
+	labvec.vlen = num_vectors;
+
+	CMulticlassLabels* labels = new CMulticlassLabels(labvec);
+	SG_REF(labels);
+
+	// Create features with the useful values from mat
+	CDenseFeatures< float64_t >* features = new CDenseFeatures<float64_t>(mat);
+	SG_REF(features);
+
+	// Create RelaxedTree Machine
+	CRelaxedTree *machine = new CRelaxedTree();
+	SG_REF(machine);
+	machine->set_labels(labels);
+	CKernel *kernel = new CGaussianKernel();
+	SG_REF(kernel);
+	machine->set_kernel(kernel);
+
+	CMulticlassLibLinear *svm = new CMulticlassLibLinear();
+
+	machine->set_machine_for_confusion_matrix(svm);
+	machine->train(features);
+
+
+	CMulticlassLabels* output = CMulticlassLabels::obtain_from_generic(machine->apply());
+
+	CMulticlassAccuracy *evaluator = new CMulticlassAccuracy();
+	SG_SPRINT("Accuracy = %.4f\n", evaluator->evaluate(output, labels));
+
+	// Free resources
+	SG_UNREF(machine);
+	SG_UNREF(output);
+	SG_UNREF(features);
+	SG_UNREF(labels);
+	SG_UNREF(train_file);
+	SG_UNREF(stream_features);
+	SG_UNREF(evaluator);
+	SG_UNREF(kernel);
+
+	exit_shogun();
+
+	return 0;
+}
+

examples/undocumented/python_modular/classifier_multiclass_relaxedtree.py

@@ -0,0 +1,39 @@
+import classifier_multiclass_shared
+
+[traindat, label_traindat, testdat, label_testdat] = classifier_multiclass_shared.prepare_data(True)
+
+parameter_list = [[traindat,testdat,label_traindat,label_testdat,2.1,1,1e-5],[traindat,testdat,label_traindat,label_testdat,2.2,1,1e-5]]
+
+def classifier_multiclass_relaxedtree (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):
+	from shogun.Features import RealFeatures, MulticlassLabels
+	from shogun.Classifier import RelaxedTree, MulticlassLibLinear
+	from shogun.Kernel import GaussianKernel
+
+	print('Working on a problem of %d features and %d samples' % fm_train_real.shape)
+
+	feats_train = RealFeatures(fm_train_real)
+
+	labels = MulticlassLabels(label_train_multiclass)
+
+	machine = RelaxedTree()
+	machine.set_machine_for_confusion_matrix(MulticlassLibLinear())
+	machine.set_kernel(GaussianKernel())
+	machine.set_labels(labels)
+	machine.train(feats_train)
+
+	label_pred = machine.apply_multiclass(RealFeatures(fm_test_real))
+	out = label_pred.get_labels()
+
+	if label_test_multiclass is not None:
+		from shogun.Evaluation import MulticlassAccuracy
+		labels_test = MulticlassLabels(label_test_multiclass)
+		evaluator = MulticlassAccuracy()
+		acc = evaluator.evaluate(label_pred, labels_test)
+		print('Accuracy = %.4f' % acc)
+
+	return out
+
+if __name__=='__main__':
+	print('MulticlassMachine')
+	classifier_multiclass_relaxedtree(*parameter_list[0])
+

src/interfaces/modular/Multiclass.i

@@ -54,6 +54,7 @@
 %rename(QDA) CQDA;
 
 %rename(ShareBoost) CShareBoost;
+%rename(RelaxedTree) CRelaxedTree;
 
 /* Include Class Headers to make them visible from within the target language */
 %include <shogun/multiclass/RejectionStrategy.h>
@@ -96,4 +97,4 @@
 %include <shogun/multiclass/GaussianNaiveBayes.h>
 %include <shogun/multiclass/QDA.h>
 %include <shogun/multiclass/ShareBoost.h>
-
+%include <shogun/multiclass/tree/RelaxedTree.h>

src/interfaces/modular/Multiclass_includes.i

@@ -39,4 +39,5 @@
  #include <shogun/multiclass/GaussianNaiveBayes.h>
  #include <shogun/multiclass/QDA.h>
  #include <shogun/multiclass/ShareBoost.h>
+ #include <shogun/multiclass/tree/RelaxedTree.h>
 %}

src/shogun/base/SGObject.h

@@ -116,6 +116,24 @@ class CSGObject
 	int32_t unref();
 #endif //USE_REFERENCE_COUNTING
 
+	/** A shallow copy.
+	 * All the SGObject instance variables will be simply assigned and SG_REF-ed.
+	 */
+	virtual CSGObject *shallow_copy() const
+	{
+		SG_NOTIMPLEMENTED;
+		return NULL;
+	}
+
+	/** A deep copy.
+	 * All the instance variables will also be copied.
+	 */
+	virtual CSGObject *deep_copy() const
+	{
+		SG_NOTIMPLEMENTED;
+		return NULL;
+	}
+
 	/** Returns the name of the SGSerializable instance.  It MUST BE
 	 *  the CLASS NAME without the prefixed `C'.
 	 *

src/shogun/evaluation/MulticlassAccuracy.h

@@ -57,7 +57,7 @@ class CMulticlassAccuracy: public CEvaluation
 	 * @param ground_truth labels assumed to be correct
 	 * @return confusion matrix
 	 */
-	SGMatrix<int32_t> get_confusion_matrix(CLabels* predicted, CLabels* ground_truth);
+	static SGMatrix<int32_t> get_confusion_matrix(CLabels* predicted, CLabels* ground_truth);
 
 	inline EEvaluationDirection get_evaluation_direction()
 	{

src/shogun/kernel/GaussianKernel.cpp

@@ -46,6 +46,21 @@ CGaussianKernel::~CGaussianKernel()
 	cleanup();
 }
 
+#include <typeinfo>
+CSGObject *CGaussianKernel::shallow_copy() const
+{
+	// TODO: remove this after all the classes get shallow_copy properly implemented
+	// this assert is to avoid any subclass of CGaussianKernel accidentally called
+	// with the implement here
+	ASSERT(typeid(*this) == typeid(CGaussianKernel));
+	CGaussianKernel *kernel = new CGaussianKernel(width, cache_size);
+	if (lhs)
+	{
+		kernel->init(lhs, rhs);
+	}
+	return kernel;
+}
+
 void CGaussianKernel::cleanup()
 {
 	if (sq_lhs != sq_rhs)

src/shogun/kernel/GaussianKernel.h

@@ -68,6 +68,9 @@ class CGaussianKernel: public CDotKernel
 
 		virtual ~CGaussianKernel();
 
+		/** Make a shallow copy of the kernel */
+		virtual CSGObject *shallow_copy() const;
+
 		/** initialize kernel
 		 *
 		 * @param l features of left-hand side

src/shogun/lib/SGVector.cpp

@@ -623,6 +623,18 @@ int32_t SGVector<T>::unique(T* output, int32_t size)
 	return j;
 }
 
+template <class T>
+SGVector<index_t> SGVector<T>::find(T elem)
+{
+	SGVector<index_t> idx(vlen);
+	index_t k=0;
+
+	for (index_t i=0; i < vlen; ++i)
+		if (vector[i] == elem)
+			idx[k++] = i;
+	idx.vlen = k;
+	return idx;
+}
 
 template class SGVector<bool>;
 template class SGVector<char>;

src/shogun/lib/SGVector.h

@@ -12,6 +12,8 @@
 #ifndef __SGVECTOR_H__
 #define __SGVECTOR_H__
 
+#include <algorithm>
+
 #include <shogun/io/SGIO.h>
 #include <shogun/lib/DataType.h>
 #include <shogun/lib/SGReferencedData.h>
@@ -471,6 +473,57 @@ template<class T> class SGVector : public SGReferencedData
 			const SGVector<T>, const char* name="vector",
 			const char* prefix="");
 
+		/** find index for occurance of an element
+		 * @param elem the element to find
+		 */
+		SGVector<index_t> find(T elem);
+
+		/** find index for elements where the predicate returns true
+		 * @param p the predicate, it should accept the value of the element and return a bool
+		 */
+		template <typename Predicate>
+			SGVector<index_t> find_if(Predicate p)
+			{
+				SGVector<index_t> idx(vlen);
+				index_t k=0; 
+
+				for (index_t i=0; i < vlen; ++i)
+					if (p(vector[i]))
+						idx[k++] = i;
+
+				idx.vlen = k;
+				return idx;
+			}
+
+		/** Helper functor for the function sorted_index */
+		struct IndexSorter
+		{
+			IndexSorter(const SGVector<T> *vec) { data = vec->vector; }
+
+			bool operator() (index_t i, index_t j) const
+			{
+				return data[i] < data[j];
+			}
+
+			const T* data;
+		};
+		/** get sorted index.
+		 *
+		 * idx = v.sorted_index() is similar to Matlab [~, idx] = sort(v)
+		 *
+		 * @return sorted index for this vector
+		 */
+		SGVector<index_t> sorted_index()
+		{
+			IndexSorter cmp(this);
+			SGVector<index_t> idx(vlen);
+			for (index_t i=0; i < vlen; ++i)
+				idx[i] = i;
+
+			std::sort(idx.vector, idx.vector+vlen, cmp);
+
+			return idx;
+		}
 
 	protected:
 		/** needs to be overridden to copy data */

src/shogun/multiclass/tree/ConditionalProbabilityTree.h

@@ -43,8 +43,6 @@ struct ConditionalProbabilityTreeNodeData
 class CConditionalProbabilityTree: public CTreeMachine<ConditionalProbabilityTreeNodeData>
 {
 public:
-	typedef CTreeMachineNode<ConditionalProbabilityTreeNodeData> node_t;
-
     /** constructor */
 	CConditionalProbabilityTree(int32_t num_passes=1)
 		:m_num_passes(num_passes), m_feats(NULL)