createConnectionMatrix.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================


#ifndef CREATE_CONNECTION_MATRIX_H
#define CREATE_CONNECTION_MATRIX_H

#include <Array/ArrayIo.h>
#include <fstream>


//===========================================================================
void createConnectionMatrix(Array<int> &con,
                            Array<unsigned> &layers,
                            bool ff_layer  = true,   // all connections
                            // between layers?
                            bool ff_in_out = true,   // shortcuts from in to
                            // out?
                            bool ff_all    = true,   // all shortcuts?
                            bool bias      = true)   // bias?
{
    unsigned N = 0;  // total number of neurons:
    unsigned row,    // connection matrix row    (target neuron)
    column, // connection matrix column (start neuron)
    k,      // counter.
    z_pos,  // first target neuron in next layer
    s_pos;  // first start neuron in current layer


    //
    // Calculate total number of neurons from the
    // number of neurons per layer:
    //
    for (k = 0; k < layers.dim(0); k++) N += layers(k);
    con.resize(N, N + 1);
    con = 0;

    //
    // set connections from each neuron of layer i to each
    // neuron of layer i + 1 for all layers:
    //
    if (ff_layer)
    {
        z_pos = layers(0);
        s_pos = 0;
        for (k = 0; k < layers.dim(0) - 1; k++)
        {
            for (row = z_pos; row < z_pos + layers(k + 1); row++)
                for (column = s_pos; column < s_pos + layers(k); column++)
                    con(row, column) = 1;
            s_pos += layers(k);
            z_pos += layers(k + 1);
        }
    }

    //
    // set connections from all input neurons to all output neurons:
    //
    if (ff_in_out)
    {
        for (row = N - layers(layers.dim(0) - 1); row < N; row++)
            for (column = 0; column < layers(0); column++)
                con(row, column) = 1;
    }

    //
    // set connections from all neurons of layer i to
    // all neurons of layers j with j > i for all layers i:
    //
    if (ff_all)
    {
        z_pos = layers(0);
        s_pos = 0;
        for (k = 0; k < layers.dim(0) - 1; k++)
        {
            for (row = z_pos; row < z_pos + layers(k + 1); row++)
                for (column = 0; column < s_pos + layers(k); column++)
                    con(row, column) = 1;
            s_pos += layers(k);
            z_pos += layers(k + 1);
        }
    }

    //
    // set connections from all neurons (except the input neurons)
    // to the bias values:
    //
    if (bias)
        for (k = layers(0); k < N; k++) con(k, N) = 1;

}


//===========================================================================
void createConnectionMatrix(Array<int> &con,
                            unsigned in, unsigned hidden, unsigned out,
                            bool ff_layer  = true,  // all connections beteween layers?
                            bool ff_in_out = true,  // shortcuts from in to out?
                            bool ff_all    = true,  // all shortcuts?
                            bool bias      = true)
{ // bias?
    Array<unsigned> layer(3);
    layer(0) = in;
    layer(1) = hidden;
    layer(2) = out;
    createConnectionMatrix(con, layer, ff_layer, ff_in_out, ff_all, bias);
}


//===========================================================================
void createConnectionMatrix(Array<int> &con,
                            unsigned in, unsigned hidden1, unsigned hidden2, unsigned out,
                            bool ff_layer  = true,  // all connections beteween layers?
                            bool ff_in_out = true,  // shortcuts from in to out?
                            bool ff_all    = true,  // all shortcuts?
                            bool bias      = true)
{ // bias?
    Array<unsigned> layer(4);
    layer(0) = in;
    layer(1) = hidden1;
    layer(2) = hidden2;
    layer(3) = out;
    createConnectionMatrix(con, layer, ff_layer, ff_in_out, ff_all, bias);
}

//===========================================================================
void createConnectionMatrixRNN(Array<int> &con,
                               unsigned in, unsigned hidden, unsigned out,
                               unsigned memory = 1, bool layered = false,
                               bool recurrentInputs = true, bool bias = true, bool elman = false, bool previousInputs = false)
{
    unsigned N;  // total number of neurons:
    unsigned k, i, j;

    //
    // Calculate total number of neurons from the
    // number of neurons per layer:
    //
    N = in + hidden + out;
    con.resize(1 + memory, N, N);
    con[0] = 0;

    if (!layered)
    {
        for (i = in; i < N; i++)
        {
            for (j = 0; j < i; j++)
                con(0, i, j) = 1;
            if (bias) con(0, i, i) = 1;
        }
    }
    else
    {
        for (i = in; i < N - out; i++)
        {
            for (j = 0; j < in; j++)
                con(0, i, j) = 1;
            if (bias) con(0, i, i) = 1;
        }
        if (elman)
            for (i = N - out; i < N; i++)
            {
                for (j = 0; j < N - out; j++)
                    con(0, i, j) = 1;
                if (bias) con(0, i, i) = 1;
            }
        else
            for (i = N - out; i < N; i++)
            {
                for (j = 0; j < in; j++)
                    con(0, i, j) = 1;
                if (bias) con(0, i, i) = 1;
            }
    }
    if (recurrentInputs)
        for (i = 1; i <= memory; i++) con[i] = 1;
    else
    {
        for (i = 1; i <= memory; i++)
        {
            con[i] = 1;
            for (j = 0; j < in; j++)
            {
                (con[i])[j] = 0;
                if (!previousInputs) for (k = in; k < N; k++) con(i, k, j) = 0;
            }
        }
    }
}

#endif