General improvements to autoencoders modules.

- VAE reparameterize() function returns just mean values at prediction
  time.
- Updated examples/autoencoder directory.
- Renamed docs/source/ml4chem.fingerprints.rst to
  docs/source/ml4chem.features.rst
- Potentials() class updated to properly work with new VAE changes.

docs/source/ml4chem.fingerprints.rst → docs/source/ml4chem.features.rst

@@ -1,35 +1,35 @@
 ml4chem.features package
-============================
+========================
 
 Submodules
 ----------
 
 ml4chem.features.autoencoders module
-----------------------------------------
+------------------------------------
 
 .. automodule:: ml4chem.features.autoencoders
     :members:
     :undoc-members:
     :show-inheritance:
 
 ml4chem.features.cartesian module
--------------------------------------
+---------------------------------
 
 .. automodule:: ml4chem.features.cartesian
     :members:
     :undoc-members:
     :show-inheritance:
 
 ml4chem.features.cutoff module
-----------------------------------
+------------------------------
 
 .. automodule:: ml4chem.features.cutoff
     :members:
     :undoc-members:
     :show-inheritance:
 
 ml4chem.features.gaussian module
-------------------------------------
+--------------------------------
 
 .. automodule:: ml4chem.features.gaussian
     :members:

docs/source/models.rst

@@ -187,7 +187,7 @@ reconstruct the input data.
     autoencoder.prepare_model(input_dimension, output_dimension, data=data_handler)
 
 
-ML4Chem also provides access to variational autoencoders (VAE)[Kingma2013]_.
+ML4Chem also provides access to variational autoencoders (VAE) [Kingma2013]_.
 These architectures differ from an AE in that the encoder codes a
 distribution with mean and variance (two vectors with the desired latent
 space dimension) instead of a single latent vector. Subsequently, this

examples/autoencoder/cu_inference.py

@@ -67,5 +67,5 @@ def autoencode():
 if __name__ == "__main__":
     logger("cu_inference.log")
     cluster = LocalCluster()
-    client = Client(cluster, asyncronous=True)
+    client = Client(cluster)
     autoencode()

examples/autoencoder/cu_training.py

@@ -82,5 +82,5 @@ def autoencode():
 if __name__ == "__main__":
     logger(filename="cu_training.log")
     cluster = LocalCluster()
-    client = Client(cluster, asyncronous=True)
+    client = Client(cluster)
     inputs, outputs, data_handler = autoencode()

ml4chem/features/autoencoders.py

@@ -170,7 +170,9 @@ def calculate(self, images, purpose="training", data=None, svm=False):
             del _latent_space
 
         else:
-            latent_space = encoder.get_latent_space(feature_space, svm=svm)
+            if encoder.name() == "VAE":
+                purpose = "inference"
+            latent_space = encoder.get_latent_space(feature_space, svm=svm, purpose=purpose)
 
         return latent_space
 

ml4chem/models/autoencoders.py

@@ -579,7 +579,7 @@ def decode(self, z, symbol=None):
         else:
             raise NotImplementedError
 
-    def reparameterize(self, mu, logvar):
+    def reparameterize(self, mu, logvar, purpose=None):
         """Reparameterization trick
 
         This trick samples the posterior (a latent vector) from a
@@ -598,9 +598,16 @@ def reparameterize(self, mu, logvar):
         Sample vector
             A sample from the distribution.
         """
-        std = torch.exp(0.5 * logvar)
-        eps = torch.randn_like(std)
-        return mu + eps * std
+        if purpose is None:
+            raise("You need to provide a purpose")
+
+        elif purpose == "training":
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return mu + eps * std
+
+        else:
+            return mu
 
     def forward(self, X):
         """Forward propagation
@@ -692,6 +699,9 @@ def get_latent_space(self, X, svm=False, purpose=None):
         forward propagate and get the latent_space.
         """
 
+        if purpose is None:
+            raise("You need to provide a purpose")
+
         # FIXME parallelize me
         if purpose == "preprocessing":
             hashes = []
@@ -706,7 +716,7 @@ def get_latent_space(self, X, svm=False, purpose=None):
                         mu_latent, logvar_latent = self.encode(x)
                     else:
                         mu_latent, logvar_latent = self.encode(x, symbol=symbol)
-                    latent_vector = self.reparameterize(mu_latent, logvar_latent)
+                    latent_vector = self.reparameterize(mu_latent, logvar_latent, purpose="latent")
                     _symbols.append(symbol)
 
                     if svm:
@@ -735,7 +745,7 @@ def get_latent_space(self, X, svm=False, purpose=None):
                         mu_latent, logvar_latent = self.encode(x)
                     else:
                         mu_latent, logvar_latent = self.encode(x, symbol=symbol)
-                    latent_vector = self.reparameterize(mu_latent, logvar_latent)
+                    latent_vector = self.reparameterize(mu_latent, logvar_latent, purpose=purpose)
 
                     if svm:
                         _latent_vector = latent_vector.detach().numpy()

ml4chem/potentials.py

@@ -240,16 +240,17 @@ def train(
             None.
         """
 
-        data_handler = Data(training_set, purpose="training")
+        purpose = "training"
+        data_handler = Data(training_set, purpose=purpose)
         # Raw input and targets aka X, y
-        training_set, targets = data_handler.get_data(purpose="training")
+        training_set, targets = data_handler.get_data(purpose=purpose)
 
         # Now let's train
         # SVM models
         if self.model.name() in Potentials.svm_models:
             # Mapping raw positions into a feature space aka X
             feature_space, reference_features = self.features.calculate(
-                training_set, data=data_handler, purpose="training", svm=True
+                training_set, data=data_handler, purpose=purpose, svm=True
             )
             self.model.prepare_model(
                 feature_space, reference_features, data=data_handler
@@ -258,8 +259,9 @@ def train(
             self.model.train(feature_space, targets)
         else:
             # Mapping raw positions into a feature space aka X
+
             feature_space = self.features.calculate(
-                training_set, data=data_handler, purpose="training", svm=False
+                training_set, data=data_handler, purpose=purpose, svm=False
             )
 
             # Fixed fingerprint dimension