/**
* This method updates the permanence matrix with a column's new permanence values. The column is
* identified by its index, which reflects the row in the matrix, and the permanence is given in
* 'sparse' form, (i.e. an array whose members are associated with specific indexes). It is in
* charge of implementing 'clipping' - ensuring that the permanence values are always between 0
* and 1 - and 'trimming' - enforcing sparseness by zeroing out all permanence values below
* 'synPermTrimThreshold'. Every method wishing to modify the permanence matrix should do so
* through this method.
*
* @param c the {@link Connections} which is the memory model.
* @param perm An array of permanence values for a column. The array is "sparse", i.e. it contains
* an entry for each input bit, even if the permanence value is 0.
* @param column The column in the permanence, potential and connectivity matrices
* @param raisePerm a boolean value indicating whether the permanence values
*/
public void updatePermanencesForColumnSparse(
Connections c, double[] perm, Column column, int[] maskPotential, boolean raisePerm) {
if (raisePerm) {
raisePermanenceToThresholdSparse(c, perm);
}
ArrayUtils.lessThanOrEqualXThanSetToY(perm, c.getSynPermTrimThreshold(), 0);
ArrayUtils.clip(perm, c.getSynPermMin(), c.getSynPermMax());
column.setProximalPermanencesSparse(c, perm, maskPotential);
}
/**
* Step two of pooler initialization kept separate from initialization of static members so that
* they may be set at a different point in the initialization (as sometimes needed by tests).
*
* <p>This step prepares the proximal dendritic synapse pools with their initial permanence values
* and connected inputs.
*
* @param c the {@link Connections} memory
*/
public void connectAndConfigureInputs(Connections c) {
// Initialize the set of permanence values for each column. Ensure that
// each column is connected to enough input bits to allow it to be
// activated.
int numColumns = c.getNumColumns();
for (int i = 0; i < numColumns; i++) {
int[] potential = mapPotential(c, i, true);
Column column = c.getColumn(i);
c.getPotentialPools().set(i, column.createPotentialPool(c, potential));
double[] perm = initPermanence(c, potential, i, c.getInitConnectedPct());
updatePermanencesForColumn(c, perm, column, potential, true);
}
// The inhibition radius determines the size of a column's local
// neighborhood. A cortical column must overcome the overlap score of
// columns in its neighborhood in order to become active. This radius is
// updated every learning round. It grows and shrinks with the average
// number of connected synapses per column.
updateInhibitionRadius(c);
}
@Test
public void testObjectGroup() {
Column c0 = new Column(9, 0);
Column c1 = new Column(9, 1);
// Illustrates the Cell's actual index = colIndex * cellsPerColumn + indexOfCellWithinCol
assertEquals(7, c0.getCell(7).getIndex());
assertEquals(12, c1.getCell(3).getIndex());
assertEquals(16, c1.getCell(7).getIndex());
DistalDendrite dd0 = new DistalDendrite(c0.getCell(7), 0, 0, 0);
DistalDendrite dd1 = new DistalDendrite(c1.getCell(3 /* Col 1's Cells start at 9 */), 1, 0, 1);
DistalDendrite dd2 = new DistalDendrite(c1.getCell(7 /* Col 1's Cells start at 9 */), 2, 0, 2);
List<DistalDendrite> l = Arrays.asList(new DistalDendrite[] {dd0, dd1, dd2});
@SuppressWarnings("unchecked")
List<Pair<DistalDendrite, Column>> expected =
Arrays.asList(
new Pair[] {
new Pair<DistalDendrite, Column>(dd0, c0),
new Pair<DistalDendrite, Column>(dd1, c1),
new Pair<DistalDendrite, Column>(dd2, c1)
});
GroupBy<DistalDendrite, Column> grouper = GroupBy.of(l, i -> i.getParentCell().getColumn());
int i = 0;
for (Pair<DistalDendrite, Column> p : grouper) {
assertEquals(expected.get(i++), p);
}
}