SpikingNeuronNetworkTrainingTests.cs

Go to the documentation of this file.

namespace SpikingNeuronNetwork.Test
{
    using Lib;
    using Lib.NeuronModels;
    using Lib.Training;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    [TestClass]
    public class SpikingNeuronNetworkTrainingTests
    {
        [TestMethod]
        public void ThetaNeuronNetworkAttemptTrainNonLayeredNetwork()
        {
            const int numInputs = 3;
            const int numNeurons = 3;
            const double weightIni = 0.01;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof (ThetaNeuron), weightIni,
                                                              new Dictionary<string, string>
                                                                  {
                                                                      {"Io", "0.001"},
                                                                      {"Method", "EventDriven"}
                                                                  });

            var trainingPattern = GetSimpleSpikeSet(numInputs + 1);
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPattern, 1e-5, 0.01, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(),
                                           TrainingMethod.Batch);
            Assert.IsFalse(trainer.StartTraining());
        }

        [TestMethod]
        public void ThetaNeuronNetworkSimpleTrainBatch()
        {
            const int numInputs = 3;
            const int numNeurons = 1;
            const int neuronIndex = numInputs + numNeurons - 1;
            const double weightIni = 0.01;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { { "Io", "0.001" }, { "Method", "EventDriven" } });

            var trainingPatterns = GetSimpleSpikeSet(neuronIndex);
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, 1e-5, 0.01, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Batch);
            Assert.IsTrue(trainer.StartTraining());

            ValidateEachPatternResponse(trainingPatterns, thetaNeuronNetwork);
        }

        [TestMethod]
        public void ThetaNeuronNetworkLayeredTrainBatch()
        {
            var numNeuronsPerLayer = new List<int> { 3, 1 };
            const int numInputs = 3;
            const double weightIni = 0.001;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeuronsPerLayer, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { { "Io", "0.001" }, { "Method", "EventDriven" } });

            var trainingPatterns = GetSimpleSpikeSet(numInputs + numNeuronsPerLayer.Sum() - 1);
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, 1e-5, 0.01, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Batch);
            Assert.IsTrue(trainer.StartTraining());

            ValidateEachPatternResponse(trainingPatterns, thetaNeuronNetwork);
        }
        
        [TestMethod]
        public void ThetaNeuronNetworkTwoOutputNeuronsTrainBatch()
        {
            const int numInputs = 3;
            const int numNeurons = 2;
            const double weightIni = 0.01;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, new List<int> { numNeurons }, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { {"Io", "0.001"}, {"Method", "EventDriven"} });

            var trainingPatterns = GetTwoOutputNeuronSpikeSet();
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, 1e-5, 0.01, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Batch);
            Assert.IsTrue(trainer.StartTraining());

            ValidateEachPatternResponse(trainingPatterns, thetaNeuronNetwork);
        }

        [TestMethod]
        public void ThetaNeuronNetworkSimpleTrainOnline()
        {
            const int numInputs = 3;
            const int numNeurons = 1;
            const int neuronIndex = numInputs + numNeurons - 1;
            const double weightIni = 0.01;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { { "Io", "0.001" }, { "Method", "EventDriven" } });

            var trainingPatterns = GetSimpleSpikeSet(neuronIndex);
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, 1e-5, 0.01, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Online);
            Assert.IsTrue(trainer.StartTraining());

            ValidateEachPatternResponse(trainingPatterns, thetaNeuronNetwork);
        }

        [TestMethod]
        public void ThetaNeuronNetworkLayeredTrainOnline()
        {
            var numNeuronsPerLayer = new List<int> { 3, 1 };
            const int numInputs = 3;
            const double weightIni = 0.0001;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeuronsPerLayer, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { { "Io", "0.001" }, { "Method", "EventDriven" } });

            var trainingPatterns = GetSimpleSpikeSet(numInputs + numNeuronsPerLayer.Sum() - 1);
            var trainer = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, 1e-5, 0.01, 4e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Online);
            Assert.IsTrue(trainer.StartTraining());

            ValidateEachPatternResponse(trainingPatterns, thetaNeuronNetwork);
        }

        [TestMethod]
        public void ThetaNeuronNetworkCheckErrorGradient()
        {
            const int numInputs = 3;
            const int numNeurons = 1;
            const int neuronIndex = numInputs + numNeurons - 1;
            const double weightIni = 0.01;
            const double learningRate = 1e-5;
            const double maximumErrorAfterTraining = 0.01;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { {"Io", "0.001"}, {"Method", "EventDriven"} });
            var trainingPatterns = GetSimpleSpikeSet(neuronIndex);
            var trainNetwork = new TrainNetwork(thetaNeuronNetwork, trainingPatterns, learningRate, maximumErrorAfterTraining, 1e4, new SumOfSquaredSpikingError(), new SteepestDescentTraining(), TrainingMethod.Batch);

            foreach (var trainingPattern in trainingPatterns)
            {
                thetaNeuronNetwork.ResetNetwork();
                var neuronFiringHistories = thetaNeuronNetwork.RunSpikingNeuronNetwork(trainingPattern.InputSpikes);             

                // Check Gradient Calculations For Post Spike Derivatives
                var postSpikeDerivatives = thetaNeuronNetwork.CalculatePostSpikeDerivatives(neuronFiringHistories[neuronIndex]);
                var postSpikeDerivativesNumerical = thetaNeuronNetwork.CalculatePostSpikeDerivativeNumerical(neuronFiringHistories[neuronIndex]);
                Assert.AreEqual(postSpikeDerivatives.Count, postSpikeDerivativesNumerical.Count);
                for (var j = 0; j < postSpikeDerivatives.Count; j++)
                {
                    Assert.IsTrue(Math.Abs(postSpikeDerivatives[j] - postSpikeDerivativesNumerical[j]) < TestHelper.Epsilon);
                }

                // Check Gradient Calculations For Error Derivatives
                var errorDerivativeParameters = trainNetwork.CalculateErrorDerivative(neuronFiringHistories, trainingPattern.OutputSpikes);
                var errorDerivativeParametersNumerical = trainNetwork.CalculateErrorDerivativeNumerical(neuronFiringHistories, trainingPattern.OutputSpikes);
                Assert.AreEqual(errorDerivativeParameters.GetSynapses().Count, errorDerivativeParametersNumerical.GetSynapses().Count);
                foreach (var synapse in errorDerivativeParameters.GetSynapses())
                {
                    Assert.IsTrue(Math.Pow(Math.Abs(errorDerivativeParameters.GetErrorDerivative(synapse) - errorDerivativeParametersNumerical.GetErrorDerivative(synapse)), 2) < TestHelper.Epsilon);
                }
            }
        }

        #region Helper Methods

        private static void ValidateEachPatternResponse(IEnumerable<SpikeSet> trainingPatterns, SpikingNeuronNetwork thetaNeuronNetwork)
        {
            foreach (var trainingPattern in trainingPatterns)
            {
                thetaNeuronNetwork.ResetNetwork();
                var neuronFiringHistories =
                    thetaNeuronNetwork.RunSpikingNeuronNetwork(trainingPattern.InputSpikes.ToList());
                foreach (var outputNeuronIndex in thetaNeuronNetwork.GetOutputLayerNeuronIndices())
                {
                    var index = outputNeuronIndex; // to prevent foreach closure
                    var currentOutputSpikes = trainingPattern.OutputSpikes.Where(x => x.NeuronIndex == index).ToList();
                    var errorCalculator = new SumOfSquaredSpikingError();
                    var error = errorCalculator.GetError(currentOutputSpikes, neuronFiringHistories[outputNeuronIndex].OutputSpikes);
                    Assert.IsTrue(error < 0.1);
                }
            }            
        }

        private static List<SpikeSet> GetTwoOutputNeuronSpikeSet()
        {
            var spikeSetList = GetSimpleSpikeSet(3);
            spikeSetList[0].OutputSpikes.Add(new Spike { Time = 7, NeuronIndex = 4 });
            spikeSetList[1].OutputSpikes.Add(new Spike { Time = 15, NeuronIndex = 4 });
            return spikeSetList;
        }

        private static List<SpikeSet> GetSimpleSpikeSet(int outputNeuronIndex)
        {
            var inputSpikeTimes1 = new List<Spike>
                {
                    new Spike { Time = 2, NeuronIndex = 0}, 
                    new Spike { Time = 1, NeuronIndex = 1}, 
                    new Spike { Time = 2.1, NeuronIndex = 2}
                };
            var outputSpikeTimes1 = new List<Spike>
                {
                    new Spike {Time = 15, NeuronIndex = outputNeuronIndex}
                };
            var inputSpikeTimes2 = new List<Spike>
                {
                    new Spike { Time = 1, NeuronIndex = 0}, 
                    new Spike { Time = 2.1, NeuronIndex = 2}
                };
            var outputSpikeTimes2 = new List<Spike>
                {
                    new Spike {Time = 7, NeuronIndex = outputNeuronIndex}
                };
            return new List<SpikeSet>
            {
                new SpikeSet
                    {
                        InputSpikes = inputSpikeTimes1,
                        OutputSpikes = outputSpikeTimes1
                    },
                new SpikeSet
                    {
                        InputSpikes = inputSpikeTimes2,
                        OutputSpikes = outputSpikeTimes2
                    }
            };
        }

        #endregion
    }
}