SpikingNeuronNetwork.cs

Go to the documentation of this file.

namespace SpikingNeuronNetwork.Lib
{
    using Interfaces;
    using NeuronModels;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using Training;

    public class SpikingNeuronNetwork
    {
        public int Id { get; set; }

        public IList<int> NumNeuronsPerLayer { get; private set; }

        public int NumInputs
        {
            get { return _weightMatrix.Cols - NumNeuronsPerLayer.Sum(); }
        }

        public bool IsLayered
        {
            get { return _isLayered; }
        }

        private Dictionary<int, SpikingNeuron> _neurons;
        private const double Epsilon = 1e-10;
        private readonly Matrix _weightMatrix; //Should supercede the connections in the neuron objects
        private readonly Random _random = new Random();
        private readonly bool _isLayered;
       
        public SpikingNeuronNetwork(int numInputs, int numNeurons, Type neuronType, double weightIni = 1e6, Dictionary<string, string> neuronProperties = null)
        {
            // Create Network with Random Topology and Weights
            NumNeuronsPerLayer = new List<int> {numNeurons};
            _isLayered = numNeurons == 1;
            _weightMatrix = weightIni > 100 ? 
                Matrix.RandomMatrix(numInputs + numNeurons, numInputs + numNeurons, 1.0, 0.5) : 
                Matrix.ConstantMatrix(numInputs + numNeurons, numInputs + numNeurons, weightIni);

            // Selfloops are disallowed is there no synaptic delays
            // an output spike could cause artificial recursion
            for (var i = 0; i < _weightMatrix.Cols; i++)
            {
                _weightMatrix[i, i] = 0;
            }

            //Input neuron or neuron to input neuron connections are disallowed
            for (var i = 0; i < numInputs; i++)
                for (var n = 0; n < _weightMatrix.Rows; n++)
                    _weightMatrix[n, i] = 0;

            AssignNeurons(numInputs, numNeurons, neuronType, neuronProperties);
        }

        public SpikingNeuronNetwork(int numInputs, IList<int> numNeuronsPerLayer, Type neuronType, double weightIni = 1e6, Dictionary<string, string> neuronProperties = null)
        {
            NumNeuronsPerLayer = numNeuronsPerLayer;
            // Create a layered weight matrix
            var numNeurons = numNeuronsPerLayer.Sum();
            var totalNeurons = numInputs + numNeurons;
            _isLayered = true;
            _weightMatrix = Matrix.ZeroMatrix(totalNeurons, totalNeurons);

            const double probability = 0.5;
            const int dispersion = 1;
            // Input layer
            for (var j = 0; j < numInputs; j++)
            {
                for (var k = numInputs; k < numInputs + numNeuronsPerLayer[0]; k++)
                {
                    var newWeight = weightIni > 100 ? ((_random.NextDouble() <= probability) ? dispersion * 2 * (_random.NextDouble() - 0.5) : 0) : weightIni;
                    _weightMatrix[j, k] = newWeight;
                }
            }
            // Hidden and output layers
            for (var layer = 1; layer < numNeuronsPerLayer.Count; layer++)
            {
                for (var j = numInputs; j < numInputs + numNeuronsPerLayer.Take(layer).Sum(); j++)
                {
                    for (var k = numInputs + numNeuronsPerLayer.Take(layer).Sum();
                         k < numInputs + numNeuronsPerLayer.Take(layer + 1).Sum();
                         k++)
                    {
                        var newWeight = weightIni > 100
                                            ? ((_random.NextDouble() <= probability)
                                                   ? dispersion * 2 * (_random.NextDouble() - 0.5)
                                                   : 0)
                                            : weightIni;
                        _weightMatrix[j, k] = newWeight;
                    }
                }
            }

            // Selfloops are disallowed without synaptic delays because 
            // an output spike could cause artificial recursion
            for (var i = 0; i < _weightMatrix.Cols; i++)
            {
                _weightMatrix[i, i] = 0;
            }

            //Input neuron or neuron to input neuron connections are disallowed
            for (var i = 0; i < numInputs; i++)
                for (var n = 0; n < _weightMatrix.Rows; n++)
                    _weightMatrix[n, i] = 0;

            AssignNeurons(numInputs, numNeurons, neuronType, neuronProperties);
        }

        private SpikingNeuronNetwork(Random random, Matrix weightMatrix, bool isLayered, IList<int> numNeuronsPerLayer, Dictionary<int, SpikingNeuron> neurons)
        {
            _random = random;
            _weightMatrix = weightMatrix;
            _isLayered = isLayered;
            _neurons = neurons;
            NumNeuronsPerLayer = numNeuronsPerLayer;
        }

        public SpikingNeuronNetwork Clone()
        {
            var newNeurons = _neurons.ToDictionary(kvp => kvp.Key, kvp => (SpikingNeuron) kvp.Value.Clone());
            var clonedNetwork = new SpikingNeuronNetwork(_random, _weightMatrix, _isLayered, NumNeuronsPerLayer, newNeurons);
            foreach (var neuronIndices in newNeurons.Keys)
            {
                newNeurons[neuronIndices].NeuronNetwork = clonedNetwork;
            }
            return clonedNetwork;
        }

        public ISpikingNeuron GetStandAloneNeuron(int neuronIndex)
        {
            return _neurons[neuronIndex].Clone();
        }

        public List<double> CalculatePostSpikeDerivatives(NeuronFiringHistory neuronFiringHistory)
        {
            return _neurons[neuronFiringHistory.NeuronIndex].CalculatePostSpikeDerivatives(neuronFiringHistory);
        }

        public List<double> CalculatePostSpikeDerivativeNumerical(NeuronFiringHistory neuronFiringHistory)
        {
            return _neurons[neuronFiringHistory.NeuronIndex].CalculatePostSpikeDerivativesNumerical(neuronFiringHistory);
        }

        public Dictionary<Synapse, NeuronDerivativeParameters> CalculateOutputSpikeTimeDerivatives(NeuronFiringHistory neuronFiringHistory)
        {
            return _neurons[neuronFiringHistory.NeuronIndex].CalculateOutputSpikeTimeDerivatives(neuronFiringHistory);
        }

        public Dictionary<Synapse, NeuronDerivativeParameters> CalculateOutputSpikeTimeDerivativesNumerical(NeuronFiringHistory neuronFiringHistory)
        {
            return _neurons[neuronFiringHistory.NeuronIndex].CalculateOutputSpikeTimeDerivativesNumerical(neuronFiringHistory);
        }

        public Dictionary<int, NeuronFiringHistory> RunSpikingNeuronNetwork(List<Spike> inputSpikes)
        {
            // Create a priority queue of NextSpikeTimes for each Neuron
            double currentTime = 0;
            const double endTime = 500;
            var neuronFiringHistories = new Dictionary<int, NeuronFiringHistory>();
            var spikeQueue = new SpikePriorityQueue();
            spikeQueue.AddRange(inputSpikes);
            foreach (var neuron in _neurons)
            {
                spikeQueue.Add(new Spike { Time = neuron.Value.NextSpikeTime, NeuronIndex = neuron.Value.NeuronIndex});
            }

            // Repeat until steady-state or for a fixed time
            while (currentTime < endTime && spikeQueue.Count > 0)
            {
                // Dequeue the next spike to process, eminating from Neuron A and add it to the outputspike List
                var currentSpike = spikeQueue.Dequeue();
                currentTime = currentSpike.Time;

                // Update Neuron A's State and add a new NextSpikeTime to the queue for Neuron A
                //     but skip this step if A is an input neuron
                if (currentSpike.NeuronIndex > NumInputs - 1)
                {
                    if (neuronFiringHistories.ContainsKey(currentSpike.NeuronIndex))
                    {
                        neuronFiringHistories[currentSpike.NeuronIndex].OutputSpikes.Add(currentSpike);
                    }
                    else
                    {
                        neuronFiringHistories.Add(currentSpike.NeuronIndex, new NeuronFiringHistory
                            {
                                NeuronIndex = currentSpike.NeuronIndex,
                                OutputSpikes = new List<Spike> { currentSpike },
                                SpikeStats = new SortedSet<SpikeStats>()
                            });
                    }                    
                    _neurons[currentSpike.NeuronIndex].State.Time = currentSpike.Time;
                    _neurons[currentSpike.NeuronIndex].State.StateVariable = _neurons[currentSpike.NeuronIndex].PostSpikeState;
                }
                
                // Get the set of neurons connected to Neuron A's output (Neurons B)
                var outputNeurons = GetNeuronsOutputNeurons(currentSpike.NeuronIndex);
                
                // Foreach neuron in B, update the State and update the NextSpikeTime in the queue
                foreach (var outputNeuron in outputNeurons)
                {
                    var oldSpike = new Spike {Time = outputNeuron.NextSpikeTime, NeuronIndex = outputNeuron.NeuronIndex};
                    SpikeStats currentSpikeStats;
                    var outputSpikeList = outputNeuron.ProcessSpike(currentSpike, out currentSpikeStats);
                    if (neuronFiringHistories.ContainsKey(outputNeuron.NeuronIndex))
                    {
                        neuronFiringHistories[outputNeuron.NeuronIndex].OutputSpikes.AddRange(outputSpikeList);
                        neuronFiringHistories[outputNeuron.NeuronIndex].SpikeStats.Add(currentSpikeStats);
                    }
                    else
                    {
                        neuronFiringHistories.Add(outputNeuron.NeuronIndex, new NeuronFiringHistory
                        {
                            NeuronIndex = outputNeuron.NeuronIndex,
                            OutputSpikes = new List<Spike>(outputSpikeList),
                            SpikeStats = currentSpikeStats == null ? new SortedSet<SpikeStats>() : new SortedSet<SpikeStats> {currentSpikeStats}
                        });
                    } 

                    // Find the outputNeuron in the spikeQueue and update the nextSpikeTime
                    spikeQueue.Update(oldSpike, outputNeuron.NextSpikeTime);
                }
            }

            return neuronFiringHistories;
        }

        public void ResetNetwork()
        {
            foreach (var neuron in _neurons)
            {
                neuron.Value.ResetState();
            }
        }

        public List<Synapse> GetNeuronsInputSynapses(int neuronIndex)
        {
            return _neurons[neuronIndex].Weights.Select(x => x.Key).ToList();
        }

        public List<Synapse> GetNeuronsOutputSynapses(int neuronIndex)
        {
            var weights = _weightMatrix.GetRow(neuronIndex);
            var outputNeuronIndices = weights.FindAllIndexOfNot(0);
            return outputNeuronIndices
                .Select(outputNeuronIndex => new Synapse(neuronIndex, outputNeuronIndex))
                .ToList();
        }

        public List<int> GetNeuronIndicesByLayer(int layerIndex)
        {
            if (!IsLayered || layerIndex >= NumNeuronsPerLayer.Count)
            {
                return null;
            }
            var startIndex = NumInputs + NumNeuronsPerLayer.Where((x,i) => i < layerIndex).Sum();
            return Enumerable.Range(startIndex, NumNeuronsPerLayer[layerIndex]).ToList();
        }

        public List<int> GetOutputLayerNeuronIndices()
        {
            return GetNeuronIndicesByLayer(NumNeuronsPerLayer.Count - 1);
        }
        
        internal double GetSynapticWeight(Synapse synapse)
        {
            if (synapse.InputNeuronIndex > _weightMatrix.Rows) throw new ArgumentException("Invalid Synapse: " + synapse);
            if (synapse.OutputNeuronIndex > _weightMatrix.Cols) throw new ArgumentException("Invalid Synapse: " + synapse);
            return _weightMatrix[synapse.InputNeuronIndex, synapse.OutputNeuronIndex];
        }
        
        internal Dictionary<Synapse, double> GetNeuronWeights(int neuronIndex)
        {
            if (neuronIndex > _weightMatrix.Cols) return null;
            var weights = new Dictionary<Synapse, double>();
            var col = _weightMatrix.GetCol(neuronIndex); // Want Column neuronIndex for connections TO neuron
            for (var j = 0; j < col.Rows; j++)
            {
                if (Math.Abs(col[j, 0]) > Epsilon)
                {
                    weights.Add(new Synapse(j, neuronIndex), col[j, 0]);
                }
            }
            return weights;
        }

        internal void SetSynapticWeight(Synapse synapse, double newValue)
        {
            if (synapse.InputNeuronIndex > _weightMatrix.Rows || synapse.OutputNeuronIndex > _weightMatrix.Cols) return;
            _weightMatrix[synapse.InputNeuronIndex, synapse.OutputNeuronIndex] = newValue;
        }

        internal List<SpikingNeuron> GetNeuronsOutputNeurons(int neuronIndex)
        {
            var weights = _weightMatrix.GetRow(neuronIndex);
            var outputNeuronIndices = weights.FindAllIndexOfNot(0);
            return outputNeuronIndices.Where(_neurons.ContainsKey)
                     .Select(x => _neurons[x])
                     .ToList();
        }

        private void AssignNeurons(int numInputs, int numNeurons, Type neuronType, Dictionary<string,string> neuronProperties = null)
        {
            _neurons = new Dictionary<int, SpikingNeuron>();
            if (!typeof(ISpikingNeuron).IsAssignableFrom(neuronType))
            {
                throw new ArgumentException("Neuron type " + neuronType.Name + " must derive from ISpikingNeuron");
            }

            var neuronConstructor = neuronType.GetConstructor(new Type[] { });
            if (neuronConstructor == null)
            {
                throw new ArgumentException("Neuron type " + neuronType.Name + " must implement an empty constructor");
            }
            foreach (var neuronIndex in Enumerable.Range(numInputs, numNeurons))
            {
                _neurons.Add(neuronIndex, (SpikingNeuron)neuronConstructor.Invoke(new object[] { }));
                _neurons[neuronIndex].NeuronNetwork = this;
                _neurons[neuronIndex].NeuronIndex = neuronIndex;
                var typeProperties = neuronType.GetProperties();
                foreach (var neuronProperty in neuronProperties ?? new Dictionary<string, string>())
                {
                    var typeProperty = typeProperties.First(x => x.Name == neuronProperty.Key);
                    if (typeProperty == null || !typeProperty.CanWrite) continue;
                    var propType = typeProperty.PropertyType;
                    object castedValue;
                    if (propType.BaseType != null && propType.BaseType.Name == "Enum")
                    {
                        castedValue = Enum.Parse(propType, neuronProperty.Value);
                    }
                    else
                    {
                        castedValue = Convert.ChangeType(neuronProperty.Value, propType);                        
                    }

                    typeProperty.SetValue(_neurons[neuronIndex], castedValue);
                }
                _neurons[neuronIndex].ResetState();
            }
        }
    }
}