---

miller.cc

Go to the documentation of this file.

#include <magic/mclass.h>
#include <inanna/annetwork.h>
#include <inanna/initializer.h>
#include <nhp/individual.h>
#include "annalee/anngenes.h"
#include "annalee/miller.h"

impl_dynamic (MillerEncoding, {ANNEncoding});



//                                                                          //
//     |   | o | |           -----                      | o                 //
//     |\ /|   | |  ___      |       _    ___           |     _             //
//     | V | | | | /   ) |/\ |---  |/ \  |   \  __   ---| | |/ \   ___      //
//     | | | | | | |---  |   |     |   | |     /  \ (   | | |   | (   \     //
//     |   | | | |  \__  |   |____ |   |  \__/ \__/  ---| | |   |  ---/     //
//                                                                 __/      //

MillerEncoding::MillerEncoding (const GeneticID& name, const StringMap& params) : ANNEncoding (name, params) {
    mPruneInputs    = params["MillerEncoding.pruneInputs"].toInt ();
    mPcVariance     = params["MillerEncoding.pcVariance"].toDouble ();
    mPcAverage      = params["MillerEncoding.pcAverage"].toDouble ();
}

MillerEncoding::MillerEncoding (const MillerEncoding& other) : ANNEncoding (other) {
    mPruneInputs = other.mPruneInputs;
    mPcVariance = other.mPcVariance;
    mPcAverage = other.mPcAverage;
}

void MillerEncoding::copy (const Genstruct& o) {
    ANNEncoding::copy (o);
    const MillerEncoding& other = static_cast<const MillerEncoding&>(o);
    mPruneInputs = other.mPruneInputs;
    mPcVariance = other.mPcVariance;
    mPcAverage = other.mPcAverage;
}

void MillerEncoding::addPrivateGenes (Gentainer& g, const StringMap& params) {
    Gentainer::addPrivateGenes (g, params);

    // Create genes for the units
    int totalUnits = mInputs+mMaxHidden+mOutputs;
    for (int i=0; i<totalUnits-mOutputs; i++) {

        // Existance of a neuron. Not encoded for input units if input
        // pruning is not enabled, nor output units which always exist
        if (i>=mInputs || mPruneInputs)
            add (new BinaryGene (format ("E%d", i)));
        
        // Connect input units and hidden units to all successive neurons
        for (int j=i+1; j<totalUnits; j++)
                add (&(new BinaryGene (format ("W%d-%d", i, j)))->hide());
    }
}

void MillerEncoding::init () {
    // Find random p_c (connection probability) for the genome
    double pc=0.5;
    do {
        pc = mPcAverage+gaussrnd(mPcVariance);
    } while (pc<0.0 || pc>1.0); // Not before it's in a range of a probability value

    // Change the pc of all binary genes we own
    for (int i=0; i<size(); i++)
        if (BinaryGene* gene = dynamic_cast<BinaryGene*> (&(*this)[i]))
            gene->setInitP(pc);

    // Let the superclass implement the initialization
    Gentainer::init ();
}

bool MillerEncoding::execute (const GeneticMsg& msg) const {
    // Take pictures only if this is a picture-taking recreation
    bool takePics = int(dynamic_cast<const TakeBrainPicsMsg*>(&msg));

    ANNetwork* net = new ANNetwork (format ("%d-%d-%d", mInputs, mMaxHidden, mOutputs));
    int totalUnits = mInputs+mMaxHidden+mOutputs;
    
    // Create and zero the connection matrix. Using this matrix is
    // useful mostly just for informative purposes (in logging)
    PackTable<int> cmatrix (totalUnits,totalUnits);
    for (int i=0; i<cmatrix.rows; i++)
        for (int j=0; j<cmatrix.rows; j++)
            cmatrix.get(i,j) = 0;

    // Go trough each input and hidden unit and check if it exists
    for (int i=0; i<totalUnits-mOutputs; i++) {
        if (i>=mInputs || mPruneInputs)
            // Enable or disable the unit from the network
            cmatrix.get(i,i) =
                static_cast<const BinaryGene&> ((*this)[(CONSTR)format ("E%d", i)]).getvalue();
    }


    // Fill the connection matrix
    for (int i=0; i<totalUnits-mOutputs; i++)
        for (int j=i+1; j<totalUnits; j++)
            if (j>=mInputs)
                if (static_cast<const BinaryGene&> (
                    (*this)[(CONSTR)format ("W%d-%d", i, j)]).getvalue())
                    cmatrix.get(i,j) = 1;

    // Calculate some statistics (probability of connection)
    int conns=0, totconns=0;
    for (int i=0; i<totalUnits-mOutputs; i++)
        for (int j=(i>=mInputs)?i+1:mInputs; j<totalUnits; j++) {
            totconns++;
            conns += cmatrix.get(i,j);
        }
    double pConn = double(conns) / double(totconns);
    msg.host.set ("pConn", new String (format ("%f", pConn)));

    // Enable outputs
    for (int i=totalUnits-mOutputs; i<totalUnits; i++)
        cmatrix.get(i,i) = 1;
    
    // Enable and connect according to the connection matrix (if both
    // source and target units exist and also the connection)
    for (int i=0; i<cmatrix.rows; i++) {
        (*net)[i].enable(cmatrix.get(i,i));
        if (cmatrix.get(i,i))
            for (int j=i+1; j<cmatrix.rows; j++)
                if (cmatrix.get(j,j) && cmatrix.get(i,j))
                    net->connect (i,j);
    }

    //for (int i=totalUnits-mOutputs; i<totalUnits; i++)
    //  (*net)[i].setTFunc (FreeNeuron::LINEAR_TF);

    // "Print" network connectivity matrix
    String desc; // Printed connection matrix
    if (takePics) {
        desc.reserve(totalUnits*(totalUnits+1)+10);
        for (int i=0; i<cmatrix.rows; i++) {
            for (int j=0; j<cmatrix.cols; j++)
                desc += cmatrix.get(i,j)? '1':'0';
            desc += '\n';
        }
    }
    
    if (net) {
        net->setInitializer (new GaussianInitializer (0.5));

        // Take some nice photos
        net->cleanup ();
        if (takePics)
            msg.host.set ("brainpic1", new String (net->drawEPS()));
        net->cleanup (true, mPrunePassthroughs);
        if (takePics) {
            msg.host.set ("brainpic2", new String (net->drawEPS()));
            net->drawFeedForward();
            msg.host.set ("brainpic3", new String (net->drawEPS()));
            msg.host.set ("braindesc1", new String (desc));
            delete net; // The net was created only for taking babypics
        } else {
            // Place the brain description into host
            msg.host.set ("brainplan", net);
        }
    }

    return true;
}

---