def testReadWrite(self): categories = ["ES", "GB", "US"] # forced: is not recommended, but is used here for readability. see # scalar.py original = CategoryEncoder(w=3, categoryList=categories, forced=True) output = original.encode("US") target = numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1], dtype=defaultDtype) self.assertTrue(numpy.array_equal(output, target)) decoded = original.decode(output) proto1 = CategoryEncoderProto.new_message() original.write(proto1) # Write the proto to a temp file and read it back into a new proto with tempfile.TemporaryFile() as f: proto1.write(f) f.seek(0) proto2 = CategoryEncoderProto.read(f) encoder = CategoryEncoder.read(proto2) self.assertIsInstance(encoder, CategoryEncoder) self.assertEqual(encoder.verbosity, original.verbosity) self.assertEqual(encoder.width, original.width) self.assertEqual(encoder.description, original.description) self.assertEqual(encoder.name, original.name) self.assertDictEqual(encoder.categoryToIndex, original.categoryToIndex) self.assertDictEqual(encoder.indexToCategory, original.indexToCategory) self.assertTrue(numpy.array_equal(encoder.encode("US"), output)) self.assertEqual(original.decode(encoder.encode("US")), encoder.decode(original.encode("US"))) self.assertEqual(decoded, encoder.decode(output))
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 __init__(self, width, nRandBits, actBitsPerLetter=1): """ @param width: The size of the encoded list of bits output. @param nRandBits: The number of random bits that the output will have after the binary representation of the string. 0 for a pure string to binary conversion. @param actBitsPerLetter: The number of active bits per letter. """ random.seed(SEED) if nRandBits > width: raise ValueError("nRandBits can't be greater than width.") if actBitsPerLetter < 1: raise ValueError("There must be at least 1 active bit per letter") self.width = width self.nRandBits = nRandBits self.actBitsPerLetter = actBitsPerLetter self.alreadyEncoded = dict() self.catEnc = CategoryEncoder(self.actBitsPerLetter, list(string.ascii_lowercase), forced=True)
de = DateEncoder(season=5) now = datetime.datetime.strptime("2014-05-02 13:08:58", "%Y-%m-%d %H:%M:%S") print "now = ", de.encode(now) nextMonth = datetime.datetime.strptime("2014-06-02 13:08:58", "%Y-%m-%d %H:%M:%S") print "next month =", de.encode(nextMonth) xmas = datetime.datetime.strptime("2014-12-25 13:08:58", "%Y-%m-%d %H:%M:%S") print "xmas = ", de.encode(xmas) from nupic.encoders.category import CategoryEncoder categories = ("cat", "dog", "monkey", "slow loris") encoder = CategoryEncoder(w=3, categoryList=categories, forced=True) cat = encoder.encode("cat") dog = encoder.encode("dog") monkey = encoder.encode("monkey") loris = encoder.encode("slow loris") print "cat = ", cat print "dog = ", dog print "monkey = ", monkey print "slow loris =", loris print encoder.decode(cat) ss=cat+monkey+dog print encoder.decode(ss) ss from nupic.bindings.algorithms import SpatialPooler
def testCategoryEncoder(self): categories = ["ES", "GB", "US"] # forced: is not recommended, but is used here for readability. # see scalar.py e = CategoryEncoder(w=3, categoryList=categories, forced=True) output = e.encode("US") expected = numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1], dtype=defaultDtype) self.assertTrue(numpy.array_equal(output, expected)) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldNames), 1) self.assertEqual(len(fieldsDict), 1) self.assertEqual(fieldNames[0], fieldsDict.keys()[0]) (ranges, desc) = fieldsDict.values()[0] self.assertEqual(desc, "US") self.assertEqual(len(ranges), 1) self.assertTrue(numpy.array_equal(ranges[0], [3, 3])) # Test topdown compute for v in categories: output = e.encode(v) topDown = e.topDownCompute(output) self.assertEqual(topDown.value, v) self.assertEqual(topDown.scalar, e.getScalars(v)[0]) bucketIndices = e.getBucketIndices(v) topDown = e.getBucketInfo(bucketIndices)[0] self.assertEqual(topDown.value, v) self.assertEqual(topDown.scalar, e.getScalars(v)[0]) self.assertTrue(numpy.array_equal(topDown.encoding, output)) self.assertEqual(topDown.value, e.getBucketValues()[bucketIndices[0]]) # --------------------- # unknown category output = e.encode("NA") expected = numpy.array([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=defaultDtype) self.assertTrue(numpy.array_equal(output, expected)) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldNames), 1) self.assertEqual(len(fieldsDict), 1) self.assertEqual(fieldNames[0], fieldsDict.keys()[0]) (ranges, desc) = fieldsDict.values()[0] self.assertEqual(len(ranges), 1) self.assertTrue(numpy.array_equal(ranges[0], [0, 0])) # Test topdown compute topDown = e.topDownCompute(output) self.assertEqual(topDown.value, UNKNOWN) self.assertEqual(topDown.scalar, 0) # -------------------------------- # ES output = e.encode("ES") expected = numpy.array([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], dtype=defaultDtype) self.assertTrue(numpy.array_equal(output, expected)) # MISSING VALUE outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA) self.assertEqual(sum(outputForMissing), 0) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldNames), 1) self.assertEqual(len(fieldsDict), 1) self.assertEqual(fieldNames[0], fieldsDict.keys()[0]) (ranges, desc) = fieldsDict.values()[0] self.assertEqual(len(ranges), 1) self.assertTrue(numpy.array_equal(ranges[0], [1, 1])) # Test topdown compute topDown = e.topDownCompute(output) self.assertEqual(topDown.value, "ES") self.assertEqual(topDown.scalar, e.getScalars("ES")[0]) # -------------------------------- # Multiple categories output.fill(1) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldNames), 1) self.assertEqual(len(fieldsDict), 1) self.assertEqual(fieldNames[0], fieldsDict.keys()[0]) (ranges, desc) = fieldsDict.values()[0] self.assertEqual(len(ranges), 1) self.assertTrue(numpy.array_equal(ranges[0], [0, 3])) # ------------------------------------------------------------- # Test with width = 1 categories = ["cat1", "cat2", "cat3", "cat4", "cat5"] # forced: is not recommended, but is used here for readability. # see scalar.py e = CategoryEncoder(w=1, categoryList=categories, forced=True) for cat in categories: output = e.encode(cat) topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # ------------------------------------------------------------- # Test with width = 9, removing some bits end the encoded output categories = ["cat%d" % (x) for x in range(1, 10)] # forced: is not recommended, but is used here for readability. # see scalar.py e = CategoryEncoder(w=9, categoryList=categories, forced=True) for cat in categories: output = e.encode(cat) topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 1 bit on the left outputNZs = output.nonzero()[0] output[outputNZs[0]] = 0 topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 1 bit on the right output[outputNZs[0]] = 1 output[outputNZs[-1]] = 0 topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 4 bits on the left output.fill(0) output[outputNZs[-5:]] = 1 topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 4 bits on the right output.fill(0) output[outputNZs[0:5]] = 1 topDown = e.topDownCompute(output) self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # OR together the output of 2 different categories, we should not get # back the mean, but rather one or the other output1 = e.encode("cat1") output2 = e.encode("cat9") output = output1 + output2 topDown = e.topDownCompute(output) self.assertTrue(topDown.scalar == e.getScalars("cat1")[0] \ or topDown.scalar == e.getScalars("cat9")[0])
def testCategoryEncoder(self): verbosity = 0 print "Testing CategoryEncoder...", categories = ["ES", "GB", "US"] e = CategoryEncoder(w=3, categoryList=categories) output = e.encode("US") self.assertTrue( (output == numpy.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1], dtype=defaultDtype)).all()) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldsDict), 1) (ranges, desc) = fieldsDict.values()[0] self.assertTrue( len(ranges) == 1 and numpy.array_equal(ranges[0], [3, 3])) print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded) # Test topdown compute for v in categories: output = e.encode(v) topDown = e.topDownCompute(output) self.assertEqual(topDown.value, v) self.assertEqual(topDown.scalar, e.getScalars(v)[0]) bucketIndices = e.getBucketIndices(v) print "bucket index =>", bucketIndices[0] topDown = e.getBucketInfo(bucketIndices)[0] self.assertEqual(topDown.value, v) self.assertEqual(topDown.scalar, e.getScalars(v)[0]) self.assertTrue((topDown.encoding == output).all()) self.assertEqual(topDown.value, e.getBucketValues()[bucketIndices[0]]) # --------------------- # unknown category output = e.encode("NA") self.assertTrue( (output == numpy.array([1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=defaultDtype)).all()) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldsDict), 1) (ranges, desc) = fieldsDict.values()[0] self.assertTrue( len(ranges) == 1 and numpy.array_equal(ranges[0], [0, 0])) print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded) # Test topdown compute topDown = e.topDownCompute(output) self.assertEqual(topDown.value, "<UNKNOWN>") self.assertEqual(topDown.scalar, 0) # -------------------------------- # ES output = e.encode("ES") self.assertTrue( (output == numpy.array([0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], dtype=defaultDtype)).all()) # MISSING VALUE outputForMissing = e.encode(SENTINEL_VALUE_FOR_MISSING_DATA) self.assertEqual(sum(outputForMissing), 0) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldsDict), 1) (ranges, desc) = fieldsDict.values()[0] self.assertTrue( len(ranges) == 1 and numpy.array_equal(ranges[0], [1, 1])) print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded) # Test topdown compute topDown = e.topDownCompute(output) self.assertEqual(topDown.value, "ES") self.assertEqual(topDown.scalar, e.getScalars("ES")[0]) # -------------------------------- # Multiple categories output.fill(1) # Test reverse lookup decoded = e.decode(output) (fieldsDict, fieldNames) = decoded self.assertEqual(len(fieldsDict), 1) (ranges, desc) = fieldsDict.values()[0] self.assertTrue( len(ranges) == 1 and numpy.array_equal(ranges[0], [0, 3])) print "decodedToStr of", ranges, "=>", e.decodedToStr(decoded) # ------------------------------------------------------------- # Test with width = 1 categories = ["cat1", "cat2", "cat3", "cat4", "cat5"] e = CategoryEncoder(w=1, categoryList=categories) for cat in categories: output = e.encode(cat) topDown = e.topDownCompute(output) if verbosity >= 1: print cat, "->", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # ------------------------------------------------------------- # Test with width = 9, removing some bits end the encoded output categories = ["cat%d" % (x) for x in range(1, 10)] e = CategoryEncoder(w=9, categoryList=categories) for cat in categories: output = e.encode(cat) topDown = e.topDownCompute(output) if verbosity >= 1: print cat, "->", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 1 bit on the left outputNZs = output.nonzero()[0] output[outputNZs[0]] = 0 topDown = e.topDownCompute(output) if verbosity >= 1: print "missing 1 bit on left:", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 1 bit on the right output[outputNZs[0]] = 1 output[outputNZs[-1]] = 0 topDown = e.topDownCompute(output) if verbosity >= 1: print "missing 1 bit on right:", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 4 bits on the left output.fill(0) output[outputNZs[-5:]] = 1 topDown = e.topDownCompute(output) if verbosity >= 1: print "missing 4 bits on left:", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # Get rid of 4 bits on the right output.fill(0) output[outputNZs[0:5]] = 1 topDown = e.topDownCompute(output) if verbosity >= 1: print "missing 4 bits on right:", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertEqual(topDown.value, cat) self.assertEqual(topDown.scalar, e.getScalars(cat)[0]) # OR together the output of 2 different categories, we should not get # back the mean, but rather one or the other output1 = e.encode("cat1") output2 = e.encode("cat9") output = output1 + output2 topDown = e.topDownCompute(output) if verbosity >= 1: print "cat1 + cat9 ->", output, output.nonzero()[0] print " scalarTopDown:", e.encoder.topDownCompute(output) print " topdown:", topDown self.assertTrue(topDown.scalar == e.getScalars("cat1")[0] \ or topDown.scalar == e.getScalars("cat9")[0]) print "passed"
from nupic.encoders.category import CategoryEncoder from nupic.research.spatial_pooler import SpatialPooler from nupic.research.TP import TP def wait(): raw_input("Press Enter to continue...") os.system("clear") print "Executing Matt's HTM Experiments\n" print "initializing categories" inputCategoriesWindowWidth = 3 inputCategoriesRaw = ("cat", "dog", "penguin", "potato") categoryEncoder = CategoryEncoder(w=inputCategoriesWindowWidth, categoryList=inputCategoriesRaw, forced=True, verbosity=0) inputCategories = {} for category in inputCategoriesRaw: inputCategories[category] = categoryEncoder.encode(category) print " " + (category + ":").ljust(10), inputCategories[category] print " " + "UNKNOWN:".ljust(10), categoryEncoder.encode("UNKNOWN") print "categories initialized\n" print "initializing spatial pooler" spatialPoolerInputWidth = (len(inputCategoriesRaw) + 1) * inputCategoriesWindowWidth spatialPoolerColumnHeight = 8 spatialPooler = SpatialPooler(inputDimensions=spatialPoolerInputWidth, columnDimensions=spatialPoolerColumnHeight,
from Utils.CLAClassifierCond import CLAClassifierCond from nupic.encoders.category import CategoryEncoder from nupic.research.spatial_pooler import SpatialPooler from nupic.research.temporal_memory import TemporalMemory import numpy encoder1 = CategoryEncoder(5, ['a', 'b', 'c'], forced=True) encoder2 = CategoryEncoder(5, ['z', 'x', 'y', 'a'], forced=True) sp = SpatialPooler(inputDimensions=(2, max(encoder1.getWidth(), encoder2.getWidth())), columnDimensions=(2, 20), potentialRadius=12, potentialPct=0.5, globalInhibition=True, localAreaDensity=-1.0, numActiveColumnsPerInhArea=5.0, stimulusThreshold=0, synPermInactiveDec=0.1, synPermActiveInc=0.1, synPermConnected=0.1, minPctOverlapDutyCycle=0.1, minPctActiveDutyCycle=0.1, dutyCyclePeriod=10, maxBoost=3, seed=42, spVerbosity=0) tm = TemporalMemory( columnDimensions=sp.getColumnDimensions(),