class Model(object): def __init__(self): self.sensorEncoder = ScalarEncoder(n=512, w=21, minval=8.9, maxval=40, clipInput=True, forced=True) self.motorEncoder = ScalarEncoder(n=512, w=21, minval=-400, maxval=400, clipInput=True, forced=True) self.experimentRunner = SensorimotorExperimentRunner( tmOverrides={ "columnDimensions": [512], "maxNewSynapseCount": 21*2, "minThreshold": 16*2, "activationThreshold": 16*2 }, tpOverrides={ "columnDimensions": [512], "numActiveColumnsPerInhArea": 20, "poolingThreshUnpredicted": 0.5 } ) def feed(self, sensorValue, motorValue, sequenceLabel=None): sensorSDR = set(self.sensorEncoder.encode(sensorValue).nonzero()[0].tolist()) motorSDR = set((self.motorEncoder.encode(motorValue).nonzero()[0] + self.sensorEncoder.n).tolist()) sensorimotorSDR = sensorSDR.union(motorSDR) self.experimentRunner.feedTransition(sensorSDR, motorSDR, sensorimotorSDR, tmLearn=True, tpLearn=True, sequenceLabel=sequenceLabel)
def encodeLetters(self): letterEncoder = ScalarEncoder(n=self.numColumns, w=self.numActiveCells, minval=0, maxval=25) numLetters = np.shape(self.letters)[0] letterArray = np.zeros((numLetters, self.numColumns)) letterIndices = [] for k in range(numLetters): letterArray[k, :] = letterEncoder.encode(k) idxLetters = [i for i, j in izip(count(), letterArray[k]) if j == 1] letterIndices.append(idxLetters) return letterIndices
def loadThingData(dataDir="data", n=150, w=11): """ Load Thing sensation data. There is one file per object, each row contains one feature, location pairs. The format is as follows: [(-33.6705, 75.5003, 2.4207)/10] => [[list of active bits of location], [list of active bits of feature]] The content before "=>" is the true 3D location / sensation We ignore the encoded values after "=>" and use :class:`ScalarEncoder` to encode the sensation in a way that is compatible with the experiment network. :param dataDir: The location data files :type dataDir: str :param n: The number of bits in the feature SDR. Usually L4 column count :type n: int :param w: Number of 'on' bits in the feature SDR. Usually L4 sample size :type w: int :return: Dictionary mapping objects to sensations that can be used directly by class L246aNetwork 'infer' and 'learn' methods :rtype: dict[str,list] """ objects = defaultdict(list) # Thing features are scalar values ranging from 1-25 inclusive encoder = ScalarEncoder(n=n, w=w, minval=1, maxval=25, forced=True) dataPath = os.path.dirname(os.path.realpath(__file__)) dataPath = os.path.join(dataPath, dataDir) objFiles = glob.glob1(dataPath, "*.log") for filename in objFiles: obj, _ = os.path.splitext(filename) # Read raw sensations from log file. Ignore SDRs after "=>" sensations = [] with open(os.path.join(dataPath, filename)) as f: for line in f.readlines(): # Parse raw location/feature values line = line.split("=>")[0].translate(None, "[,]()") locationStr, featureStr = line.split("/") location = map(float, locationStr.split()) feature = encoder.encode(int(featureStr)).nonzero()[0].tolist() sensations.append((location, feature)) # Assume single column objects[obj] = [sensations] return objects
def encodeTime(self): timeEncoder = ScalarEncoder(n=self.numTimeColumns, w=self.numActiveTimeCells, minval=0, maxval=self.numTimeSteps, forced=True) timeArray = np.zeros((self.numTimeSteps, self.numTimeColumns)) timeIndices = [] for k in range(self.numTimeSteps): timeArray[k, :] = timeEncoder.encode(k) idxTimes = [i for i, j in izip(count(), timeArray[k]) if j == 1] timeIndices.append(idxTimes) return timeIndices
def __init__(self, w=5, minval=1e-07, maxval=10000, periodic=False, n=0, radius=0, resolution=0, name="log", verbosity=0, clipInput=True, forced=False): # Lower bound for log encoding near machine precision limit lowLimit = 1e-07 # Limit minval as log10(0) is undefined. if minval < lowLimit: minval = lowLimit # Check that minval is still lower than maxval if not minval < maxval: raise ValueError("Max val must be larger than min val or the lower limit " "for this encoder %.7f" % lowLimit) self.encoders = None self.verbosity = verbosity # Scale values for calculations within the class self.minScaledValue = math.log10(minval) self.maxScaledValue = math.log10(maxval) if not self.maxScaledValue > self.minScaledValue: raise ValueError("Max val must be larger, in log space, than min val.") self.clipInput = clipInput self.minval = minval self.maxval = maxval self.encoder = ScalarEncoder(w=w, minval=self.minScaledValue, maxval=self.maxScaledValue, periodic=False, n=n, radius=radius, resolution=resolution, verbosity=self.verbosity, clipInput=self.clipInput, forced=forced) self.width = self.encoder.getWidth() self.description = [(name, 0)] self.name = name # This list is created by getBucketValues() the first time it is called, # and re-created whenever our buckets would be re-arranged. self._bucketValues = None
def __init__(self): self.sensorEncoder = ScalarEncoder(n=512, w=21, minval=8.9, maxval=40, clipInput=True, forced=True) self.motorEncoder = ScalarEncoder(n=512, w=21, minval=-400, maxval=400, clipInput=True, forced=True) self.experimentRunner = SensorimotorExperimentRunner( tmOverrides={ "columnDimensions": [512], "maxNewSynapseCount": 21*2, "minThreshold": 16*2, "activationThreshold": 16*2 }, tpOverrides={ "columnDimensions": [512], "numActiveColumnsPerInhArea": 20, "poolingThreshUnpredicted": 0.5 } )
def read(cls, proto): encoder = object.__new__(cls) encoder.verbosity = proto.verbosity encoder.minScaledValue = round(proto.minScaledValue, EPSILON_ROUND) encoder.maxScaledValue = round(proto.maxScaledValue, EPSILON_ROUND) encoder.clipInput = proto.clipInput encoder.minval = round(proto.minval, EPSILON_ROUND) encoder.maxval = round(proto.maxval, EPSILON_ROUND) encoder.encoder = ScalarEncoder.read(proto.encoder) encoder.name = proto.name encoder.width = encoder.encoder.getWidth() encoder.description = [(encoder.name, 0)] encoder._bucketValues = None encoder.encoders = None return encoder
def test_sp(): from nupic.encoders import ScalarEncoder from nupic.regions import SPRegion columns = 128 se = ScalarEncoder(n=21 + 50, w=3 + 9, minval=0, maxval=100, forced=True) queue = cl.CommandQueue( cl.Context([cl.get_platforms()[0].get_devices()[0]])) sp = SpatialPooler(queue, columnCount=columns, inputWidth=se.n, spVerbosity=1) sp_nupic = SPRegion.SPRegion(columnCount=columns, inputWidth=se.n) val = 1 # return for _ in range(0, 2): for i in range(0, 10): encoding = se.encode(val) bucketIdx = se.getBucketIndices(val)[0] print("Actual Value: {} , Active Bits: {}, BucketIdx: {}".format( val, np.where(encoding == 1), bucketIdx)) sp.compute(encoding, True, method=2) val += 0.5 print("-" * 10)
def createEncoder(): """Create the encoder instance for our test and return it.""" consumption_encoder = ScalarEncoder(21, 0.0, 100.0, n=50, name="consumption", clipInput=True) time_encoder = DateEncoder(timeOfDay=(21, 9.5), name="timestamp_timeOfDay") encoder = MultiEncoder() encoder.addEncoder("consumption", consumption_encoder) encoder.addEncoder("timestamp", time_encoder) return encoder
def createEncoder(): diagCoorA_encoder = ScalarEncoder(105, 0.0, 200.0, n=1324, name="diagCoorA", clipInput=False, forced=True) diagCoorB_encoder = ScalarEncoder(105, 0.0, 200.0, n=1324, name="diagCoorB", clipInput=False, forced=True) global encoder encoder = MultiEncoder() encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) return encoder
def compare_overlap(): print("Using device: ", device) from nupic.encoders import ScalarEncoder from nupic.regions import SPRegion cols = 2048 se = ScalarEncoder(n=1024, w=33, minval=0, maxval=20, forced=True, clipInput=True, name='testInput') queue = cl.CommandQueue(cl.Context([device])) potentialPct = 0.25 sp_nupic = SPRegion.SPRegion(columnCount=cols, inputWidth=se.n, spatialImp='py', spVerbosity=1, potentialPct=potentialPct) sp_cl = SpatialPooler(queue, columnCount=cols, inputWidth=se.n, spVerbosity=1, inputActive=se.w, potentialPct=potentialPct) sp_nupic.initialize(None, None) lim = 1 print("\ntesting nupic") test_nupic(sp_nupic, se, lim) print("testing cl loop all") test_cl_loop_all(sp_cl, se, lim) # print("testing cl bit idx") # test_cl_idx(sp_cl, se, lim) # # sp_cl.dump_kernel_info() print("testing cl column ") test_cl_overlap_all_synapse(sp_cl, se, lim) print("Testing numpy") test_numpy_idx(sp_cl, se, lim) print("testing inverse") test_input_inverse(sp_cl, se, lim) print("testing cl for loop bin search") test_cl_loop_bin(sp_cl, se, lim)
def initialize(self, useRandomEncoder): """ Initialize the various data structures. """ self.setRandomSeed(self.seed) self.dim = numpy.shape(self.spatialConfig)[-1] self.spatialMap = dict( zip(map(tuple, list(self.spatialConfig)), self.sensoryInputElements)) self.lengthMotorInput1D = (2*self.maxDisplacement + 1) * \ self.numActiveBitsMotorInput uniqueSensoryElements = list(set(self.sensoryInputElementsPool)) if useRandomEncoder: self.sensoryEncoder = SDRCategoryEncoder( n=1024, w=self.numActiveBitsSensoryInput, categoryList=uniqueSensoryElements, forced=True) self.lengthSensoryInput = self.sensoryEncoder.getWidth() else: self.lengthSensoryInput = (len(self.sensoryInputElementsPool)+1) * \ self.numActiveBitsSensoryInput self.sensoryEncoder = CategoryEncoder( w=self.numActiveBitsSensoryInput, categoryList=uniqueSensoryElements, forced=True) motorEncoder1D = ScalarEncoder(n=self.lengthMotorInput1D, w=self.numActiveBitsMotorInput, minval=-self.maxDisplacement, maxval=self.maxDisplacement, clipInput=True, forced=True) self.motorEncoder = VectorEncoder(length=self.dim, encoder=motorEncoder1D)
def createEncoder(): #volume_encoder = ScalarEncoder(7, 0.0, 70.0, n=200, name="volume", clipInput=False, forced=True) #floorheight_encoder = ScalarEncoder(1, 0.0, 70.0, n=25, name="floorheight", clipInput=False, forced=True) diagCoorA_encoder = ScalarEncoder(257, 0.0, 200.0, n=2048, name="diagCoorA", clipInput=False, forced=True) #diagCoorB_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorB", clipInput=False, forced=True) #diagCoorC_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorC", clipInput=False, forced=True) #diagCoorD_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorD", clipInput=False, forced=True) #diagCoorE_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorE", clipInput=False, forced=True) #diagCoorF_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorF", clipInput=False, forced=True) #diagCoorG_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorG", clipInput=False, forced=True) #diagCoorH_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorH", clipInput=False, forced=True) #diagCoorI_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorI", clipInput=False, forced=True) #diagCoorJ_encoder = ScalarEncoder(157, 0.0, 200.0, n=2000, name="diagCoorJ", clipInput=False, forced=True) global encoder encoder = MultiEncoder() #encoder.addEncoder("volume", volume_encoder) #encoder.addEncoder("floorheight", floorheight_encoder) encoder.addEncoder("diagCoorA", diagCoorA_encoder) #encoder.addEncoder("diagCoorB", diagCoorB_encoder) #encoder.addEncoder("diagCoorC", diagCoorC_encoder) #encoder.addEncoder("diagCoorD", diagCoorD_encoder) #encoder.addEncoder("diagCoorE", diagCoorE_encoder) #encoder.addEncoder("diagCoorF", diagCoorF_encoder) #encoder.addEncoder("diagCoorG", diagCoorG_encoder) #encoder.addEncoder("diagCoorH", diagCoorH_encoder) #encoder.addEncoder("diagCoorI", diagCoorI_encoder) #encoder.addEncoder("diagCoorJ", diagCoorJ_encoder) return encoder
def test_cla_se(): from nupic.encoders import ScalarEncoder from nupic.algorithms.CLAClassifier import CLAClassifier as npCLAClassifier se = ScalarEncoder(n=10, w=3, minval=0, maxval=20, forced=True) queue = cl.CommandQueue(cl.Context([cl.get_platforms()[0].get_devices()[0]])) classifier = CLAClassifier(queue, numbuckets=len(se.getBucketValues()), bits=se.n, verbosity=True) np_cla = npCLAClassifier(verbosity=1) print("Buckets", se.getBucketValues()) val = 5 for _ in range(0, 2): for i in range(0, 10): encoding = np.where(se.encode(val) == 1)[0] bucketIdx = se.getBucketIndices(val)[0] print("Actual Value: {} , Active Bits: {}, BucketIdx: {}".format(val, encoding, bucketIdx)) cl_preds = classifier.compute(i, encoding, bucketIdx, val, True, True) nupic_preds = np_cla.compute(i, encoding, {'bucketIdx': bucketIdx, 'actValue': val}, True, True) print("cl", cl_preds) print("nup", np_cla._actualValues) print("nup", nupic_preds) # assert cl_preds == nupic_preds val += 0.5 print("-" * 32)
def testMultiEncoder(self): """Testing MultiEncoder...""" e = MultiEncoder() # should be 7 bits wide # use of forced=True is not recommended, but here for readibility, see # scalar.py e.addEncoder( "dow", ScalarEncoder(w=3, resolution=1, minval=1, maxval=8, periodic=True, name="day of week", forced=True)) # sould be 14 bits wide e.addEncoder( "myval", ScalarEncoder(w=5, resolution=1, minval=1, maxval=10, periodic=False, name="aux", forced=True)) self.assertEqual(e.getWidth(), 21) self.assertEqual(e.getDescription(), [("day of week", 0), ("aux", 7)]) d = DictObj(dow=3, myval=10) expected = numpy.array([0, 1, 1, 1, 0, 0, 0] + [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1], dtype="uint8") output = e.encode(d) self.assertTrue(numpy.array_equal(expected, output)) # Check decoding decoded = e.decode(output) self.assertEqual(len(decoded), 2) (ranges, _) = decoded[0]["aux"] self.assertEqual(len(ranges), 1) self.assertTrue(numpy.array_equal(ranges[0], [10, 10])) (ranges, _) = decoded[0]["day of week"] self.assertTrue( len(ranges) == 1 and numpy.array_equal(ranges[0], [3, 3])) e.addEncoder( "myCat", SDRCategoryEncoder(n=7, w=3, categoryList=["run", "pass", "kick"], forced=True)) d = DictObj(dow=4, myval=6, myCat="pass") output = e.encode(d) topDownOut = e.topDownCompute(output) self.assertAlmostEqual(topDownOut[0].value, 4.5) self.assertEqual(topDownOut[1].value, 6.0) self.assertEqual(topDownOut[2].value, "pass") self.assertEqual(topDownOut[2].scalar, 2) self.assertEqual(topDownOut[2].encoding.sum(), 3)
def getDescription(datasets): # ======================================================================== # Encoder for the sensor encoder = MultiEncoder() if config['encodingFieldStyleA'] == 'contiguous': encoder.addEncoder('fieldA', ScalarEncoder(w=config['encodingOnBitsA'], n=config['encodingFieldWidthA'], minval=0, maxval=config['numAValues'], periodic=True, name='fieldA')) elif config['encodingFieldStyleA'] == 'sdr': encoder.addEncoder('fieldA', SDRCategoryEncoder(w=config['encodingOnBitsA'], n=config['encodingFieldWidthA'], categoryList=range(config['numAValues']), name='fieldA')) else: assert False if config['encodingFieldStyleB'] == 'contiguous': encoder.addEncoder('fieldB', ScalarEncoder(w=config['encodingOnBitsB'], n=config['encodingFieldWidthB'], minval=0, maxval=config['numBValues'], periodic=True, name='fieldB')) elif config['encodingFieldStyleB'] == 'zero': encoder.addEncoder('fieldB', SDRRandomEncoder(w=0, n=config['encodingFieldWidthB'], name='fieldB')) elif config['encodingFieldStyleB'] == 'sdr': encoder.addEncoder('fieldB', SDRCategoryEncoder(w=config['encodingOnBitsB'], n=config['encodingFieldWidthB'], categoryList=range(config['numBValues']), name='fieldB')) else: assert False # ======================================================================== # Network definition # ------------------------------------------------------------------ # Node params # The inputs are long, horizontal vectors inputShape = (1, encoder.getWidth()) # Layout the coincidences vertically stacked on top of each other, each # looking at the entire input field. coincidencesShape = (config['spCoincCount'], 1) inputBorder = inputShape[1]/2 if inputBorder*2 >= inputShape[1]: inputBorder -= 1 sensorParams = dict( # encoder/datasource are not parameters so don't include here verbosity=config['sensorVerbosity'] ) CLAParams = dict( inputShape = inputShape, inputBorder = inputBorder, coincidencesShape = coincidencesShape, coincInputRadius = inputShape[1]/2, coincInputPoolPct = 1.0, gaussianDist = 0, commonDistributions = 0, # should be False if possibly not training localAreaDensity = -1, #0.05, numActivePerInhArea = config['spNumActivePerInhArea'], dutyCyclePeriod = 1000, stimulusThreshold = 1, synPermInactiveDec = config['spSynPermInactiveDec'], synPermActiveInc = 0.02, synPermActiveSharedDec=0.0, synPermOrphanDec = 0.0, minPctDutyCycleBeforeInh = 0.001, minPctDutyCycleAfterInh = config['spMinPctDutyCycleAfterInh'], minDistance = 0.05, computeTopDown = 1, spVerbosity = config['spVerbosity'], spSeed = 1, printPeriodicStats = int(config['spPeriodicStats']), # TP params disableTemporal = 1, # General params trainingStep = 'spatial', ) trainingDataSource = FileRecordStream(datasets['trainingFilename']) description = dict( options = dict( logOutputsDuringInference = False, ), network = dict( sensorDataSource = trainingDataSource, sensorEncoder = encoder, sensorParams = sensorParams, CLAType = 'py.CLARegion', CLAParams = CLAParams, classifierType = None, classifierParams = None), ) if config['trainSP']: description['spTrain'] = dict( iterationCount=config['iterationCount'], #iter=displaySPCoincidences(50), finish=printSPCoincidences() ), else: description['spTrain'] = dict( # need to train with one iteration just to initialize data structures iterationCount=1) # ============================================================================ # Inference tests inferSteps = [] # ---------------------------------------- # Training dataset if True: datasetName = 'bothTraining' inferSteps.append( dict(name = '%s_baseline' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['trainingFilename'])], ppOptions = dict(printLearnedCoincidences=True), ) ) inferSteps.append( dict(name = '%s_acc' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['trainingFilename'])], ppOptions = dict(onlyClassificationAcc=True, tpActivationThresholds=config['tpActivationThresholds'], computeDistances=True, verbosity = 1), ) ) # ---------------------------------------- # Testing dataset if 'testingFilename' in datasets: datasetName = 'bothTesting' inferSteps.append( dict(name = '%s_baseline' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['testingFilename'])], ppOptions = dict(printLearnedCoincidences=False), ) ) inferSteps.append( dict(name = '%s_acc' % datasetName, iterationCount = config['iterationCount'], setup = [sensorOpen(datasets['testingFilename'])], ppOptions = dict(onlyClassificationAcc=True, tpActivationThresholds=config['tpActivationThresholds']), ) ) description['infer'] = inferSteps return description
class LogEncoder(Encoder): """ This class wraps the :class:`.ScalarEncoder`. A Log encoder represents a floating point value on a logarithmic scale. .. code-block:: python valueToEncode = log10(input) :param resolution: The minimum change in scaled value needed to produce a change in encoding. This should be specified in log space. For example, the scaled values 10 and 11 will be distinguishable in the output. In terms of the original input values, this means 10^1 (1) and 10^1.1 (1.25) will be distinguishable. :param radius: inputs separated by more than this distance in log space will have non-overlapping representations """ def __init__(self, w=5, minval=1e-07, maxval=10000, periodic=False, n=0, radius=0, resolution=0, name="log", verbosity=0, clipInput=True, forced=False): # Lower bound for log encoding near machine precision limit lowLimit = 1e-07 # Limit minval as log10(0) is undefined. if minval < lowLimit: minval = lowLimit # Check that minval is still lower than maxval if not minval < maxval: raise ValueError("Max val must be larger than min val or the lower limit " "for this encoder %.7f" % lowLimit) self.encoders = None self.verbosity = verbosity # Scale values for calculations within the class self.minScaledValue = math.log10(minval) self.maxScaledValue = math.log10(maxval) if not self.maxScaledValue > self.minScaledValue: raise ValueError("Max val must be larger, in log space, than min val.") self.clipInput = clipInput self.minval = minval self.maxval = maxval self.encoder = ScalarEncoder(w=w, minval=self.minScaledValue, maxval=self.maxScaledValue, periodic=False, n=n, radius=radius, resolution=resolution, verbosity=self.verbosity, clipInput=self.clipInput, forced=forced) self.width = self.encoder.getWidth() self.description = [(name, 0)] self.name = name # This list is created by getBucketValues() the first time it is called, # and re-created whenever our buckets would be re-arranged. self._bucketValues = None def getWidth(self): return self.width def getDescription(self): return self.description def getDecoderOutputFieldTypes(self): """ Encoder class virtual method override """ return (FieldMetaType.float, ) def _getScaledValue(self, inpt): """ Convert the input, which is in normal space, into log space """ if inpt == SENTINEL_VALUE_FOR_MISSING_DATA: return None else: val = inpt if val < self.minval: val = self.minval elif val > self.maxval: val = self.maxval scaledVal = math.log10(val) return scaledVal def getBucketIndices(self, inpt): """ See the function description in base.py """ # Get the scaled value scaledVal = self._getScaledValue(inpt) if scaledVal is None: return [None] else: return self.encoder.getBucketIndices(scaledVal) def encodeIntoArray(self, inpt, output): """ See the function description in base.py """ # Get the scaled value scaledVal = self._getScaledValue(inpt) if scaledVal is None: output[0:] = 0 else: self.encoder.encodeIntoArray(scaledVal, output) if self.verbosity >= 2: print "input:", inpt, "scaledVal:", scaledVal, "output:", output print "decoded:", self.decodedToStr(self.decode(output)) def decode(self, encoded, parentFieldName=''): """ See the function description in base.py """ # Get the scalar values from the underlying scalar encoder (fieldsDict, fieldNames) = self.encoder.decode(encoded) if len(fieldsDict) == 0: return (fieldsDict, fieldNames) # Expect only 1 field assert(len(fieldsDict) == 1) # Convert each range into normal space (inRanges, inDesc) = fieldsDict.values()[0] outRanges = [] for (minV, maxV) in inRanges: outRanges.append((math.pow(10, minV), math.pow(10, maxV))) # Generate a text description of the ranges desc = "" numRanges = len(outRanges) for i in xrange(numRanges): if outRanges[i][0] != outRanges[i][1]: desc += "%.2f-%.2f" % (outRanges[i][0], outRanges[i][1]) else: desc += "%.2f" % (outRanges[i][0]) if i < numRanges-1: desc += ", " # Return result if parentFieldName != '': fieldName = "%s.%s" % (parentFieldName, self.name) else: fieldName = self.name return ({fieldName: (outRanges, desc)}, [fieldName]) def getBucketValues(self): """ See the function description in base.py """ # Need to re-create? if self._bucketValues is None: scaledValues = self.encoder.getBucketValues() self._bucketValues = [] for scaledValue in scaledValues: value = math.pow(10, scaledValue) self._bucketValues.append(value) return self._bucketValues def getBucketInfo(self, buckets): """ See the function description in base.py """ scaledResult = self.encoder.getBucketInfo(buckets)[0] scaledValue = scaledResult.value value = math.pow(10, scaledValue) return [EncoderResult(value=value, scalar=value, encoding = scaledResult.encoding)] def topDownCompute(self, encoded): """ See the function description in base.py """ scaledResult = self.encoder.topDownCompute(encoded)[0] scaledValue = scaledResult.value value = math.pow(10, scaledValue) return EncoderResult(value=value, scalar=value, encoding = scaledResult.encoding) def closenessScores(self, expValues, actValues, fractional=True): """ See the function description in base.py """ # Compute the percent error in log space if expValues[0] > 0: expValue = math.log10(expValues[0]) else: expValue = self.minScaledValue if actValues [0] > 0: actValue = math.log10(actValues[0]) else: actValue = self.minScaledValue if fractional: err = abs(expValue - actValue) pctErr = err / (self.maxScaledValue - self.minScaledValue) pctErr = min(1.0, pctErr) closeness = 1.0 - pctErr else: err = abs(expValue - actValue) closeness = err #print "log::", "expValue:", expValues[0], "actValue:", actValues[0], \ # "closeness", closeness #import pdb; pdb.set_trace() return numpy.array([closeness]) @classmethod def getSchema(cls): return LogEncoderProto @classmethod def read(cls, proto): encoder = object.__new__(cls) encoder.verbosity = proto.verbosity encoder.minScaledValue = round(proto.minScaledValue, EPSILON_ROUND) encoder.maxScaledValue = round(proto.maxScaledValue, EPSILON_ROUND) encoder.clipInput = proto.clipInput encoder.minval = round(proto.minval, EPSILON_ROUND) encoder.maxval = round(proto.maxval, EPSILON_ROUND) encoder.encoder = ScalarEncoder.read(proto.encoder) encoder.name = proto.name encoder.width = encoder.encoder.getWidth() encoder.description = [(encoder.name, 0)] encoder._bucketValues = None encoder.encoders = None return encoder def write(self, proto): proto.verbosity = self.verbosity proto.minScaledValue = self.minScaledValue proto.maxScaledValue = self.maxScaledValue proto.clipInput = self.clipInput proto.minval = self.minval proto.maxval = self.maxval self.encoder.write(proto.encoder) proto.name = self.name
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. import pyaudio import audioop import math from nupic.encoders import ScalarEncoder from nupic.research.TP import TP from termcolor import colored # Create our NuPIC entities enc = ScalarEncoder(n=50, w=3, minval=0, maxval=100, clipInput=True, forced=True) tp = TP(numberOfCols=50, cellsPerColumn=4, initialPerm=0.5, connectedPerm=0.5, minThreshold=5, newSynapseCount=5, permanenceInc=0.1, permanenceDec=0.1, activationThreshold=3, globalDecay=0.1, burnIn=1, checkSynapseConsistency=False, pamLength=3) # Setup our PyAudio Stream p = pyaudio.PyAudio() stream = p.open(format = pyaudio.paInt16, channels = 1, rate = int(p.get_device_info_by_index(0)['defaultSampleRate']), input = True, frames_per_buffer = 1024*5) print "%-48s %48s" % (colored("DECIBELS","green"),
month = Month(date) self.dayOfWeek = date.weekday() self.dayOfMonth = date.day self.firstLastOfMonth = 0 if date.day == 1 else 2 if date.day == month.last_day else 1 self.weekOfMonth = get_week_of_month(date) self.yearOfDecade = date.year % 10 self.monthOfYear = date.month self.quarterOfYear = month.quarter self.halfOfYear = month.half if __name__ == "__main__": day_of_week_enc = ScalarEncoder(w=3, minval=0, maxval=7, radius=1.5, periodic=True, name="dayOfWeek", forced=True) day_of_month_enc = ScalarEncoder(w=3, minval=1, maxval=31, radius=1.5, periodic=False, name="dayOfMonth", forced=True) first_last_of_month_enc = ScalarEncoder(w=1, minval=0, maxval=2, radius=1, periodic=False,
Created on Sun Apr 30 16:19:23 2017 @author: BJ """ from __future__ import absolute_import, division, print_function import numpy numpy.set_printoptions(threshold=numpy.nan) from nupic.encoders import ScalarEncoder # Scalar encoders # n is number of bits # w is the number of on bits # minval and maxval is the range the bits represent enc = ScalarEncoder(n=22, w=3, minval=2.5, maxval=97.5, clipInput=True, forced=True) enc = ScalarEncoder(n=22, w=3, minval=0, maxval=100, clipInput=True, forced=True) [print(enc.encode(i)) for i in xrange(1, 10)] print("3 =", enc.encode(10200)) enc = ScalarEncoder(n=14, w=3, minval=1, maxval=8,
# #output = nupic_output.NuPICFileOutput([dataSet]) # skips = 0 truths = [] # predictions = [] loop_length = len(df) if limit_to is None else limit_to pred_n = 109 date_n = 100 time_n = 600#600#(29+48-1) * 3 use_pred = True use_date = True use_time = True total_n = (pred_n if use_pred else 0) + (date_n if use_date else 0) + (time_n if use_time else 0) buckets = 22 enc = ScalarEncoder(29, minval=0, maxval=40000, n=pred_n) encDate = ScalarEncoder(29, minval=0, maxval=7, n=date_n,) encTime = ScalarEncoder(29, minval=0, maxval=1411, n=time_n) encOut = ScalarEncoder(29, minval=0, maxval=40000, n=50) from_command = False if from_command: nTrain = int(argv[3]) batch = int(argv[4]) epochs = int(argv[5]) epochs_retrain = int(argv[6]) lr = float(argv[7]) verbose = False else: nTrain = 4000 batch = 1024 lr = 0.005
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. import pyaudio import audioop import math from nupic.encoders import ScalarEncoder from nupic.research.TP import TP from termcolor import colored # Create our NuPIC entities enc = ScalarEncoder(n=50, w=3, minval=0, maxval=100, clipInput=True, forced=True) tp = TP(numberOfCols=50, cellsPerColumn=4, initialPerm=0.5, connectedPerm=0.5, minThreshold=5, newSynapseCount=5, permanenceInc=0.1, permanenceDec=0.1, activationThreshold=3, globalDecay=0.1, burnIn=1, checkSynapseConsistency=False,
def testSimpleMulticlassNetwork(self): # Setup data record stream of fake data (with three categories) filename = _getTempFileName() fields = [("timestamp", "datetime", "T"), ("value", "float", ""), ("reset", "int", "R"), ("sid", "int", "S"), ("categories", "list", "C")] records = ([datetime(day=1, month=3, year=2010), 0.0, 1, 0, ""], [ datetime(day=2, month=3, year=2010), 1.0, 0, 0, "1 2" ], [datetime(day=3, month=3, year=2010), 1.0, 0, 0, "1 2"], [datetime(day=4, month=3, year=2010), 2.0, 0, 0, "0"], [ datetime(day=5, month=3, year=2010), 3.0, 0, 0, "1 2" ], [datetime(day=6, month=3, year=2010), 5.0, 0, 0, "1 2"], [datetime(day=7, month=3, year=2010), 8.0, 0, 0, "0"], [datetime(day=8, month=3, year=2010), 13.0, 0, 0, "1 2"]) dataSource = FileRecordStream(streamID=filename, write=True, fields=fields) for r in records: dataSource.appendRecord(list(r)) # Create the network and get region instances. net = Network() net.addRegion("sensor", "py.RecordSensor", "{'numCategories': 3}") net.addRegion("classifier", "py.KNNClassifierRegion", "{'k': 2,'distThreshold': 0,'maxCategoryCount': 3}") net.link("sensor", "classifier", "UniformLink", "", srcOutput="dataOut", destInput="bottomUpIn") net.link("sensor", "classifier", "UniformLink", "", srcOutput="categoryOut", destInput="categoryIn") sensor = net.regions["sensor"] classifier = net.regions["classifier"] # Setup sensor region encoder and data stream. dataSource.close() dataSource = FileRecordStream(filename) sensorRegion = sensor.getSelf() sensorRegion.encoder = MultiEncoder() sensorRegion.encoder.addEncoder( "value", ScalarEncoder(21, 0.0, 13.0, n=256, name="value")) sensorRegion.dataSource = dataSource # Get ready to run. net.initialize() # Train the network (by default learning is ON in the classifier, but assert # anyway) and then turn off learning and turn on inference mode. self.assertEqual(classifier.getParameter("learningMode"), 1) net.run(8) classifier.setParameter("inferenceMode", 1) classifier.setParameter("learningMode", 0) # Assert learning is OFF and that the classifier learned the dataset. self.assertEqual(classifier.getParameter("learningMode"), 0, "Learning mode is not turned off.") self.assertEqual(classifier.getParameter("inferenceMode"), 1, "Inference mode is not turned on.") self.assertEqual( classifier.getParameter("categoryCount"), 3, "The classifier should count three total categories.") # classififer learns 12 patterns b/c there are 12 categories amongst the # records: self.assertEqual( classifier.getParameter("patternCount"), 12, "The classifier should've learned 12 samples in total.") # Test the network on the same data as it trained on; should classify with # 100% accuracy. expectedCats = ([0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.5, 0.5, 0.0], [0.0, 0.5, 0.5], [0.0, 0.5, 0.5], [0.5, 0.5, 0.0], [0.0, 0.5, 0.5]) dataSource.rewind() for i in xrange(8): net.run(1) inferredCats = classifier.getOutputData("categoriesOut") self.assertSequenceEqual( expectedCats[i], inferredCats.tolist(), "Classififer did not infer expected category probabilites for record " "number {}.".format(i)) # Close data stream, delete file. dataSource.close() os.remove(filename)
class LogEncoder(Encoder): """ This class wraps the :class:`.ScalarEncoder`. A Log encoder represents a floating point value on a logarithmic scale. .. code-block:: python valueToEncode = log10(input) :param resolution: The minimum change in scaled value needed to produce a change in encoding. This should be specified in log space. For example, the scaled values 10 and 11 will be distinguishable in the output. In terms of the original input values, this means 10^1 (1) and 10^1.1 (1.25) will be distinguishable. :param radius: inputs separated by more than this distance in log space will have non-overlapping representations """ def __init__(self, w=5, minval=1e-07, maxval=10000, periodic=False, n=0, radius=0, resolution=0, name="log", verbosity=0, clipInput=True, forced=False): # Lower bound for log encoding near machine precision limit lowLimit = 1e-07 # Limit minval as log10(0) is undefined. if minval < lowLimit: minval = lowLimit # Check that minval is still lower than maxval if not minval < maxval: raise ValueError( "Max val must be larger than min val or the lower limit " "for this encoder %.7f" % lowLimit) self.encoders = None self.verbosity = verbosity # Scale values for calculations within the class self.minScaledValue = math.log10(minval) self.maxScaledValue = math.log10(maxval) if not self.maxScaledValue > self.minScaledValue: raise ValueError( "Max val must be larger, in log space, than min val.") self.clipInput = clipInput self.minval = minval self.maxval = maxval self.encoder = ScalarEncoder(w=w, minval=self.minScaledValue, maxval=self.maxScaledValue, periodic=False, n=n, radius=radius, resolution=resolution, verbosity=self.verbosity, clipInput=self.clipInput, forced=forced) self.width = self.encoder.getWidth() self.description = [(name, 0)] self.name = name # This list is created by getBucketValues() the first time it is called, # and re-created whenever our buckets would be re-arranged. self._bucketValues = None def getWidth(self): return self.width def getDescription(self): return self.description def getDecoderOutputFieldTypes(self): """ Encoder class virtual method override """ return (FieldMetaType.float, ) def _getScaledValue(self, inpt): """ Convert the input, which is in normal space, into log space """ if inpt == SENTINEL_VALUE_FOR_MISSING_DATA: return None else: val = inpt if val < self.minval: val = self.minval elif val > self.maxval: val = self.maxval scaledVal = math.log10(val) return scaledVal def getBucketIndices(self, inpt): """ See the function description in base.py """ # Get the scaled value scaledVal = self._getScaledValue(inpt) if scaledVal is None: return [None] else: return self.encoder.getBucketIndices(scaledVal) def encodeIntoArray(self, inpt, output): """ See the function description in base.py """ # Get the scaled value scaledVal = self._getScaledValue(inpt) if scaledVal is None: output[0:] = 0 else: self.encoder.encodeIntoArray(scaledVal, output) if self.verbosity >= 2: print("input:", inpt, "scaledVal:", scaledVal, "output:", output) print("decoded:", self.decodedToStr(self.decode(output))) def decode(self, encoded, parentFieldName=''): """ See the function description in base.py """ # Get the scalar values from the underlying scalar encoder (fieldsDict, fieldNames) = self.encoder.decode(encoded) if len(fieldsDict) == 0: return (fieldsDict, fieldNames) # Expect only 1 field assert (len(fieldsDict) == 1) # Convert each range into normal space (inRanges, inDesc) = list(fieldsDict.values())[0] outRanges = [] for (minV, maxV) in inRanges: outRanges.append((math.pow(10, minV), math.pow(10, maxV))) # Generate a text description of the ranges desc = "" numRanges = len(outRanges) for i in range(numRanges): if outRanges[i][0] != outRanges[i][1]: desc += "%.2f-%.2f" % (outRanges[i][0], outRanges[i][1]) else: desc += "%.2f" % (outRanges[i][0]) if i < numRanges - 1: desc += ", " # Return result if parentFieldName != '': fieldName = "%s.%s" % (parentFieldName, self.name) else: fieldName = self.name return ({fieldName: (outRanges, desc)}, [fieldName]) def getBucketValues(self): """ See the function description in base.py """ # Need to re-create? if self._bucketValues is None: scaledValues = self.encoder.getBucketValues() self._bucketValues = [] for scaledValue in scaledValues: value = math.pow(10, scaledValue) self._bucketValues.append(value) return self._bucketValues def getBucketInfo(self, buckets): """ See the function description in base.py """ scaledResult = self.encoder.getBucketInfo(buckets)[0] scaledValue = scaledResult.value value = math.pow(10, scaledValue) return [ EncoderResult(value=value, scalar=value, encoding=scaledResult.encoding) ] def topDownCompute(self, encoded): """ See the function description in base.py """ scaledResult = self.encoder.topDownCompute(encoded)[0] scaledValue = scaledResult.value value = math.pow(10, scaledValue) return EncoderResult(value=value, scalar=value, encoding=scaledResult.encoding) def closenessScores(self, expValues, actValues, fractional=True): """ See the function description in base.py """ # Compute the percent error in log space if expValues[0] > 0: expValue = math.log10(expValues[0]) else: expValue = self.minScaledValue if actValues[0] > 0: actValue = math.log10(actValues[0]) else: actValue = self.minScaledValue if fractional: err = abs(expValue - actValue) pctErr = err / (self.maxScaledValue - self.minScaledValue) pctErr = min(1.0, pctErr) closeness = 1.0 - pctErr else: err = abs(expValue - actValue) closeness = err #print "log::", "expValue:", expValues[0], "actValue:", actValues[0], \ # "closeness", closeness #import pdb; pdb.set_trace() return numpy.array([closeness]) @classmethod def read(cls, proto): encoder = object.__new__(cls) encoder.verbosity = proto.verbosity encoder.minScaledValue = proto.minScaledValue encoder.maxScaledValue = proto.maxScaledValue encoder.clipInput = proto.clipInput encoder.minval = proto.minval encoder.maxval = proto.maxval encoder.encoder = ScalarEncoder.read(proto.encoder) encoder.name = proto.name encoder.width = encoder.encoder.getWidth() encoder.description = [(encoder.name, 0)] encoder._bucketValues = None return encoder def write(self, proto): proto.verbosity = self.verbosity proto.minScaledValue = self.minScaledValue proto.maxScaledValue = self.maxScaledValue proto.clipInput = self.clipInput proto.minval = self.minval proto.maxval = self.maxval self.encoder.write(proto.encoder) proto.name = self.name
# -*- coding: utf-8 -*- """ Created on Sun Nov 11 22:11:49 2018 @author: Arunodhaya """ import numpy as np from nupic.encoders import ScalarEncoder ScalarEncoder? enc = ScalarEncoder(n=22, w=3, minval=2.5, maxval=97.5, clipInput=False, forced=True) print "3 =", enc.encode(3) print "4 =", enc.encode(4) print "5 =", enc.encode(5) print "1000 =", enc.encode(1000) from nupic.encoders.random_distributed_scalar import RandomDistributedScalarEncoder RandomDistributedScalarEncoder? rdse = RandomDistributedScalarEncoder(n=21, w=3, resolution=5, offset=2.5) print "3 = ", rdse.encode(3) print "4 = ", rdse.encode(4) print "5 = ", rdse.encode(5) print print "100 = ", rdse.encode(100) print "100000 =", rdse.encode(1000)
#!/usr/bin/env python import rospy import numpy from nupic.encoders import ScalarEncoder from nupic.research.spatial_pooler import SpatialPooler enc = ScalarEncoder(n=10000, w=21, minval = 0, maxval=10000) from std_msgs.msg import String, Float64 t =[] for i in range(10000): t.append(enc.encode(i)) print("Encoding is done") sp = SpatialPooler(inputDimensions=(10000,), columnDimensions=(20,), potentialRadius=15, numActiveColumnsPerInhArea=1, globalInhibition=True, synPermActiveInc=0.03, potentialPct=1.0) output = numpy.zeros((20,),dtype="int") for _ in range(10): for i in xrange(10000): sp.compute(t[i], learn=True, activeArray=output) print("Spatial pooler strengthened")
def createEncoder(): volume_encoder = ScalarEncoder(7, 0.0, 70.0, n=200, name="volume", forced=True) floorheight_encoder = ScalarEncoder(1, 0.0, 70.0, n=25, name="floorheight", forced=True) diagCoorA_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorA") diagCoorB_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorB") diagCoorC_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorC") diagCoorD_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorD") diagCoorE_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorE") diagCoorF_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorF") diagCoorG_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorG") diagCoorH_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorH") diagCoorI_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorI") diagCoorJ_encoder = ScalarEncoder(105, 0.0, 200.0, n=1000, name="diagCoorJ") global encoder encoder = MultiEncoder() encoder.addEncoder("volume", volume_encoder) encoder.addEncoder("floorheight", floorheight_encoder) encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) encoder.addEncoder("diagCoorC", diagCoorC_encoder) encoder.addEncoder("diagCoorD", diagCoorD_encoder) encoder.addEncoder("diagCoorE", diagCoorE_encoder) encoder.addEncoder("diagCoorF", diagCoorF_encoder) encoder.addEncoder("diagCoorG", diagCoorG_encoder) encoder.addEncoder("diagCoorH", diagCoorH_encoder) encoder.addEncoder("diagCoorI", diagCoorI_encoder) encoder.addEncoder("diagCoorJ", diagCoorJ_encoder) return encoder
def createTemporalAnomaly(recordParams, spatialParams=_SP_PARAMS, temporalParams=_TP_PARAMS, verbosity=_VERBOSITY): """Generates a Network with connected RecordSensor, SP, TP. This function takes care of generating regions and the canonical links. The network has a sensor region reading data from a specified input and passing the encoded representation to an SPRegion. The SPRegion output is passed to a TPRegion. Note: this function returns a network that needs to be initialized. This allows the user to extend the network by adding further regions and connections. :param recordParams: a dict with parameters for creating RecordSensor region. :param spatialParams: a dict with parameters for creating SPRegion. :param temporalParams: a dict with parameters for creating TPRegion. :param verbosity: an integer representing how chatty the network will be. """ inputFilePath = recordParams["inputFilePath"] scalarEncoderArgs = recordParams["scalarEncoderArgs"] dateEncoderArgs = recordParams["dateEncoderArgs"] scalarEncoder = ScalarEncoder(**scalarEncoderArgs) dateEncoder = DateEncoder(**dateEncoderArgs) encoder = MultiEncoder() encoder.addEncoder(scalarEncoderArgs["name"], scalarEncoder) encoder.addEncoder(dateEncoderArgs["name"], dateEncoder) network = Network() network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": verbosity})) sensor = network.regions["sensor"].getSelf() sensor.encoder = encoder sensor.dataSource = FileRecordStream(streamID=inputFilePath) # Create the spatial pooler region spatialParams["inputWidth"] = sensor.encoder.getWidth() network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(spatialParams)) # Link the SP region to the sensor input network.link("sensor", "spatialPoolerRegion", "UniformLink", "") network.link("sensor", "spatialPoolerRegion", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="temporalTopDownOut", destInput="temporalTopDownIn") # Add the TPRegion on top of the SPRegion network.addRegion("temporalPoolerRegion", "py.TPRegion", json.dumps(temporalParams)) network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "") network.link("temporalPoolerRegion", "spatialPoolerRegion", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") spatialPoolerRegion = network.regions["spatialPoolerRegion"] # Make sure learning is enabled spatialPoolerRegion.setParameter("learningMode", True) # We want temporal anomalies so disable anomalyMode in the SP. This mode is # used for computing anomalies in a non-temporal model. spatialPoolerRegion.setParameter("anomalyMode", False) temporalPoolerRegion = network.regions["temporalPoolerRegion"] # Enable topDownMode to get the predicted columns output temporalPoolerRegion.setParameter("topDownMode", True) # Make sure learning is enabled (this is the default) temporalPoolerRegion.setParameter("learningMode", True) # Enable inference mode so we get predictions temporalPoolerRegion.setParameter("inferenceMode", True) # Enable anomalyMode to compute the anomaly score. temporalPoolerRegion.setParameter("anomalyMode", True) return network
def testSimpleMulticlassNetworkPY(self): # Setup data record stream of fake data (with three categories) filename = _getTempFileName() fields = [("timestamp", "datetime", "T"), ("value", "float", ""), ("reset", "int", "R"), ("sid", "int", "S"), ("categories", "list", "C")] records = ([datetime(day=1, month=3, year=2010), 0.0, 1, 0, "0"], [ datetime(day=2, month=3, year=2010), 1.0, 0, 0, "1" ], [datetime(day=3, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=4, month=3, year=2010), 1.0, 0, 0, "1"], [datetime(day=5, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=6, month=3, year=2010), 1.0, 0, 0, "1" ], [datetime(day=7, month=3, year=2010), 0.0, 0, 0, "0"], [datetime(day=8, month=3, year=2010), 1.0, 0, 0, "1"]) dataSource = FileRecordStream(streamID=filename, write=True, fields=fields) for r in records: dataSource.appendRecord(list(r)) # Create the network and get region instances. net = Network() net.addRegion("sensor", "py.RecordSensor", "{'numCategories': 3}") net.addRegion("classifier", "py.SDRClassifierRegion", "{steps: '0', alpha: 0.001, implementation: 'py'}") net.link("sensor", "classifier", "UniformLink", "", srcOutput="dataOut", destInput="bottomUpIn") net.link("sensor", "classifier", "UniformLink", "", srcOutput="categoryOut", destInput="categoryIn") sensor = net.regions["sensor"] classifier = net.regions["classifier"] # Setup sensor region encoder and data stream. dataSource.close() dataSource = FileRecordStream(filename) sensorRegion = sensor.getSelf() sensorRegion.encoder = MultiEncoder() sensorRegion.encoder.addEncoder( "value", ScalarEncoder(21, 0.0, 13.0, n=256, name="value")) sensorRegion.dataSource = dataSource # Get ready to run. net.initialize() # Train the network (by default learning is ON in the classifier, but assert # anyway) and then turn off learning and turn on inference mode. self.assertEqual(classifier.getParameter("learningMode"), 1) net.run(8) # Test the network on the same data as it trained on; should classify with # 100% accuracy. classifier.setParameter("inferenceMode", 1) classifier.setParameter("learningMode", 0) # Assert learning is OFF and that the classifier learned the dataset. self.assertEqual(classifier.getParameter("learningMode"), 0, "Learning mode is not turned off.") self.assertEqual(classifier.getParameter("inferenceMode"), 1, "Inference mode is not turned on.") # make sure we can access all the parameters with getParameter self.assertEqual(classifier.getParameter("maxCategoryCount"), 2000) self.assertAlmostEqual(float(classifier.getParameter("alpha")), 0.001) self.assertEqual(int(classifier.getParameter("steps")), 0) self.assertTrue(classifier.getParameter("implementation") == "py") self.assertEqual(classifier.getParameter("verbosity"), 0) expectedCats = ( [0.0], [1.0], [0.0], [1.0], [0.0], [1.0], [0.0], [1.0], ) dataSource.rewind() for i in xrange(8): net.run(1) inferredCats = classifier.getOutputData("categoriesOut") self.assertSequenceEqual( expectedCats[i], inferredCats.tolist(), "Classififer did not infer expected category " "for record number {}.".format(i)) # Close data stream, delete file. dataSource.close() os.remove(filename)
def createTemporalAnomaly_chemical(recordParams, spatialParams, temporalParams, verbosity): inputFilePath = recordParams["inputFilePath"] scalarEncoder1Args = recordParams["scalarEncoder1Args"] scalarEncoder2Args = recordParams["scalarEncoder2Args"] scalarEncoder3Args = recordParams["scalarEncoder3Args"] scalarEncoder4Args = recordParams["scalarEncoder4Args"] scalarEncoder5Args = recordParams["scalarEncoder5Args"] scalarEncoder6Args = recordParams["scalarEncoder6Args"] scalarEncoder7Args = recordParams["scalarEncoder7Args"] dateEncoderArgs = recordParams["dateEncoderArgs"] scalarEncoder1 = ScalarEncoder(**scalarEncoder1Args) scalarEncoder2 = ScalarEncoder(**scalarEncoder2Args) scalarEncoder3 = ScalarEncoder(**scalarEncoder3Args) scalarEncoder4 = ScalarEncoder(**scalarEncoder4Args) scalarEncoder5 = ScalarEncoder(**scalarEncoder5Args) scalarEncoder6 = ScalarEncoder(**scalarEncoder6Args) scalarEncoder7 = ScalarEncoder(**scalarEncoder7Args) dateEncoder = DateEncoder(**dateEncoderArgs) encoder = MultiEncoder() encoder.addEncoder(scalarEncoder1Args["name"], scalarEncoder1) encoder.addEncoder(scalarEncoder2Args["name"], scalarEncoder2) encoder.addEncoder(scalarEncoder3Args["name"], scalarEncoder3) encoder.addEncoder(scalarEncoder4Args["name"], scalarEncoder4) encoder.addEncoder(scalarEncoder5Args["name"], scalarEncoder5) encoder.addEncoder(scalarEncoder6Args["name"], scalarEncoder6) encoder.addEncoder(scalarEncoder7Args["name"], scalarEncoder7) encoder.addEncoder(dateEncoderArgs["name"], dateEncoder) network = Network() network.addRegion("sensor", "py.RecordSensor", json.dumps({"verbosity": verbosity})) sensor = network.regions["sensor"].getSelf() sensor.encoder = encoder sensor.dataSource = FileRecordStream(streamID=inputFilePath) # Create the spatial pooler region spatialParams["inputWidth"] = sensor.encoder.getWidth() network.addRegion("spatialPoolerRegion", "py.SPRegion", json.dumps(spatialParams)) # Link the SP region to the sensor input network.link("sensor", "spatialPoolerRegion", "UniformLink", "") network.link("sensor", "spatialPoolerRegion", "UniformLink", "", srcOutput="resetOut", destInput="resetIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="spatialTopDownOut", destInput="spatialTopDownIn") network.link("spatialPoolerRegion", "sensor", "UniformLink", "", srcOutput="temporalTopDownOut", destInput="temporalTopDownIn") # Add the TPRegion on top of the SPRegion network.addRegion("temporalPoolerRegion", "py.TMRegion", json.dumps(temporalParams)) network.link("spatialPoolerRegion", "temporalPoolerRegion", "UniformLink", "") network.link("temporalPoolerRegion", "spatialPoolerRegion", "UniformLink", "", srcOutput="topDownOut", destInput="topDownIn") # Add the AnomalyLikelihoodRegion on top of the TMRegion network.addRegion("anomalyLikelihoodRegion", "py.AnomalyLikelihoodRegion", json.dumps({})) network.link("temporalPoolerRegion", "anomalyLikelihoodRegion", "UniformLink", "", srcOutput="anomalyScore", destInput="rawAnomalyScore") network.link("sensor", "anomalyLikelihoodRegion", "UniformLink", "", srcOutput="sourceOut", destInput="metricValue") spatialPoolerRegion = network.regions["spatialPoolerRegion"] # Make sure learning is enabled spatialPoolerRegion.setParameter("learningMode", True) # We want temporal anomalies so disable anomalyMode in the SP. This mode is # used for computing anomalies in a non-temporal model. spatialPoolerRegion.setParameter("anomalyMode", False) temporalPoolerRegion = network.regions["temporalPoolerRegion"] # Enable topDownMode to get the predicted columns output temporalPoolerRegion.setParameter("topDownMode", True) # Make sure learning is enabled (this is the default) temporalPoolerRegion.setParameter("learningMode", True) # Enable inference mode so we get predictions temporalPoolerRegion.setParameter("inferenceMode", True) # Enable anomalyMode to compute the anomaly score. temporalPoolerRegion.setParameter("anomalyMode", True) return network
def createEncoder(): volume_encoder = ScalarEncoder(21, 0.0, 20.0, n=200, name="volume", clipInput=False) floorheight_encoder = ScalarEncoder(21, 0.0, 24.0, n=125, name="floorheight", clipInput=False) diagCoorA_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorA", clipInput=False) diagCoorB_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorB", clipInput=False) diagCoorC_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorC", clipInput=False) diagCoorD_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorD", clipInput=False) diagCoorE_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorE", clipInput=False) diagCoorF_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorF", clipInput=False) diagCoorG_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorG", clipInput=False) diagCoorH_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorH", clipInput=False) diagCoorI_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorI", clipInput=False) diagCoorJ_encoder = ScalarEncoder(21, 0.0, 200.0, n=200, name="diagCoorJ", clipInput=False) global encoder encoder = MultiEncoder() encoder.addEncoder("volume", volume_encoder) encoder.addEncoder("floorheight", floorheight_encoder) encoder.addEncoder("diagCoorA", diagCoorA_encoder) encoder.addEncoder("diagCoorB", diagCoorB_encoder) encoder.addEncoder("diagCoorC", diagCoorC_encoder) encoder.addEncoder("diagCoorD", diagCoorD_encoder) encoder.addEncoder("diagCoorE", diagCoorE_encoder) encoder.addEncoder("diagCoorF", diagCoorF_encoder) encoder.addEncoder("diagCoorG", diagCoorG_encoder) encoder.addEncoder("diagCoorH", diagCoorH_encoder) encoder.addEncoder("diagCoorI", diagCoorI_encoder) encoder.addEncoder("diagCoorJ", diagCoorJ_encoder) return encoder
def getDescription(datasets): encoder = MultiEncoder() encoder.addEncoder("date", DateEncoder(timeOfDay=3)) encoder.addEncoder("amount", LogEncoder(name="amount", maxval=1000)) for i in xrange(0, nRandomFields): s = ScalarEncoder(name="scalar", minval=0, maxval=randomFieldWidth, resolution=1, w=3) encoder.addEncoder("random%d" % i, s) dataSource = FunctionSource( generateFunction, dict(nRandomFields=nRandomFields, randomFieldWidth=randomFieldWidth)) inputShape = (1, encoder.getWidth()) # Layout the coincidences vertically stacked on top of each other, each # looking at the entire input field. coincidencesShape = (nCoincidences, 1) # TODO: why do we need input border? inputBorder = inputShape[1] / 2 if inputBorder * 2 >= inputShape[1]: inputBorder -= 1 nodeParams = dict() spParams = dict( commonDistributions=0, inputShape=inputShape, inputBorder=inputBorder, coincidencesShape=coincidencesShape, coincInputRadius=inputShape[1] / 2, coincInputPoolPct=0.75, gaussianDist=0, localAreaDensity=0.10, # localAreaDensity = 0.04, numActivePerInhArea=-1, dutyCyclePeriod=1000, stimulusThreshold=5, synPermInactiveDec=0.08, # synPermInactiveDec=0.02, synPermActiveInc=0.02, synPermActiveSharedDec=0.0, synPermOrphanDec=0.0, minPctDutyCycleBeforeInh=0.05, # minPctDutyCycleAfterInh = 0.1, # minPctDutyCycleBeforeInh = 0.05, minPctDutyCycleAfterInh=0.05, # minPctDutyCycleAfterInh = 0.4, seed=1, ) otherParams = dict( disableTemporal=1, trainingStep='spatial', ) nodeParams.update(spParams) nodeParams.update(otherParams) def mySetupCallback(experiment): print "Setup function called" description = dict( options=dict(logOutputsDuringInference=False, ), network=dict(sensorDataSource=dataSource, sensorEncoder=encoder, CLAType="py.CLARegion", CLAParams=nodeParams, classifierType=None, classifierParams=None), # step spTrain=dict( name="phase1", setup=mySetupCallback, iterationCount=5000, #iter=displaySPCoincidences(100), finish=printSPCoincidences()), tpTrain=None, # same format as sptrain if non-empty infer=None, # same format as sptrain if non-empty ) return description