SpikingNeuronNetworkRunningTests.cs

Go to the documentation of this file.

namespace SpikingNeuronNetwork.Test
{
    using Lib;
    using Lib.NeuronModels;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.Linq;
    
    [TestClass]
    public class SpikingNeuronNetworkRunningTests
    {
        [TestMethod]
        public void ThetaNeuronNetworkLayeredTest()
        {
            const int numInputs = 3;
            var numNeuronsPerLayer = new[] { 1, 2 };
            var network = new SpikingNeuronNetwork(numInputs, numNeuronsPerLayer, typeof(ThetaNeuron), 1);
            Assert.IsTrue(network.IsLayered);
            Assert.IsTrue(new List<int> { 3 }.SequenceEqual(network.GetNeuronIndicesByLayer(0)));
            Assert.IsTrue(new List<int> { 4, 5 }.SequenceEqual(network.GetNeuronIndicesByLayer(1)));
            network = new SpikingNeuronNetwork(numInputs, numNeuronsPerLayer.Sum(), typeof(ThetaNeuron), 1);
            Assert.IsFalse(network.IsLayered);
        }

        [TestMethod]
        public void ThetaNeuronNetworkBasicRunCompareOneInputTest()
        {
            const int numInputs = 1;
            const int numNeurons = 1;
            const double weightIni = 0.15;
            const double baselineCurrent = 0.001;
            var inputSpikeTimes = new List<Spike>
                {
                    new Spike { Time = 1, NeuronIndex = 0}, 
                };

            SpikeTrainTestHelper(numInputs, numNeurons, weightIni, baselineCurrent, inputSpikeTimes);
        }

        [TestMethod]
        public void ThetaNeuronNetworkBasicRunCompareTwoInputsTest()
        {
            const int numInputs = 2;
            const int numNeurons = 1;
            const double weightIni = 0.1;
            const double baselineCurrent = 0.001;
            var inputSpikeTimes = new List<Spike>
                {
                    new Spike { Time = 2, NeuronIndex = 0}, 
                    new Spike { Time = 1, NeuronIndex = 1}, 
                };

            SpikeTrainTestHelper(numInputs, numNeurons, weightIni, baselineCurrent, inputSpikeTimes);
        }

        [TestMethod]
        public void ThetaNeuronNetworkBasicRunCompareThreeInputsTest()
        {
            const int numInputs = 3;
            const int numNeurons = 1;
            const double weightIni = 0.01;
            const double baselineCurrent = 0.001;
            var inputSpikeTimes = new List<Spike>
                {
                    new Spike { Time = 2, NeuronIndex = 0}, 
                    new Spike { Time = 1, NeuronIndex = 1}, 
                    new Spike { Time = 2.1, NeuronIndex = 2}
                };

            SpikeTrainTestHelper(numInputs, numNeurons, weightIni, baselineCurrent, inputSpikeTimes);
        }

        [TestMethod]
        public void ThetaNeuronNetworkBasicRunNoOutputSpikesTest()
        {
            const int numInputs = 1;
            const int numNeurons = 1;
            const double weightIni = -0.15;
            const double baselineCurrent = -0.001;
            var inputSpikeTimes = new List<Spike>
                {
                    new Spike { Time = 0.01, NeuronIndex = 0}, 
                };

            SpikeTrainTestHelper(numInputs, numNeurons, weightIni, baselineCurrent, inputSpikeTimes);
        }

        [TestMethod]
        public void ThetaNeuronNetworkBasicRunAllInputSpikesComeBeforeNetworkTime()
        {
            const int numInputs = 1;
            const int numNeurons = 1;
            const double weightIni = -0.15;
            const double baselineCurrent = -0.001;
            const int currentNeuron = numInputs + numNeurons - 1;
            var inputSpikeTimes = new List<Spike>
                {
                    new Spike { Time = 0.01, NeuronIndex = 0}, 
                };

            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { {"Io", baselineCurrent.ToString(CultureInfo.InvariantCulture)}, {"Method", "EventDriven"} });
            thetaNeuronNetwork.RunSpikingNeuronNetwork(inputSpikeTimes);
            inputSpikeTimes.First().Time -= 0.005;
            var neuronFiringHistories = thetaNeuronNetwork.RunSpikingNeuronNetwork(inputSpikeTimes);

            Assert.AreEqual(1, neuronFiringHistories.Count);
            Assert.AreEqual(currentNeuron, neuronFiringHistories.First().Key);
            Assert.AreEqual(-1, neuronFiringHistories.First().Value.StartTime);
            Assert.AreEqual(-1, neuronFiringHistories.First().Value.EndTime);
            Assert.AreEqual(0, neuronFiringHistories.First().Value.OutputSpikes.Count);
            Assert.AreEqual(0, neuronFiringHistories.First().Value.SpikeStats.Count);
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentException))]
        public void ThetaNeuronNetworkBadNeuronTypeTest()
        {
            const int numInputs = 2;
            const int numNeurons = 1;
            const double weightIni = 0.1;
            // ReSharper disable ObjectCreationAsStatement
            new SpikingNeuronNetwork(numInputs, numNeurons, typeof(double), weightIni);
            // ReSharper restore ObjectCreationAsStatement
        }

        #region Helper Methods

        private static void SpikeTrainTestHelper(int numInputs, int numNeurons, double weightIni, double baselineCurrent, List<Spike> inputSpikeTimes)
        {
            var currentNeuron = numInputs + numNeurons - 1;
            var thetaNeuronNetwork = new SpikingNeuronNetwork(numInputs, numNeurons, typeof(ThetaNeuron), weightIni, new Dictionary<string, string> { {"Io", baselineCurrent.ToString(CultureInfo.InvariantCulture)}, {"Method", "EventDriven"} });
            var neuronFiringHistories = thetaNeuronNetwork.RunSpikingNeuronNetwork(inputSpikeTimes);

            // Compare Running With Stand-Alone Neuron, numerically
            var outputSpikeTimesNetwork = neuronFiringHistories[currentNeuron].OutputSpikes;
            var thetaNeuron = (ThetaNeuron)thetaNeuronNetwork.GetStandAloneNeuron(currentNeuron); //new ThetaNeuron(numInputs, weightIni) {Method = ThetaNeuron.SimulationMethod.Numerical};
            thetaNeuron.Method = SimulationMethod.Numerical;
            thetaNeuron.ResetState();
            var outputSpikeTimesStandAlone = thetaNeuron.RunThetaNeuron(inputSpikeTimes).ToList();
            TestHelper.CompareSpikeTrains(outputSpikeTimesNetwork, outputSpikeTimesStandAlone, 0.01);
        }

        #endregion
    }
}