예제 #1
0
    def __init__(self):
        """
		Initializes a new instance of this class.
		"""

        #region Instance fields

        self.x = -1
        """Position on X axis"""

        self.y = -1
        """Position on Y axis"""

        self.segment = Segment(SegmentType.proximal)
        """Proximal segment of this column"""

        self.cells = []
        """List of cells that compose this column."""

        #region 3d-tree properties (simulation form)

        self.tree3d_x = 0
        self.tree3d_y = 0
        self.tree3d_z = 0
예제 #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
예제 #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)