Net.h

Go to the documentation of this file.

#ifndef OPENANN_NET_H_
#define OPENANN_NET_H_

#include <OpenANN/Learner.h>
#include <OpenANN/ActivationFunctions.h>
#include <OpenANN/Regularization.h>
#include <OpenANN/layers/Layer.h>
#include <vector>
#include <sstream>

namespace OpenANN
{

enum ErrorFunction
{
  NO_E_DEFINED,
  MSE, 
  CE   
};

class Net : public Learner
{
protected:
  std::vector<OutputInfo> infos;
  std::vector<Layer*> layers;
  std::vector<double*> parameters;
  std::vector<double*> derivatives;
  Regularization regularization;
  ErrorFunction errorFunction;
  bool dropout;

  bool initialized;
  int P, L;
  Eigen::VectorXd parameterVector, tempGradient;
  Eigen::MatrixXd tempInput, tempOutput, tempError;

  std::stringstream architecture;

public:
  Net();
  virtual ~Net();


  Net& inputLayer(int dim1, int dim2 = 1, int dim3 = 1);
  Net& alphaBetaFilterLayer(double deltaT, double stdDev = 0.05);
  Net& fullyConnectedLayer(int units, ActivationFunction act,
                           double stdDev = 0.05, bool bias = true);
  Net& restrictedBoltzmannMachineLayer(int H, int cdN = 1,
                                       double stdDev = 0.01,
                                       bool backprop = true);
  Net& sparseAutoEncoderLayer(int H, double beta, double rho,
                              ActivationFunction act);
  Net& compressedLayer(int units, int params, ActivationFunction act,
                       const std::string& compression, double stdDev = 0.05,
                       bool bias = true);
  Net& extremeLayer(int units, ActivationFunction act, double stdDev = 5.0,
                    bool bias = true);
  Net& intrinsicPlasticityLayer(double targetMean, double stdDev = 1.0);
  Net& convolutionalLayer(int featureMaps, int kernelRows, int kernelCols,
                          ActivationFunction act, double stdDev = 0.05,
                          bool bias = true);
  Net& subsamplingLayer(int kernelRows, int kernelCols,
                        ActivationFunction act, double stdDev = 0.05,
                        bool bias = true);
  Net& maxPoolingLayer(int kernelRows, int kernelCols);
  Net& localReponseNormalizationLayer(double k, int n, double alpha,
                                      double beta);
  Net& dropoutLayer(double dropoutProbability);
  Net& outputLayer(int units, ActivationFunction act, double stdDev = 0.05,
                   bool bias = true);
  Net& compressedOutputLayer(int units, int params, ActivationFunction act,
                             const std::string& compression,
                             double stdDev = 0.05, bool bias = true);
  Net& addLayer(Layer* layer);
  Net& addOutputLayer(Layer* layer);


  unsigned int numberOflayers();
  Layer& getLayer(unsigned int l);
  OutputInfo getOutputInfo(unsigned int l);
  DataSet* propagateDataSet(DataSet& dataSet, int l);


  void save(const std::string& fileName);
  void save(std::ostream& stream);
  void load(const std::string& fileName);
  void load(std::istream& stream);

  Net& setRegularization(double l1Penalty = 0.0, double l2Penalty = 0.0,
                         double maxSquaredWeightNorm = 0.0);
  Net& setErrorFunction(ErrorFunction errorFunction);
  Net& useDropout(bool activate = true);

  virtual Eigen::VectorXd operator()(const Eigen::VectorXd& x);
  virtual Eigen::MatrixXd operator()(const Eigen::MatrixXd& X);
  virtual unsigned int dimension();
  virtual const Eigen::VectorXd& currentParameters();
  virtual void setParameters(const Eigen::VectorXd& parameters);
  virtual bool providesInitialization();
  virtual void initialize();
  virtual unsigned int examples();
  virtual double error(unsigned int n);
  virtual double error();
  virtual bool providesGradient();
  virtual Eigen::VectorXd gradient(unsigned int n);
  virtual Eigen::VectorXd gradient();
  virtual void errorGradient(int n, double& value, Eigen::VectorXd& grad);
  virtual void errorGradient(double& value, Eigen::VectorXd& grad);
  virtual void errorGradient(std::vector<int>::const_iterator startN,
                             std::vector<int>::const_iterator endN,
                             double& value, Eigen::VectorXd& grad);
  virtual void finishedIteration();

protected:
  void initializeNetwork();
  void forwardPropagate(double* error);
  void backpropagate();
};

} // namespace OpenANN

#endif // OPENANN_NET_H