sg_options for readability

shogun-toolbox · Mar 2, 2019 · 7224abe · 7224abe
1 parent cd8b321
commit 7224abe
Show file tree

Hide file tree

Showing 33 changed files with 136 additions and 73 deletions.
diff --git a/.gitignore b/.gitignore
@@ -294,4 +294,3 @@ $RECYCLE.BIN/
 # -*- mode: gitignore; -*-
 # -*- coding: utf-8 -*-
 # vim: set fileencoding=utf-8
-cmake-*/
diff --git a/examples/meta/generator/targets/cpp.json b/examples/meta/generator/targets/cpp.json
@@ -101,7 +101,6 @@
             "get_real_matrix": "$object->get<SGMatrix<float64_t>>($arguments)",
             "get_int_string_list": "$object->get<SGStringList<int32_t>>($arguments)",
             "get_char_string_list": "$object->get<SGStringList<char>>($arguments)",
-            "get_option": "$object->get<std::string>($arguments)"
             "get_word_string_list": "$object->get<SGStringList<uint16_t>>($arguments)",
             "get_option": "$object->get<std::string>($arguments)"
         },

diff --git a/src/shogun/base/SGObject.h b/src/shogun/base/SGObject.h
@@ -388,7 +388,7 @@ class CSGObject
 	 * @param _tag name and type information of parameter
 	 * @param value value of the parameter
 	 */
-    template <typename T, typename std::enable_if_t<is_string<T>::value>* = nullptr>
+	template <typename T, typename std::enable_if_t<is_string<T>::value>* = nullptr>
 	void put(const Tag<T>& _tag, const T& value) noexcept(false)
 	{
 	    std::string val_string(value);

diff --git a/src/shogun/base/macros.h b/src/shogun/base/macros.h
@@ -50,6 +50,10 @@
 
 #define VALUE_TO_STRING_MACRO(s) #s
 
+#define SG_ADD_OPTION(...) VARARG(SG_ADD_OPTION, __VA_ARGS__)
+
+#define SG_OPTIONS(...) __VA_ARGS__
+
 #define SG_ADD_OPTION_BASE(param_name, enum_value)                             \
 	{                                                                          \
 		static_assert(                                                         \
@@ -73,6 +77,7 @@
 		static_assert(false, "Need to provide enums to add as options");       \
 	}
 
+#ifdef _MSC_VER
 #define SG_ADD_OPTION2(param_name, enum_value)                                 \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
@@ -81,46 +86,92 @@
 #define SG_ADD_OPTION3(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION2(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION4(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION3(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION5(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION4(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION6(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION5(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION7(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION6(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION8(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION7(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
 	}
 
 #define SG_ADD_OPTION9(param_name, enum_value, ...)                            \
 	{                                                                          \
 		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
-		SG_ADD_OPTION8(param_name, __VA_ARGS__)                                \
+		SG_ADD_OPTION(param_name, __VA_ARGS__)                                 \
+	}
+#else
+#define SG_ADD_OPTION2(param_name, enum_value)                                 \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
 	}
 
-#define SG_ADD_OPTION(...) VARARG(SG_ADD_OPTION, __VA_ARGS__)
+#define SG_ADD_OPTION3(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION2(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION4(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION3(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION5(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION4(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION6(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION5(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION7(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION6(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION8(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION7(param_name, __VA_ARGS__)                                 \
+	}
+
+#define SG_ADD_OPTION9(param_name, enum_value, ...)                            \
+	{                                                                          \
+		SG_ADD_OPTION_BASE(param_name, enum_value)                             \
+		SG_ADD_OPTION8(param_name, __VA_ARGS__)                                 \
+	}
+#endif
 
 // TODO: in C++17 add a if constexpr in the macro to support SG_ADD3 and
 //  SG_ADD4. This is needed because param_properties is a enum class
@@ -130,12 +181,12 @@
 //		         decltype(param_properties), ParameterProperties>::value)
 //     {
 //	       SG_ADD(param, name, description, param_properties)
-//         VARARG(SG_ADD_OPTION, name, __VA_ARGS__)
+//         SG_ADD_OPTION(name, __VA_ARGS__)
 //     }
 //  else
 //     {
 //         SG_ADD(param, name, description)
-//         VARARG(SG_ADD_OPTION, name, param_properties, __VA_ARGS__)
+//         SG_ADD_OPTION(name, param_properties, __VA_ARGS__)
 //     }
 #define SG_ADD_OPTIONS(param, name, description, param_properties, ...)        \
 	{                                                                          \
@@ -149,7 +200,7 @@
 		        decltype(param_properties), ParameterProperties>::value,       \
 		    "SG_ADD_OPTIONS requires ParameterProperties in the fourth "       \
 		    "argument position");                                              \
-		SG_ADD(param, name, description, param_properties)                     \
-		SG_ADD_OPTION(name, __VA_ARGS__)                                       \
+		SG_ADD(param, name, description, param_properties);                    \
+		SG_ADD_OPTION(name, __VA_ARGS__);                                      \
 	}
 #endif
diff --git a/src/shogun/classifier/LDA.cpp b/src/shogun/classifier/LDA.cpp
@@ -53,8 +53,8 @@ void CLDA::init()
 	SG_ADD(&m_bdc_svd, "m_bdc_svd", "Use BDC-SVD algorithm");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_method, "m_method",
-	    "Method used for LDA calculation", ParameterProperties::NONE, AUTO_LDA,
-	    SVD_LDA, FLD_LDA);
+	    "Method used for LDA calculation", ParameterProperties::NONE,
+	    SG_OPTIONS(AUTO_LDA, SVD_LDA, FLD_LDA));
 }
 
 CLDA::~CLDA()

diff --git a/src/shogun/classifier/svm/LibLinear.cpp b/src/shogun/classifier/svm/LibLinear.cpp
@@ -58,9 +58,10 @@ void CLibLinear::init()
 	SG_ADD(&m_linear_term, "linear_term", "Linear Term");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&liblinear_solver_type, "liblinear_solver_type",
-	    "Type of LibLinear solver.", ParameterProperties::NONE, L2R_LR,
-	    L2R_L2LOSS_SVC_DUAL, L2R_L2LOSS_SVC, L2R_L1LOSS_SVC_DUAL,
-	    L1R_L2LOSS_SVC, L1R_LR, L2R_LR_DUAL)
+	    "Type of LibLinear solver.", ParameterProperties::NONE,
+	    SG_OPTIONS(
+	        L2R_LR, L2R_L2LOSS_SVC_DUAL, L2R_L2LOSS_SVC, L2R_L1LOSS_SVC_DUAL,
+	        L1R_L2LOSS_SVC, L1R_LR, L2R_LR_DUAL))
 }
 
 CLibLinear::~CLibLinear()

diff --git a/src/shogun/classifier/svm/LibSVM.cpp b/src/shogun/classifier/svm/LibSVM.cpp
@@ -38,8 +38,8 @@ void CLibSVM::register_params()
 {
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&solver_type, "libsvm_solver_type",
-	    "LibSVM Solver type", ParameterProperties::NONE, LIBSVM_C_SVC,
-	    LIBSVM_NU_SVC);
+	    "LibSVM Solver type", ParameterProperties::NONE,
+	    SG_OPTIONS(LIBSVM_C_SVC, LIBSVM_NU_SVC));
 }
 
 bool CLibSVM::train_machine(CFeatures* data)

diff --git a/src/shogun/classifier/svm/SVMOcas.cpp b/src/shogun/classifier/svm/SVMOcas.cpp
@@ -352,7 +352,7 @@ void CSVMOcas::init()
 	SG_ADD(&bufsize, "bufsize", "Maximum number of cutting planes.");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&method, "method", "SVMOcas solver type.",
-	    ParameterProperties::NONE, SVM_OCAS, SVM_BMRM);
+	    ParameterProperties::NONE, SG_OPTIONS(SVM_OCAS, SVM_BMRM));
 }
 
 float64_t CSVMOcas::compute_primal_objective() const

diff --git a/src/shogun/converter/StochasticProximityEmbedding.cpp b/src/shogun/converter/StochasticProximityEmbedding.cpp
@@ -32,7 +32,7 @@ void CStochasticProximityEmbedding::init()
 	SG_ADD(&m_max_iteration, "max_iteration", "maximum number of iterations");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_strategy, "m_strategy", "SPE strategy",
-	    ParameterProperties::NONE, SPE_GLOBAL, SPE_LOCAL);
+	    ParameterProperties::NONE, SG_OPTIONS(SPE_GLOBAL, SPE_LOCAL));
 }
 
 CStochasticProximityEmbedding::~CStochasticProximityEmbedding()

diff --git a/src/shogun/distributions/Gaussian.cpp b/src/shogun/distributions/Gaussian.cpp
@@ -343,7 +343,7 @@ void CGaussian::register_params()
 	SG_ADD(&m_constant, "m_constant", "Constant part.");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_cov_type, "m_cov_type", "Covariance type.",
-	    ParameterProperties::NONE, FULL, DIAG, SPHERICAL);
+	    ParameterProperties::NONE, SG_OPTIONS(FULL, DIAG, SPHERICAL));
 }
 
 void CGaussian::decompose_cov(SGMatrix<float64_t> cov)

diff --git a/src/shogun/features/RandomFourierDotFeatures.cpp b/src/shogun/features/RandomFourierDotFeatures.cpp
@@ -61,7 +61,7 @@ CRandomFourierDotFeatures::~CRandomFourierDotFeatures()
 		SG_ADD(&constant, "constant", "A constant needed");
 		SG_ADD_OPTIONS(
 		    (machine_int_t*)&kernel, "kernel", "The kernel to approximate",
-		    ParameterProperties::NONE, GAUSSIAN, NOT_SPECIFIED);
+		    ParameterProperties::NONE, SG_OPTIONS(GAUSSIAN, NOT_SPECIFIED));
 	}
 
 CFeatures* CRandomFourierDotFeatures::duplicate() const

diff --git a/src/shogun/kernel/Kernel.cpp b/src/shogun/kernel/Kernel.cpp
@@ -941,7 +941,8 @@ void CKernel::register_params()
 
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&opt_type, "opt_type", "Optimization type.",
-	    ParameterProperties::NONE, FASTBUTMEMHUNGRY, SLOWBUTMEMEFFICIENT);
+	    ParameterProperties::NONE,
+	    SG_OPTIONS(FASTBUTMEMHUNGRY, SLOWBUTMEMEFFICIENT));
 }
 
 

diff --git a/src/shogun/kernel/normalizer/KernelNormalizer.h b/src/shogun/kernel/normalizer/KernelNormalizer.h
@@ -91,7 +91,7 @@ class CKernelNormalizer : public CSGObject
 		{
 			SG_ADD_OPTIONS(
 			    (machine_int_t*)&m_type, "m_type", "Normalizer type.",
-			    ParameterProperties::NONE, N_REGULAR, N_MULTITASK);
+			    ParameterProperties::NONE, SG_OPTIONS(N_REGULAR, N_MULTITASK));
 		}
 
 		/** getter for normalizer type

diff --git a/src/shogun/kernel/string/WeightedDegreePositionStringKernel.cpp b/src/shogun/kernel/string/WeightedDegreePositionStringKernel.cpp
@@ -1968,7 +1968,8 @@ void CWeightedDegreePositionStringKernel::init()
 	SG_ADD((CSGObject**)&alphabet, "alphabet", "Alphabet of Features.");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&type, "type", "WeightedDegree kernel type.",
-	    ParameterProperties::HYPER, E_WD, E_EXTERNAL, E_BLOCK_CONST,
-	    E_BLOCK_LINEAR, E_BLOCK_SQPOLY, E_BLOCK_CUBICPOLY, E_BLOCK_EXP,
-	    E_BLOCK_LOG);
+	    ParameterProperties::HYPER,
+	    SG_OPTIONS(
+	        E_WD, E_EXTERNAL, E_BLOCK_CONST, E_BLOCK_LINEAR, E_BLOCK_SQPOLY,
+	        E_BLOCK_CUBICPOLY, E_BLOCK_EXP, E_BLOCK_LOG));
 }
diff --git a/src/shogun/kernel/string/WeightedDegreeStringKernel.cpp b/src/shogun/kernel/string/WeightedDegreeStringKernel.cpp
@@ -1037,7 +1037,8 @@ void CWeightedDegreeStringKernel::init()
 	SG_ADD((CSGObject**)&alphabet, "alphabet", "Alphabet of Features.");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&type, "type", "WeightedDegree kernel type.",
-	    ParameterProperties::HYPER, E_WD, E_EXTERNAL, E_BLOCK_CONST,
-	    E_BLOCK_LINEAR, E_BLOCK_SQPOLY, E_BLOCK_CUBICPOLY, E_BLOCK_EXP,
-	    E_BLOCK_LOG);
+	    ParameterProperties::HYPER,
+	    SG_OPTIONS(
+	        E_WD, E_EXTERNAL, E_BLOCK_CONST, E_BLOCK_LINEAR, E_BLOCK_SQPOLY,
+	        E_BLOCK_CUBICPOLY, E_BLOCK_EXP, E_BLOCK_LOG));
 }
diff --git a/src/shogun/machine/Machine.cpp b/src/shogun/machine/Machine.cpp
@@ -28,8 +28,10 @@ CMachine::CMachine()
 	SG_ADD(&m_data_locked, "data_locked", "Indicates whether data is locked");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_solver_type, "solver_type", "Type of solver.",
-	    ParameterProperties::NONE, ST_AUTO, ST_CPLEX, ST_GLPK, ST_NEWTON,
-	    ST_DIRECT, ST_ELASTICNET, ST_BLOCK_NORM);
+	    ParameterProperties::NONE,
+	    SG_OPTIONS(
+	        ST_AUTO, ST_CPLEX, ST_GLPK, ST_NEWTON, ST_DIRECT, ST_ELASTICNET,
+	        ST_BLOCK_NORM));
 }
 
 CMachine::~CMachine()

diff --git a/src/shogun/multiclass/KNN.cpp b/src/shogun/multiclass/KNN.cpp
@@ -65,8 +65,8 @@ void CKNN::init()
 	SG_ADD(&m_leaf_size, "leaf_size", "Leaf size for KDTree");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_knn_solver, "knn_solver", "Algorithm to solve knn",
-	    ParameterProperties::NONE, KNN_BRUTE, KNN_KDTREE, KNN_COVER_TREE,
-	    KNN_LSH);
+	    ParameterProperties::NONE,
+	    SG_OPTIONS(KNN_BRUTE, KNN_KDTREE, KNN_COVER_TREE, KNN_LSH));
 }
 
 CKNN::~CKNN()

diff --git a/src/shogun/multiclass/MulticlassLibSVM.cpp b/src/shogun/multiclass/MulticlassLibSVM.cpp
@@ -30,8 +30,8 @@ void CMulticlassLibSVM::register_params()
 {
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&solver_type, "libsvm_solver_type",
-	    "LibSVM solver type", ParameterProperties::NONE, LIBSVM_C_SVC,
-	    LIBSVM_NU_SVC);
+	    "LibSVM solver type", ParameterProperties::NONE,
+	    SG_OPTIONS(LIBSVM_C_SVC, LIBSVM_NU_SVC));
 }
 
 bool CMulticlassLibSVM::train_machine(CFeatures* data)

diff --git a/src/shogun/multiclass/MulticlassStrategy.cpp b/src/shogun/multiclass/MulticlassStrategy.cpp
@@ -41,8 +41,8 @@ void CMulticlassStrategy::init()
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_prob_heuris, "prob_heuris",
 	    "Probability estimation heuristics", ParameterProperties::NONE,
-	    PROB_HEURIS_NONE, OVA_NORM, OVA_SOFTMAX, OVO_PRICE, OVO_HASTIE,
-	    OVO_HAMAMURA)
+	    SG_OPTIONS(PROB_HEURIS_NONE, OVA_NORM, OVA_SOFTMAX, OVO_PRICE, OVO_HASTIE,
+	    OVO_HAMAMURA))
 }
 
 void CMulticlassStrategy::train_start(CMulticlassLabels *orig_labels, CBinaryLabels *train_labels)

diff --git a/src/shogun/multiclass/ScatterSVM.cpp b/src/shogun/multiclass/ScatterSVM.cpp
@@ -56,11 +56,11 @@ void CScatterSVM::register_params()
 
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&scatter_type, "scatter_type", "Type of scatter SVM",
-	    ParameterProperties::NONE, NO_BIAS_LIBSVM,
+	    ParameterProperties::NONE, SG_OPTIONS(NO_BIAS_LIBSVM,
 #ifdef USE_SVMLIGHT
 	    NO_BIAS_SVMLIGHT,
 #endif // USE_SVMLIGHT
-	    TEST_RULE1, TEST_RULE2);
+	    TEST_RULE1, TEST_RULE2));
 }
 
 bool CScatterSVM::train_machine(CFeatures* data)

diff --git a/src/shogun/multiclass/tree/CARTree.cpp b/src/shogun/multiclass/tree/CARTree.cpp
@@ -1506,6 +1506,7 @@ void CCARTree::init()
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_mode, "mode",
 	    "problem type (multiclass or regression)", ParameterProperties::NONE,
-	    PT_BINARY, PT_REGRESSION, PT_MULTICLASS, PT_STRUCTURED, PT_LATENT,
-	    PT_CLASS);
+	    SG_OPTIONS(
+	        PT_BINARY, PT_REGRESSION, PT_MULTICLASS, PT_STRUCTURED, PT_LATENT,
+	        PT_CLASS));
 }
diff --git a/src/shogun/neuralnets/Autoencoder.cpp b/src/shogun/neuralnets/Autoencoder.cpp
@@ -181,5 +181,6 @@ void CAutoencoder::init()
 	    "Contraction Coefficient");
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_noise_type, "noise_type", "Noise Type",
-	    ParameterProperties::NONE, AENT_NONE, AENT_DROPOUT, AENT_GAUSSIAN);
+	    ParameterProperties::NONE,
+	    SG_OPTIONS(AENT_NONE, AENT_DROPOUT, AENT_GAUSSIAN));
 }
diff --git a/src/shogun/neuralnets/DeepBeliefNetwork.cpp b/src/shogun/neuralnets/DeepBeliefNetwork.cpp
@@ -650,6 +650,6 @@ void CDeepBeliefNetwork::init()
 
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_visible_units_type, "visible_units_type",
-	    "Type of the visible units", ParameterProperties::HYPER, RBMVUT_BINARY,
-	    RBMVUT_GAUSSIAN, RBMVUT_SOFTMAX);
+	    "Type of the visible units", ParameterProperties::HYPER,
+	    SG_OPTIONS(RBMVUT_BINARY, RBMVUT_GAUSSIAN, RBMVUT_SOFTMAX));
 }
diff --git a/src/shogun/neuralnets/NeuralConvolutionalLayer.cpp b/src/shogun/neuralnets/NeuralConvolutionalLayer.cpp
@@ -304,9 +304,10 @@ void CNeuralConvolutionalLayer::init()
 
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_initialization_mode, "initialization_mode",
-	    "Initialization Mode", ParameterProperties::NONE, NORMAL, RE_NORMAL);
+	    "Initialization Mode", ParameterProperties::NONE,
+	    SG_OPTIONS(NORMAL, RE_NORMAL));
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&m_activation_function, "activation_function",
-	    "Activation Function", ParameterProperties::NONE, CMAF_IDENTITY,
-	    CMAF_LOGISTIC, CMAF_RECTIFIED_LINEAR)
+	    "Activation Function", ParameterProperties::NONE,
+	    SG_OPTIONS(CMAF_IDENTITY, CMAF_LOGISTIC, CMAF_RECTIFIED_LINEAR))
 }
diff --git a/src/shogun/neuralnets/NeuralLayer.cpp b/src/shogun/neuralnets/NeuralLayer.cpp
@@ -140,6 +140,6 @@ void CNeuralLayer::init()
 
 	SG_ADD_OPTIONS(
 	    (machine_int_t*)&autoencoder_position, "autoencoder_position",
-	    "Autoencoder Position", ParameterProperties::NONE, NLAP_NONE,
-	    NLAP_ENCODING, NLAP_DECODING);
+	    "Autoencoder Position", ParameterProperties::NONE,
+	    SG_OPTIONS(NLAP_NONE, NLAP_ENCODING, NLAP_DECODING));
 }