def testExtract_patches(self):
from PIL import Image
image = Image.open('./tests/test.jpg').convert('L').resize((16, 16))
image_arr = np.asarray(image)
patch_size = (4, 4)
overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 49)
patch_size = (8, 8)
# overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 4)
# patch_size = (8, 8)
overlap = (0, 0)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 4)
image_arr = np.asarray(image.resize((20, 20)))
# patch_size = (8, 8)
overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 9)
def testExtract_patches(self):
from PIL import Image
image = Image.open("./tests/test.jpg").convert("L").resize((16, 16))
image_arr = np.asarray(image)
patch_size = (4, 4)
overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 49)
patch_size = (8, 8)
# overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 4)
# patch_size = (8, 8)
overlap = (0, 0)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 4)
image_arr = np.asarray(image.resize((20, 20)))
# patch_size = (8, 8)
overlap = (2, 2)
patches = utils.extract_patches(image_arr, patch_size, overlap)
self.assertEqual(len(patches), 9)
def _get_train_patterns(self, level, all_patterns=True):
"""Get an image from the sensor and either extracts one pattern or all
of them.
Args:
level: level number
all_patterns: A boolean indicating whether all patterns (image
patches) should be used
Returns:
A list of pattern(s).
"""
data = self.sensor.compute()
sensor_im, is_reset = data['data'], data['is_reset']
if not isinstance(self.sensor, ImageSensor):
return sensor_im, is_reset
# if level.level_no == 0:
# visualize.show_image(sensor_im)
# if level.level_no == 0 and level.node_cloning:
if not all_patterns:
# TODO how to pick a good spot?
# central patch
f = int(self.sensor.width/2 - self.patch_size[0]/2)
t = int(self.sensor.width/2 + (self.patch_size[0] - self.patch_size[0]/2))
pattern = sensor_im[f:t, f:t].reshape(np.prod(self.patch_size), 1)
patterns = [pattern] # * np.prod(self.levels[0].size)
else:
patterns = utils.extract_patches(sensor_im, self.patch_size, self.levels[0].overlap)
return patterns, is_reset
def _get_train_patterns(self, level, all_patterns=True):
"""Get an image from the sensor and either extracts one pattern or all
of them.
Args:
level: level number
all_patterns: A boolean indicating whether all patterns (image
patches) should be used
Returns:
A list of pattern(s).
"""
data = self.sensor.compute()
sensor_im, is_reset = data['data'], data['is_reset']
if not isinstance(self.sensor, ImageSensor):
return sensor_im, is_reset
# if level.level_no == 0:
# visualize.show_image(sensor_im)
# if level.level_no == 0 and level.node_cloning:
if not all_patterns:
# TODO how to pick a good spot?
# central patch
f = int(self.sensor.width / 2 - self.patch_size[0] / 2)
t = int(self.sensor.width / 2 +
(self.patch_size[0] - self.patch_size[0] / 2))
pattern = sensor_im[f:t, f:t].reshape(np.prod(self.patch_size), 1)
patterns = [pattern] # * np.prod(self.levels[0].size)
else:
patterns = utils.extract_patches(sensor_im, self.patch_size,
self.levels[0].overlap)
return patterns, is_reset
def testFlattenPatches(self):
from PIL import Image
image = np.asarray(Image.open("./tests/test.jpg").convert("L").resize((64, 64)))
image_size = image.shape
patch_size = (4, 4)
patches = utils.extract_patches(image, patch_size)
im = utils.flatten_patches(patches, patch_size, image_size)
self.assertEqual(im.shape[0], image_size[0])
self.assertEqual(im.shape[1], image_size[1])
def testFlattenPatches(self):
from PIL import Image
image = np.asarray(
Image.open('./tests/test.jpg').convert('L').resize((64, 64)))
image_size = image.shape
patch_size = (4, 4)
patches = utils.extract_patches(image, patch_size)
im = utils.flatten_patches(patches, patch_size, image_size)
self.assertEqual(im.shape[0], image_size[0])
self.assertEqual(im.shape[1], image_size[1])
def testSegment(self):
# TODO
return True
sensor_params = {"width": 32, "height": 32, "background": 1, "mode": "bw"}
net_params = [
{
"nodeCloning": True,
"size": [2, 2],
"overlap": [0, 0],
# Spatial pooler
"maxCoincidenceCount": 128,
"spatialPoolerAlgorithm": "gaussian",
"sigma": 1,
"maxDistance": 0.1,
# Temporal pooler
"requestedGroupsCount": 20,
"temporalPoolerAlgorithm": "maxProp",
"transitionMemory": 4,
}
]
learning_params = [
# Level 0
{
"sp":
# Spatial pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 100,
},
"tp":
# Temporal pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 1000,
},
}
]
train_data = "data/pictures-subset/train"
sensor = ImageSensor(
width=sensor_params["width"],
height=sensor_params["height"],
background=sensor_params["background"],
mode=sensor_params["mode"],
)
net = HTM(sensor, verbose=False)
net.create_network(net_params)
sensor.loadMultipleImages(train_data)
net.learn(learning_params)
sensor.clearImageList()
sensor.loadSingleImage("data/test_clean.png")
data = sensor.compute()
im_clean, cat = data["data"], data["category"]
patch_size = net.patch_size
im_clean_fw = net.infer(utils.extract_patches(im_clean, patch_size), merge_output=True)
weights = np.asarray(net.segment(im_clean_fw))
def testMultipleLevelInference(self):
return
from datasets import DatasetConfig
dataset = DatasetConfig().load("pictures-subset")
train_data = dataset["test_data_path"] # dataset['train_data_path']
test_data = dataset["test_data_path"]
sensor_params = {
"width": dataset["image_width"],
"height": dataset["image_height"],
"background": dataset["image_background"],
"mode": dataset["image_mode"],
}
net_params = [
# Level 0
{
"nodeCloning": True,
"size": [4, 4],
"overlap": [0, 0],
# Spatial pooler
"maxCoincidenceCount": 64,
"spatialPoolerAlgorithm": "gaussian",
"sigma": 1,
"maxDistance": 0.1,
# Temporal pooler
"requestedGroupsCount": 20,
"temporalPoolerAlgorithm": "sumProp",
"transitionMemory": 4,
},
# Level 1
{
"nodeCloning": True,
"size": [2, 2],
"overlap": [0, 0],
# Spatial pooler
"maxCoincidenceCount": 128,
"spatialPoolerAlgorithm": "product",
"sigma": 1,
"maxDistance": 0.1,
# Temporal pooler
"requestedGroupsCount": 10,
"temporalPoolerAlgorithm": "sumProp",
"transitionMemory": 8,
},
# Level 2
{
"nodeCloning": True,
"size": [1],
"overlap": [0, 0],
# Spatial pooler
"maxCoincidenceCount": 128,
"spatialPoolerAlgorithm": "product",
"sigma": 1,
"maxDistance": 0.1,
# Temporal pooler
"requestedGroupsCount": 20,
"temporalPoolerAlgorithm": "sumProp",
"transitionMemory": 10,
},
# Level 3
# {
# 'nodeCloning': True,
# 'size': [1],
# 'overlap': [0, 0],
# # Spatial pooler
# 'maxCoincidenceCount': 128,
# 'spatialPoolerAlgorithm': 'gaussian',
# 'sigma': 1,
# 'maxDistance': 0.1,
# # Temporal pooler
# 'requestedGroupsCount': 30,
# 'temporalPoolerAlgorithm': 'maxProp',
# 'transitionMemory': 10,
# }
]
learning_params = [
# Level 0
{
"sp":
# Spatial pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 300,
},
"tp":
# Temporal pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 10000,
},
},
# Level 1
{
"sp":
# Spatial pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 200,
},
"tp":
# Temporal pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 5000,
},
},
# Level 2
{
"sp":
# Spatial pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 200,
},
"tp":
# Temporal pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 5000,
},
},
# Level 3
{
"sp":
# Spatial pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 200,
},
"tp":
# Temporal pooler
{
"explorer": ["RandomSweep", {"sweepOffObject": False, "sweepDirections": "all"}],
"numIterations": 5000,
},
},
]
train_data = "data/pictures-subset/train"
test_data = "data/pictures-subset/test"
sensor = ImageSensor(
width=sensor_params["width"],
height=sensor_params["height"],
background=sensor_params["background"],
mode=sensor_params["mode"],
)
net = HTM(sensor, verbose=False)
net.create_network(net_params)
sensor.loadMultipleImages(train_data)
net.learn(learning_params)
# getting testing data
sensor.clearImageList()
sensor.loadMultipleImages(test_data)
sensor.setParameter("explorer", "Flash")
import matplotlib.pyplot as plt
import matplotlib.cm as cm
for i in range(40):
data = sensor.compute()
im, cat = data["data"], data["category"]
print(cat)
patterns = utils.extract_patches(im, net.patch_size)
if cat == 0:
plt.plot(net.infer(patterns), color="b")
else:
plt.plot(net.infer(patterns), color="r")
plt.show()
start_time = time.clock()
# getting training data
sensor.loadMultipleImages(train_data)
sensor.setParameter('explorer', 'Flash')
print(' Num of train images: %d' % sensor.getNumIterations())
train = [] # infered output of HTM for each of the original images
train_set_orig = [] # original training images
train_labels = [] # labels of training original images
for i in range(sensor.getNumIterations()):
data = sensor.compute()
im, cat = data['data'], data['category']
train_set_orig.append(im.reshape(np.prod(im.shape), ))
train_labels.append(cat)
out = htmNet.infer(extract_patches(im, patch_size), merge_output=True)
train.append(np.asarray(out))
# getting testing data
sensor.clearImageList()
sensor.loadMultipleImages(test_data)
sensor.setParameter('explorer', 'Flash')
print(' Num of test images: %d' % sensor.getNumIterations())
test = [] # infered output of HTM for each of the original images
test_set_orig = [] # original testing images
test_labels = [] # labels oftesting original images
for i in range(sensor.getNumIterations()):
data = sensor.compute()
im, cat = data['data'], data['category']
test_set_orig.append(im.reshape(np.prod(im.shape), ))
def testSegment(self):
# TODO
return True
sensor_params = {
'width': 32,
'height': 32,
'background': 1,
'mode': 'bw'
}
net_params = [{
'nodeCloning': True,
'size': [2, 2],
'overlap': [0, 0],
# Spatial pooler
'maxCoincidenceCount': 128,
'spatialPoolerAlgorithm': 'gaussian',
'sigma': 1,
'maxDistance': 0.1,
# Temporal pooler
'requestedGroupsCount': 20,
'temporalPoolerAlgorithm': 'maxProp',
'transitionMemory': 4,
}]
learning_params = [
# Level 0
{
'sp':
# Spatial pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
100
},
'tp':
# Temporal pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
1000
},
},
]
train_data = 'data/pictures-subset/train'
sensor = ImageSensor(width=sensor_params['width'],
height=sensor_params['height'],
background=sensor_params['background'],
mode=sensor_params['mode'])
net = HTM(sensor, verbose=False)
net.create_network(net_params)
sensor.loadMultipleImages(train_data)
net.learn(learning_params)
sensor.clearImageList()
sensor.loadSingleImage('data/test_clean.png')
data = sensor.compute()
im_clean, cat = data['data'], data['category']
patch_size = net.patch_size
im_clean_fw = net.infer(utils.extract_patches(im_clean, patch_size),
merge_output=True)
weights = np.asarray(net.segment(im_clean_fw))
def testMultipleLevelInference(self):
return
from datasets import DatasetConfig
dataset = DatasetConfig().load('pictures-subset')
train_data = dataset['test_data_path'] #dataset['train_data_path']
test_data = dataset['test_data_path']
sensor_params = {
'width': dataset['image_width'],
'height': dataset['image_height'],
'background': dataset['image_background'],
'mode': dataset['image_mode']
}
net_params = [
# Level 0
{
'nodeCloning': True,
'size': [4, 4],
'overlap': [0, 0],
# Spatial pooler
'maxCoincidenceCount': 64,
'spatialPoolerAlgorithm': 'gaussian',
'sigma': 1,
'maxDistance': 0.1,
# Temporal pooler
'requestedGroupsCount': 20,
'temporalPoolerAlgorithm': 'sumProp',
'transitionMemory': 4,
},
# Level 1
{
'nodeCloning': True,
'size': [2, 2],
'overlap': [0, 0],
# Spatial pooler
'maxCoincidenceCount': 128,
'spatialPoolerAlgorithm': 'product',
'sigma': 1,
'maxDistance': 0.1,
# Temporal pooler
'requestedGroupsCount': 10,
'temporalPoolerAlgorithm': 'sumProp',
'transitionMemory': 8,
},
# Level 2
{
'nodeCloning': True,
'size': [1],
'overlap': [0, 0],
# Spatial pooler
'maxCoincidenceCount': 128,
'spatialPoolerAlgorithm': 'product',
'sigma': 1,
'maxDistance': 0.1,
# Temporal pooler
'requestedGroupsCount': 20,
'temporalPoolerAlgorithm': 'sumProp',
'transitionMemory': 10,
},
# Level 3
# {
# 'nodeCloning': True,
# 'size': [1],
# 'overlap': [0, 0],
# # Spatial pooler
# 'maxCoincidenceCount': 128,
# 'spatialPoolerAlgorithm': 'gaussian',
# 'sigma': 1,
# 'maxDistance': 0.1,
# # Temporal pooler
# 'requestedGroupsCount': 30,
# 'temporalPoolerAlgorithm': 'maxProp',
# 'transitionMemory': 10,
# }
]
learning_params = [
# Level 0
{
'sp':
# Spatial pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
300
},
'tp':
# Temporal pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
10000
},
},
# Level 1
{
'sp':
# Spatial pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
200
},
'tp':
# Temporal pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
5000
},
},
# Level 2
{
'sp':
# Spatial pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
200
},
'tp':
# Temporal pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
5000
},
},
# Level 3
{
'sp':
# Spatial pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
200
},
'tp':
# Temporal pooler
{
'explorer': [
'RandomSweep', {
'sweepOffObject': False,
'sweepDirections': 'all'
}
],
'numIterations':
5000
},
}
]
train_data = 'data/pictures-subset/train'
test_data = 'data/pictures-subset/test'
sensor = ImageSensor(width=sensor_params['width'],
height=sensor_params['height'],
background=sensor_params['background'],
mode=sensor_params['mode'])
net = HTM(sensor, verbose=False)
net.create_network(net_params)
sensor.loadMultipleImages(train_data)
net.learn(learning_params)
# getting testing data
sensor.clearImageList()
sensor.loadMultipleImages(test_data)
sensor.setParameter('explorer', 'Flash')
import matplotlib.pyplot as plt
import matplotlib.cm as cm
for i in range(40):
data = sensor.compute()
im, cat = data['data'], data['category']
print(cat)
patterns = utils.extract_patches(im, net.patch_size)
if cat == 0:
plt.plot(net.infer(patterns), color='b')
else:
plt.plot(net.infer(patterns), color='r')
plt.show()
