Hi !
I got next errors :
File “/home/sergey/.local/lib/python2.7/site-packages/nupic/regions/sp_region.py”, line 537, in _compute
buInputVector = inputs[‘bottomUpIn’] #inputs bottomUpIn
KeyError: ‘bottomUpIn’
Do you have some thoughts, how can I solve this errors.
Thanx a lot,
Sergey
Sergey, we are definitely going to need to see some of your code to help debug this problem.
@rhyolight We separate our project in module. I think it is depend on network and link module .
# import global modules
import re
# import nupic modules
from nupic.engine import Network
# import custom modules
import include.utils as utils
from L1 import L1
from Ch1 import Ch1
from links import Links
from include.filter.f1_region import F1Region
from include.region.pluggable_encoder_sensor_patch import PluggableEncoderSensorPatch
from include.region.pluggable_encoder_sensor_patch_chunk import PluggableEncoderSensorPatchChunk
class HTMNetwork():
def __init__(self, load):
self.loadPath = '/var/www/challenge/model/model.nta'
self.wordEndCode = 31
self.chunkStartCode = 1
self.chunkEndCode = 2
if load == True:
self.network = self.load()
else:
self.network = self.newNetwork()
# get network regions
self.networkRegions()
def newNetwork(self):
self.registerRegions()
self.network = Network()
# Create Level 1
level1 = L1(self.network)
self.network = level1.initialize()
# Create Chunk region 1
chunk1 = Ch1(self.network)
self.network = chunk1.initialize()
# Create network links
Links(self.network)
# Filter 1 output is end of word or emtpy array
#self.network = Filter1(self.network)
# Filter 2 make groups in
# network = Filter1(network)
return self.network
def load(self):
"""
TODO! load nrtwork
"""
self.registerRegions()
self.network = Network(self.loadPath)
return self.network
def registerRegions(self):
Network.registerRegion(PluggableEncoderSensorPatch)
Network.registerRegion(PluggableEncoderSensorPatchChunk)
Network.registerRegion(F1Region)
def networkRegions(self):
# Network regions
# level 1
self.L1_Region_encoder = self.network.regions['L1_encoder']
self.L1_Region_sp = self.network.regions['L1_sp']
self.L1_Region_tm = self.network.regions['L1_tm']
self.L1_Region_classifier = self.network.regions['L1_classifier']
# chunk level 1
def turnOnLearning(self):
self.L1_Region_sp.setParameter('learningMode', True)
self.L1_Region_tm.setParameter('learningMode', True)
self.L1_Region_classifier.setParameter('learningMode', True)
def turnOffLearning(self):
self.L1_Region_sp.setParameter('learningMode', False)
self.L1_Region_tm.setParameter('learningMode', False)
self.L1_Region_classifier.setParameter('learningMode', False)
def run(self, learn=False, sequence=None, answer=None, times=1, singleWord=False):
"""
network run for learning or getting inference
:param learn: bolean. Need to learn or get inference
:param sequence: string that contains sequence for learning
:param answer: if @sequence has answer - string with answer
:param times: num iterations for learning
:param singleWord: is @sequence a single word
:return: None
"""
if learn == True:
return self.learning(sequence, answer, times, singleWord)
else:
return self.inference()
"""
TODO! sequence with answer
"""
if answer != None:
pass
else:
# print L1_spRegion.spec
# print L1_tmRegion.spec
# exit()
print 1
def inference(self):
self.turnOffLearning()
return 1
def learning(self, sequence=None, answer=None, times=1, singleWord=False):
if sequence == None:
return False
# else:
# sequence = re.sub(' +', ' ', sequence)
# IF single word, add word's end symbol
if singleWord == True:
sequence += chr(self.wordEndCode)
# Turn on learning
self.turnOnLearning()
if answer != None:
self.learningWithAnswer()
else:
self.learningAsIs(sequence, times)
return 1
def learningAsIs(self, sequence=None, times=1):
for x in range(times):
for symbol in sequence:
s = utils.symbolToInt(symbol)
# print s
self.L1_Region_encoder.getSelf().setTask(0)
self.L1_Region_encoder.getSelf().setSensedValue(s)
self.network.run(1)
# print self.L1_Region_encoder.spec
# print self.L1_Region_classifier.spec
# exit()
# print len(L1_tmRegion.getOutputData("lrnActiveStateT"))
# print len(L1_tmRegion.getOutputData("activeCells"))
# print len(L1_tmRegion.getOutputData("bottomUpOut"))
# print len(L1_tmRegion.getOutputData("topDownOut"))
# print len(L1_tmRegion.getOutputData("predictedActiveCells"))
# print (L1_tmRegion.getOutputData("bottomUpOut").nonzero())
# print len(L1_tmRegion.getOutputData("anomalyScore"))
if x == 49 and s != 31:
print '*' * 80
print s
print chr(s)
print '-' * 80
l2Predictions = self.L1_Region_classifier.getOutputData("actualValues")
l2Probabilities = self.L1_Region_classifier.getOutputData("probabilities")
l2Prediction = l2Predictions[l2Probabilities.argmax()]
if type(l2Prediction) != float:
l2Prediction = float(l2Prediction)
print int(l2Prediction)
print chr(int(round(l2Prediction)))
else:
print (l2Prediction)
print chr(int(l2Prediction))
print '*' * 80
self.L1_Region_tm.getSelf().resetSequenceStates()
return 1
def learningWithAnswer(self):
return 1
And our link module
"""
Links between all network regions
"""
import utils
class Links():
def __init__(self, network=None):
self.network = network
def links(self):
self.network.link('L1_encoder', 'L1_sp', 'UniformLink', '')
self.network.link('L1_sp', 'L1_tm', 'UniformLink', '')
self.network.link('L1_tm', 'L1_classifier', 'UniformLink', '')
#self.network.link('L1_classifier', 'Ch1_encoder', 'UniformLink', '')
utils.encoderToClassifierLinks(self.network, 'L1_encoder', 'L1_classifier')
self.network.link('Ch1_encoder', 'Ch1_sp', 'UniformLink', '')
self.network.link('Ch1_sp', 'Ch1_tm', 'UniformLink', '')
self.network.link('Ch1_tm', 'Ch1_classifier', 'UniformLink', '')
utils.encoderToClassifierLinks(self.network, 'Ch1_encoder', 'Ch1_classifier')
#self.network.link('L1_encoder', 'Ch1_encoder', 'UniformLink', '', srcOutput='actValueOut', destInput='actualValueIn')
#self.network.link('L1_encoder', 'Ch1_encoder', 'UniformLink', '', srcOutput='dataOut', destInput='encoderSdrIn')
#self.network.link('L1_classifier', 'Ch1_encoder', 'UniformLink', '', srcOutput='actualValues', destInput='classifierValuesIn')
#self.network.link('L1_classifier', 'Ch1_encoder', 'UniformLink', '', srcOutput='probabilities', destInput='predictionIn')
self.network.link('L1_classifier', 'Ch1_encoder', 'UniformLink', '', srcOutput='actValueOut', destInput='actualValueIn')