Ejemplo n.º 1
0
    def updateSpatialElements(self, activeColumns):
        """
		Update elements regarding spatial pooler
		"""

        # Update proximal segments and synapses according to active columns
        for colIdx in range(len(self.columns)):
            column = self.columns[colIdx]

            # Update proximal segment
            segment = column.segment
            if activeColumns[colIdx] == 1:
                segment.isActive[maxStoredSteps - 1] = True
            else:
                segment.isActive[maxStoredSteps - 1] = False

            # Check if proximal segment is predicted by check if the column has any predicted cell
            for cell in column.cells:
                if cell.index in self.temporalPooler.predictiveCells:
                    segment.isPredicted[maxStoredSteps - 1] = True

            # Update proximal synapses
            if segment.isActive[maxStoredSteps -
                                1] or segment.isPredicted[maxStoredSteps - 1]:
                permanencesSynapses = []
                self.spatialPooler.getPermanence(colIdx, permanencesSynapses)
                connectedSynapses = []
                self.spatialPooler.getConnectedSynapses(
                    colIdx, connectedSynapses)
                for synIdx in range(len(permanencesSynapses)):
                    # Get the proximal synapse given its position in the input map
                    # Create a new one if it doesn't exist
                    synapse = segment.getSynapse(synIdx)

                    # Update proximal synapse
                    if permanencesSynapses[synIdx] > 0.:
                        if synapse == None:
                            # Create a new synapse to a input element
                            # An input element is a column if child is a region
                            # or then a bit if child is a sensor
                            synapse = Synapse()
                            synapse.inputElem = self._inputMap[synIdx]
                            synapse.indexSP = synIdx
                            segment.synapses.append(synapse)

                        # Update state
                        synapse.isRemoved[maxStoredSteps - 1] = False
                        synapse.permanence[maxStoredSteps -
                                           1] = permanencesSynapses[synIdx]
                        if connectedSynapses[synIdx] == 1:
                            synapse.isConnected[maxStoredSteps - 1] = True
                        else:
                            synapse.isConnected[maxStoredSteps - 1] = False
                    else:
                        if synapse != None:
                            synapse.isRemoved[maxStoredSteps - 1] = True
Ejemplo n.º 2
0
    def updateTemporalElements(self):
        """
		Update elements regarding temporal pooler
		"""

        # Update cells, distal segments and synapses according to active columns
        for colIdx in range(len(self.columns)):
            column = self.columns[colIdx]

            # Mark proximal segment and its connected synapses as predicted
            if column.segment.isPredicted[maxStoredSteps - 1]:
                for synapse in column.segment.synapses:
                    if synapse.isConnected[maxStoredSteps - 1]:
                        synapse.isPredicted[maxStoredSteps - 1] = True
                        synapse.inputElem.isPredicted[maxStoredSteps -
                                                      1] = True

            for cell in column.cells:
                cellIdx = cell.index

                # Update cell's states
                if cellIdx in self.temporalPooler.winnerCells:
                    cell.isLearning[maxStoredSteps - 1] = True
                if cellIdx in self.temporalPooler.activeCells:
                    cell.isActive[maxStoredSteps - 1] = True
                if cellIdx in self.temporalPooler.predictiveCells:
                    cell.isPredicted[maxStoredSteps - 1] = True

                # Get the indexes of the distal segments of this cell
                segmentsForCell = self.temporalPooler.connections.segmentsForCell(
                    cellIdx)

                # Add the segments that appeared after last iteration
                for segIdx in segmentsForCell:
                    # Check if segment already exists in the cell
                    segFound = False
                    for segment in cell.segments:
                        if segment.indexTP == segIdx:
                            segFound = True
                            break

                    # If segment is new, add it to cell
                    if not segFound:
                        segment = Segment(SegmentType.distal)
                        segment.indexTP = segIdx
                        cell.segments.append(segment)

                # Update distal segments
                for segment in cell.segments:
                    segIdx = segment.indexTP

                    # If segment not found in segments indexes returned in last iteration mark it as removed
                    if segIdx in segmentsForCell:

                        # Update segment's state
                        if segIdx in self.temporalPooler.activeSegments:
                            segment.isActive[maxStoredSteps - 1] = True
                        else:
                            segment.isActive[maxStoredSteps - 1] = False

                        # Get the indexes of the synapses of this segment
                        synapsesForSegment = self.temporalPooler.connections.synapsesForSegment(
                            segIdx)

                        # Add the synapses that appeared after last iteration
                        for synIdx in synapsesForSegment:
                            # Check if synapse already exists in the segment
                            synFound = False
                            for synapse in segment.synapses:
                                if synapse.indexTP == synIdx:
                                    synFound = True
                                    break

                            # If synapse is new, add it to segment
                            if not synFound:
                                synapse = Synapse()
                                synapse.indexTP = synIdx
                                segment.synapses.append(synapse)

                        # Update synapses
                        for synapse in segment.synapses:
                            synIdx = synapse.indexTP

                            # If synapse not found in synapses indexes returned in last iteration mark it as removed
                            if synIdx in synapsesForSegment:

                                # Update synapse's state
                                (
                                    _, sourceCellIdx, permanence
                                ) = self.temporalPooler.connections.dataForSynapse(
                                    synIdx)
                                synapse.permanence[maxStoredSteps -
                                                   1] = permanence
                                if permanence >= self.distalSynConnectedPerm:
                                    synapse.isConnected[maxStoredSteps -
                                                        1] = True
                                else:
                                    synapse.isConnected[maxStoredSteps -
                                                        1] = False

                                # Get cell given cell's index
                                for sourceColumn in self.columns:
                                    for sourceCell in sourceColumn.cells:
                                        if sourceCell.index == sourceCellIdx:
                                            synapse.inputElem = sourceCell
                            else:
                                synapse.isRemoved[maxStoredSteps - 1] = True
                    else:
                        segment.isRemoved[maxStoredSteps - 1] = True
Ejemplo n.º 3
0
    def updateTemporalElements(self):
        """
		Update elements regarding temporal pooler
		"""

        # Update cells, distal segments and synapses according to active columns
        for colIdx in range(len(self.columns)):
            column = self.columns[colIdx]

            # Mark proximal segment and its connected synapses as predicted
            if column.segment.isPredicted.atCurrStep():
                for synapse in column.segment.synapses:
                    if synapse.isConnected.atCurrStep():
                        synapse.isPredicted.setForCurrStep(True)
                        synapse.inputElem.isPredicted.setForCurrStep(True)

            # Mark proximal segment and its connected synapses that were predicted but are not active now
            if column.segment.isPredicted.atPreviousStep():
                if not column.segment.isActive.atCurrStep():
                    column.segment.isFalselyPredicted.setForCurrStep(True)
                for synapse in column.segment.synapses:
                    if (synapse.isPredicted.atPreviousStep()
                            and not synapse.isConnected.atCurrStep()
                        ) or (
                            synapse.isConnected.atCurrStep() and
                            synapse.inputElem.isFalselyPredicted.atCurrStep()):
                        synapse.isFalselyPredicted.setForCurrStep(True)

            for cell in column.cells:
                cellIdx = cell.index

                # Update cell's states
                if cellIdx in self.temporalPooler.winnerCells:
                    cell.isLearning.setForCurrStep(True)
                if cellIdx in self.temporalPooler.activeCells:
                    cell.isActive.setForCurrStep(True)
                if cellIdx in self.temporalPooler.predictiveCells:
                    cell.isPredicted.setForCurrStep(True)
                if cell.isPredicted.atPreviousStep(
                ) and not cell.isActive.atCurrStep():
                    cell.isFalselyPredicted.setForCurrStep(True)

                # Get the indexes of the distal segments of this cell
                segmentsForCell = self.temporalPooler.connections.segmentsForCell(
                    cellIdx)

                # Add the segments that appeared after last iteration
                for segIdx in segmentsForCell:
                    # Check if segment already exists in the cell
                    segFound = False
                    for segment in cell.segments:
                        if segment.indexTP == segIdx:
                            segFound = True
                            break

                    # If segment is new, add it to cell
                    if not segFound:
                        segment = Segment(SegmentType.distal)
                        segment.indexTP = segIdx
                        cell.segments.append(segment)

                # Update distal segments
                for segment in cell.segments:
                    segIdx = segment.indexTP

                    # If segment not found in segments indexes returned in last iteration mark it as removed
                    if segIdx in segmentsForCell:

                        # Update segment's state
                        if segIdx in self.temporalPooler.activeSegments:
                            segment.isActive.setForCurrStep(True)
                        else:
                            segment.isActive.setForCurrStep(False)

                        # Get the indexes of the synapses of this segment
                        synapsesForSegment = self.temporalPooler.connections.synapsesForSegment(
                            segIdx)

                        # Add the synapses that appeared after last iteration
                        for synIdx in synapsesForSegment:
                            # Check if synapse already exists in the segment
                            synFound = False
                            for synapse in segment.synapses:
                                if synapse.indexTP == synIdx:
                                    synFound = True
                                    break

                            # If synapse is new, add it to segment
                            if not synFound:
                                synapse = Synapse()
                                synapse.indexTP = synIdx
                                segment.synapses.append(synapse)

                        # Update synapses
                        for synapse in segment.synapses:
                            synIdx = synapse.indexTP

                            # If synapse not found in synapses indexes returned in last iteration mark it as removed
                            if synIdx in synapsesForSegment:

                                # Update synapse's state
                                (
                                    _, sourceCellAbsIdx, permanence
                                ) = self.temporalPooler.connections.dataForSynapse(
                                    synIdx)
                                synapse.permanence.setForCurrStep(permanence)
                                if permanence >= self.distalSynConnectedPerm:
                                    synapse.isConnected.setForCurrStep(True)
                                else:
                                    synapse.isConnected.setForCurrStep(False)

                                # Get cell given cell's index
                                sourceColIdx = sourceCellAbsIdx / self.numCellsPerColumn
                                sourceCellRelIdx = sourceCellAbsIdx % self.numCellsPerColumn
                                sourceCell = self.columns[sourceColIdx].cells[
                                    sourceCellRelIdx]
                                synapse.inputElem = sourceCell
                            else:
                                synapse.isRemoved.setForCurrStep(True)
                    else:
                        segment.isRemoved.setForCurrStep(True)