SymbRegEvalOp.cpp

#include <cmath>
#include <ecf/ECF.h>
#include "SymbRegEvalOp.h"
#include "infixTree.h"
 
extern bool evaluateVerbose;
 
 
// called only once, before the evolution – generates training data
bool SymbRegEvalOp::initialize(StateP state)
{
    state_ = state;
 
    x.clear();
    y.clear();
 
    // circle
    nSamples = 40;
    double s = -1;
    for(uint i = 0; i < nSamples / 2; i++) {
        x.push_back(s);
        y.push_back(sqrt(1 - s*s));
        x.push_back(s);
        y.push_back(-1 * sqrt(1 - s*s));
        s += 0.1;
    }
 
    // elliptic
    //double t = 1;
    //for(uint i = 0; i < 30; i++) {
    //  x.push_back(t);
    //  y.push_back(sqrt(t*t*t + t - 1.5));
    //  x.push_back(t);
    //  y.push_back(-1 * sqrt(t*t*t + t - 1.5));
    //  t += 0.1;
    //}
    //nSamples = x.size();
 
    return true;
}
 
 
FitnessP SymbRegEvalOp::evaluate(IndividualP individual)
{
    // we try to minimize the function value, so we use FitnessMin fitness (for minimization problems)
    FitnessP fitness (new FitnessMin);
 
    // get the genotype we defined in the configuration file
    Tree::Tree* tree = (Tree::Tree*) individual->getGenotype().get();
 
    // test for variables
    bool foundX = false, foundY = false;
    for(uint i = 0; i < tree->size(); i++) {
        std::string prim = tree->at(i)->primitive_->getName();
        if(prim == "x")
            foundX = true;
        if(prim == "y")
            foundY = true;
    }
    if(!foundX || !foundY) {
        fitness->setValue(nSamples * nSamples * nSamples);
        return fitness;
    }
 
    // test for constant value
    uint testSize = 20;
    std::vector<double> testValues(testSize);
    double result;
    for(uint i = 0; i < testSize; i++) {
        // shpere R = 1
        double x = - 1 + 2 * state_->getRandomizer()->getRandomDouble();
        double y = - 1 + 2 * state_->getRandomizer()->getRandomDouble();
 
        // elliptic 
        //double x = 1 + 3 * state_->getRandomizer()->getRandomDouble();
        //double y = 1 + 7 * state_->getRandomizer()->getRandomDouble();
 
        tree->setTerminalValue("x", &x);
        tree->setTerminalValue("y", &y);
        tree->execute(&result);
        testValues[i] = result;
    }
    double testDev = getStdDev(testValues);
    if(testDev < 1e-6) {
        fitness->setValue(nSamples * nSamples * nSamples);
        return fitness;
    }
 
    std::vector<double> values(nSamples);
    double average = 0;
    for(uint i = 0; i < nSamples; i++) {
        // for each test data instance, the x value (domain) must be set
        tree->setTerminalValue("x", &x[i]);
        tree->setTerminalValue("y", &y[i]);
        // get the y value of the current tree
        double result;
        tree->execute(&result);
        values[i] = result;
        average += result;
    }
    average /= nSamples;
 
    double dev = 0;
    for(uint i = 0; i < nSamples; i++) {
        // add the difference
        dev += (values[i] - average) * (values[i] - average);
    }
    dev = sqrt(dev / (nSamples - 1));
 
    fitness->setValue(dev);
 
    if(evaluateVerbose) {
        std::string infix;
        showTree(infix, tree);
        ECF_LOG_ERROR(state_, infix);
 
        ofstream outmap("outmap.txt");
        for(double x = -1; x <= 1; x += 0.1) {
            for(double y = -1; y <= 1; y += 0.1) {
                tree->setTerminalValue("x", &x);
                tree->setTerminalValue("y", &y);
                tree->execute(&result);
                outmap << result << "\t";
            }
            outmap << endl;
        }
        outmap.close();
 
        ofstream outval("values.txt");
        for(uint i = 0; i < values.size(); i++) {
            outval << values[i] << endl;
        }
        outval.close();
    }
 
    return fitness;
}
 
 
double SymbRegEvalOp::getMean(vector<double>& values)
{
    double sum = 0;
    for(uint i = 0; i < values.size(); i++)
        sum += values[i];
    return sum / values.size();
}
 
 
double SymbRegEvalOp::getStdDev(vector<double>& values)
{
    if(values.size() == 0)
        return 0;
    double numerator = 0, denominator;
    double average = getMean(values);
    for(uint i = 0; i < values.size(); i++) {
        numerator += ((values[i] - average) * (values[i] - average));
    }
    denominator = (values.size() - 1);
    return sqrt(numerator / denominator);
}