reparametrization.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_ANN_LAYER_REPARAMETRIZATION_HPP
#define MLPACK_METHODS_ANN_LAYER_REPARAMETRIZATION_HPP

#include <mlpack/prereqs.hpp>

#include "layer.hpp"
// #include "../activation_functions/softplus_function.hpp"

namespace mlpack {
namespace ann  {

template <
    typename InputType = arma::mat,
    typename OutputType = arma::mat
>
class ReparametrizationType : public Layer<InputType, OutputType>
{
 public:
  ReparametrizationType(const bool stochastic = true,
                        const bool includeKl = true,
                        const double beta = 1);

  ReparametrizationType* Clone() const
  {
    return new ReparametrizationType(*this);
  }

  // Virtual destructor.
  virtual ~ReparametrizationType() { }

  ReparametrizationType(const ReparametrizationType& layer);

  ReparametrizationType(ReparametrizationType&& layer);

  ReparametrizationType& operator=(const ReparametrizationType& layer);

  ReparametrizationType& operator=(ReparametrizationType&& layer);

  void Forward(const InputType& input, OutputType& output);

  void Backward(const InputType& input,
                const OutputType& gy,
                OutputType& g);

  double Loss();

  bool Stochastic() const { return stochastic; }
  bool& Stochastic() { return stochastic; }

  bool IncludeKL() const { return includeKl; }
  bool& IncludeKL() { return includeKl; }

  double Beta() const { return beta; }
  double& Beta() { return beta; }

  void ComputeOutputDimensions()
  {
    const size_t inputElem = std::accumulate(this->inputDimensions.begin(),
        this->inputDimensions.end(), 0);
    if (inputElem % 2 != 0)
    {
      std::ostringstream oss;
      oss << "Reparametrization layer requires that the total number of input "
          << "elements is divisible by 2!  (Received input with " << inputElem
          << " total elements.)";
      throw std::invalid_argument(oss.str());
    }

    this->outputDimensions = std::vector<size_t>(
        this->inputDimensions.size(), 1);
    // This flattens the input, and removes half the elements.
    this->outputDimensions[0] = inputElem / 2;
  }

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

 private:
  bool stochastic;

  bool includeKl;

  double beta;

  OutputType gaussianSample;

  OutputType mean;

  OutputType preStdDev;

  OutputType stdDev;
}; // class ReparametrizationType

// Standard Reparametrization layer.
typedef ReparametrizationType<arma::mat, arma::mat> Reparametrization;

} // namespace ann
} // namespace mlpack

// Include implementation.
#include "reparametrization_impl.hpp"

#endif