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