Merge branch 'develop' of https://github.com/shogun-toolbox/shogun into develop.

Author: vinnik-dmitry07

data

@@ -5,14 +5,13 @@
         "IncludeInterfacedClasses": true, 
         "IncludeEnums": true,
         "IncludeGlobalFunctions": true,
-        "DependencyListElement": "from shogun import $typeName",
-        "DependencyListElementEnum": "from shogun import $value",
+        "DependencyListElement": "import shogun as sg",
         "DependencyListSeparator": "\n"
     },
     "Statement": "$statement\n",
     "Comment": "#$comment\n",
     "Init": {
-        "Construct": "$name = $typeName($arguments$kwargs)",
+        "Construct": "$name = sg.$typeName($arguments$kwargs)",
         "Copy": "$name = $expr",
         "KeywordArguments": {
             "List": "$elements",
@@ -81,10 +80,10 @@
             "get_option": "$object.get($arguments)",
             "get_string": "$object.get($arguments)"
         },
-        "StaticCall": "$typeName.$method($arguments)",
-        "GlobalCall": "$method($arguments$kwargs)",
+        "StaticCall": "sg.$typeName.$method($arguments)",
+        "GlobalCall": "sg.$method($arguments$kwargs)",
         "Identifier": "$identifier",
-        "Enum":"$value"
+        "Enum":"sg.$value"
     },
     "Element": {
         "Access": {

examples/meta/generator/targets/python.json

@@ -0,0 +1,20 @@
+LibSVMFile f_feats_a("@SHOGUN_DATA@/fm_train_sparsereal.dat")
+LibSVMFile f_feats_b("@SHOGUN_DATA@/fm_test_sparsereal.dat")
+
+#![create_features]
+Features features_a = features(f_feats_a)
+Features features_b = features(f_feats_b)
+#![create_features]
+
+#![create_instance]
+Distance d = distance("SparseEuclideanDistance", lhs=features_a, rhs=features_a)
+#![create_instance]
+
+#![extract_distance]
+RealMatrix distance_matrix_aa = d.get_distance_matrix()
+#![extract_distance]
+
+#![refresh_distance]
+d.init(features_a, features_b)
+RealMatrix distance_matrix_ab = d.get_distance_matrix()
+#![refresh_distance]

examples/meta/src/distance/sparseeuclidean.sg.in

@@ -0,0 +1,25 @@
+File f_feats_train = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_features_train.dat")
+File f_feats_test = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_features_test.dat")
+File f_labels_train = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_train.dat")
+File f_labels_test = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_test.dat")
+
+#![create_features]
+Features feats_train = features(f_feats_train)
+Features feats_test = features(f_feats_test)
+Labels labels_train = labels(f_labels_train)
+Labels labels_test = labels(f_labels_test)
+#![create_features]
+
+#![create_classifier]
+Machine svm= machine("MulticlassLibLinear", C=1.0, labels=labels_train)
+#![create_classifier]
+
+#![train_and_apply]
+svm.train(feats_train)
+Labels predicted_labels = svm.apply(feats_test)
+#![train_and_apply]
+
+#![evaluate_accuracy]
+Evaluation evaluator = evaluation("MulticlassAccuracy")
+real accuracy = evaluator.evaluate(predicted_labels,labels_test)
+#![evaluate_accuracy]

examples/meta/src/evaluation/accuracy_multiclass.sg.in

@@ -0,0 +1,23 @@
+File f_feats_train = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_features_train.dat")
+File f_labels_train = csv_file("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_train.dat")
+
+#![create_features]
+Features feats_train = features(f_feats_train)
+Labels labels_train = labels(f_labels_train)
+#![create_features]
+
+#![create_classifier]
+Machine svm= machine("MulticlassLibLinear", C=1.0, labels=labels_train)
+#![create_classifier]
+
+#![train_and_apply]
+svm.train(feats_train)
+Labels labels_predicted = svm.apply()
+RealVector labels = labels_predicted.get_real_vector("labels")
+#![train_and_apply]
+
+#![evaluate_accuracy]
+Evaluation binary_evaluator = evaluation("ContingencyTableEvaluation", type="ACCURACY")
+Evaluation contingency_table_evaluator = evaluation("MulticlassOVREvaluation", binary_evaluation=binary_evaluator)
+real mean_accuracy = contingency_table_evaluator.evaluate(labels_predicted,labels_train)
+#![evaluate_accuracy]

examples/meta/src/evaluation/multiclass_ovr.sg.in

@@ -0,0 +1,34 @@
+CSVFile f_feats_train("@SHOGUN_DATA@/classifier_4class_2d_linear_features_train.dat")
+CSVFile f_feats_test("@SHOGUN_DATA@/classifier_4class_2d_linear_features_test.dat")
+CSVFile f_labels_train("@SHOGUN_DATA@/classifier_4class_2d_linear_labels_train.dat")
+
+#![create_features]
+Features features_train = features(f_feats_train)
+Features features_test = features(f_feats_test)
+Labels labels_train = labels(f_labels_train)
+#![create_features]
+
+#![create_kernel]
+Kernel k = kernel("GaussianKernel", log_width=0.0)
+#![create_kernel]
+
+#![choose_strategy]
+MulticlassStrategy one_versus_rest=multiclass_strategy("MulticlassOneVsRestStrategy")
+#![choose_strategy]
+
+#![create_classifier]
+Machine classifier = machine("LibSVM")
+#![create_classifier]
+
+#![create_machine]
+Machine multiclass_machine =  machine("KernelMulticlassMachine", multiclass_strategy=one_versus_rest, kernel=k, machine=classifier, labels=labels_train)
+#![create_machine]
+
+#![train_and_apply]
+multiclass_machine.train(features_train)
+Labels labels_predict = multiclass_machine.apply(features_test)
+#![train_and_apply]
+
+#![extract_labels]
+RealVector output = labels_predict.get_real_vector("labels")
+#![extract_labels]

examples/meta/src/multiclass/one_versus_rest.sg.in

@@ -91,12 +91,14 @@ bool KernelDensity::train(std::shared_ptr<Features> data)
 	return true;
 }
 
-SGVector<float64_t> KernelDensity::get_log_density(const std::shared_ptr<DenseFeatures<float64_t>>& test, int32_t leaf_size)
+SGVector<float64_t> KernelDensity::get_log_density(const std::shared_ptr<Features>& test, int32_t leaf_size)
 {
 	require(test,"data not supplied");
+	auto dense_feat =std::dynamic_pointer_cast<DenseFeatures<float64_t>>(test);
+	require(dense_feat,"Expected DenseFeatures<float64_t> type");
 
 	if ((m_eval==EM_KDTREE_SINGLE) || (m_eval==EM_BALLTREE_SINGLE))
-		return tree->log_kernel_density(test->get_feature_matrix(),m_kernel_type,m_bandwidth,m_atol,m_rtol);
+		return tree->log_kernel_density(dense_feat->get_feature_matrix(),m_kernel_type,m_bandwidth,m_atol,m_rtol);
 
 	std::shared_ptr<CNbodyTree> query_tree=NULL;
 	if (m_eval==EM_KDTREE_DUAL)
@@ -106,7 +108,7 @@ SGVector<float64_t> KernelDensity::get_log_density(const std::shared_ptr<DenseFe
 	else
 		error("Evaluation mode not identified");
 
-	query_tree->build_tree(test);
+	query_tree->build_tree(dense_feat);
 	std::shared_ptr<BinaryTreeMachineNode<NbodyTreeNodeData>> qroot=NULL;
 	auto root=query_tree->get_root();
 	if (root)
@@ -115,7 +117,7 @@ SGVector<float64_t> KernelDensity::get_log_density(const std::shared_ptr<DenseFe
 		error("Query tree root not found!");
 
 	SGVector<index_t> qid=query_tree->get_rearranged_vector_ids();
-	SGVector<float64_t> ret=tree->log_kernel_density_dual(test->get_feature_matrix(),qid,qroot,m_kernel_type,m_bandwidth,m_atol,m_rtol);
+	SGVector<float64_t> ret=tree->log_kernel_density_dual(dense_feat->get_feature_matrix(),qid,qroot,m_kernel_type,m_bandwidth,m_atol,m_rtol);
 
 
 

examples/undocumented/python/classifier_multiclassmachine.py

@@ -97,7 +97,7 @@ public :
 	 * @param leaf_size leaf size of query tree (ignored in case of single tree evaluation mode)
 	 * @return log of estimated kernel density velues at given test points
 	 */
-	SGVector<float64_t> get_log_density(const std::shared_ptr<DenseFeatures<float64_t>>& test, int32_t leaf_size=1);
+	SGVector<float64_t> get_log_density(const std::shared_ptr<Features>& test, int32_t leaf_size=1);
 
 	/** return number of model parameters
 	 * NOT IMPLEMENTED

examples/undocumented/python/distance_sparseeuclidean.py

@@ -338,30 +338,6 @@ SGVector<T> SGVector<T>::slice(index_t l, index_t h) const
 	return SGVector<T>(vector, h - l, l);
 }
 
-/** addition operator */
-template<class T>
-SGVector<T> SGVector<T>::operator+ (SGVector<T> x)
-{
-	assert_on_cpu();
-	require(x.vector && vector, "Addition possible for only non-null vectors.");
-	require(x.vlen == vlen, "Length of the two vectors to be added should be same. [V({}) + V({})]", vlen, x.vlen);
-
-	SGVector<T> result=clone();
-	result.add(x);
-	return result;
-}
-
-template<class T>
-void SGVector<T>::add(const SGVector<T> x)
-{
-	assert_on_cpu();
-	require(x.vector && vector, "Addition possible for only non-null vectors.");
-	require(x.vlen == vlen, "Length of the two vectors to be added should be same. [V({}) + V({})]", vlen, x.vlen);
-
-	for (int32_t i=0; i<vlen; i++)
-		vector[i]+=x.vector[i];
-}
-
 template<class T>
 void SGVector<T>::add(const T x)
 {

examples/undocumented/python/evaluation_multiclassaccuracy.py

@@ -371,12 +371,6 @@ template<class T> class SGVector : public SGReferencedData
 			return vector[index];
 		}
 
-		/** Add vector to current vector
-		 *
-		 * @param x add vector x to current vector
-		 */
-		void add(const SGVector<T> x);
-
 		/** Add sparse vector to current vector
 		 *
 		 * @param x add sparse vector x to current vector
@@ -389,23 +383,6 @@ template<class T> class SGVector : public SGReferencedData
 		 */
 		void add(const T x);
 
-		/** Addition operator */
-		SGVector<T> operator+ (SGVector<T> x);
-
-		/** Inplace addition operator */
-		SGVector<T> operator+= (SGVector<T> x)
-		{
-			add(x);
-			return *this;
-		}
-
-		/** Inplace addition operator for sparse vector */
-		SGVector<T> operator+= (SGSparseVector<T>& x)
-		{
-			add(x);
-			return *this;
-		}
-
 		/** Equals method up to precision for vectors (element-wise)
 		 * @param other vector to compare with
 		 * @return false if any element differs or if sizes are different,

examples/undocumented/python/evaluation_multiclassovrevaluation.py

@@ -55,6 +55,8 @@ namespace shogun
 	    Type beta, Container<Type>& result) const;
 		DEFINE_FOR_NUMERIC_PTYPE(BACKEND_GENERIC_IN_PLACE_ADD, SGVector)
 		DEFINE_FOR_NUMERIC_PTYPE(BACKEND_GENERIC_IN_PLACE_ADD, SGMatrix)
+		BACKEND_GENERIC_IN_PLACE_ADD(complex128_t, SGVector);
+		BACKEND_GENERIC_IN_PLACE_ADD(complex128_t, SGMatrix);
 #undef BACKEND_GENERIC_IN_PLACE_ADD
 
 /** Implementation of @see LinalgBackendBase::add_col_vec */

src/shogun/distributions/KernelDensity.cpp

@@ -45,6 +45,8 @@ using namespace shogun;
 	}
 DEFINE_FOR_NUMERIC_PTYPE(BACKEND_GENERIC_IN_PLACE_ADD, SGVector)
 DEFINE_FOR_NUMERIC_PTYPE(BACKEND_GENERIC_IN_PLACE_ADD, SGMatrix)
+BACKEND_GENERIC_IN_PLACE_ADD(complex128_t, SGVector);
+BACKEND_GENERIC_IN_PLACE_ADD(complex128_t, SGMatrix);
 #undef BACKEND_GENERIC_IN_PLACE_ADD
 
 #define BACKEND_GENERIC_ADD_COL_VEC(Type, Container)                           \

src/shogun/distributions/KernelDensity.h

@@ -127,7 +127,7 @@ LogRationalApproximationIndividual::compute(SGVector<float64_t> sample) const
 		v *= m_weights[i];
 		v = -v;
 		// aggregate the result
-		agg += vec;
+		linalg::add(agg, vec, agg);
 	}
 	float64_t result =
 		linalg::dot(sample, m_linear_operator->apply(agg.get_imag()));