SpikeSlabRBM

src/mlpack/core/math/random.hpp

@@ -60,6 +60,17 @@ inline double Random(const double lo, const double hi)
   return lo + (hi - lo) * randUniformDist(randGen);
 }
 
+/**
+ * Generates a 0/1 specified by the input.
+ */
+inline double RandBernoulli(const double input)
+{
+  if (Random() < input)
+    return 1;
+  else
+    return 0;
+}
+
 /**
  * Generates a uniform random integer.
  */

src/mlpack/methods/ann/CMakeLists.txt

@@ -3,6 +3,8 @@
 set(SOURCES
   ffn.hpp
   ffn_impl.hpp
+  rbm.hpp
+  rbm_impl.hpp
   rnn.hpp
   rnn_impl.hpp
 )
@@ -21,3 +23,4 @@ add_subdirectory(activation_functions)
 add_subdirectory(init_rules)
 add_subdirectory(layer)
 add_subdirectory(convolution_rules)
+add_subdirectory(rbm)

src/mlpack/methods/ann/init_rules/gaussian_init.hpp

@@ -47,13 +47,14 @@ class GaussianInitialization
    * @param rows Number of rows.
    * @param cols Number of columns.
    */
-  void Initialize(arma::mat& W,
+  template<typename eT>
+  void Initialize(arma::Mat<eT>& W,
                   const size_t rows,
                   const size_t cols)
   {
     if (W.is_empty())
     {
-      W = arma::mat(rows, cols);
+      W = arma::Mat<eT>(rows, cols);
     }
     W.imbue( [&]() { return arma::as_scalar(RandNormal(mean, variance)); } );
   }
@@ -66,12 +67,13 @@ class GaussianInitialization
    * @param cols Number of columns.
    * @param slice Numbers of slices.
    */
-  void Initialize(arma::cube & W,
+  template<typename eT>
+  void Initialize(arma::Cube<eT> & W,
                   const size_t rows,
                   const size_t cols,
                   const size_t slices)
   {
-    W = arma::cube(rows, cols, slices);
+    W = arma::Cube<eT>(rows, cols, slices);
 
     for (size_t i = 0; i < slices; i++)
       Initialize(W.slice(i), rows, cols);

src/mlpack/methods/ann/layer/layer.hpp

@@ -27,4 +27,5 @@
 #include "concat.hpp"
 #include "vr_class_reward.hpp"
 
+
 #endif

src/mlpack/methods/ann/layer/linear.hpp

@@ -45,7 +45,7 @@ class Linear
    * @param inSize The number of input units.
    * @param outSize The number of output units.
    */
-  Linear(const size_t inSize, const size_t outSize);;
+  Linear(const size_t inSize, const size_t outSize);
 
   /*
    * Reset the layer parameter.

src/mlpack/methods/ann/rbm.hpp

@@ -0,0 +1,183 @@
+/**
+ * @file rbm.hpp
+ * @author Kris Singh
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_METHODS_ANN_RBM_HPP
+#define MLPACK_METHODS_ANN_RBM_HPP
+
+#include <mlpack/core.hpp>
+#include <mlpack/prereqs.hpp>
+#include <mlpack/core/math/random.hpp>
+
+#include <mlpack/methods/ann/activation_functions/softplus_function.hpp>
+#include <mlpack/methods/ann/init_rules/gaussian_init.hpp>
+#include <mlpack/methods/ann/init_rules/random_init.hpp>
+
+namespace mlpack {
+namespace ann /** Artificial neural networks.  */ {
+
+template<typename InitializationRuleType, typename RBMPolicy>
+class RBM
+{
+ public:
+  using NetworkType = RBM<InitializationRuleType, RBMPolicy>;
+  typedef typename RBMPolicy::ElemType eT;
+
+  /* 
+   * Intalise all the parameters of the network
+   * using the intialise rule. 
+   *
+   * @tparam IntialiserType rule to intialise the parameters of the network
+   * @param predictors training data
+   * @param numSteps Number of gibbs steps sampling
+   * @param useMonitoringCost evaluation function to use
+   * @param persistence indicates to use persistent CD
+   */
+  RBM(arma::Mat<eT> predictors, InitializationRuleType initializeRule,
+      RBMPolicy rbmPolicy,
+      const size_t numSteps = 1,
+      const size_t mSteps = 1,
+      const bool useMonitoringCost = true,
+      const bool persistence = false);
+
+  // Reset the network
+  void Reset();
+
+  /* 
+   * Train the network using the Opitimzer with given set of args.
+   * the optimiser sets the parameters of the network for providing
+   * most likely parameters given the inputs
+   * @param: predictors data points
+   * @param: optimizer Optimizer type
+   */
+  template<typename OptimizerType>
+  void Train(const arma::Mat<eT>& predictors, OptimizerType& optimizer);
+
+ /**
+  * Evaluate the rbm network with the given parameters.
+  * The function is needed for monitoring the progress of the network.
+  *
+  * @param parameters Matrix model parameters.
+  * @param i Index of point to use for objective function evaluation.
+  */
+  double Evaluate(const arma::Mat<eT>& parameters, const size_t i);
+
+ /** 
+  * This function calculates
+  * the free energy of the model
+  * @param: input data point 
+  */
+  double FreeEnergy(arma::Mat<eT>&& input);
+
+ /*
+  * This functions samples the hidden
+  * layer given the visible layer
+  *
+  * @param input visible layer input
+  * @param output the sampled hidden layer
+  */
+  void SampleHidden(arma::Mat<eT>&& input, arma::Mat<eT>&& output);
+
+  /*
+  * This functions samples the visible
+  * layer given the hidden layer
+  *
+  * @param input hidden layer
+  * @param output the sampled visible layer 
+  */
+  void SampleVisible(arma::Mat<eT>&& input, arma::Mat<eT>&& output);
+
+ /*
+  * This function does the k-step
+  * gibbs sampling.
+  *
+  * @param input: input to the gibbs function
+  * @param output: stores the negative sample
+  * @param steps: number of gibbs sampling steps
+  */
+  void Gibbs(arma::Mat<eT>&& input, arma::Mat<eT>&& output,
+      size_t steps = SIZE_MAX);
+
+  /*
+   * Calculates the gradients for the rbm network
+   *
+   * @param parameters the current parmaeters of the network
+   * @param input index the visible layer/data point
+   * @param output store the gradients
+   */
+  void Gradient(arma::Mat<eT>& parameters, const size_t input,
+      arma::Mat<eT>& output);
+
+  //! Return the number of separable functions (the number of predictor points).
+  size_t NumFunctions() const { return numFunctions; }
+
+  //! Return the number of stes of gibbs sampling.
+  size_t NumSteps() const { return numSteps; }
+
+  //! Return the parameters of the network
+  const arma::Mat<eT>& Parameters() const { return parameter; }
+  //! Modify the parameters of the network
+  arma::Mat<eT>& Parameters() { return parameter; }
+
+  //! Retutrn the rbm policy for the network
+  const RBMPolicy& Policy() const { return rbmPolicy; }
+  //! Modify the rbm policy for the network
+  RBMPolicy& Policy() { return rbmPolicy; }
+
+  //! Serialize the model.
+  template<typename Archive>
+  void Serialize(Archive& ar, const unsigned int /* version */);
+
+ private:
+  //! Locally stored parameters of the network
+  arma::Mat<eT> parameter;
+  //! Policy type of RBM
+  RBMPolicy rbmPolicy;
+  //! The matrix of data points (predictors).
+  arma::Mat<eT> predictors;
+  // Intialiser
+  InitializationRuleType initializeRule;
+  //! Locally-stored state of the persistent cdk.
+  arma::Mat<eT> state;
+  //! Locally-stored number of data points
+  size_t numFunctions;
+  //! Locally-stored number of steps in gibbs sampling
+  size_t numSteps;
+  //! Locally-stored number of negative samples
+  size_t mSteps;
+  //! Locally-stored monitoring cost
+  bool useMonitoringCost;
+  //! Locally-stored persistent cd-k or not
+  bool persistence;
+  //! Locally-stored reset variable
+  bool reset;
+
+  //! Locally-stored reconstructed output from hidden layer
+  arma::Mat<eT> hiddenReconstruction;
+  //! Locally-stored reconstructed output from visible layer
+  arma::Mat<eT> visibleReconstruction;
+
+  //! Locally-stored negative samples from gibbs Distribution
+  arma::Mat<eT> negativeSamples;
+  //! Locally-stored gradients from the negative phase
+  arma::Mat<eT> negativeGradient;
+  //! Locally-stored temproray negative gradient used for negative phase
+  arma::Mat<eT> tempNegativeGradient;
+  //! Locally-stored gradient for positive phase
+  arma::Mat<eT> positiveGradient;
+  //! Locally-stored temporary output of gibbs chain
+  arma::Mat<eT> gibbsTemporary;
+  //! Locally-stored output of the preActivation function used in FreeEnergy
+  arma::Mat<eT> preActivation;
+};
+} // namespace ann
+} // namespace mlpack
+
+#include "rbm_impl.hpp"
+
+#endif // MLPACK_METHODS_ANN_RBM_HPP

src/mlpack/methods/ann/rbm/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Define the files we need to compile
+# Anything not in this list will not be compiled into mlpack.
+set(SOURCES
+  binary_rbm_policy.hpp
+  binary_rbm_policy_impl.hpp
+  spike_slab_rbm_policy.hpp
+  spike_slab_rbm_policy_impl.hpp
+)
+
+# Add directory name to sources.
+set(DIR_SRCS)
+foreach(file ${SOURCES})
+  set(DIR_SRCS ${DIR_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/${file})
+endforeach()
+# Append sources (with directory name) to list of all mlpack sources (used at
+# the parent scope).
+set(MLPACK_SRCS ${MLPACK_SRCS} ${DIR_SRCS} PARENT_SCOPE)