rbm.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_ANN_RBM_RBM_HPP
#define MLPACK_METHODS_ANN_RBM_RBM_HPP

#include <mlpack/core.hpp>
#include <mlpack/methods/ann/rbm/rbm_policies.hpp>

namespace mlpack {
namespace ann  {

template<
  typename InitializationRuleType,
  typename DataType = arma::mat,
  typename PolicyType = BinaryRBM
>
class RBM
{
 public:
  using NetworkType = RBM<InitializationRuleType, DataType, PolicyType>;
  typedef typename DataType::elem_type ElemType;

  RBM(arma::Mat<ElemType> predictors,
      InitializationRuleType initializeRule,
      const size_t visibleSize,
      const size_t hiddenSize,
      const size_t batchSize = 1,
      const size_t numSteps = 1,
      const size_t negSteps = 1,
      const size_t poolSize = 2,
      const ElemType slabPenalty = 8,
      const ElemType radius = 1,
      const bool persistence = false);

  // Reset the network.
  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  Reset();

  // Reset the network.
  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  Reset();

  template<typename OptimizerType>
  double Train(OptimizerType& optimizer);

  double Evaluate(const arma::Mat<ElemType>& parameters,
                  const size_t i,
                  const size_t batchSize);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, double>::type
  FreeEnergy(arma::Mat<ElemType>&& input);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value,
      double>::type
  FreeEnergy(arma::Mat<ElemType>&& input);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  Phase(DataType&& input, DataType&& gradient);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  Phase(DataType&& input, DataType&& gradient);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  SampleHidden(arma::Mat<ElemType>&& input, arma::Mat<ElemType>&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SampleHidden(arma::Mat<ElemType>&& input, arma::Mat<ElemType>&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  SampleVisible(arma::Mat<ElemType>&& input, arma::Mat<ElemType>&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SampleVisible(arma::Mat<ElemType>&& input, arma::Mat<ElemType>&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  VisibleMean(DataType&& input, DataType&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  VisibleMean(DataType&& input, DataType&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, BinaryRBM>::value, void>::type
  HiddenMean(DataType&& input, DataType&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  HiddenMean(DataType&& input, DataType&& output);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SpikeMean(DataType&& visible, DataType&& spikeMean);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SampleSpike(DataType&& spikeMean, DataType&& spike);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SlabMean(DataType&& visible, DataType&& spike, DataType&& slabMean);

  template<typename Policy = PolicyType>
  typename std::enable_if<std::is_same<Policy, SpikeSlabRBM>::value, void>::type
  SampleSlab(DataType&& slabMean, DataType&& slab);

  void Gibbs(arma::Mat<ElemType>&& input,
             arma::Mat<ElemType>&& output,
             const size_t steps = SIZE_MAX);

  void Gradient(const arma::Mat<ElemType>& parameters,
                const size_t i,
                arma::Mat<ElemType>& gradient,
                const size_t batchSize);

  void Shuffle();

  size_t NumFunctions() const { return numFunctions; }

  size_t NumSteps() const { return numSteps; }

  const arma::Mat<ElemType>& Parameters() const { return parameter; }
  arma::Mat<ElemType>& Parameters() { return parameter; }

  arma::Cube<ElemType> const& Weight() const { return weight; }
  arma::Cube<ElemType>& Weight() { return weight; }

  DataType const& VisibleBias() const { return visibleBias; }
  DataType& VisibleBias() { return visibleBias; }

  DataType const& HiddenBias() const { return hiddenBias; }
  DataType& HiddenBias() { return hiddenBias; }

  DataType const& SpikeBias() const { return spikeBias; }
  DataType& SpikeBias() { return spikeBias; }

  ElemType const& SlabPenalty() const { return 1.0 / slabPenalty; }

  DataType const& VisiblePenalty() const { return visiblePenalty; }
  DataType& VisiblePenalty() { return visiblePenalty; }

  size_t const& VisibleSize() const { return visibleSize; }
  size_t const& HiddenSize() const { return hiddenSize; }
  size_t const& PoolSize() const { return poolSize; }

  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */);

 private:
  arma::Mat<ElemType> parameter;
  arma::Mat<ElemType> predictors;
  // Initializer for initializing the weights of the network.
  InitializationRuleType initializeRule;
  arma::Mat<ElemType> state;
  size_t numFunctions;
  size_t visibleSize;
  size_t hiddenSize;
  size_t batchSize;
  size_t numSteps;
  size_t negSteps;
  size_t poolSize;
  size_t steps;
  arma::Cube<ElemType> weight;
  DataType visibleBias;
  DataType hiddenBias;
  DataType preActivation;
  DataType spikeBias;
  DataType visiblePenalty;
  DataType visibleMean;
  DataType spikeMean;
  DataType spikeSamples;
  DataType slabMean;
  ElemType slabPenalty;
  ElemType radius;
  arma::Mat<ElemType> hiddenReconstruction;
  arma::Mat<ElemType> visibleReconstruction;
  arma::Mat<ElemType> negativeSamples;
  arma::Mat<ElemType> negativeGradient;
  arma::Mat<ElemType> tempNegativeGradient;
  arma::Mat<ElemType> positiveGradient;
  arma::Mat<ElemType> gibbsTemporary;
  bool persistence;
  bool reset;
};

} // namespace ann
} // namespace mlpack

#include "rbm_impl.hpp"
#include "spike_slab_rbm_impl.hpp"

#endif