evoga.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 EVOGA_H
#define EVOGA_H
#include <cstdlib>
#include <stdio.h>
#include <string.h>
#include "evorobotexperiment.h"

#include <configurationparameters.h>
#include <parametersettable.h>

#include <QObject>
#include <QString>
#include <QMutex>
#include <QWaitCondition>

#include <Eigen/Core>

namespace farsa {

class FARSA_EXPERIMENTS_API Evoga : public QObject, public ParameterSettableWithConfigureFunction, public ConcurrentResourcesUser
{
    Q_OBJECT
signals:
    void startingReplication( int replication );
    void recoveredInterruptedEvolution( QString statfile );
    void endGeneration( int generation, double fmax, double faverage, double fmin );
    void finished();
public:
    static const int MAXINDIVIDUALS = 1000;
    Evoga();
    ~Evoga();

    void xnes();

    void saveStatistics(int popSize, int rp);
    
    void evolveSteadyState();
    void evolveGenerational();
    void evolveSpecializerSteadyState();
    void evolveSpecializerSteadyState2();

    QString getEvolutionType();
    float* xnesGetGenesForIndividual(unsigned int id);
    float* xnesGetGenes(int ind);
    void xnesComputeStats();
    void xnesSaveStats();
    void xnesSaveGen(FILE *fp, float* genotype);
    void xnesSaveAllGen();
    void xnesSaveBest(int bi);
    void xnesSaveBestPhe(int gen, int bi);
    void xnesLoadGen(FILE *fp, int ind);
    int xnesLoadAllGen(int gen, const char *filew);

    void saveBestFitness();

    int rouletteWheel(QVector<double> candidates);

    int mrand(int i);
    double drand();
    double getNoise(double minn, double maxn);
    void  reproduce();
    void  mreproduce();
    void putGenome(int fromgenome, int tobestgenome);
    void getGenome(int frombestgenome, int togenome, int mut);
    void setSeed(int s);
    int mutate(int w, double mut);
    void randomizePop();
    void setInitialPopulation(int*);
    void setMutations(float*);
    void printPop();
    void printBest();
    void saveagenotype(FILE *fp, int ind);
    void loadgenotype(FILE *fp, int ind);
    void saveallg();

    void saveallgComposed(QVector< QVector<int> > composedGen);

    int loadallg(int gen, const char *filew);


    void loadallTeams(int gen, const char *filew, QVector< QVector<int> > &teams);
    void computeFStat();
    void computeFStat2();
    void saveFStat();
    void saveRStat(QVector<int> subsVec);
    void getLastFStat( double &min, double &max, double &average );
    int loadStatistics(char *filename);
    int* getGenes(int ind);
    int* getBestGenes(int ind);
    void resetGenerationCounter();
    void copyGenes(int from, int to, int mut);
    void saveBestInd();

    void saveBestTeam(QVector< QVector<int> > teams, QVector<double> fitness);


    void getPheParametersAndMutationsFromEvonet();

    void updateGenomeFromEvonet( int ind );

    virtual void configure(ConfigurationParameters& params, QString prefix);

    virtual void save(ConfigurationParameters& params, QString prefix);

    static void describe( QString type );

    virtual void postConfigureInitialization();

    virtual void evolveAllReplicas();

    void stop();

    bool commitStep();

    bool isStopped();

    void resetStop();

    bool isEnabledStepByStep();

    virtual EvoRobotExperiment* getEvoRobotExperiment();

    virtual QVector<EvoRobotExperiment*> getEvoRobotExperimentPool();

    virtual unsigned int getCurrentGeneration();

    virtual unsigned int getStartingSeed();

    virtual unsigned int getCurrentSeed();

    virtual unsigned int getNumReplications();

    virtual unsigned int getNumOfGenerations();

    virtual double getCurrentMutationRate();

    virtual void setCurrentMutationRate( double mutation_rate );

    virtual unsigned int loadGenotypes(QString filename);

    virtual unsigned int numLoadedGenotypes() const;

    virtual int* getGenesForIndividual(unsigned int id);

    virtual QString statisticsFilename(unsigned int seed);

    virtual QString bestsFilename(unsigned int seed);

    virtual QString bestsFilename();

    virtual QString generationFilename(unsigned int generation, unsigned int seed);

    virtual QString generationFilename();

    virtual void doNotUseMultipleThreads();

    virtual QString retentionsFilename(unsigned int seed);

    int numModules;

public slots:
    void enableStepByStep( bool enable );
    void doNextStep();

protected:
    EvoRobotExperiment *exp;
    int popSize;
    int glen;
    bool elitism;
    int nreproducing;
    int noffspring;

    class Population {
    public:
        Population() :
            m_pop(),
            m_genomelength(1)
        {
        }

        ~Population()
        {
            clear();
        }

        void setGenomeLength(int genomelength)
        {
            if (genomelength < 1) {
                genomelength = 1;
            }
            m_genomelength = genomelength;

            clear();
        }

        int getGenomeLength() const
        {
            return m_genomelength;
        }

        void resize(int newSize)
        {
            if (newSize < 0) {
                newSize = 0;
            }

            // We have to be careful clearing or allocating memory
            if (newSize < m_pop.size()) {
                for (int i = (m_pop.size() - 1); i >= newSize; i--) {
                    delete[] m_pop[i];
                }
                m_pop.resize(newSize);
            } else if (newSize > m_pop.size()) {
                const int oldSize = m_pop.size();
                m_pop.resize(newSize);
                for (int i = oldSize; i < newSize; i++) {
                    m_pop[i] = new int[m_genomelength];
                }
            }
        }

        int addOne()
        {
            m_pop.append(new int[m_genomelength]);

            // Returning the index of the new genome
            return (m_pop.size() - 1);
        }

        void clear()
        {
            resize(0);
        }

        int size() const
        {
            return m_pop.size();
        }

        int* operator[](int i)
        {
#ifdef FARSA_DEBUG
            if (i > m_pop.size()) {
                abort();
            }
#endif
            return m_pop[i];
        }

        const int* operator[](int i) const
        {
#ifdef FARSA_DEBUG
            if (i > m_pop.size()) {
                abort();
            }
#endif
            return m_pop[i];
        }

    private:
        QVector<int *> m_pop;
        int m_genomelength;
    };
    Population genome;
    Population bestgenome;
    // Matrix containing genotypes for XNES algorithm
    QVector<float *> genotypes;
    int loadedIndividuals;
    double *tfitness;
    double *ntfitness;
    double **statfit;
    double *terror;
    QString evolutionType;
    int nogenerations;
    int nreplications;
    int seed;
    int currentSeed;
    double mutation;
    double mutationdecay;
    double initial_mutation;
    float *mutations;
    int cgen;
    int savebest;
    double fmin, fmax,faverage;
    double fbest;
    int fbestgen;
    int ccycle;
    bool stopEvolution;
    bool isStepByStep;
    QMutex mutexStepByStep;
    QWaitCondition waitForNextStep;
    unsigned int numThreads;
    int savePopulationEachNGenerations;
    bool averageIndividualFitnessOverGenerations;
    
    double mutationRange;
    double offspringMutRange;
    bool useGaussian;
    double gaussianMean;
    double gaussianStdDev;
    double offspringStdDev;
    bool variableStdDev;
    int numStartInd;
    double mutationLearningRate;
    bool xnesCombination;
    int xnesCombinationType;
    int backPropOffspringUtilityRank;
    bool backPropOffspringFitnessIncrease;
    float backPropOffspringFitnessIncreasePercentage;
    int pheGen;
    bool standardNes;
    bool minimization;
    bool debugPrintInfoToFile;
    bool dissociateInd;
    bool dissociateCovMatrix;
    bool specialUtilityRanking;

    bool saveRetStat;

    bool limitRetention;

    double crossRate;

    double modulesMutationRate;

    bool mutateOnlyRelatives;

    double rankBasedProb;

    QString selectionType;

    double overwriteRate;

    double targetRetentionRate;
    double limitationFactor;

    ConfigurationParameters savedConfigurationParameters;

    QString savedExperimentPrefix;
};

} // end namespace farsa

#endif