feat: add get_sampleset method to GaussianProcess and update bindings

Author: mblum

examples/PythonTutorial.ipynb

@@ -210,24 +210,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "0783f49b",
+   "execution_count": 9,
+   "id": "926ea540",
    "metadata": {},
    "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "99e7a214",
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "model_json = gp.to_json()"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "650d9295",
+   "id": "cdb01041",
    "metadata": {},
    "outputs": [],
    "source": []

include/gp.h

@@ -86,6 +86,8 @@ namespace libgp {
 
     /** Clear sample set and free memory. */
     void clear_sampleset();
+
+    Eigen::MatrixXd get_sampleset();
 
     /** Get reference on currently used covariance function. */
     CovarianceFunction & covf();

libgp/gaussian_process.py

@@ -10,6 +10,15 @@ class GaussianProcess(libgp_cpp.GaussianProcess):
     This class provides methods for training and predicting with a Gaussian Process model.
     """
 
+    def __init__(self, input_dim: int, covariance_function: str) -> None:
+        """Initialize the Gaussian Process model.
+
+        Parameters:
+        - input_dim: Number of input dimensions.
+        - covariance_function: Covariance function to use (e.g., 'RBF', 'Matern').
+        """
+        super().__init__(input_dim, covariance_function)
+
     def add_pattern(self, x: np.array, y: float) -> None:
         """Add a single training pattern to the Gaussian Process model.
 
@@ -87,6 +96,15 @@ def clear_sampleset(self) -> None:
         """Clear the training set."""
         super().clear_sampleset()
 
+    def get_sampleset(self) -> tuple:
+        """Get the training set.
+
+        Returns:
+        - A tuple containing the input features and target values.
+        """
+        data = super().get_sampleset()
+        return data[:, :-1], data[:, -1]
+
     def get_log_likelihood(self) -> float:
         """Get the log likelihood of the current model.
 
@@ -134,3 +152,41 @@ def get_param_dim(self) -> int:
         - The number of hyperparameters as an integer.
         """
         return super().get_param_dim()
+
+    def to_json(self) -> dict:
+        """Convert the Gaussian Process model to a JSON-compatible dictionary.
+
+        Returns:
+        - A dictionary representation of the model.
+        """
+        x, y = self.get_sampleset()
+        return {
+            "type": "GaussianProcess",
+            "covariance_function": self.get_covariance_function(),
+            "loghyper": self.get_loghyper().tolist(),
+            "input_dim": self.get_input_dim(),
+            "sampleset_size": self.get_sampleset_size(),
+            "sampleset_x": x.tolist(),
+            "sampleset_y": y.tolist()
+        }
+
+    @classmethod
+    def from_json(cls, json_data: dict) -> "GaussianProcess":
+        """Create a Gaussian Process model from a JSON-compatible dictionary.
+
+        Parameters:
+        - json_data: A dictionary containing the model parameters.
+
+        Returns:
+        - An instance of the GaussianProcess class.
+        """
+        input_dim = json_data["input_dim"]
+        covariance_function = json_data["covariance_function"]
+        gp = cls(input_dim, covariance_function)
+        gp.set_loghyper(np.array(json_data["loghyper"]))
+        gp.add_patterns(np.array(json_data["sampleset_x"]), np.array(json_data["sampleset_y"]))
+        return gp
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Gaussian Process model."""
+        return f"GaussianProcess(input_dim={self.get_input_dim()}, covariance_function='{self.get_covariance_function()}')"

src/bindings.cpp

@@ -12,9 +12,7 @@ PYBIND11_MODULE(libgp_cpp, m) {
     m.doc() = "Python bindings for libgp - Gaussian Process Regression Library";
 
     py::class_<libgp::GaussianProcess>(m, "GaussianProcess")
-        .def(py::init<>())
         .def(py::init<size_t, const std::string&>())
-        .def(py::init<const char*>())
         .def("add_pattern", [](libgp::GaussianProcess& self, py::array_t<double> x, double y) {
             py::buffer_info buf = x.request();
             if (buf.ndim != 1) 
@@ -46,6 +44,7 @@ PYBIND11_MODULE(libgp_cpp, m) {
         .def("set_y", &libgp::GaussianProcess::set_y)
         .def("get_sampleset_size", &libgp::GaussianProcess::get_sampleset_size)
         .def("clear_sampleset", &libgp::GaussianProcess::clear_sampleset)
+        .def("get_sampleset", &libgp::GaussianProcess::get_sampleset)
         .def("get_log_likelihood", &libgp::GaussianProcess::log_likelihood)
         .def("get_log_likelihood_gradient", &libgp::GaussianProcess::log_likelihood_gradient)
         .def("get_input_dim", &libgp::GaussianProcess::get_input_dim)
@@ -65,6 +64,9 @@ PYBIND11_MODULE(libgp_cpp, m) {
         })
         .def("get_param_dim", [](libgp::GaussianProcess& self) {
             return self.covf().get_param_dim();
+        })
+        .def("get_covariance_function", [](libgp::GaussianProcess& self) {
+            return self.covf().to_string();
         });
 
     py::class_<libgp::CovFactory>(m, "CovFactory")

src/gp.cc

@@ -265,6 +265,16 @@ namespace libgp {
     sampleset->clear();
   }
 
+  Eigen::MatrixXd GaussianProcess::get_sampleset()
+  {
+    Eigen::MatrixXd samples(sampleset->size(), input_dim + 1);
+    for (size_t i=0; i<sampleset->size(); ++i) {
+      samples.row(i).head(input_dim) = sampleset->x(i);
+      samples(i, input_dim) = sampleset->y(i);
+    }
+    return samples;
+  }
+
   void GaussianProcess::write(const char * filename)
   {
     // output