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(),
