multi_layer.hpp

Go to the documentation of this file.

#ifndef MLPACK_METHODS_ANN_LAYER_MULTI_LAYER_HPP
#define MLPACK_METHODS_ANN_LAYER_MULTI_LAYER_HPP

#include "../make_alias.hpp"
#include "layer.hpp"

namespace mlpack {
namespace ann {

template<typename MatType>
class MultiLayer : public Layer<MatType>
{
 public:
  MultiLayer();

  MultiLayer(const MultiLayer& other);
  MultiLayer(MultiLayer&& other);
  MultiLayer& operator=(const MultiLayer& other);
  MultiLayer& operator=(MultiLayer&& other);

  virtual ~MultiLayer()
  {
    for (size_t i = 0; i < network.size(); ++i)
      delete network[i];
  }

  virtual MultiLayer* Clone() const { return new MultiLayer(*this); }

  virtual void Forward(const MatType& input, MatType& output);

  void Forward(const MatType& input,
               MatType& output,
               const size_t start,
               const size_t end);

  virtual void Backward(const MatType& input,
                        const MatType& gy,
                        MatType& g);

  virtual void Gradient(const MatType& input,
                        const MatType& error,
                        MatType& gradient);

  virtual void SetWeights(typename MatType::elem_type* weightsPtr);

  virtual void CustomInitialize(
      MatType& W,
      const size_t elements);

  virtual size_t WeightSize() const;

  virtual void ComputeOutputDimensions();

  virtual double Loss() const;

  template <typename LayerType, typename... Args>
  void Add(Args... args)
  {
    network.push_back(new LayerType(args...));
    layerOutputs.push_back(MatType());
    layerDeltas.push_back(MatType());
    layerGradients.push_back(MatType());
  }

  void Add(Layer<MatType>* layer)
  {
    network.push_back(layer);
    layerOutputs.push_back(MatType());
    layerDeltas.push_back(MatType());
    layerGradients.push_back(MatType());
  }

  const std::vector<Layer<MatType>*>& Network() const
  {
    return network;
  }
  std::vector<Layer<MatType>*>& Network() { return network; }

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

 protected:
  void InitializeForwardPassMemory(const size_t batchSize);

  void InitializeBackwardPassMemory(const size_t batchSize);

  void InitializeGradientPassMemory(MatType& gradient);

  std::vector<Layer<MatType>*> network;

  // Total number of elements in the input, cached for convenience.
  size_t inSize;
  // Total number of input elements for *every* layer.
  size_t totalInputSize;
  // Total number of output elements for *every* layer.
  size_t totalOutputSize;

  MatType layerOutputMatrix;
  std::vector<MatType> layerOutputs;

  MatType layerDeltaMatrix;
  std::vector<MatType> layerDeltas;

  std::vector<MatType> layerGradients;
};

} // namespace ann
} // namespace mlpack

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

#endif