Merge branch 'feat/split_pr_test_1' into feat/sparsified_soap

Author: felixmusil

bindings/bind_include.hh

@@ -29,6 +29,7 @@
 #define BINDINGS_BIND_INCLUDE_HH_
 
 #include "rascal/structure_managers/atomic_structure.hh"
+#include "rascal/utils/json_io.hh"
 #include "rascal/utils/utils.hh"
 
 #include <pybind11/eigen.h>
@@ -54,9 +55,64 @@ PYBIND11_MAKE_OPAQUE(std::vector<rascal::AtomicStructure<3>>);
 
 namespace py = pybind11;
 
-namespace rascal {
+/**
+ * Simplistic but robust implicit conversion of py::dict to/from nlohmann::json,
+ * e.g. py::dict to nlohmann::json json j = py::dict("one"_a=1, "b"_a="fgssdf");
+ * py::dict to/from nlohmann::json
+ * py::dict d = j.get<py::dict>();
+ */
+namespace nlohmann {
+  template <>
+  struct adl_serializer<py::dict> {
+    static void to_json(json & j, const py::dict & dic) {
+      py::module py_json = py::module::import("json");
+      j = json::parse(
+          static_cast<std::string>(py::str(py_json.attr("dumps")(dic))));
+    }
+    static void from_json(const json & j, py::dict & dic) {
+      py::module py_json = py::module::import("json");
+      dic = py_json.attr("loads")(j.dump());
+    }
+  };
+}  // namespace nlohmann
 
+namespace rascal {
   namespace internal {
+    /**
+     * Expose to python the serialization of rascal objects as a python
+     * dictionary.
+     *
+     * @tparam Object is expected to be nlohmann::json (de)serializable
+     *
+     * A copy and a json (de)serialization are necessary to make sure that if
+     * the resulting dictionary is written in json, then it will be directly
+     * convertible to the original object in C++ and vice-versa.
+     */
+    template <class Object, class... Bases>
+    void bind_dict_representation(py::class_<Object, Bases...> & obj) {
+      // serialization to a python dictionary
+      obj.def("to_dict", [](const Object & self) {
+        json j;
+        j = self;  // implicit conversion to nlohmann::json
+        return j.template get<py::dict>();
+      });
+      // construction from a python dictionary
+      obj.def_static("from_dict", [](const py::dict & d) {
+        json j;
+        j = d;  // implicit conversion to nlohmann::json
+        return std::make_unique<Object>(j.template get<Object>());
+      });
+      // string representation
+      obj.def("__str__", [](const Object & self) {
+        json j = self;  // implicit conversion to nlohmann::json
+        std::string str = j.dump(2);
+        std::string representation_name{internal::type_name<Object>()};
+        std::string sep{" | Parameters: "};
+        std::string prefix{"Class: "};
+        return prefix + representation_name + sep + str;
+      });
+    }
+
     /**
      * Transforms the template type to a string for the python bindings.
      * There are submodules in the python bindings with the class

bindings/bind_py_models.cc

@@ -35,9 +35,9 @@ namespace rascal {
                                        py::module & /*m_internal*/) {
     std::string kernel_name = internal::GetBindingTypeName<Kernel>();
     py::class_<Kernel> kernel(mod, kernel_name.c_str());
-    kernel.def(py::init([](std::string & hyper_str) {
+    kernel.def(py::init([](const py::dict & hyper) {
       // convert to json
-      json hypers = json::parse(hyper_str);
+      json hypers = hyper;
       return std::make_unique<Kernel>(hypers);
     }));
 
@@ -158,17 +158,20 @@ namespace rascal {
 
     // Bind the interface of this representation manager
     auto kernel = add_kernel<Kernel>(mod, m_internal);
+    internal::bind_dict_representation(kernel);
     bind_kernel_compute_function<internal::KernelType::Cosine, Calc1_t,
                                  ManagerCollection_1_t>(kernel);
     bind_kernel_compute_function<internal::KernelType::Cosine, Calc1_t,
                                  ManagerCollection_2_t>(kernel);
 
     // bind the sparse kernel and pseudo points class
     auto sparse_kernel = add_kernel<SparseKernel>(mod, m_internal);
+    internal::bind_dict_representation(sparse_kernel);
     bind_sparse_kernel_compute_function<internal::SparseKernelType::GAP,
                                         Calc1_t, ManagerCollection_2_t,
                                         SparsePoints_1_t>(sparse_kernel);
     auto sparse_points = add_sparse_points<SparsePoints_1_t>(mod, m_internal);
     bind_sparse_points_push_back<ManagerCollection_2_t, Calc1_t>(sparse_points);
+    internal::bind_dict_representation(sparse_points);
   }
 }  // namespace rascal

bindings/bind_py_representation_calculator.cc

@@ -40,15 +40,12 @@ namespace rascal {
 
     py::class_<Calculator, CalculatorBase> representation(
         mod, representation_name.c_str());
-    // use custom constructor to pass json formated string as initializer
-    // an alternative would be to convert python dict to json internally
-    // but needs some work on in the pybind machinery
-    representation.def(py::init([](std::string & hyper_str) {
+    representation.def(py::init([](const py::dict & hyper) {
       // convert to json
-      json hypers = json::parse(hyper_str);
+      json hypers = hyper;
       return std::make_unique<Calculator>(hypers);
     }));
-
+    internal::bind_dict_representation(representation);
     return representation;
   }
 

bindings/rascal/models/IP_ase_interface.py

@@ -1,8 +1,9 @@
+from ..utils import BaseIO
 from ase.calculators.calculator import Calculator, all_changes
 from copy import deepcopy
 
 
-class ASEMLCalculator(Calculator):
+class ASEMLCalculator(Calculator, BaseIO):
     """Wrapper class to use a rascal model as an interatomic potential in ASE
 
     Parameters
@@ -23,10 +24,10 @@ class ASEMLCalculator(Calculator):
     nolabel = True
 
     def __init__(self, model, representation, **kwargs):
-        Calculator.__init__(self, **kwargs)
-
+        super(ASEMLCalculator, self).__init__(**kwargs)
         self.model = model
         self.representation = representation
+        self.kwargs = kwargs
 
     def calculate(self, atoms=None, properties=['energy'],
                   system_changes=all_changes):
@@ -41,3 +42,14 @@ def calculate(self, atoms=None, properties=['energy'],
         self.results['energy'] = energy
         self.results['free_energy'] = energy
         self.results['forces'] = forces
+
+    def get_init_params(self):
+        init_params = dict(model=self.model, representation=self.representation)
+        init_params.update(**self.kwargs)
+        return init_params
+
+    def _set_data(self, data):
+        pass
+
+    def _get_data(self):
+        return dict()

bindings/rascal/models/kernels.py

@@ -2,10 +2,11 @@
 from ..lib._rascal.models.kernels import SparseKernel as SparseKernelcpp
 from ..neighbourlist import AtomsList
 from .sparse_points import SparsePoints
+from ..utils import BaseIO
 import json
 
 
-class Kernel(object):
+class Kernel(BaseIO):
 
     """
     Computes the kernel for a given representation. In the following
@@ -74,7 +75,7 @@ class Kernel(object):
 
     def __init__(self, representation, name='Cosine', kernel_type='Full', target_type='Structure',
                  **kwargs):
-
+        super(Kernel, self).__init__()
         # This case cannot be handled by the c++ side because c++ cannot deduce the
         # type from arguments inside a json, so it has to be casted in the c++
         # side. Therefore zeta has to be checked here.
@@ -94,17 +95,30 @@ def __init__(self, representation, name='Cosine', kernel_type='Full', target_typ
             raise RuntimeError("Kernel name must be one of: Cosine, GAP.")
         hypers = dict(name=name, target_type=target_type)
         hypers.update(**kwargs)
-        hypers_str = json.dumps(hypers)
         self._rep = representation
         self._representation = representation._representation
         self.name = name
         self._kwargs = kwargs
         self.kernel_type = kernel_type
         self.target_type = target_type
         if 'Sparse' in kernel_type:
-            self._kernel = SparseKernelcpp(hypers_str)
+            self._kernel = SparseKernelcpp(hypers)
         else:
-            self._kernel = Kernelcpp(hypers_str)
+            self._kernel = Kernelcpp(hypers)
+
+    def get_init_params(self):
+        init_params = dict(representation=self._rep,
+                           name=self.name,
+                           kernel_type=self.kernel_type,
+                           target_type=self.target_type)
+        init_params.update(**self._kwargs)
+        return init_params
+
+    def _set_data(self, data):
+        pass
+
+    def _get_data(self):
+        return dict()
 
     def __call__(self, X, Y=None, grad=(False, False)):
         if isinstance(X, AtomsList):

bindings/rascal/models/krr.py

@@ -1,7 +1,9 @@
+from ..utils import BaseIO
+
 import numpy as np
 
 
-class KRR(object):
+class KRR(BaseIO):
     """Kernel Ridge Regression model. Only supports sparse GPR
     training for the moment.
 
@@ -82,6 +84,19 @@ def predict(self, managers, compute_gradients=False):
     def get_weights(self):
         return self.weights
 
+    def get_init_params(self):
+        init_params = dict(weights=self.weights, kernel=self.kernel,
+                           X_train=self.X_train, self_contributions=self.self_contributions)
+        return init_params
+
+    def _set_data(self, data):
+        pass
+
+    def _get_data(self):
+        return dict()
+
+    def get_representation_calculator(self):
+        return self.kernel._rep
 
 def train_gap_model(kernel, managers, KNM_, X_pseudo, y_train, self_contributions, grad_train=None, lambdas=None, jitter=1e-8):
     """

bindings/rascal/models/sparse_points.py

@@ -1,15 +1,16 @@
 from ..lib._rascal.models import kernels
 from ..neighbourlist import AtomsList
+from ..utils import BaseIO
 
 # names of existing pseudo points implementation on the pybinding side.
-_pseudo_points = {}
+_sparse_points = {}
 for k, v in kernels.__dict__.items():
     if "SparsePoints" in k:
         name = k
-        _pseudo_points[name] = v
+        _sparse_points[name] = v
 
 
-class SparsePoints(object):
+class SparsePoints(BaseIO):
     """
     Holds features to be used as references / sparse points / pseudo points
     in sparse GPR methods.
@@ -44,24 +45,36 @@ class SparsePoints(object):
     """
 
     def __init__(self, representation):
+        super(SparsePoints, self).__init__()
         self.representation = representation
         if 'SphericalInvariants' in str(representation):
-            self._pseudo_points = _pseudo_points['SparsePointsBlockSparse_SphericalInvariants'](
+            self._sparse_points = _sparse_points['SparsePointsBlockSparse_SphericalInvariants'](
             )
         else:
             raise ValueError(
                 'No pseudo point is appropiate for ' + str(representation))
 
+    def get_init_params(self):
+        init_params = dict(representation=self.representation)
+        return init_params
+
+    def _set_data(self, data):
+        self._sparse_points = self._sparse_points.from_dict(
+            data['sparse_points'])
+
+    def _get_data(self):
+        return dict(sparse_points=self._sparse_points.to_dict())
+
     def extend(self, atoms_list, selected_indices):
         if isinstance(atoms_list, AtomsList):
-            self._pseudo_points.extend(
+            self._sparse_points.extend(
                 self.representation._representation, atoms_list.managers, selected_indices)
         else:
-            self._pseudo_points.extend(
+            self._sparse_points.extend(
                 self.representation._representation, atoms_list, selected_indices)
 
     def size(self):
-        return self._pseudo_points.size()
+        return self._sparse_points.size()
 
     def get_features(self):
-        return self._pseudo_points.get_features()
+        return self._sparse_points.get_features()

bindings/rascal/representations/coulomb_matrix.py

@@ -5,9 +5,10 @@
 from .base import CalculatorFactory
 from ..utils import FactoryPool
 from itertools import starmap
+from ..utils import BaseIO
 
 
-class SortedCoulombMatrix(object):
+class SortedCoulombMatrix(BaseIO):
     """
     Computes the Sorted Coulomb matrix representation [1].
 
@@ -38,8 +39,7 @@ class SortedCoulombMatrix(object):
         Physical Review Letters, 108(5), 58301. https://doi.org/10.1103/PhysRevLett.108.058301
     """
 
-    def __init__(self, cutoff, sorting_algorithm='row_norm', size=10, central_decay=-1, interaction_cutoff=10, interaction_decay=-1,
-                 method='thread', n_workers=1, disable_pbar=False):
+    def __init__(self, cutoff, sorting_algorithm='row_norm', size=10, central_decay=-1, interaction_cutoff=10, interaction_decay=-1):
         self.name = 'sortedcoulomb'
         self.size = size
         self.hypers = dict()
@@ -57,8 +57,6 @@ def __init__(self, cutoff, sorting_algorithm='row_norm', size=10, central_decay=
             dict(name='neighbourlist', args=dict(cutoff=cutoff)),
             dict(name='strict', args=dict(cutoff=cutoff))
         ]
-        self.misc = dict(method=method, n_workers=n_workers,
-                         disable_pbar=disable_pbar)
 
     def update_hyperparameters(self, **hypers):
         """Store the given dict of hyperparameters
@@ -91,8 +89,7 @@ def transform(self, frames):
 
         self.size = self.get_size(frames.managers)
         self.update_hyperparameters(size=self.size)
-        hypers_str = json.dumps(self.hypers)
-        self.rep_options = dict(name=self.name, args=[hypers_str])
+        self.rep_options = dict(name=self.name, args=[self.hypers])
         self._representation = CalculatorFactory(self.rep_options)
 
         self._representation.compute(frames.managers)
@@ -109,3 +106,20 @@ def get_size(self, managers):
                 Nneigh.append(center.nb_pairs + 1)
         size = int(np.max(Nneigh))
         return size
+
+    def get_init_params(self):
+        init_params = dict(
+            cutoff=self.hypers['central_cutoff'],
+            sorting_algorithm=self.hypers['sorting_algorithm'],
+            size=self.hypers['size'],
+            central_decay=self.hypers['central_decay'],
+            interaction_cutoff=self.hypers['interaction_cutoff'],
+            interaction_decay=self.hypers['interaction_decay']
+        )
+        return init_params
+
+    def _set_data(self, data):
+        pass
+
+    def _get_data(self):
+        return dict()