multilayerperceptron.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */


#ifndef AIMS_NEURALNET_MULTILAYERPERCEPTRON_H
#define AIMS_NEURALNET_MULTILAYERPERCEPTRON_H

#include <aims/config/aimsalgo_config.h>
#include <string>

template <class T> class AimsData;
template <class T,int D> class AimsVector;


class AIMSALGO_API AimsMLPNeuron
{ protected:
    int _nInputs;
    float _output;
    float _activation;
    float _error;
    AimsData<float> *_deltaW;
    AimsData<float> *_weight;

  public:
    AimsMLPNeuron(int ninputs);
    virtual ~AimsMLPNeuron();

    int nInputs()    const;
    float output()     const;
    float activation() const;
    float error()      const;
    float deltaW(int i) const;
    float weight(int i) const;
    void  setWeight(const AimsData<float> &weight);

    void forward(const AimsData<float> &input);
    void evaluateError(float target);
    void backPropagation(const AimsData<float> &nexterror,
                         const AimsData<float> &nextweight);
    void adjust(const AimsData<float> &input,
                float learningrate,
                float momentum);
};


class AIMSALGO_API AimsMLPLayer
{ protected:
    int           _nNeurons;
    AimsMLPNeuron **_neuron;

  public:
    AimsMLPLayer(int nneurons,int ninputs);
    virtual ~AimsMLPLayer();

    int nNeurons() const;
    AimsData<float> activations() const;
    AimsData<float> outputs() const;
    AimsData<float> errors() const;
    AimsData<float> nextWeights(int n) const;
    void setWeight(const AimsData<float> &weight, int neuron);

    void  forward(const AimsData<float> &input);
    float evaluateError(const AimsData<float> &target);
    void  backPropagation(const AimsMLPLayer &nextlayer);
    void adjust(const AimsData<float> &input,
                float learningrate, float momentum);
};


class AIMSALGO_API AimsMultilayerPerceptron
{ protected:
    int        _nLayers;
    int        _nInputs;
    int        _nOutputs;
    float        _learningRate;
    float        _momentum;
    float        _maxError;
    int        _stabilityTime;
    int        _maxTime;
    AimsMLPLayer **_layer;
    AimsData<int32_t> *_topology;

  public:
    AimsMultilayerPerceptron(const AimsData<int32_t> &topology, int ninputs,
                             float learningrate, float momentum,
                             float maxerror, int stabilitytime, int maxtime);
    AimsMultilayerPerceptron(const AimsData<int32_t> &topology,
                             const AimsData<float> &weights,
                             int ninputs, float learningrate=0,
                             float momentum=0, float maxerror=0,
                             int stabilitytime=0, int maxtime=0);
    virtual ~AimsMultilayerPerceptron();

    AimsData<int32_t> topology() const;
    int nLayers() const;
    int nInputs() const;
    int nOutputs() const;
    float learningRate() const;
    float momentum() const;
    float maxError() const;
    int stabilityTime() const;
    int maxTime() const;
    void setLearningRate(float learningrate);
    void setMomentum(float momentum);
    void setMaxError(float maxerror);
    void setStabilityTime(int stabilitytime);
    void setMaxTime(int maxtime);

    void learn(const AimsData<float> &base,
               const AimsData<float> &target,
               int counter);
    void forward(const AimsData<float> &input);
    void backPropagation();
    void adjust(const AimsData<float> &input);
    AimsData<float> test(const AimsData<float> &base);

    AimsData<float> weights() const;

    void save(const std::string &filetopology,
              const std::string &fileweight);
};


#endif