evonet.h

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@istc.cnr.it>                           *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program 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 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program 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 this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef EVONET_H
#define EVONET_H

#include "experimentsconfig.h"
#include "parametersettable.h"
#include "simpletimer.h"
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>
#include <QString>
#include <QStringList>
#include <QColor>
#include <QDebug>
#include <QObject>
#include <QMutex>

// All this stuff is to get rid of annoying warnings...
#ifdef __GNUC__
    #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5)
        #pragma GCC diagnostic push
        #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
    #else
        #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
    #endif
#endif

#include "Eigen/Dense"

#ifdef __GNUC__
    #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5)
        #pragma GCC diagnostic pop
    #else
        #pragma GCC diagnostic warning "-Wunused-local-typedefs"
    #endif
#endif

namespace farsa {

class FARSA_EXPERIMENTS_API Evonet : public QObject, public ParameterSettableWithConfigureFunction {
    Q_OBJECT

    friend class NetworkDialog;
    friend class RendNetwork;
signals:
    void evonetUpdated();
public:
    static const int MAXSTOREDACTIVATIONS = 100;
    static const int MAXN = 1000;
    static const float DEFAULT_VALUE;
    void configure(ConfigurationParameters& params, QString prefix);
    void save(ConfigurationParameters& params, QString prefix);
    static void describe( QString type );
    ParameterSettableUI* getUIManager();
    void create_net_block( int inputNeuronType, int hiddenNeuronType, int outputNeuronType, bool recurrentHiddens, bool inputOutputConnections, bool recurrentOutputs, bool biasOnHidden, bool biasOnOutput );
    int load_net_blocks(const char *filename, int mode);
    void save_net_blocks(const char *filename, int mode);
    void readNewPheLine(QStringList, float*, float*);
    void readOldPheLine(QStringList, float*, float*);
    void updateNet();
    void computeParameters();
    int setInput(int inp, float value); //
    float getOutput(int out);
    float getInput(int in);
    float getHidden(int h);
    void resetNet();
    int freeParameters(); //return number of free parameters
    float getFreeParameter(int i); // Returns the i-th free parameter
    void setParameters(const int* dt);
    void getMutations(float* mut);
    void copyPheParameters(int* pheGene);
    void printIO();//to print inputs and outputs
    int getParamBias(int nbias);
    float getWrange();
    void injectHidden(int nh, float val);
    float logistic(float f);
    void printBlocks();
    int getNoInputs();
    int getNoHiddens();
    int getNoOutputs();
    int getNoNeurons();
    float getNeuron(int in);
    bool pheFileLoaded();
    Evonet();
    char neuronl[MAXN][10];
    int neurondisplay[MAXN];   // whether neurons should be displayed or not
    double neuronrange[MAXN][2];  // the range of variation of the neuron
    QColor neurondcolor[MAXN];    // the color used by the neuron monitor
    bool neuronlesion[MAXN];    // if >0 the n neurons will be silented
    float neuronlesionVal[MAXN]; //value to be assigned to the lesioned neuron
    void setRanges(double weight, double bias, double gain); // set ranges of weights, biases and gains
    float* getOldestStoredActivations();
    int updateCounts();
    float **selectedp;          //pointer to a list of selected parameters
    int   nselected;            //number of selected parameters
    int neuronlesions;          // whether some of the neurons has been lesioned or manually set

    float tansig(float f);
    int maxIterations;

    bool inTraining() { return training; };

    void initWeightsInRange(float min, float max);
    void initWeightsNguyenWidrow(float min, float max);
    void printWeights();
    void printAct();
    void prepareForTraining(QVector<float>& err_w);
    void endTraining();

    float computeMeanSquaredError(QVector<float> trainingSet, QVector<float> desiredOutput);
    float trainLevembergMarquardt(QVector<float> trainingSet, QVector<float> desiredOutput, float maxError);
    float trainLevembergMarquardtThroughTime(QVector<float> trainingSet, QVector<float> desiredOutput, int time, float maxError);

    void hardwire();
    int extractWeightsFromNet(Eigen::VectorXf& w);
    int importWeightsFromVector(Eigen::VectorXf& w);
    int importWeightsFromMATLABFile(char *path);
    int exportWeightsToMATLABFile(char *path);
    float getWeight(int to, int from);
    void setWeight(int to, int from, float w);

    void setNeckReflex();
private:
    int isHidden(int neuron);
    float derivative(int n, float x);

    bool training;
    int nconnections;
    int n_outputsToTrain;
    char *outputsToTrain;

    char **trainingHiddenBlock;

    QVector<float> err_weights;
    float err_weight_sum;

private:
    int ninputs;                // n. input units
    int nhiddens;               // n. hidden units
    int noutputs;               // n. output units
    int nneurons;               // total n. of neurons
    int net_nblocks;            // network number of connection blocks
    int net_block[MAXN][6];     // blocks: 0=(connection,update,gain), 12=(id first neuron and n.neurons), 34=(id second neuron and n.neurons, optional),5=(genetic, fixed, backprop)
    int neuronbias[MAXN];       // whether neurons have bias
    int neurontype[MAXN];       // the type of neuron (0=logistic,1=dynamic with timeconstant, 2=binary, 3=logistic netinput*0.2
    int neurongain[MAXN];       // whether neurons have gain parameters
    int neuronxy[MAXN][2];      // neurons xy position in display space
    float wrange;               // weights range
    float grange;               // gain range
    float brange;               // bias range
    int nparameters;            // usefull to set GA parameters number of free parameters
    int nparambias;             // number of parametric bias to add to the number of genes need for the nnet
        // neurons label by default Input In0 In1.. Hidden: Hid0 Hid1 Output: Out0

    //variable to compute activation
    float act[MAXN];            //activation
    float storedActivations[MAXSTOREDACTIVATIONS][MAXN]; // Stored activations
    int nextStoredActivation;   // The index where the next activation will be stored
    int firstStoredActivation;  // The index of the first activation that was stored (since the stored activations were reset)
    float input[MAXN];          //input vector
    float netinput[MAXN];
    float *freep;               //dynamically resized to contain needed parameters
    float *phep;                //dynamically resized to contain manually set values specified in .phe files
    bool  pheloaded;            //whether a .phe file has been loaded
    float *muts;                //mutation parameters
    int geneMaxValue;           //how parameters are codified into the GA (es. 255, 511, 1023 <0 is included!>)

    // counter of updates of the network; resetted to zero by resetNet, incremented by updateNet
    int updatescounter;

    int p;                  //usato come puntatore per data
    int ndata;              //number of free parameters
    //variable for rendering
    int drawnymax;
    int drawnxmax;

    // ConfigurationParameters variables
    QString netFile;

};

} // end namespace farsa

#endif