Refactor ObservedValue.

src/shogun/base/SGObject.cpp

@@ -50,9 +50,7 @@ namespace shogun
 {
 
 	typedef std::map<BaseTag, AnyParameter> ParametersMap;
-	typedef std::unordered_map<
-	    std::string, std::pair<SG_OBS_VALUE_TYPE, std::string>>
-	    ObsParamsList;
+	typedef std::unordered_map<std::string, std::string> ObsParamsList;
 
 	class CSGObject::Self
 	{
@@ -774,44 +772,24 @@ void CSGObject::subscribe_to_parameters(ParameterObserverInterface* obs)
 	// Create an observable which emits values only if they are about
 	// parameters selected by the observable.
 	auto subscription = m_observable_params
-	                        ->filter([obs](ObservedValue v) {
-		                        return obs->filter(v.get_name());
+	                        ->filter([obs](Some<ObservedValue> v) {
+		                        return obs->filter(v->get<std::string>("name"));
 		                    })
 	                        .timestamp()
 	                        .subscribe(sub);
 }
 
-void CSGObject::observe(const ObservedValue value)
+void CSGObject::observe(const Some<ObservedValue> value)
 {
 	m_subscriber_params->on_next(value);
 }
 
 class CSGObject::ParameterObserverList
 {
 public:
-	void register_param(
-	    const std::string& name, const SG_OBS_VALUE_TYPE type,
-	    const std::string& description)
+	void register_param(const std::string& name, const std::string& description)
 	{
-		m_list_obs_params[name] = std::make_pair(type, description);
-	}
-
-	std::string type_name(SG_OBS_VALUE_TYPE type)
-	{
-		std::string value;
-		switch (type)
-		{
-		case TENSORBOARD:
-			value = std::string("Tensorboard");
-			break;
-		case CROSSVALIDATION:
-			value = std::string("CrossValidation");
-			break;
-		default:
-			value = std::string("Unknown");
-			break;
-		}
-		return value;
+		m_list_obs_params[name] = description;
 	}
 
 	ObsParamsList get_list() const
@@ -824,24 +802,19 @@ class CSGObject::ParameterObserverList
 	ObsParamsList m_list_obs_params;
 };
 
-void CSGObject::register_observable_param(
-    const std::string& name, const SG_OBS_VALUE_TYPE type,
-    const std::string& description)
+void CSGObject::register_observable(
+    const std::string& name, const std::string& description)
 {
-	param_obs_list->register_param(name, type, description);
+	param_obs_list->register_param(name, description);
 }
 
-void CSGObject::list_observable_parameters()
+std::vector<std::string> CSGObject::observable_names()
 {
-	SG_INFO("List of observable parameters of object %s\n", get_name());
-	SG_PRINT("------");
-	for (auto const& x : param_obs_list->get_list())
-	{
-		SG_PRINT(
-		    "%s [%s]: %s\n", x.first.c_str(),
-		    param_obs_list->type_name(x.second.first).c_str(),
-		    x.second.second.c_str());
-	}
+	std::vector<std::string> list;
+	std::transform(param_obs_list->get_list().begin(),
+				   param_obs_list->get_list().end(), list.begin(),
+				   [](auto const &x ) {return x.first;});
+	return list;
 }
 
 bool CSGObject::has(const std::string& name) const

src/shogun/base/SGObject.h

@@ -24,7 +24,6 @@
 #include <shogun/lib/common.h>
 #include <shogun/lib/config.h>
 #include <shogun/lib/exception/ShogunException.h>
-#include <shogun/lib/parameter_observers/ObservedValue.h>
 #include <shogun/lib/tag.h>
 
 #include <map>
@@ -43,6 +42,7 @@ class Parallel;
 class Parameter;
 class CSerializableFile;
 class ParameterObserverInterface;
+class ObservedValue;
 class CDynamicObjectArray;
 
 template <class T, class K> class CMap;
@@ -124,14 +124,15 @@ class CSGObject
 {
 public:
 	/** Definition of observed subject */
-	typedef rxcpp::subjects::subject<ObservedValue> SGSubject;
+	typedef rxcpp::subjects::subject<Some<ObservedValue>> SGSubject;
 	/** Definition of observable */
-	typedef rxcpp::observable<ObservedValue,
-		                      rxcpp::dynamic_observable<ObservedValue>>
+	typedef rxcpp::observable<Some<ObservedValue>,
+		                      rxcpp::dynamic_observable<Some<ObservedValue>>>
 		SGObservable;
 	/** Definition of subscriber */
 	typedef rxcpp::subscriber<
-		ObservedValue, rxcpp::observer<ObservedValue, void, void, void, void>>
+		Some<ObservedValue>,
+		rxcpp::observer<Some<ObservedValue>, void, void, void, void>>
 		SGSubscriber;
 
 	/** default constructor */
@@ -568,9 +569,20 @@ class CSGObject
 	{
 		if (m_string_to_enum_map.find(_tag.name()) == m_string_to_enum_map.end())
 		{
-			SG_ERROR(
-					"There are no options for parameter %s::%s", get_name(),
-					_tag.name().c_str());
+			const Any value = get_parameter(_tag).get_value();
+			try
+			{
+				return any_cast<T>(value);
+			}
+			catch (const TypeMismatchException& exc)
+			{
+				SG_ERROR(
+					"Cannot get parameter %s::%s of type %s, incompatible "
+					"requested type %s or there are no options for parameter "
+					"%s::%s.\n",
+					get_name(), _tag.name().c_str(), exc.actual().c_str(),
+					exc.expected().c_str(), get_name(), _tag.name().c_str());
+			}
 		}
 		return string_enum_reverse_lookup(_tag.name(), get<machine_int_t>(_tag.name()));
 	}
@@ -646,7 +658,7 @@ class CSGObject
 	void subscribe_to_parameters(ParameterObserverInterface* obs);
 
 	/** Print to stdout a list of observable parameters */
-	void list_observable_parameters();
+	std::vector<std::string> observable_names();
 
 	/** Get string to enum mapping */
 	stringToEnumMapType get_string_to_enum_map() const
@@ -952,17 +964,16 @@ class CSGObject
 	 * Observe a parameter value and emit them to observer.
 	 * @param value Observed parameter's value
 	 */
-	void observe(const ObservedValue value);
+	void observe(const Some<ObservedValue> value);
 
 	/**
 	 * Register which params this object can emit.
 	 * @param name the param name
 	 * @param type the param type
 	 * @param description a user oriented description
 	 */
-	void register_observable_param(
-		const std::string& name, const SG_OBS_VALUE_TYPE type,
-		const std::string& description);
+	void register_observable(
+		const std::string& name, const std::string& description);
 
 	/** mapping from strings to enum for SWIG interface */
 	stringToEnumMapType m_string_to_enum_map;

src/shogun/evaluation/CrossValidation.cpp

@@ -13,6 +13,8 @@
 #include <shogun/evaluation/Evaluation.h>
 #include <shogun/evaluation/SplittingStrategy.h>
 #include <shogun/lib/List.h>
+//#include <shogun/lib/parameter_observers/ObservedValue.h>
+#include <shogun/lib/parameter_observers/ObservedValueTemplated.h>
 #include <shogun/machine/Machine.h>
 #include <shogun/mathematics/Statistics.h>
 
@@ -108,10 +110,10 @@ CEvaluationResult* CCrossValidation::evaluate_impl()
 		SG_DEBUG("result of cross-validation run %d is %f\n", i, results[i])
 
 		/* Emit the value*/
-		std::string obs_value_name{"cross_validation_run"};
-		ObservedValue cv_data{i, obs_value_name, make_any(storage),
-		                      CROSSVALIDATION};
-		observe(cv_data);
+		observe(
+		    ObservedValue::make_observation<CrossValidationStorage*>(
+		        i, "cross_validation_run", storage));
+
 		SG_UNREF(storage)
 	}
 

src/shogun/io/TBOutputFormat.cpp

@@ -44,23 +44,14 @@
 
 using namespace shogun;
 
-#define CHECK_TYPE(type)                                                       \
-	else if (                                                                  \
-	    value.first.get_value().type_info().hash_code() ==                     \
-	    typeid(type).hash_code())                                              \
-	{                                                                          \
-		summaryValue->set_simple_value(                                        \
-		    any_cast<type>(value.first.get_value()));                          \
-	}
-
 #define CHECK_TYPE_HISTO(type)                                                 \
 	else if (                                                                  \
-	    value.first.get_value().type_info().hash_code() ==                     \
+	    value.first->get_any().type_info().hash_code() ==                      \
 	    typeid(type).hash_code())                                              \
 	{                                                                          \
 		tensorflow::histogram::Histogram h;                                    \
 		tensorflow::HistogramProto* hp = new tensorflow::HistogramProto();     \
-		auto v = any_cast<type>(value.first.get_value());                      \
+		auto v = any_cast<type>(value.first->get_any());                       \
 		for (auto value_v : v)                                                 \
 			h.Add(value_v);                                                    \
 		h.EncodeToProto(hp, true);                                             \
@@ -77,18 +68,18 @@ tensorflow::Event TBOutputFormat::convert_scalar(
 	tensorflow::Event e;
 	std::time_t now_t = convert_to_millis(value.second);
 	e.set_wall_time(now_t);
-	e.set_step(value.first.get_step());
+	e.set_step(value.first->get<int64_t>("step"));
 
 	tensorflow::Summary* summary = e.mutable_summary();
 	auto summaryValue = summary->add_value();
-	summaryValue->set_tag(value.first.get_name());
+	summaryValue->set_tag(value.first->get<std::string>("name"));
 	summaryValue->set_node_name(node_name);
 
 	auto write_summary = [&summaryValue=summaryValue](auto val) {
 		summaryValue->set_simple_value(val);
 	};
 
-	sg_any_dispatch(value.first.get_value(), sg_all_typemap, write_summary);
+	sg_any_dispatch(value.first->get_any(), sg_all_typemap, write_summary);
 
 	return e;
 }
@@ -99,19 +90,19 @@ tensorflow::Event TBOutputFormat::convert_vector(
 	tensorflow::Event e;
 	std::time_t now_t = convert_to_millis(value.second);
 	e.set_wall_time(now_t);
-	e.set_step(value.first.get_step());
+	e.set_step(value.first->get<int64_t>("step"));
 
 	tensorflow::Summary* summary = e.mutable_summary();
 	auto summaryValue = summary->add_value();
-	summaryValue->set_tag(value.first.get_name());
+	summaryValue->set_tag(value.first->get<std::string>("name"));
 	summaryValue->set_node_name(node_name);
 
-	if (value.first.get_value().type_info().hash_code() ==
+	if (value.first->get_any().type_info().hash_code() ==
 	    typeid(std::vector<int8_t>).hash_code())
 	{
 		tensorflow::histogram::Histogram h;
 		tensorflow::HistogramProto* hp = new tensorflow::HistogramProto();
-		auto v = any_cast<std::vector<int8_t>>(value.first.get_value());
+		auto v = any_cast<std::vector<int8_t>>(value.first->get_any());
 		for (auto value_v : v)
 			h.Add(value_v);
 		h.EncodeToProto(hp, true);
@@ -131,7 +122,7 @@ tensorflow::Event TBOutputFormat::convert_vector(
 	else
 	{
 		SG_ERROR(
-		    "Unsupported type %s", value.first.get_value().type_info().name());
+		    "Unsupported type %s", value.first->get_any().type_info().name());
 	}
 
 	return e;

src/shogun/lib/parameter_observers/ObservedValue.cpp

@@ -0,0 +1,20 @@
+/*
+ * This software is distributed under BSD 3-clause license (see LICENSE file).
+ *
+ * Authors: Giovanni De Toni
+ *
+ */
+
+#include <shogun/base/Parameter.h>
+#include <shogun/lib/parameter_observers/ObservedValue.h>
+
+using namespace shogun;
+
+ObservedValue::ObservedValue(int64_t step, std::string name)
+    : CSGObject(), m_step(step), m_name(name), m_any_value(make_any(nullptr))
+{
+	SG_ADD(&m_step, "step", "Step");
+	this->watch_param(
+	    "name", &m_name,
+	    AnyParameterProperties("Name of the observed value"));
+}