---

topology.cc

Go to the documentation of this file.

#include "inanna/annetwork.h"

ANNTopology::~ANNTopology () {
}



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

ANNLayering::~ANNLayering () {
}

void ANNLayering::make (const char* description) {
    if (!description)
        return;
    String desc = description;
    
    Array<String> sizes_tmp;
    desc.split (sizes_tmp, '-');
    ASSERTWITH (sizes_tmp.size()>=1, "Layering description must have at least 1 layer");

    // Move the string array to self
    mLayers.make (sizes_tmp.size());
    for (int i=0; i<sizes_tmp.size(); i++)
        mLayers[i] = sizes_tmp[i].toInt();
}

int ANNLayering::layerIndex (int layer) const {
    if (layer<0)
        layer = mLayers.size()+layer;

    ASSERT (layer>=0 && layer<mLayers.size());
    
    int index = 0;
    for (int k=0; k<layer; k++)
        index += mLayers[k];

    return index;
}

void ANNLayering::getPos (int i, int& layerno, int& layerpos) const {
    layerpos=i;
    for (layerno=0; layerno<mLayers.size() && layerpos>=mLayers[layerno];
         layerpos-=mLayers[layerno++]);
    ASSERTWITH (layerno<mLayers.size(), format ("Index %d doesn't map to layering", i));
} 

String ANNLayering::toString () const {
    // Make an array containing the layer sizes
    Array<String> layers_arr (layers());
    for (int i=0; i<layers(); i++)
        layers_arr[i] = String ((*this)[i]);

    // Join the layer sizes into a layered network description string
    String layers_str;
    layers_str.join (layers_arr, '-');

    return layers_str;
}



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

LayeredTopology::~LayeredTopology () {
}

void LayeredTopology::build (ANNetwork& network) const {
    const ANNLayering& mLayering = dynamic_cast<const ANNLayering&>(*this);
    int inputs=mLayering[0];
    int outputlimit=mLayering.layerIndex (-1);

    // network.makeNeurons (mLayering.totalUnits());

    // Make the unit array
    for (int i=0; i<mLayering.totalUnits(); i++)
        // If unit template is given, use it
        if (network.getUnitPrototype())
            network.add (network.getUnitPrototype()->clone());
        else // Ordinary neuron
            network.add (new Neuron());

    // Set the unit attributes according to their position in the network
    for (int i=0; i<network.size(); i++) {
        // Set the unit's type
        if (i<inputs)
            network[i].setType (Neuron::INPUTUNIT);
        else
            if (i<outputlimit)
                network[i].setType (Neuron::HIDDENUNIT);
        else
            network[i].setType (Neuron::OUTPUTUNIT);

        // Set unit's coordinates

        // Calculate unit's layer and offset
        int layerno, layerpos;
        mLayering.getPos (i, layerno, layerpos);

        // Move the unit to it's proper location
        network[i].moveTo (layerno*8, layerpos, 0);
    }
}

---