def test_openre():
from openre.neurons import IS_INHIBITORY, IS_TRANSMITTER, IS_RECEIVER
from openre.data_types import null
from openre.device import Dummy
from openre.domain import create_domain_factory
from pytest import raises
synapse_max_level = 30000
config = {
'defaults': {
'rate_limit': 0,
},
'synapse': {
'max_level': synapse_max_level,
'learn_rate': 10,
'learn_threshold': 9000,
'spike_learn_threshold': 0,
'spike_forget_threshold': 0,
},
'layers': [
{
'name': 'V1',
'threshold': 20000,
'relaxation': 1000,
'width': 20,
'height': 20,
'spike_cost': 11,
'max_vitality': types.max(types.vitality) - 1,
'connect': [
{
'name': 'V2',
'radius': 1,
'shift': [0, 0],
},
],
},
{
'name': 'V2',
'threshold': 10000,
'relaxation': 2000,
'width': 10,
'height': 10,
'is_inhibitory': True,
'connect': [
{
'name': 'V3',
'radius': 1,
'shift': [-1, 1],
},
],
},
{
'name': 'V3',
'threshold': 15000,
'relaxation': 3000,
'width': 5,
'height': 10,
'connect': [
{
'name': 'V4',
'radius': 2,
'shift': [0, 0],
},
],
},
{
'name': 'V4',
'threshold': 25000,
'relaxation': 4000,
'width': 5,
'height': 10,
},
],
'domains': [
{
'name' : 'D1',
'device': {'type': 'Dummy'},
'layers' : [
# 'shape': [x, y, width, height]
{'name': 'V1', 'shape': [0, 0, 10, 10]},
{'name': 'V1', 'shape': [10, 0, 10, 10]},
# если параметр shape не указан - подразумеваем весь слой
{'name': 'V2'},
],
},
{
'name' : 'D2',
'device': {'type': 'Dummy'},
'layers' : [
{'name': 'V1', 'shape': [10, 10, 10, 10]},
{'name': 'V1', 'shape': [0, 10, 10, 10]},
{'name': 'V3', 'shape': [-1, -1, 20, 20]},
],
},
{
'name' : 'D3',
'device': {'type': 'Dummy'},
'layers' : [
{'name': 'V4', 'shape': [4, 4, 20, 20]},
{'name': 'V4', 'shape': [5, 10, 20, 20]},
],
},
],
}
ore = OpenRE(config)
ore.deploy(create_domain_factory())
assert ore
assert ore.find('V2', 0, 10) == None
assert ore.find('V1', 0, 20) == None
assert ore.find('V1', 1, 1) == {
'domain_name': 'D1',
'layer_index': 0
}
assert ore.find('V1', 1, 11) == {
'domain_name': 'D2',
'layer_index': 1
}
assert ore.domains[0].index == 0
# domain layers
assert isinstance(ore.domains[0].device, Dummy)
assert ore.domains[0].config['stat_size'] == 1000
# defaults
assert ore.config['rate_limit'] == 0
# 200 synapses in domain D1
assert len(ore.domains[0].stat_vector.data) \
== ore.domains[0].stat_fields
assert ore.domains[0].layers[0].name == 'V1'
assert ore.domains[0].layers_config[0]['layer'].name == 'V1'
assert ore.domains[0] \
.layers_config[0]['connect'][0]['domain_layers'][0].name == 'V2'
assert ore.domains[0].layers[1].address == 100
assert ore.domains[0].layers[2].address == 200
assert not ore.domains[0].layers[0].neurons_metadata.flags[0] \
& IS_INHIBITORY
assert not ore.domains[0].layers[1].neurons_metadata.flags[0] \
& IS_INHIBITORY
assert ore.domains[0].layers[2].neurons_metadata.flags[0] & IS_INHIBITORY
assert list(ore.domains[0].layers_vector.threshold.data) \
== [20000, 20000, 10000]
assert list(ore.domains[1].layers_vector.threshold.data) \
== [20000, 20000, 15000]
assert list(ore.domains[2].layers_vector.threshold.data) == [25000, 25000]
assert list(ore.domains[0].layers_vector.relaxation.data) \
== [1000, 1000, 2000]
assert list(ore.domains[1].layers_vector.relaxation.data) \
== [1000, 1000, 3000]
assert list(ore.domains[2].layers_vector.relaxation.data) == [4000, 4000]
assert list(ore.domains[0].layers_vector.spike_cost.data) == [11, 11, 10]
max_vitality = types.max(types.vitality)
assert list(ore.domains[0].layers_vector.max_vitality.data) \
== [max_vitality - 1, max_vitality - 1, max_vitality]
# neurons
assert ore.domains[0].neurons.length == 300 + 200 # 200 - remote neurons
assert ore.domains[0].neurons.length == len(ore.domains[0].neurons)
assert ore.domains[0].neurons.vitality[0] == max_vitality - 1
assert ore.domains[0].neurons.vitality[100] == max_vitality - 1
assert ore.domains[0].neurons.vitality[200] == max_vitality
assert ore.domains[1].neurons.length == 250 + 72 # 72 remote neurons
neuron_layers_0 = [0]*100
neuron_layers_0.extend([1]*100)
neuron_layers_0.extend([2]*100)
# remote neurons
neuron_layers_0.extend([0]*100)
neuron_layers_0.extend([1]*100)
assert list(ore.domains[0].neurons.layer.data) == neuron_layers_0
# synapses
assert ore.domains[0].synapses
assert ore.domains[0].synapses.length
assert ore.domains[0].synapses.length == \
ore.domains[0].synapses.level.length
assert ore.domains[0].synapses.length == \
len(ore.domains[0].synapses.level.data)
assert len(ore.domains[0].pre_synapse_index.value.data) \
== len(ore.domains[0].synapses)
assert len(ore.domains[0].pre_synapse_index.key.data) \
== len(ore.domains[0].neurons)
# every pre neuron has only one synapse
assert len([x for x in ore.domains[0].pre_synapse_index.value.data
if x != null]) == 0
# every neuron in V2 has 4 connections from V1 layer
# -> 3/4 has valid address
assert len([x for x in ore.domains[0].post_synapse_index.value.data
if x != null]) == 150 + 150 # second one is remote neurons
# number of connected pre neurons
assert len([x for x in ore.domains[0].pre_synapse_index.key.data
if x != null]) == 200 + 200 # second one is remote neurons
# number of connected post neurons
assert len([x for x in ore.domains[0].post_synapse_index.key.data
if x != null]) == 50 + 50 # second one connections from remote
# neurons
# check layer shape
assert ore.domains[1].layers[2].shape == [0, 0, 5, 10]
assert ore.domains[2].layers[0].shape == [4, 4, 1, 6]
assert ore.domains[2].layers[1].shape == [5, 10, 0, 0]
# multy domains
d1 = ore.domains[0]
d2 = ore.domains[1]
d3 = ore.domains[2]
v2 = d1.layers[2]
assert not v2.neurons_metadata.flags[0] & IS_TRANSMITTER
assert v2.neurons_metadata.flags[2, 0] & IS_TRANSMITTER
assert d1.remote_neurons_metadata.flags[199] & IS_RECEIVER
assert len(d2.remote_neurons_metadata.level) == 72
with raises(IndexError):
d1.remote_neurons_metadata.flags[200]
assert d1.remote_neurons_metadata.vitality[0] \
== types.max(types.vitality) - 1
assert d2.remote_neurons_metadata.vitality[0] & IS_INHIBITORY
assert not d1.remote_neurons_metadata.vitality[0] & IS_INHIBITORY
# remote neuron in d2 (domain index == 1)
# to local neuron in d3->remote_neurons
assert d3.receiver_index.data[1][218] == 6
# local neuron #218 in d2 to remote neuron #6 in d3 (domain index == 2)
assert d2.transmitter_index.data[218][2] == (6, 0)
assert d2.transmitter_index.address_to_key_index[218] == 200
assert d2.neurons.flags.data[218] & IS_TRANSMITTER
assert d3.neurons.flags.data[6] & IS_RECEIVER
assert len(d2.transmitter_index.key.data) == 214
assert len(d2.transmitter_index.value.data) == 214
assert d1.stat('transmitter_index_again') is None
assert d2.stat('transmitter_index_again') is None
assert d3.stat('transmitter_index_again') is None
assert d1.stat('receiver_index_again') is None
assert d2.stat('receiver_index_again') is None
assert d3.stat('receiver_index_again') is None
assert d1.stat('total_transmitter_neurons') \
== d2.stat('total_receiver_neurons')
assert d1.stat('total_transmitter_neurons') \
== len(d2.remote_neurons_metadata.level)
assert d1.stat('total_transmitter_neurons') == 72
assert d1.stat('total_receiver_neurons') == 200
assert d2.stat('total_transmitter_neurons') == 214
assert d2.stat('total_receiver_neurons') == 72
assert not d3.stat('total_transmitter_neurons')
assert d3.stat('total_receiver_neurons') == 14
for i, domain_config in enumerate(config['domains']):
domain = ore.domains[i]
assert domain.name == domain_config['name']
assert domain.spike_learn_threshold == \
ore.config['synapse']['spike_learn_threshold']
assert domain.spike_forget_threshold == \
ore.config['synapse']['spike_forget_threshold']
assert domain.learn_rate == \
ore.config['synapse']['learn_rate']
assert domain.learn_threshold == \
ore.config['synapse']['learn_threshold']
assert domain.ticks == 0
for j, layer_config in enumerate(domain.config['layers']):
layer = domain.layers[j]
assert layer.name == layer_config['name']
assert layer.address == layer.neurons_metadata.address
assert layer.threshold == layer_config['threshold']
assert layer.relaxation == \
layer_config.get('relaxation', 0)
assert layer.neurons_metadata
domain.tick()
assert domain.ticks == 1
def test_device():
if cl is None:
# skip test
return
from openre import OpenRE
import numpy as np
from openre import neurons
synapse_max_level = 30000
config = {
'synapse': {
'max_level': synapse_max_level,
'spike_learn_threshold': 2,
},
'layers': [
{
'name': 'V1',
'threshold': synapse_max_level,
'relaxation': 1000,
'width': 20,
'height': 20,
'is_inhibitory': True,
'connect': [
{
'name': 'V2',
'radius': 1,
'shift': [0, 0],
},
],
},
{
'name': 'V2',
'threshold': synapse_max_level,
'relaxation': 1000,
'width': 20,
'height': 20,
},
],
'domains': [
{
'name' : 'D1',
'device' : {
'type': 'OpenCL',
'threshold_inc': 0,
'threshold_dec': 0
},
'stat_size': 1,
'layers' : [
{'name': 'V1'},
{'name': 'V2'},
],
},
],
}
ore = OpenRE(config)
ore.deploy()
assert isinstance(ore.domains[0].device, OpenCL)
assert ore.domains[0].neurons.level.device_data_pointer
assert ore.domains[0].layers_vector.threshold.device_data_pointer
domain = ore.domains[0]
layer = domain.layers[0]
layer2 = domain.layers[1]
device = ore.domains[0].device
max_vitality = types.max(types.vitality)
# check lengths
assert len(domain.synapses.level) == 400
assert len(domain.synapses) == 400
assert domain.neurons.length == 800
assert layer.neurons_metadata.threshold[0] == synapse_max_level
assert layer.neurons_metadata.level.length == 400
assert layer2.neurons_metadata.level.length == 400
for field, field_type in domain.synapses_metadata.__class__.fields:
assert getattr(domain.synapses_metadata, field).length == 400
assert len(getattr(domain.synapses, field).data) == 400
assert domain.pre_synapse_index.key.length == 800
assert domain.pre_synapse_index.value.length == 400
assert domain.post_synapse_index.key.length == 800
assert domain.post_synapse_index.value.length == 400
# prepare neurons
layer.neurons_metadata.level[0, 0] = synapse_max_level
assert not layer.neurons_metadata.flags[0, 0] & neurons.IS_SPIKED
layer.neurons_metadata.level[0, 1] = layer.relaxation + 1
layer.neurons_metadata.flags[0, 1] |= neurons.IS_SPIKED
assert layer.neurons_metadata.flags[0, 1] | neurons.IS_SPIKED
layer.neurons_metadata.level[0, 2] = synapse_max_level
layer.neurons_metadata.flags[0, 2] |= neurons.IS_DEAD
layer.neurons_metadata.flags[0, 2] |= neurons.IS_SPIKED
layer.neurons_metadata.level[0, 3] = synapse_max_level
layer.neurons_metadata.flags[0, 3] |= neurons.IS_RECEIVER
layer.neurons_metadata.flags[0, 3] |= neurons.IS_SPIKED
layer.neurons_metadata.level[0, 4] = -1
layer.neurons_metadata.level[0, 5] = -1
layer.neurons_metadata.level[0, 6] = synapse_max_level
layer.neurons_metadata.vitality[0, 6] = layer.spike_cost
layer.neurons_metadata.level[0, 7] = synapse_max_level
layer2.neurons_metadata.level[0, 7] = synapse_max_level
# synapses
before = layer2.neurons_metadata.level[0, 0]
synapse_address = domain.pre_synapse_index.key[0]
synapse_level = domain.synapses.level[synapse_address]
layer.neurons_metadata.level[1, 0] = synapse_max_level
layer2.neurons_metadata.flags[1, 0] |= neurons.IS_DEAD
layer2.neurons_metadata.level[1, 1] = synapse_max_level
layer.neurons_metadata.flags[1, 2] |= neurons.IS_DEAD
layer2.neurons_metadata.level[1, 2] = synapse_max_level
l2_n_level_before = layer2.neurons_metadata.level[0, 0]
layer2.neurons_metadata.level[0, 6] = synapse_max_level
s_level_before_7 = domain.synapses.level[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 7)
]]
domain.synapses.learn[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 7)
]] = domain.learn_threshold
domain.neurons.to_device(device)
domain.synapses.to_device(device)
domain.tick()
domain.neurons.from_device(device)
domain.synapses.from_device(device)
s_level = domain.synapses.level[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 0)
]]
if l2_n_level_before - layer2.relaxation < 0:
res = np.int32(0) - s_level
assert res == layer2.neurons_metadata.level[0, 0]
else:
assert l2_n_level_before - s_level - layer2.relaxation \
== layer2.neurons_metadata.level[0, 0]
# check neurons (layer.neurons_metadata.level[x, y])
assert layer.neurons_metadata.level[0, 0] == 0
assert layer.neurons_metadata.flags[0, 0] & neurons.IS_SPIKED
assert layer.neurons_metadata.spike_tick[0, 0] == 1
assert layer.neurons_metadata.vitality[0, 0] \
== max_vitality - layer.spike_cost + 1
assert layer.neurons_metadata.level[0, 1] == 1
assert not layer.neurons_metadata.flags[0, 1] & neurons.IS_SPIKED
assert layer.neurons_metadata.spike_tick[0, 1] == 0
assert layer.neurons_metadata.vitality[0, 1] \
== max_vitality
assert layer.neurons_metadata.level[0, 2] == synapse_max_level
assert layer.neurons_metadata.flags[0, 2] & neurons.IS_DEAD
assert layer.neurons_metadata.flags[0, 2] & neurons.IS_SPIKED
assert layer.neurons_metadata.level[0, 3] == synapse_max_level
assert layer.neurons_metadata.flags[0, 3] & neurons.IS_RECEIVER
assert not layer.neurons_metadata.flags[0, 3] & neurons.IS_SPIKED
assert layer.neurons_metadata.level[0, 4] == 0
assert layer.neurons_metadata.level[0, 5] == 0
# spike and dies (low neuron.vitality)
assert not layer.neurons_metadata.flags[0, 6] & neurons.IS_SPIKED
assert layer.neurons_metadata.flags[0, 6] & neurons.IS_DEAD
assert layer.neurons_metadata.vitality[0, 6] \
== max_vitality
# check synapses
s_level_after_7 = domain.synapses.level[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 7)
]]
s_learn_after_7 = domain.synapses.learn[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 7)
]]
#assert s_level_before_7 == s_level_after_7
assert domain.synapses.flags[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 7)
]] & synapses.IS_STRENGTHENED
assert not domain.synapses.flags[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(0, 0)
]] & synapses.IS_STRENGTHENED
before = before - 1000
if before < 0:
before = 0
# layer 1 is inhibitory
assert layer2.neurons_metadata.level[0, 0] == before - synapse_level
# dead post-neuron so synapse level should be 0
assert domain.synapses.level[domain.pre_synapse_index.key[
layer.neurons_metadata.level.to_address(1, 0)
]] == 0
assert layer2.neurons_metadata.flags[1, 1] & neurons.IS_SPIKED
# dead pre-neuron so synapse level should be 0
assert domain.synapses.level[domain.post_synapse_index.key[
layer2.neurons_metadata.level.to_address(1, 2)
]] == 0
assert domain.synapses.learn[domain.pre_synapse_index.key[
layer.neurons_metadata.level.to_address(0, 0)
]] == 0
# check stats
for field_num in range(0, domain.stat_fields):
if field_num not in [2, 4]:
assert domain.stat_vector[0 + field_num] \
== domain.layers_stat[0 + field_num] \
+ domain.layers_stat[ \
0 + field_num + len(domain.stat_vector)]
assert domain.config['stat_size'] == domain.stat('stat_size')
# field 0 - total spikes
assert domain.stat_vector[0] >= 4
assert domain.stat_vector[0] == domain.stat('total_spikes')
assert domain.layers_stat[0] >= 2
assert domain.layers_stat[0 + len(domain.stat_vector)] >= 2
# field 1 - number of the dead neurons
assert domain.layers_stat[1] == 3
assert domain.stat_vector[1] == domain.stat('dead_neurons')
assert domain.layers_stat[1 + len(domain.stat_vector)] == 1
# field 2 - number of synapses with IS_STRENGTHENED flag
assert domain.stat_vector[2] == 1
assert domain.stat_vector[2] == domain.stat('strengthened_synapses')
# field 3 - tiredness
assert domain.layers_stat[3] \
== (layer.spike_cost - 1) * domain.layers_stat[0]
assert domain.layers_stat[3 + len(domain.stat_vector)] \
== (layer2.spike_cost - 1) \
* domain.layers_stat[0 + len(domain.stat_vector)]
assert domain.stat_vector[3] == domain.stat('neurons_tiredness')
# field 4 - sum(synapse.learn)
assert domain.stat_vector[4] >= (domain.learn_rate - 1)
assert domain.stat_vector[4] == domain.stat('synapse_learn_level')
# test kernel
test_length = 16
test_kernel = np.zeros((test_length,)).astype(np.uint32)
test_kernel_buf = cl.Buffer(
device.ctx,
cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR,
hostbuf=test_kernel
)
device.program.test_kernel(
device.queue, (test_length,), None,
test_kernel_buf,
np.int32(test_length),
np.uint32(types.max(types.vitality))
)
cl.enqueue_copy(device.queue, test_kernel, test_kernel_buf)
assert 8 | (3 & neurons.IS_SPIKED) == 10
assert 8 | (1 & neurons.IS_SPIKED) == 8
assert 7 & ~neurons.IS_SPIKED == 5
assert 8 & ~neurons.IS_SPIKED == 8
assert list(test_kernel) == [
neurons.IS_INHIBITORY,
neurons.IS_SPIKED,
neurons.IS_DEAD,
neurons.IS_TRANSMITTER,
neurons.IS_RECEIVER,
test_length,
1, # 3 & IS_INHIBITORY
2, # 3 & IS_SPIKED
0, # 3 & IS_DEAD
test_length,
null,
synapses.IS_STRENGTHENED,
3,
8 | (3 & neurons.IS_SPIKED),
7 & ~neurons.IS_SPIKED,
types.max(types.vitality),
]
# remote domains
config = {
'synapse': {
'max_level': synapse_max_level,
'spike_learn_threshold': 2,
},
'layers': [
{
'name': 'V1',
'threshold': synapse_max_level,
'relaxation': 1000,
'width': 20,
'height': 20,
'is_inhibitory': True,
'connect': [
{
'name': 'V2',
'radius': 1,
'shift': [0, 0],
},
],
},
{
'name': 'V2',
'threshold': synapse_max_level,
'relaxation': 1000,
'width': 20,
'height': 20,
},
],
'domains': [
{
'name' : 'D1',
'device' : {
'type': 'OpenCL',
},
'layers' : [
{'name': 'V1'},
],
},
{
'name' : 'D2',
'device' : {
'type': 'OpenCL',
},
'layers' : [
{'name': 'V2'},
],
},
],
}
ore = OpenRE(config)
ore.deploy()
d1 = ore.domains[0]
d2 = ore.domains[1]
v1 = d1.layers[0]
v1.neurons_metadata.level[0, 0] = synapse_max_level
d1.neurons.to_device(d1.device)
d1.synapses.to_device(d1.device)
d1.tick()
d1.neurons.from_device(d1.device)
d1.synapses.from_device(d1.device)
d1.transmitter_index.is_spiked.from_device(d1.device)
assert v1.neurons_metadata.flags[0, 0] & neurons.IS_SPIKED
assert v1.neurons_metadata.flags[0, 0] & neurons.IS_INHIBITORY
assert d1.transmitter_index.is_spiked[0]
#assert d1.transmitter_index.flags[0] & neurons.IS_INHIBITORY
assert d2.receiver_index.is_spiked[0]
local_address = d2.receiver_index.local_address[0]
assert local_address == 400
assert not d2.neurons.flags[local_address] & neurons.IS_SPIKED
assert d2.neurons.flags[local_address] & neurons.IS_INHIBITORY
assert d2.neurons.flags[local_address] & neurons.IS_RECEIVER
d2.tick()
d2.neurons.from_device(d2.device)
assert not d2.receiver_index.is_spiked[0]
assert d2.neurons.flags[local_address] & neurons.IS_SPIKED
assert d2.neurons.flags[local_address] & neurons.IS_INHIBITORY
assert d2.neurons.flags[local_address] & neurons.IS_RECEIVER
