GEPSymbRegEvalOp.cpp

#include "GEPSymbRegEvalOp.h"
#include "ReadData.h"
 
 
 
void GEPSymbRegEvalOp::registerParameters(StateP state)
{
    state->getRegistry()->registerEntry("input_file", (voidP)(new std::string), ECF::STRING);
}
 
 
// called only once, before the evolution – generates training data
bool GEPSymbRegEvalOp::initialize(StateP state)
{
    x.clear();
    y.clear();
    f.clear();
 
    // initialize the Evaluator
    eval.initialize();
 
    // check if the parameters are stated (used) in the conf. file
    if (state->getRegistry()->isModified("input_file")) {
        std::string dataFile = *((std::string*) state->getRegistry()->getEntry("input_file").get());
 
        // read from file into Evaluator data
        if(!readDataFromFile(eval.data, dataFile))
            return false;
 
        nSamples = eval.data.size();
        nVariables = eval.data[0].size() - 1;
 
        return true;
    }
 
 
    nSamples = 10;
    double s = 1;
    double X = -10*s;
    double Y = -10*s;
 
    for (uint i = 0; i < nSamples; i++) {
        x.push_back(X);
        y.push_back(Y);
        Y += 2*s;
        X += 2*s;
    }
 
    for (uint i = 0; i < nSamples; i++) {
        X = x.at(i);
        for (uint j = 0; j < nSamples; j++) {
            Y = y.at(j);
            // F1
            f.push_back(sin(X) + sin(Y*Y)); // F2
            //f.push_back(2*sin(X)*cos(Y)); // F3
            //f.push_back(X*Y + sin((X + 1)*(Y - 1))); // F4
            //f.push_back(8 / (2+X*X+Y*Y)); // F5
            //f.push_back((X*X*X)/5+(Y*Y*Y)/2-X-Y); // F6
        }
    }
    return true;
 
}
 
 
bool GEPSymbRegEvalOp::csvRead(StateP state, std::string entry, std::vector<double>* vec){
    std::ifstream stream;
    std::string line;
    voidP sptr = state->getRegistry()->getEntry(entry);
    std::string fname = *((std::string*) sptr.get());
    stream.open(fname);
    if (!stream.is_open()) return false;
    while (getline(stream, line)){
        vec->push_back(atof(line.c_str()));
    }
    return true;
}
 
 
FitnessP GEPSymbRegEvalOp::evaluate(IndividualP individual)
{
    // we try to minimize the function value, so we use FitnessMin fitness (for minimization problems)
    FitnessP fitness(new FitnessMin);
    // get genotype
    GEPChromosomeP gep = boost::static_pointer_cast<GEPChromosome::GEPChromosome> (individual->getGenotype());
    // The system is multigenic. We iterate over every gene, transform it to a tree, execute it and link it with the results of its fellow genes
    // The user programatically specifies the linking function. In this case, addition is used.
    readIndividual(individual);
    double value = 0;
    double result;
    //nSamples = f.size();
    for(uint i = 0; i < nSamples; i++) {
        result = eval.executeParsedExpression(i);
 
        // add the difference
        value += pow(eval.data[i][nVariables] - result, 2);
        // += fabs(f.at(i*nSamples + j) - result);
    }
value /= pow(1.*nSamples, 2);
fitness->setValue(value);
return fitness;
}
 
void GEPSymbRegEvalOp::readIndividual(IndividualP individual){
    GEPChromosomeP chr = boost::dynamic_pointer_cast<GEPChromosome::GEPChromosome> (individual->getGenotype());
    static std::string strPrimitive;
    uint nTrees = (uint)(chr->genes);
    // The first dimension encompasses the list of genes in the chromosome
    // The final gene is the cell gene
    eval.parsedExpression.resize(nTrees+1);
    //Translate to tree form
    chr->assemble();
    for (uint iTree = 0; iTree <= nTrees; iTree++) {
        uint idx = iTree == nTrees ? 0 : iTree+1;
        Tree::Tree* pTree;
        if (idx != 0)   pTree = chr->subtrees.at(iTree); // Assign a subtree
        else pTree = chr->cellTree; // Asign the cell structure tree
        uint nTreeSize = (uint)pTree->size();
        eval.parsedExpression[idx].resize(nTreeSize);
        // read whole tree expression
        for (uint i = 0; i < nTreeSize; i++) {
            strPrimitive = (*pTree)[i]->primitive_->getName();
            // check function names
            for (uint iPrim = 0; iPrim < eval.funcNames.size(); iPrim++)
            {   // TODO: skip unused functions
                //if(!Nodes[iPrim].active)
                //  continue;
                if (strPrimitive == eval.funcNames[iPrim]) {
                    eval.parsedExpression[idx][i] = iPrim;
                    break;
                }
            }
 
            // check terminals
            for (uint iPrim = 0; iPrim < eval.termNames.size(); iPrim++)
            {   //if(!Nodes[iPrim].active)
                //  continue;
                if (strPrimitive == eval.termNames[iPrim]) {
                    eval.parsedExpression[idx][i] = iPrim + Evaluator::TERMINALS;
                    break;
                }
            }
 
            // check gene IDs
            for (uint iPrim = 0; iPrim < nTrees; iPrim++)
            {   //if(!Nodes[iPrim].active)
                //  continue;
                std::string name = GEP_GENE_PREFIX + uint2str(iPrim);
                if (strPrimitive == name) {
                    eval.parsedExpression[idx][i] = iPrim + Evaluator::SUBTREES;
                    break;
                }
            }
        }
    }
}