MSEFFNet.cpp

Go to the documentation of this file.

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

#include <SharkDefs.h>
#include <ReClaM/MSEFFNet.h>
#include <sstream>


using namespace std;

//===========================================================================
void MSEFFNet::modelDerivative(const Array<double> &input, Array<double> &output, Array<double>& derivative)
{
    throw SHARKEXCEPTION("modelDerivative(..) not implemented in MSEFFNet");
}


//===========================================================================
void MSEFFNet::modelDerivative(const Array<double> &input, Array<double>& derivative)
{
    throw SHARKEXCEPTION("modelDerivative(...) not implemented in MSEFFNet");
}


//===========================================================================
double MSEFFNet::error(Model& model, const Array<double> &input, const Array<double> &target)
{
    double se = 0;
    if (input.ndim() == 1)
    {
        Array<double> output(target.dim(0));
        model.model(input, output);
        for (unsigned c = 0; c < target.dim(0); c++)
        {
            se += (target(c) - output(c)) * (target(c) - output(c));
        }
    }
    else
    {
        Array<double> output(target.dim(1));
        for (unsigned pattern = 0; pattern < input.dim(0); ++pattern)
        {
            model.model(input[pattern], output);
            for (unsigned c = 0; c < target.dim(1); c++)
            {
                se += (target(pattern, c) - output(c)) * (target(pattern, c) - output(c));
            }
        }
    }
    // normalise
    se /= (double) target.nelem();
    return se;
}

//===========================================================================
double MSEFFNet::errorDerivative(Model& model, const Array<double> &input, const Array<double> &target, Array<double>& derivative)
{
    unsigned i, j;  // denote neurons
    unsigned c;     // denotes output
    unsigned pos;   // the actual position in the Array derivative
    double sum;
    double se = 0.;

    derivative  = 0;
    derivative.resize(model.getParameterDimension(), false);

    readParameters();

    if (input.ndim() == 1)
    {
        // calculate output
        activate(input);

        for (i = firstOutputNeuron, c = 0 ; i < numberOfNeurons; i++, c++)
        {
            d(i) =  2 * (target(c) - z[i]) * dgOutput(z[i]);
            se += (target(c) - z[i]) * (target(c) - z[i]);
        }

        // hidden units
        for (j = firstOutputNeuron - 1; j >= inputDimension; j--)
        {
            sum = 0;
            for (i = j + 1; i < numberOfNeurons; i++)
            {
                if (connection(i, j)) sum += weight(i, j) * d(i);
            }
            d(j) = dg(z[j]) * sum;
        }

        // calculate error gradient
        pos = 0;
        for (i = inputDimension; i < numberOfNeurons; i++)
        {
            for (j = 0; j < i; j++)
            {
                if (connection(i, j))
                {
                    derivative(pos) -= d(i) * z[j];
                    pos++;
                }
            }
            if (connection(i, bias))
            { // bias
                derivative(pos) -= d(i);
                pos++;
            }
        }
    }
    else
    { // more than one pattern
        for (unsigned pattern = 0; pattern < input.dim(0); ++pattern)
        {
            // calculate output
            activate(input[pattern]);

            for (i = firstOutputNeuron, c = 0 ; i < numberOfNeurons; i++, c++)
            {
                d(i) =  2 * (target(pattern, c) - z[i]) * dgOutput(z[i]);
            }

            // hidden units
            for (j = firstOutputNeuron - 1; j >= inputDimension; j--)
            {
                sum = 0;
                for (i = j + 1; i < numberOfNeurons; i++)
                {
                    if (connection(i, j)) sum += weight(i, j) * d(i);
                }
                d(j) = dg(z[j]) * sum;
            }

            // calculate error gradient
            pos = 0;
            for (i = inputDimension; i < numberOfNeurons; i++)
            {
                for (j = 0; j < i; j++)
                {
                    if (connection(i, j))
                    {
                        derivative(pos) -= d(i) * z[j];
                        pos++;
                    }
                }
                if (connection(i, bias))
                { // bias
                    derivative(pos) -= d(i);
                    pos++;
                }
            }
        }
    }
    derivative /= (double) target.nelem(); // mt & igel 20010917

    se /= (double) target.nelem(); // mt & igel 20010917

    return se;
}


//===========================================================================
MSEFFNet::MSEFFNet(const unsigned in, const unsigned out) : FFNet(in, out)
{}


//===========================================================================
MSEFFNet::MSEFFNet(const unsigned in, unsigned out,
                   const Array<int>& cmat) : FFNet(in, out, cmat)
{
    d.resize(numberOfNeurons);
}

//===========================================================================
MSEFFNet::MSEFFNet(const unsigned in, unsigned out,
                   const Array<int>& cmat, const Array<double>& wmat) :
        FFNet(in, out, cmat, wmat)
{
    d.resize(numberOfNeurons, false);
}


//===========================================================================
MSEFFNet::MSEFFNet(const string &filename) : FFNet(filename)
{
    d.resize(numberOfNeurons, false);
}