//Methods
/// <summary>
/// Resets the neuron to its initial state
/// </summary>
/// <param name="statistics">Specifies whether to reset also internal statistics</param>
public void Reset(bool statistics)
{
_activation.Reset();
_tStimuli = 0;
_rStimuli = 0;
OutputSignal = _activation.Compute(_tStimuli);
OutputSignalLeak = 0;
if (statistics)
{
Statistics.Reset();
}
return;
}
private double FindCurrent(IActivationFunction af, double targetResponse, double tolerance)
{
double lo = -100, hi = 100;
while (true)
{
af.Reset();
double current = (lo + (hi - lo) / 2);
double response = af.Compute(current);
if (af.TypeOfActivation == Neural.Activation.ActivationType.Spiking)
{
response = af.InternalState;
}
Console.CursorLeft = 0;
Console.Write($"lo {lo}, hi {hi}, current {current}, response {response}".PadRight(150, ' '));
if (Math.Abs(response - targetResponse) <= tolerance)
{
Console.WriteLine();
return(current);
}
if (response > targetResponse)
{
hi = current;
}
else if (response < targetResponse)
{
lo = current;
}
}
}
public virtual float Compute(List <float> inputs)
{
Debug.Assert(Weights != null);
lastNet = SumOfProduct(inputs);
lastOutput = activationFunction.Compute(lastNet);
return(lastOutput);
}
/// <summary>
/// Computes neuron's new output signal and updates statistics
/// </summary>
/// <param name="collectStatistics">Specifies whether to update internal statistics</param>
public void Recompute(bool collectStatistics)
{
//Spike leak handling
if (OutputData._spikingSignal > 0)
{
//Spike during previous cycle, so reset the counter
OutputData._afterFirstSpike = true;
OutputData._spikeLeak = 0;
}
++OutputData._spikeLeak;
double normalizedActivation;
if (_activation.TypeOfActivation == ActivationType.Spiking)
{
//Spiking activation
OutputData._spikingSignal = _activation.Compute(_tStimuli);
//OutputData._analogSignal = OutputData._spikingSignal;
_activationState = _activation.InternalState;
normalizedActivation = _outputRange.Rescale(_activation.InternalState, _activation.InternalStateRange).Bound(_outputRange.Min, _outputRange.Max);
OutputData._analogSignal = normalizedActivation;
}
else
{
//Analog activation
double newState = _activation.Compute(_tStimuli);
_activationState = (_analogRetainmentStrength * _activationState) + (1d - _analogRetainmentStrength) * newState;
normalizedActivation = _outputRange.Rescale(_activationState, _activation.OutputRange).Bound(_outputRange.Min, _outputRange.Max);
bool firingEvent = _histActivationsQueue == null ? ((normalizedActivation - OutputData._analogSignal) > _analogFiringThreshold) : (_histActivationsQueue.Full ? (normalizedActivation - _histActivationsQueue.Dequeue()) > _analogFiringThreshold : (normalizedActivation - 0.5d) > _analogFiringThreshold);
_histActivationsQueue?.Enqueue(normalizedActivation);
//New output data
OutputData._analogSignal = normalizedActivation;
OutputData._spikingSignal = firingEvent ? 1d : 0d;
}
//Update predictors
_predictors?.Update(_activationState, normalizedActivation, (OutputData._spikingSignal > 0));
//Update statistics
if (collectStatistics)
{
Statistics.Update(_iStimuli, _rStimuli, _tStimuli, _activationState, OutputData._analogSignal, OutputData._spikingSignal);
}
return;
}
private void TestActivation(IActivationFunction af, int simLength, double constCurrent, int from, int count)
{
Random rand = new Random();
for (int i = 1; i <= simLength; i++)
{
double signal = 0;
if (i >= from && i < from + count)
{
double input = double.IsNaN(constCurrent) ? rand.NextDouble(0, 1, false, RandomClassExtensions.DistributionType.Uniform) : constCurrent;
signal = af.Compute(input);
}
else
{
signal = af.Compute(0);
}
Console.WriteLine($"{i}, State {af.InternalState} signal {signal}");
}
Console.ReadLine();
return;
}
private void TestActivation(IActivationFunction af, int simLength, double constCurrent, int from, int count)
{
Random rand = new Random();
for (int i = 1; i <= simLength; i++)
{
double signal;
if (i >= from && i < from + count)
{
double input = double.IsNaN(constCurrent) ? rand.NextDouble() : constCurrent;
signal = af.Compute(input);
}
else
{
signal = af.Compute(0);
}
Console.WriteLine($"{i}, State {(af.TypeOfActivation == Neural.Activation.ActivationType.Spiking ? af.InternalState : signal)} signal {signal}");
}
Console.ReadLine();
return;
}
public double Compute(double[] input)
{
double output = 0;
for (int i = 0; i < input.Length; i++)
{
output += m_weights[i] * input[i];
}
output += m_weights[input.Length] * m_threshold;
output = m_function.Compute(output);
m_output = output;
return(output);
}
/// <summary>
/// Computes neuron's new output signal and updates statistics
/// </summary>
/// <param name="collectStatistics">Specifies whether to update internal statistics</param>
public void ComputeSignal(bool collectStatistics)
{
//Spike leak handling
if (_spikingSignal > 0)
{
//Spike during previous cycle, so reset the counter
AfterFirstSpike = true;
SpikeLeak = 0;
}
++SpikeLeak;
if (_activation.TypeOfActivation == ActivationType.Spiking)
{
//Spiking activation
_spikingSignal = _activation.Compute(_tStimuli);
_activationState = _activation.InternalState;
_analogSignal = _spikingSignal;
}
else
{
//Analog activation
double prevActivationState = _activationState;
double newState = _activation.Compute(_tStimuli);
_activationState = (_retainmentStrength * _activationState) + (1d - _retainmentStrength) * newState;
_analogSignal = _outputRange.Rescale(_activationState, _activation.OutputRange);
bool firingEvent = (_activationState - prevActivationState) > _analogFiringThreshold;
_spikingSignal = firingEvent ? 1d : 0d;
}
//Update predictors
_predictors?.Update(_activationState, (_spikingSignal > 0));
//Update statistics
if (collectStatistics)
{
Statistics.Update(_iStimuli, _rStimuli, _tStimuli, _activationState, _analogSignal, _spikingSignal);
}
return;
}
public Matrix Compute()
{
if (IsInputLayer)
{
return(Weights);
}
var inputMatrix = _input.Compute();
for (var row = 0; row < ActivationsMatrix.Rows; row++)
{
var neuronWeights = Weights.GetRow(row);
WeightedInputMatrix[row, 0] = Matrix.DotProduct(inputMatrix, neuronWeights) + Bias[row, 0];
var activated = _activation.Compute(WeightedInputMatrix[row, 0]);
ActivationsMatrix[row, 0] = activated;
}
return(ActivationsMatrix);
}
/// <summary>
/// Computes neuron's new output signal and updates statistics
/// </summary>
/// <param name="collectStatistics">Specifies whether to update internal statistics</param>
public void NewState(bool collectStatistics)
{
//Output signal leak handling
if (OutputSignal > 0)
{
//Spike during previous cycle, so reset the counter
OutputSignalLeak = 0;
}
++OutputSignalLeak;
//New output signal
OutputSignal = _activation.Compute(_tStimuli);
_firingRate.Update(OutputSignal > 0);
if (collectStatistics)
{
Statistics.Update(_tStimuli, _rStimuli, _activation.InternalState, OutputSignal);
}
return;
}
/// <summary>
/// Computes the neuron.
/// </summary>
/// <param name="stimuli">Input stimulation</param>
/// <param name="collectStatistics">Specifies whether to update internal statistics</param>
public void Compute(double stimuli, bool collectStatistics)
{
stimuli = (stimuli + Bias).Bound();
if (collectStatistics)
{
StimuliStat.AddSampleValue(stimuli);
}
//State and signal
_signal = (_retainmentRatio * _state) + (1d - _retainmentRatio) * _activation.Compute(stimuli);
_state = _signal;
//Compute rescaled state
_rescaledState = _rescalledStateRange.Rescale(_state, _activation.InternalStateRange);
//Statistics
if (collectStatistics)
{
StatesStat.AddSampleValue(_rescaledState);
}
return;
}
/// <summary>
/// Computes the neuron.
/// </summary>
/// <param name="stimuli">Input stimulation</param>
/// <param name="collectStatistics">Specifies whether to update internal statistics</param>
public void Compute(double stimuli, bool collectStatistics)
{
stimuli = (stimuli + Bias).Bound();
if (collectStatistics)
{
StimuliStat.AddSampleValue(stimuli);
}
//State and spike
_spike = _activation.Compute(stimuli);
_state = _activation.InternalState;
_firingRate.Update(_spike > 0);
//Compute rescaled state
_rescaledState = _rescalledStateRange.Rescale(_state, _activation.InternalStateRange);
//Statistics
if (collectStatistics)
{
StatesStat.AddSampleValue(_rescaledState);
}
return;
}
//Methods
private void TestActivation(IActivationFunction af, int simLength, double constCurrent, int from, int count)
{
for (int i = 1; i <= simLength; i++)
{
double signal;
double input;
if (i >= from && i < from + count)
{
input = double.IsNaN(constCurrent) ? _rand.NextDouble() : constCurrent;
}
else
{
input = 0d;
}
signal = af.Compute(input);
Console.WriteLine($"{af.GetType().Name} step {i}, State {(af.TypeOfActivation == ActivationType.Spiking ? af.InternalState : signal)} signal {signal}");
}
Console.ReadLine();
return;
}