TrainNetwork.cs

Go to the documentation of this file.

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

    public class TrainNetwork
    {
        public TrainingStats TrainingStats { get; set; }

        public TrainNetwork(TrainingStats trainingStats)
        {
            TrainingStats = trainingStats;
        }

        public TrainNetwork(SpikingNeuronNetwork spikingNeuronNetwork, List<SpikeSet> trainingSet, double learningRate, double maximumErrorAfterTraining, double maximumNumberOfTrainingEpochs, ISpikingError errorCalculator, ITrainingAlgorithm trainingAlgorithm, TrainingMethod trainingMethod)
        {
            TrainingStats = new TrainingStats
                {
                    OriginalNetwork = spikingNeuronNetwork,
                    TrainingSet = trainingSet,
                    LearningRate = learningRate,
                    MaximumErrorAfterTraining = maximumErrorAfterTraining,
                    MaximumNumberOfTrainingEpochs = maximumNumberOfTrainingEpochs,
                    ErrorCalculator = errorCalculator,
                    TrainingMethod = trainingMethod,
                    TrainingAlgorithm = trainingAlgorithm
                };
            TrainingStats.ResetTraining();
        }

        public ErrorDerivativeParameters CalculateErrorDerivative(Dictionary<int, NeuronFiringHistory> neuronFiringHistories, List<Spike> desiredOutputSpikeTimes)
        {
            var neuronDerivativeParameters = new Dictionary<Synapse, NeuronDerivativeParameters>();
            foreach (var value in neuronFiringHistories.Values)
                neuronDerivativeParameters = neuronDerivativeParameters.Concat(TrainingStats.CurrentNetwork.CalculateOutputSpikeTimeDerivatives(value)).ToDictionary(x => x.Key, x => x.Value);
            TrainingStats.ErrorCalculator.SimulationMethod = SimulationMethod.EventDriven;

            return CalculateErrorDerivativeHelper(neuronFiringHistories, desiredOutputSpikeTimes,
                                                  neuronDerivativeParameters);
        }

        public ErrorDerivativeParameters CalculateErrorDerivativeNumerical(Dictionary<int, NeuronFiringHistory> neuronFiringHistories, List<Spike> desiredOutputSpikeTimes)
        {
            var neuronDerivativeParameters = new Dictionary<Synapse, NeuronDerivativeParameters>();
            foreach (var value in neuronFiringHistories.Values)
                neuronDerivativeParameters = neuronDerivativeParameters.Concat(TrainingStats.CurrentNetwork.CalculateOutputSpikeTimeDerivativesNumerical(value)).ToDictionary(x => x.Key, x => x.Value);
            TrainingStats.ErrorCalculator.SimulationMethod = SimulationMethod.Numerical;

            return CalculateErrorDerivativeHelper(neuronFiringHistories, desiredOutputSpikeTimes,
                                                  neuronDerivativeParameters);
        }

        public bool StartTraining()
        {
            if (TrainingStats.CurrentNetwork == null)
            {
                TrainingStats.ResetTraining();
            }

            if (!TrainingStats.CurrentNetwork.IsLayered)
            {
                return false;
            }

            ErrorDerivativeParametersBatch previousErrorDerivativesBatch = null;
            int epoch;
            for (epoch = 1; epoch < TrainingStats.MaximumNumberOfTrainingEpochs; epoch++)
            {
                Console.WriteLine("Epoch: " + epoch);
                var trainingsetNumber = 0;
                var currentError = 0.0;
                var nonFiringNeuronIndices = new List<int>();
                ErrorDerivativeParametersBatch errorDerivativesBatch = null;
                ErrorDerivativeParameters previousErrorDerivatives = null;                
                foreach (var trainingPattern in TrainingStats.TrainingSet)
                {
                    TrainingStats.CurrentNetwork.ResetNetwork();
                    var neuronFiringHistories = TrainingStats.CurrentNetwork.RunSpikingNeuronNetwork(trainingPattern.InputSpikes);
                    nonFiringNeuronIndices.AddRange(NeuronFiringHistory.GetNonFiringNeuronIndices(neuronFiringHistories));
                    var errorDerivatives = CalculateErrorDerivative(neuronFiringHistories, trainingPattern.OutputSpikes);

                    foreach (var outputNeuronIndex in TrainingStats.CurrentNetwork.GetOutputLayerNeuronIndices())
                    {
                        var currentOutputSpikes = trainingPattern.OutputSpikes.Where(x => x.NeuronIndex == outputNeuronIndex).ToList();
                        currentError += TrainingStats.ErrorCalculator.GetError(currentOutputSpikes, neuronFiringHistories[outputNeuronIndex].OutputSpikes);
                    }

                    if (TrainingStats.TrainingMethod == TrainingMethod.Online)
                    {
                        TrainingStats.TrainingAlgorithm.UpdateWeights(TrainingStats, errorDerivatives, previousErrorDerivatives);
                    }
                    else if (errorDerivatives != null)
                    {
                        if (errorDerivativesBatch == null)
                        {
                            errorDerivativesBatch = new ErrorDerivativeParametersBatch(errorDerivatives);
                        }
                        else
                        {
                            foreach (var synapse in errorDerivatives.GetSynapses())
                            {
                                errorDerivativesBatch.AddErrorDerivative(synapse, errorDerivatives.GetErrorDerivative(synapse));
                            }
                        }
                    }

                    previousErrorDerivatives = errorDerivatives;
                    trainingsetNumber++;
                }
                if (TrainingStats.TrainingMethod == TrainingMethod.Batch)
                {
                    TrainingStats.TrainingAlgorithm.UpdateWeights(TrainingStats, errorDerivativesBatch, previousErrorDerivativesBatch);
                    previousErrorDerivativesBatch = errorDerivativesBatch;
                }
                nonFiringNeuronIndices = nonFiringNeuronIndices.Distinct().OrderBy(x => x).ToList();
                TrainingStats.PerEpochStats.Add(TrainingStats.NumEpochs + epoch, new TrainingStatsPerEpoch(currentError, nonFiringNeuronIndices));
                Console.WriteLine("\tError on training set " + trainingsetNumber + ": " + currentError);
                if (currentError >= TrainingStats.MaximumErrorAfterTraining) continue;
                TrainingStats.NumEpochs += epoch;
                return true;
            }
            TrainingStats.NumEpochs += epoch;
            return false;
        }

        #region Helper Methods

        private ErrorDerivativeParameters CalculateErrorDerivativeHelper(IReadOnlyDictionary<int, NeuronFiringHistory> neuronFiringHistories, List<Spike> desiredOutputSpikeTimes, IReadOnlyDictionary<Synapse, NeuronDerivativeParameters> neuronDerivativeParameters)
        {
            var errorDerivativeParameters = new ErrorDerivativeParameters();

            #region Output Neurons
            foreach (var outputNeuronIndex in TrainingStats.CurrentNetwork.GetOutputLayerNeuronIndices())
            {
                if (desiredOutputSpikeTimes.Count(x => x.NeuronIndex == outputNeuronIndex) > 1)
                {
                    throw new ArgumentException("MIMO Training Not Implemented");
                }

                if (neuronFiringHistories[outputNeuronIndex].OutputSpikes.Count == 0 || desiredOutputSpikeTimes.Count(x => x.NeuronIndex == outputNeuronIndex) == 0)
                {
                    throw new ArgumentException("Actual or Desired Output Spike Times are Missing");
                }

                errorDerivativeParameters.ErrorToOutputSpikeTimeDerivatives.Add(
                    outputNeuronIndex,
                    TrainingStats.ErrorCalculator.GetErrorToOutputSpikeTimeDerivative(
                        desiredOutputSpikeTimes.Where(x => x.NeuronIndex == outputNeuronIndex).ToList(),
                        neuronFiringHistories[outputNeuronIndex].OutputSpikes).First());

                // Where clause here is because not all input synapses may have spikes
                foreach (var synapse in TrainingStats.CurrentNetwork.GetNeuronsInputSynapses(outputNeuronIndex).Where(neuronDerivativeParameters.ContainsKey))
                {
                    errorDerivativeParameters.OutputSpikeTimeToWeightDerivatives.Add(synapse, neuronDerivativeParameters[synapse].OutputSpikeTimeToWeightDerivative);
                }
            }
            #endregion

            #region Hidden Neurons
            foreach (var layerIndex in Enumerable.Range(0, TrainingStats.CurrentNetwork.NumNeuronsPerLayer.Count - 1).Reverse()) // - 1 because output layer is already done
            {
                foreach (var hiddenNeuronIndex in TrainingStats.CurrentNetwork.GetNeuronIndicesByLayer(layerIndex))
                {
                    var outputSynapses = TrainingStats.CurrentNetwork.GetNeuronsOutputSynapses(hiddenNeuronIndex);
                    errorDerivativeParameters.ErrorToOutputSpikeTimeDerivatives.Add(hiddenNeuronIndex, 0);
                    foreach (var outputSynapse in outputSynapses)
                    {
                        // ToDo: Confirm that OutputSpikeTimeToInputSpikeTimeDerivative reduces to 0 if 
                        // ToDo: the output neuron's output spike happens before the input neuron's output spike
                        errorDerivativeParameters.ErrorToOutputSpikeTimeDerivatives[hiddenNeuronIndex] +=
                            errorDerivativeParameters.ErrorToOutputSpikeTimeDerivatives[outputSynapse.OutputNeuronIndex] *
                            neuronDerivativeParameters[outputSynapse].OutputSpikeTimeToInputSpikeTimeDerivative;
                    }
                    foreach (var synapse in TrainingStats.CurrentNetwork.GetNeuronsInputSynapses(hiddenNeuronIndex))
                    {
                        errorDerivativeParameters.OutputSpikeTimeToWeightDerivatives.Add(synapse, neuronDerivativeParameters[synapse].OutputSpikeTimeToWeightDerivative);
                    }
                }
            }
            #endregion

            return errorDerivativeParameters;
        }

        #endregion
    }
}