Ejemplo n.º 1
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[maxPreviousSteps - 1]:
				for synapse in column.segment.synapses:
					if synapse.isConnected[maxPreviousSteps - 1]:
						synapse.isPredicted[maxPreviousSteps - 1] = True
						synapse.inputElem.isPredicted[maxPreviousSteps - 1] = True

			# Mark proximal segment and its connected synapses that were predicted but are not active now
			if column.segment.isPredicted[maxPreviousSteps - 2]:
				if not column.segment.isActive[maxPreviousSteps - 1]:
					column.segment.isFalselyPredicted[maxPreviousSteps - 1] = True
				for synapse in column.segment.synapses:
					if (synapse.isPredicted[maxPreviousSteps - 2] and not synapse.isConnected[maxPreviousSteps - 1]) or (synapse.isConnected[maxPreviousSteps - 1] and synapse.inputElem.isFalselyPredicted[maxPreviousSteps - 1]):
						synapse.isFalselyPredicted[maxPreviousSteps - 1] = True

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

				# Update cell's states
				if cellIdx in self.temporalPooler.winnerCells:
					cell.isLearning[maxPreviousSteps - 1] = True
				if cellIdx in self.temporalPooler.activeCells:
					cell.isActive[maxPreviousSteps - 1] = True
				if cellIdx in self.temporalPooler.predictiveCells:
					cell.isPredicted[maxPreviousSteps - 1] = True
				if cell.isPredicted[maxPreviousSteps - 2] and not cell.isActive[maxPreviousSteps - 1]:
					cell.isFalselyPredicted[maxPreviousSteps - 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[maxPreviousSteps - 1] = True
						else:
							segment.isActive[maxPreviousSteps - 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
								(_, sourceCellAbsIdx, permanence) = self.temporalPooler.connections.dataForSynapse(synIdx)
								synapse.permanence[maxPreviousSteps - 1] = permanence
								if permanence >= self.distalSynConnectedPerm:
									synapse.isConnected[maxPreviousSteps - 1] = True
								else:
									synapse.isConnected[maxPreviousSteps - 1] = 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[maxPreviousSteps - 1] = True
					else:
						segment.isRemoved[maxPreviousSteps - 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)