SumOfSquaredSpikingError.cs

Go to the documentation of this file.

namespace SpikingNeuronNetwork.Lib
{
    using Interfaces;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    public class SumOfSquaredSpikingError : ISpikingError
    {
        public SimulationMethod SimulationMethod { get; set; }

        public double GetError(List<Spike> desiredOutputSpikes, List<Spike> actualOutputSpikes)
        {            
            if (desiredOutputSpikes.Count > actualOutputSpikes.Count)
            {
                throw new ArgumentException("Desired Spikes Count Must Not Be Greater Than The Actual Spike Count To Calculate Error");
            }

            if (actualOutputSpikes.Count > desiredOutputSpikes.Count)
            {
                actualOutputSpikes = actualOutputSpikes.Take(desiredOutputSpikes.Count).ToList();
            }

            desiredOutputSpikes = desiredOutputSpikes.OrderBy(x => x.Time).ToList();
            desiredOutputSpikes = desiredOutputSpikes.OrderBy(x => x.NeuronIndex).ToList();
            actualOutputSpikes = actualOutputSpikes.OrderBy(x => x.Time).ToList();
            actualOutputSpikes = actualOutputSpikes.OrderBy(x => x.NeuronIndex).ToList();

            double error = 0;
            for (var j = 0; j < desiredOutputSpikes.Count; j++)
            {
                if (desiredOutputSpikes[j].NeuronIndex != actualOutputSpikes[j].NeuronIndex)
                {
                    throw new ArgumentException("Desired and Actual Spikes Counts On Each Neuron Must Be Equal To Calculate Error");
                }
                error += Math.Pow(desiredOutputSpikes[j].Time - actualOutputSpikes[j].Time, 2);
            }
            return error/2;
        }

        public List<double> GetErrorToOutputSpikeTimeDerivative(List<Spike> desiredOutputSpikes, List<Spike> actualOutputSpikes)
        {
            if (desiredOutputSpikes.Count > actualOutputSpikes.Count)
            {
                throw new ArgumentException("Desired Spike Count Must Not Be Greater Than the Actual Spike Count To Calculate Error");
            }

            if (actualOutputSpikes.Count > desiredOutputSpikes.Count)
            {
                actualOutputSpikes = actualOutputSpikes.Take(desiredOutputSpikes.Count).ToList();
            }

            var errorDerivatives = new List<double>();
            if (SimulationMethod == SimulationMethod.Numerical)
            {
                const double offset = 1e-4;
                foreach (var actualOutputSpike in actualOutputSpikes)
                {
                    actualOutputSpike.Time -= offset;
                    var error1 = GetError(desiredOutputSpikes, actualOutputSpikes);
                    actualOutputSpike.Time += 2*offset;
                    var error2 = GetError(desiredOutputSpikes, actualOutputSpikes);
                    actualOutputSpike.Time -= offset;
                    errorDerivatives.Add((error2-error1)/(2*offset));
                }
            }
            else
            {
                desiredOutputSpikes = desiredOutputSpikes.OrderBy(x => x.Time).ToList();
                desiredOutputSpikes = desiredOutputSpikes.OrderBy(x => x.NeuronIndex).ToList();
                actualOutputSpikes = actualOutputSpikes.OrderBy(x => x.Time).ToList();
                actualOutputSpikes = actualOutputSpikes.OrderBy(x => x.NeuronIndex).ToList();

                for (var j = 0; j < desiredOutputSpikes.Count; j++)
                {
                    if (desiredOutputSpikes[j].NeuronIndex != actualOutputSpikes[j].NeuronIndex)
                    {
                        throw new ArgumentException("Desired and Actual Spikes Counts On Each Neuron Must Be Equal To Calculate Error");
                    }
                    errorDerivatives.Add(actualOutputSpikes[j].Time - desiredOutputSpikes[j].Time);
                }
            }

            return errorDerivatives;                
        }
    }
}