/// <summary>
/// Updates the statistics.
/// </summary>
/// <param name="neuron">The hidden neuron.</param>
/// <param name="inputSynapses">A collection of the input synapses.</param>
/// <param name="internalSynapses">A collection of the internal synapses.</param>
public void Update(HiddenNeuron neuron, IList <Synapse> inputSynapses, IList <Synapse> internalSynapses)
{
++NumOfNeurons;
Activation.Update(neuron.Statistics.ActivationStat);
Stimuli.Update(neuron);
Synapses.Update(inputSynapses);
Synapses.Update(internalSynapses);
Signal.Update(neuron);
NeuronsAnomalies.Update(neuron, internalSynapses.Count);
return;
}
/// <summary>
/// Informs this Epoch that stimulus data was output by the Symphony.Core output pipeline.
/// </summary>
/// <param name="device">ExternalDevice that was the target of the output data</param>
/// <param name="outputTime">Approximate time the data was written "to the wire"</param>
/// <param name="duration">Duration of the output data segment</param>
/// <param name="configuration">Pipeline node configuration(s) for nodes that processed the outgoing data</param>
public virtual void DidOutputData(IExternalDevice device, DateTimeOffset outputTime, TimeSpan duration, IEnumerable <IPipelineNodeConfiguration> configuration)
{
//virtual so that we can mock it
if (outputTime < StartTime)
{
throw new ArgumentException("Data output time must be after Epoch start time", "outputTime");
}
if (Stimuli.ContainsKey(device))
{
Stimuli[device].DidOutputData(duration, configuration);
}
}
//Generate confusion matrix log
public string GenerateConfusionMatrixLog()
{
int k = Stimuli.Count;
int[,] matrix = new int[k, k];
for (int i = 0; i < k; ++i)
{
for (int j = 0; j < k; ++j)
{
matrix[i, j] = 0;
}
}
foreach (string pair in stimuliResponsePairs)
{
string stimulus = pair.Split(","[0])[0];
string response = pair.Split(","[0])[1];
int i = GetIndexOfStimulus(stimulus);
int j = GetIndexOfStimulus(response);
if (i != -1 && j != -1)
{
matrix[i, j] += 1;
}
}
string log = "EMPTY";
foreach (Stimulus stimulus in Stimuli)
{
log += "," + stimulus.Name;
}
log += "\n";
for (int i = 0; i < k; ++i)
{
log += Stimuli.ElementAt(i).Name;
for (int j = 0; j < k; ++j)
{
log += "," + matrix[i, j];
}
if (i != k - 1)
{
log += "\n";
}
}
return(log);
}
/// <summary>
/// Pulls output data from the given device of the given duration.
/// <para>If the given device has an associated Stimulus in this.Stimuli,
/// the data is pulled from that Stimulus. If there is no associated Stimulus,
/// data is generated according to this.Background[dev].</para>
/// </summary>
/// <param name="dev">Output device requesting data</param>
/// <param name="blockDuration">Requested duration of the IOutputData</param>
/// <returns>IOutputData intsance with duration less than or equal to blockDuration</returns>
public IOutputData PullOutputData(IExternalDevice dev, TimeSpan blockDuration)
{
if (Stimuli.ContainsKey(dev))
{
var blockIter = StimulusDataEnumerators.GetOrAdd(dev,
(d) => Stimuli[d].DataBlocks(blockDuration).GetEnumerator()
);
IOutputData stimData = null;
while (stimData == null || stimData.Duration < blockDuration)
{
if (!blockIter.MoveNext())
{
break;
}
stimData =
stimData == null ? blockIter.Current : stimData.Concat(blockIter.Current);
}
if (stimData == null)
{
return(BackgroundDataForDevice(dev, blockDuration));
}
if (stimData.Duration < blockDuration)
{
var remainingDuration = blockDuration - stimData.Duration;
stimData = stimData.Concat(BackgroundDataForDevice(dev, remainingDuration));
}
return(stimData);
}
log.DebugFormat("Will send background for device {0} ({1})", dev.Name, blockDuration);
return(BackgroundDataForDevice(dev, blockDuration));
}
//Get a random stimulus from the stimuli set
public Stimulus GetRandomStimulus()
{
return(Stimuli.ElementAt(r.Next(0, Stimuli.Count)));
}
