src/Mlp.hpp

Go to the documentation of this file.

#ifndef MLP_HPP_
#define MLP_HPP_

#include "SynapticRandomizer.hpp"

#include<vector>
#include<cstdlib>
#include<iostream>
#include<random>
#include<string>

using std::vector;
using std::cout;
using std::ostream;
using std::istream;
using std::string;

namespace jymlp{

namespace actf{
    enum ActF : int {Unset = 0, linear = 1, hyptan = 2, logsig = 3};
}
namespace errt{
    enum ErrT : int {Unset = 0, q2a2 = 1, q2a1 = 2, q1a1 = 3};
}
using jymlp::actf::ActF;
using jymlp::errt::ErrT;

enum PrettyPrintStyle : int  {plaintext = 0, latexeq = 1};

class Mlp{
protected:
    vector<double> weights;
    vector<size_t> nneur;
    vector<ActF> actf;

    void initRnd(double a, SynapticRandomizer & sr);

public:

    Mlp();

    Mlp(const vector<size_t>& inneur);

    Mlp(const vector<size_t>& inneur, const vector<ActF>& iactf, const vector<double>& iweights);

    Mlp(const Mlp &other);

    Mlp(const vector<size_t>& inneur, const vector<ActF>& iactf, SynapticRandomizer& sr);

    size_t getWorkspaceSize();

    size_t getNLayers() const {return nneur.size();}

    size_t getNWeights() const {return weights.size();}

    size_t getNNeurons(int layer) const {return nneur[layer];}

    size_t getNHiddenNeurons() const;

    size_t getNumNonzeroWeights() const;

    size_t getNumConnectedInputs() const;

    size_t getNumInputs() const {return nneur[0];}

    size_t getNumOutputs() const {return nneur[nneur.size()-1];}

    void forward(const vector<double> &input, double * workspace) const;

    void errorVec(const vector<double> &target, double * workspace) const;

    vector <double>
    copyOutputVec(double * workspace) const;

    size_t
    outputVecAsClassIndex(const double * workspace) const;

#if 0

    void addEuc2(double coeff, double * dest, double * workspace) const;
#endif

    void backwardEucSq(double coeff,
                       double * destE,
                       double * destG,
                       double * workspace,
                       ErrT errortype) const;


    void weightDecaySq(double coeff,
                       double *destE,
                       double *destG,
                       bool excludeOutputBias) const;

    void weightDecayAbs(double coeff,
                        double *destE,
                        double *destG,
                        bool excludeOutputBias) const;

    void update(double coeff, const double *wupd);

    void addErrorAndGradient(const vector<double> &input,
                             const vector<double> &target,
                             double coefficient,
                             double * sqerror,
                             double * error,
                             vector<double> * mseGrad,
                             vector<double> * meeGrad) const;


    void toStream(ostream & o);

    void fromStream(istream & ins);

    string prettyPrintLayerSizes();

    string prettyPrintLayerActivations();

    string prettyPrintWeights() const;

    string prettyPrintGradient(const vector <double> & grad) const;

    string prettyPrint();
};

}
#endif /* MLP_HPP_ */

---