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 "dataexchange.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 EvonetUI;

struct ActivationsToGui
{
    bool activations;

    QVector<float> data;

    int updatesCounter;

    QVector<QString> neuronl;

    QVector<QColor> neurondcolor;

    bool updateLabelAndColors;
};

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();
    EvonetUI* getCurrentUIManager() const
    {
    return m_evonetUI;
    }
    DataUploader<ActivationsToGui>* getNeuronsMonitorUploader()
    {
    return &neuronsMonitorUploader;
    }
    Evonet();

    Evonet* cloneNet() const;

    void setNetworkName(const QString& name);
    const QString& getNetworkName() const;
    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();
    float getFreeParameter(int i);
    void setParameters(const float* dt);
    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();
    float getBrange();
    float getGrange();
    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();
    void activateMonitorUpdate();
    void deactivateMonitorUpdate();

    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];
    bool neuronlesion[MAXN];    // if >0 the n neurons will be silented
    float neuronlesionVal[MAXN]; //value to be assigned to the lesioned neuron
    bool updateNeuronMonitor;
    void setRanges(double weight, double bias, double gain);
    float* getOldestStoredActivations();
    int updateCounts();
    float **selectedp;
    int   nselected;
    int neuronlesions;

    /******************** backpropagation *************************************/

    void prepareForTraining(QVector<float>& err_w);
    float tansig(float f);
    void initWeightsInRange(float min, float max);
    void initWeightsInRange(float minBias, float maxBias, float minWeight, float maxWeight);
    void initWeightsNguyenWidrow(float min, float max);
    void printWeights();
    void printAct();
    void endTraining();

    float computeMeanSquaredError(QVector<float> trainingSet, QVector<float> desiredOutput);

    bool showTeachingInput();

    float getTeachingInputEntry(int id);

    float getBackPropError();

    float backPropStep(QVector<float> tInput, double rate);

    float backPropStep2(QVector<float> tInput, double rate);

    void calculateBackPropagationError(QVector<float> tInput);

    void initBackPropFreep();

    void updateWeightsAfterBackProp();

    float* getBackPropWeightModification();

    void saveCopyBackPropFreep();

    void initCopyBackPropFreep();

    float* getCopyBackPropFreep();

    float* getActivations();

    float* getNetInputs();

    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();
    int maxIterations;
    bool inTraining() { return training; };
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;
/***********************  End back-propagation **************************************************/

private:
    int ninputs;
    int nhiddens;
    int noutputs;
    int nneurons;
    int net_nblocks;            // network number of connection blocks
    int net_block[MAXN][6];
    int neuronbias[MAXN];
    int neurontype[MAXN];
    int neurongain[MAXN];
    int neuronxy[MAXN][2];
    float wrange;
    float grange;
    float brange;
    int nparameters;
    int nparambias;             // number of parametric bias to add to the number of genes need for the nnet

    float act[MAXN];
    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];
    float netinput[MAXN];
    float *freep;
    float *backpropfreep;

    float *copybackpropfreep;
    float backproperror;
    QVector<float> teachingInput;
    bool showTInput;
    bool updateMonitor;
    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;
    int updatescounter;

    int p;                  //usato come puntatore per data
    int ndata;              //number of free parameters
    int drawnymax;
    int drawnxmax;
    QString netFile;

    QString networkName;

    DataUploader<ActivationsToGui> neuronsMonitorUploader;

    EvonetUI* m_evonetUI;
};

} // end namespace farsa

#endif