public void Learn(IEnumerable <SpatialPoolerColumn> activeColumns, SparseBitArray activeInputs)
{
foreach (var column in activeColumns)
{
column.IsActive = true;
column.MiniColumn.UpdatePermanences(activeInputs, Parameters.SynapticPermanenceInc, Parameters.SynapticPermanenceDec);
}
foreach (var column in PoolerColumns)
{
int active = column.IsActive ? 1 : 0;
column.UpdateActiveDutyCycle(active, Parameters.DutyCycleLength);
column.IsActive = false;
int overlapped = column.OverlapScore > Parameters.StimulusThreshold ? 1 : 0;
column.UpdateOverlapDutyCycle(overlapped, Parameters.DutyCycleLength);
}
_MeanActiveDutyCycle = PoolerColumns.Average(column => column.ActiveDutyCycle);
foreach (var column in PoolerColumns)
{
column.UpdateBoostFactor(Parameters.BoostStrength, column.ActiveDutyCycle, _MeanActiveDutyCycle);
column.MiniColumn.UpdateSynapses();
}
}
/// <summary>
/// Initialize a <see cref="MiniColumn">
/// </summary>
/// <param name="inputSize"></param>
/// <param name="activeBits"></param>
public MiniColumn(
int index,
int inputSize,
double potentialSynapsePercent,
double connectedPermThreshold)
{
_LinearIndex = index;
var potentialConnections = new List <int>();
var activeConnections = new List <int>();
_SynapticPermanences = new List <double>();
var rng = new Random();
for (var i = 0; i < inputSize; i++)
{
var r = rng.NextDouble();
if (r < potentialSynapsePercent)
{
potentialConnections.Add(i);
_SynapticPermanences.Add(r);
if (r >= connectedPermThreshold)
{
activeConnections.Add(i);
}
}
}
_PotentialConnections = new SparseBitArray(potentialConnections, inputSize);
_ActiveConnections = new SparseBitArray(activeConnections, inputSize);
}
public List <SpatialPoolerColumn> ComputeActive(SparseBitArray input)
{
var overlapScores = new List <double>(CorticalRegion.MiniColumns.Count);
foreach (var column in PoolerColumns)
{
column.IsActive = false;
var overlapScore = column.ComputeOverlap(input);
column.OverlapScore = overlapScore;
overlapScores.Add(overlapScore);
}
var topScores = overlapScores.KMax(Parameters.ActivationsPerInhibitionRegion);
var minimumScore = topScores.Last();
var activeColumns = new List <SpatialPoolerColumn>();
foreach (var column in PoolerColumns)
{
if (overlapScores[column.MiniColumn.LinearIndex] > Parameters.StimulusThreshold &&
overlapScores[column.MiniColumn.LinearIndex] >= minimumScore)
{
column.IsActive = true;
activeColumns.Add(column);
}
}
_ActiveColumns = activeColumns;
return(activeColumns);
}
public void AllZeroAfterCreation()
{
var bitarray = new SparseBitArray();
Assert.True(!bitarray.Get(0));
Assert.True(!bitarray.Get(1));
Assert.True(!bitarray.Get(2));
Assert.True(!bitarray.Get(100));
Assert.True(!bitarray.Get(1000));
}
public void SimpleSets()
{
var bitarray = new SparseBitArray();
bitarray.Set(0, true);
bitarray.Set(1, true);
bitarray.Set(2, true);
bitarray.Set(3, true);
Assert.True(bitarray.Get(0));
Assert.True(bitarray.Get(1));
Assert.True(bitarray.Get(2));
Assert.True(bitarray.Get(3));
Assert.True(!bitarray.Get(4));
}
/// <summary>
/// Reinforces active synapses and discourages inactive ones.
/// </summary>
/// <param name="activeInputs"></param>
/// <param name="inc"></param>
/// <param name="dec"></param>
public void UpdatePermanences(SparseBitArray activeInputs, double inc, double dec)
{
Action <int, int, int> increment = (x, iPotential, jActiveInput) =>
{
_SynapticPermanences[iPotential] += inc;
_SynapticPermanences[iPotential] = Math.Min(1.0, _SynapticPermanences[iPotential]);
};
Action <int, int, int, int> decrement = (x, iPotential, y, jActiveInput) =>
{
_SynapticPermanences[iPotential] -= dec;
_SynapticPermanences[iPotential] = Math.Max(0.0, _SynapticPermanences[iPotential]);
};
PotentialConnections.SparseZipMap(activeInputs,
Comparer <int> .Default.Compare,
increment,
decrement,
decrement);
}
public void Indexers()
{
var indices = new[] { 0, 20, 25, 28, 35, 44, 47, 49 };
var array = new SparseBitArray(indices, 50);
foreach (var index in indices)
{
Assert.IsTrue(array.Contains(index));
}
for (var i = 0; i < 50; i++)
{
if (indices.Contains(i))
{
Assert.AreEqual(1, array[i]);
}
else
{
Assert.AreEqual(0, array[i]);
}
}
}
public double ComputeOverlap(SparseBitArray input)
{
var overlapCount = MiniColumn.ActiveConnections.OverlapCount(input);
return(overlapCount * BoostFactor);
}
public void ProcessAndLearn(SparseBitArray activeInputs)
{
var activeColumns = ComputeActive(activeInputs);
Learn(activeColumns, activeInputs);
}
