neuralnetwork.h

/*
* This file is part of Copiste.
*
* Copiste is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*  Copiste is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with Copiste.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef INCLUDEDNEURALNETWORKH
#define INCLUDEDNEURALNETWORKH

#include <string>

// Math functions
#include <cmath>
#include <cstdlib>

// Matrix and vector management
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/matrix_proxy.hpp>
#include <boost/numeric/ublas/io.hpp>

// Serialization
#include <fstream>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>

// Temporaire
#include "corpus.h"


using namespace boost::numeric;

double sigmoid(double x);

class NeuralNetwork
{
    public:
       NeuralNetwork(std::string file = "");

       void reset(std::vector<int> geometry);

       bool fromFile(std::string file);

       bool toFile(std::string file);

       double train(Corpus &c, double rate, double regularization, int nbIter, bool debug = false);

       double classify(std::vector<double> input);

       double accuracy(Corpus &c);

       void randomize();


       unsigned int nbLayers() { return mLayers.size(); }

       unsigned int dimension();

   private:
       std::vector< ublas::matrix<double> > mLayers;

       double gradientDescent(ublas::matrix<double> &ds, ublas::vector<double> &tv, double rate, unsigned int steps);

       ublas::matrix<double> classify(ublas::matrix<double> input);

       std::vector< ublas::matrix<double> > gradient(ublas::matrix<double> &ds, ublas::vector<double> &tv, double regularization = 0);

       std::vector< ublas::matrix<double> > gradientChecking(ublas::matrix<double> &ds, ublas::vector<double> &tv, double regularization = 0, double epsilon = 0.0001);

       double costFunction(ublas::matrix<double> &ds, ublas::vector<double> &tv, double regularization = 0);


       static ublas::matrix<double> createDataset(Corpus &c);

       static ublas::vector<double> createTargetVector(Corpus &c);


       static ublas::vector<double> addOne(ublas::vector<double> v);

       static ublas::matrix<double> addOne(ublas::matrix<double> v);

       static ublas::matrix_range<ublas::matrix<double> > removeOnes(ublas::matrix<double> m);

       static ublas::matrix_range<ublas::matrix<double> > jthCol(ublas::matrix<double> m, size_t j);

       static ublas::vector<double> elementWise(ublas::vector<double> v, double (*f)(double));

       static ublas::matrix<double> elementWise(ublas::matrix<double> v, double (*f)(double));

       static ublas::matrix<double> vecToMat(ublas::vector<double> v);

       static ublas::vector<double> unroll(ublas::matrix<double> m);

       static ublas::matrix<double> roll(ublas::vector<double> m, unsigned int r, unsigned int c);

       friend class boost::serialization::access;
       template<class Archive>
       void serialize(Archive & ar, const unsigned int version);

};


#endif