def test_brain_variable_weight(self, sim_mock):
config.brain_root = FooBrain()
dev = LeakyIntegrator(weight=config.brain_root.foo)
start_new_tf_manager()
config.active_node.brain_adapter = MockBrainCommunicationAdapter()
self.assertTrue(sim_mock().Population.called)
self.assertTrue(sim_mock().initialize.called)
self.assertDictEqual(
dev.get_parameters(), {
'v_thresh': float('inf'),
'cm': 1.0,
'tau_m': 10.0,
'tau_syn_E': 2.,
'tau_syn_I': 2.,
'v_rest': 0.0,
'v_reset': 0.0,
'tau_refrac': 0.1,
'i_offset': 0.0,
'connector': sim_mock().AllToAllConnector(),
'weight': 1.0,
'delay': 0.1,
'source': None,
'receptor_type': 'excitatory',
'synapse_type': sim_mock().StaticSynapse(),
'label': None,
'rng': None
})
def test_map_neuron_wrong_parameter_fails(self):
nrp.start_new_tf_manager()
# This test checks if the initialization fails as expected, because "neuronX" cannot be mapped to a parameter
with self.assertRaises(Exception):
@nrp.MapSpikeSink("neuronX", [1, 2, 3], nrp.leaky_integrator_exp)
@nrp.NeuronMonitor(nrp.brain.foo, nrp.spike_recorder)
def example_monitor(t, neuron1):
return neuron1.voltage > 20
def test_map_neuron_wrong_parameter_fails(self):
nrp.start_new_tf_manager()
# This test checks if the initialization fails as expected, because "neuronX" cannot be mapped to a parameter
with self.assertRaises(Exception):
@nrp.MapSpikeSink("neuronX", [1, 2, 3], nrp.leaky_integrator_exp)
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron1):
return neuron1.voltage
def setUp(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
brain.actors = MockPopulation(range(0, 60))
brain.sensors = MockPopulation(range(45, 645))
config.brain_root = brain
def __load_cle(self, roscontrol, roscomm, braincontrol, braincomm,
brain_file_path, neurons_config, externalmodulearray,
robot_poses, models, lights):
"""
Load the ClosedLoopEngine and initializes all interfaces
:param roscontrol Robot Control Adapter to use
:param roscomm Robot Communication Adapter to use
:param braincontrol Brain Control Adapter to use
:param braincomm Brain Communication Adapter to use
:param brain_file_path Accessible path to brain file
:param neurons_config Neuron configuration specified in the BIBI
:param robot_post Initial robot pose
:param models Initial models loaded into the environment
:param lights Initial lights loaded into the environment
"""
# Needed in order to cleanup global static variables
self._notify("Connecting brain simulator to robot")
tfm.start_new_tf_manager()
# Create transfer functions manager
tfmanager = tfm.config.active_node
# set adapters
tfmanager.robot_adapter = roscomm
tfmanager.brain_adapter = braincomm
# integration timestep between simulators, convert from ms to s (default to CLE value)
timestep = (ClosedLoopEngine.DEFAULT_TIMESTEP
if self.sim_config.timestep is None else
self.sim_config.timestep)
roscontrol.set_robots(self.robotManager.get_robot_dict())
# initialize CLE
self._notify("Initializing CLE")
cle = DeterministicClosedLoopEngine(roscontrol, roscomm, braincontrol,
braincomm, tfmanager,
externalmodulearray, timestep)
if brain_file_path:
cle.initialize(brain_file_path, **neurons_config)
else:
cle.initialize()
# Set initial pose
cle.initial_robot_poses = robot_poses
# Set initial models and lights
cle.initial_models = models
cle.initial_lights = lights
return cle
def test_parameter_not_parsable_fails(self):
nrp.start_new_tf_manager()
# This test checks if the initialization fails as expected, because there is no mapping for parameter "neuron1"
@nrp.NeuronMonitor(nrp.brain.foo, nrp.spike_recorder)
def example_monitor(t, neuronA):
return neuronA.voltage > 20
self.init_adapters()
self.assertRaises(Exception, nrp.initialize)
def test_parameter_not_parsable_fails(self):
nrp.start_new_tf_manager()
# This test checks if the initialization fails as expected, because there is no mapping for parameter "neuron1"
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuronA):
return neuronA.voltage
self.init_adapters()
self.assertRaises(Exception, nrp.initialize)
def test_tf_delete(self, mock_cleanup):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
config.active_node.brain_adapter = brain
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
@nrp.MapCSVRecorder("recorder1", filename = "1", headers=["Name", "time", "Position"])
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0, recorder1):
return neuron0.voltage * 1.345
@nrp.MapCSVRecorder("recorder2", filename = "2", headers=["Name", "time", "Position"])
@nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neuron1, neuron2, recorder2):
if neuron1.voltage < 0.678:
if neuron2.voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neuron2.voltage < 0.789:
return 0.632
else:
return 0.256
nrp.initialize("MyTransferFunctions")
# Delete an existing transfer function
self.assertEqual(2, len(nrp.get_transfer_functions()))
self.assertEqual(True, nrp.delete_transfer_function("left_arm_tw"))
self.assertEqual(1, len(nrp.get_transfer_functions()))
self.assertEqual(mock_cleanup.call_count, 1)
# Try to delete it again
self.assertEqual(False, nrp.delete_transfer_function("left_arm_tw"))
self.assertEqual(1, len(nrp.get_transfer_functions()))
# Delete another existing transfer function
self.assertEqual(True, nrp.delete_transfer_function("right_arm"))
self.assertEqual(0, len(nrp.get_transfer_functions()))
self.assertEqual(0, len(config.active_node.brain_adapter.detector_devices))
self.assertEqual(mock_cleanup.call_count, 2)
def __load_cle(self, roscontrol, roscomm, braincontrol, braincomm,
brain_file_path, neurons_config, robot_pose, models,
lights):
"""
Load the ClosedLoopEngine and initializes all interfaces
:param roscontrol Robot Control Adapter to use
:param roscomm Robot Communication Adapter to use
:param braincontrol Brain Control Adapter to use
:param braincomm Brain Communication Adapter to use
:param brain_file_path Accessible path to brain file
:param neurons_config Neuron configuration specified in the BIBI
:param robot_post Initial robot pose
:param models Initial models loaded into the environment
:param lights Initial lights loaded into the environment
"""
# Needed in order to cleanup global static variables
self._notify("Connecting brain simulator to robot")
nrp.start_new_tf_manager()
# Create transfer functions manager
tfmanager = nrp.config.active_node
# set adapters
tfmanager.robot_adapter = roscomm
tfmanager.brain_adapter = braincomm
# Import dependencies
for dep in self.__dependencies:
importlib.import_module(dep[:dep.rfind('.')])
# integration timestep between simulators, convert from ms to s
# (default to CLE value)
timestep = ClosedLoopEngine.DEFAULT_TIMESTEP
if self.bibi.timestep is not None:
timestep = float(self.bibi.timestep) / 1000.0
# initialize CLE
self._notify("Initializing CLE")
cle = DeterministicClosedLoopEngine(roscontrol, roscomm, braincontrol,
braincomm, tfmanager, timestep)
cle.initialize(brain_file_path, **neurons_config)
# Set initial pose
cle.initial_robot_pose = robot_pose
# Set initial models and lights
cle.initial_models = models
cle.initial_lights = lights
return cle
def test_no_tf_decorator_works(self):
nrp.start_new_tf_manager()
@nrp.MapSpikeSink("neuron", [1, 2, 3], nrp.leaky_integrator_alpha)
def tf_sink_without_decorator(t, neuron):
pass
self.assertIsInstance(tf_sink_without_decorator, nrp.Neuron2Robot)
@nrp.MapRobotPublisher("topic", "/a/topic")
def tf_publisher_no_decorator(t, topic):
pass
self.assertIsInstance(tf_publisher_no_decorator, nrp.Neuron2Robot)
def test_no_tf_decorator(self):
nrp.start_new_tf_manager()
@nrp.MapSpikeSource("neuron", [1, 2, 3], nrp.poisson)
def tf_source_without_decorator(t, neuron):
pass
self.assertIsInstance(tf_source_without_decorator, nrp.Robot2Neuron)
@nrp.MapRobotSubscriber("topic", "/a/topic")
def tf_subscriber_without_decorator(t, topic):
pass
self.assertIsInstance(tf_subscriber_without_decorator, nrp.Robot2Neuron)
def test_set_flawed_tf(self):
nrp.start_new_tf_manager()
tf_name = "tf_name"
tf_src = "def tf_name(self): pass"
tf_error = Exception()
nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error)
# check if correctly added
flawed_tf = nrp.get_flawed_transfer_function(tf_name)
self.assertEqual(flawed_tf.name, tf_name)
self.assertEqual(flawed_tf.source, tf_src)
self.assertTrue(flawed_tf.error is tf_error)
def test_delete_flawed_tf(self):
nrp.start_new_tf_manager()
tf_name = "tf_name"
tf_src = "def tf_name(self): pass"
tf_error = Exception()
nrp.set_flawed_transfer_function(tf_src, tf_name, tf_error)
result = nrp.delete_flawed_transfer_function(tf_name)
self.assertTrue(result)
# can't find it anymore
self.assertIsNone(nrp.get_flawed_transfer_function(tf_name))
def test_tf_publish_error(self, logcapture):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
config.active_node.brain_adapter = brain
config.active_node.publish_error_callback = MagicMock(return_value=None)
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
raise Exception('foo')
tf = nrp.get_transfer_function('right_arm')
self.assertRaises(TFException, tf.run, 0.1)
def test_spike_recorder_monitor(self):
nrp.start_new_tf_manager()
self.init_adapters()
@nrp.NeuronMonitor(nrp.brain.foo, nrp.spike_recorder)
def my_monitor(t):
return True
nrp.initialize("test")
my_monitor.run(42.0)
msg = my_monitor.publisher.sent[-1]
self.assertIsInstance(msg, SpikeEvent)
self.assertEqual(msg.simulationTime, 42.0)
self.assertEqual(msg.monitorName, "my_monitor")
self.assertEqual(msg.neuronCount, 42)
self.assertEqual(len(msg.spikes), 0)
my_monitor.unregister()
self.assertIsNone(my_monitor.device)
def test_population_rate_monitor(self):
nrp.start_new_tf_manager()
self.init_adapters()
@nrp.NeuronMonitor(nrp.brain.foo, nrp.population_rate)
def my_monitor(t):
return True
nrp.initialize("test")
my_monitor.run(42.0)
msg = my_monitor.publisher.sent[-1]
self.assertIsInstance(msg, SpikeRate)
self.assertEqual(msg.simulationTime, 42.0)
self.assertEqual(msg.monitorName, "my_monitor")
self.assertEqual(msg.rate, my_monitor.device.rate)
my_monitor.unregister()
self.assertIsNone(my_monitor.device)
def test_tf_source(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return neuron0.voltage * 1.345
@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
camera_device.inner.amplitude = 42.0
expected_source_n2r = """@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return neuron0.voltage * 1.345
"""
expected_source_r2n = """@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
camera_device.inner.amplitude = 42.0
"""
loaded_source_n2r = config.active_node.n2r[0].source
self.assertEqual(loaded_source_n2r, expected_source_n2r)
loaded_source_r2n = config.active_node.r2n[0].source
self.assertEqual(loaded_source_r2n, expected_source_r2n)
loaded_source_n2r_and_r2n = [tf.source for tf in nrp.get_transfer_functions()]
self.assertIn(expected_source_n2r, loaded_source_n2r_and_r2n)
self.assertIn(expected_source_r2n, loaded_source_n2r_and_r2n)
self.assertEqual(2, len(loaded_source_n2r_and_r2n))
def test_all_right(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return neuron0.voltage * 1.345
@nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(2, 4, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.MapSpikeSink("neuron2", nrp.brain.actors[slice(4, 6, 1)], nrp.leaky_integrator_alpha,
updates=[(1.0, 0.4)], v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neuron1, neuron2):
if neuron1.voltage < 0.678:
if neuron2.voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neuron2.voltage < 0.789:
return 0.632
else:
return 0.256
# Here is an example of a transfer function mapping robot sensor data to spikes
# As the image processing is a common task, this is done through a specialized
# device in the neuronal simulator. However, this device might not be mapped to
# physical Nest device, but do some processing internally and use a less specialized
# device type internally
@nrp.MapRobotSubscriber("camera", Husky.Eye.camera)
@nrp.MapSpikeSource("camera_device", nrp.brain.sensors[slice(0, 600, 1)],
TestDevice())
@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
camera_device.inner.amplitude = 42.0
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
brain.__dict__["actors"] = MockPopulation(range(0, 60))
brain.__dict__["sensors"] = MockPopulation(range(45, 645))
config.brain_root = brain
nrp.initialize("MyTransferFunctions")
husky_right_arm = right_arm.topic
husky_left_arm = left_arm_tw.topic
camera = transform_camera.camera
camera_device = transform_camera.camera_device
brain.refresh_buffers(0.5)
robot.refresh_buffers(0.5)
config.active_node.run_neuron_to_robot(0.5)
config.active_node.run_robot_to_neuron(0.5)
camera.value = "Definitely not an image"
brain.refresh_buffers(1.5)
robot.refresh_buffers(1.5)
config.active_node.run_neuron_to_robot(1.5)
config.active_node.run_robot_to_neuron(1.5)
assert isinstance(husky_right_arm, MockPublishedTopic)
assert isinstance(husky_left_arm, MockPublishedTopic)
assert len(husky_right_arm.sent) == 2
assert len(husky_left_arm.sent) == 2
assert husky_right_arm.sent[0] == 1.345
assert husky_right_arm.sent[1] == 1.345 * 0.3
assert husky_left_arm.sent[0] == 0.256
assert husky_left_arm.sent[1] == 0.756
assert camera_device.inner.amplitude == 42.0
config.active_node.reset()
def setUp(self):
self.bcm = MockBrainCommunicationAdapter()
self.rcm = MockRobotCommunicationAdapter()
nrp.start_new_tf_manager()
nrp.config.brain_root = TestBrain()
self.tfm = nrp.config.active_node
def test_tf_set(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
config.active_node.brain_adapter = brain
config.active_node.robot_adapter = robot
config.active_node.initialize_tf = MagicMock(return_value=None)
@nrp.MapSpikeSink("neuron0", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(1.0, 0.3)]
)
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return neuron0.voltage * 1.345
@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
camera_device.inner.amplitude = 42.0
tf_n2r = """@nrp.MapSpikeSink("neuron1", nrp.brain.actors[slice(0, 2, 1)], nrp.leaky_integrator_alpha,
v_rest=1.0, updates=[(3.0, 0.1)])
@nrp.Neuron2Robot()
def right_arm(t, neuron1):
return neuron1.voltage * 2.345
"""
tf_r2n = """@nrp.MapRobotSubscriber("camera", Topic('/husky/camera', sensor_msgs.msg.Image))
@nrp.Robot2Neuron()
def transform_camera(t, camera):
if camera.changed:
pass
"""
nrp.delete_transfer_function('right_arm')
nrp.delete_transfer_function('transform_camera')
nrp.set_transfer_function(tf_n2r, tf_n2r, 'right_arm')
nrp.set_transfer_function(tf_r2n, tf_r2n, 'transform_camera')
self.assertEqual(config.active_node.initialize_tf.call_count, 2)
loaded_source_n2r_and_r2n = [tf.source for tf in nrp.get_transfer_functions()]
self.assertIn(tf_n2r, loaded_source_n2r_and_r2n)
self.assertIn(tf_r2n, loaded_source_n2r_and_r2n)
number_of_tf = len(loaded_source_n2r_and_r2n)
self.assertEqual(2, number_of_tf)
source_update_flags = [tf.updated for tf in nrp.get_transfer_functions()]
self.assertEqual([True] * number_of_tf, source_update_flags)
fancy_tf = "def it_wont_work():\n return None"
self.assertRaises(TFLoadingException, nrp.set_transfer_function, fancy_tf, fancy_tf, "it_wont_work")
try:
nrp.set_transfer_function(fancy_tf, fancy_tf, 'it_wont_work')
except TFLoadingException as e:
self.assertIn('no decorator', e.message)
self.assertEqual('it_wont_work', e.tf_name)
funny_tf = """@nrp.Robot2Neuron()
def transform_camera(t, camera, camera_device):
if camera.changed:
return Nothing!
"""
self.assertRaises(TFLoadingException, nrp.set_transfer_function, funny_tf, funny_tf, "it_cant_work")
try:
nrp.set_transfer_function(funny_tf, funny_tf, 'it_cant_work')
except TFLoadingException as e:
self.assertIn('invalid syntax', e.message)
self.assertIn('line 4', e.message)
self.assertEqual('it_cant_work', e.tf_name)
def setUp(self):
nrp.start_new_tf_manager()
def test_brain_source(self):
nrp.start_new_tf_manager()
config.brain_source = "some source"
self.assertEqual(config.brain_source, nrp.get_brain_source())
def setUp(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
config.active_node.brain_adapter = brain
config.active_node.robot_adapter = robot
def test_all_right(self):
nrp.start_new_tf_manager()
brain = MockBrainCommunicationAdapter()
robot = MockRobotCommunicationAdapter()
@nrp.MapSpikeSink("neuron0",
nrp.map_neurons(range(0, 2),
lambda i: nrp.brain.actors[i]),
nrp.leaky_integrator_alpha,
v_rest=1.0,
updates=[(1.0, [0.3, 0.0])])
@nrp.Neuron2Robot(Husky.RightArm.pose)
def right_arm(t, neuron0):
return np.sum(neuron0.voltage) * 1.345
# Here is a another transfer function from neurons to robot messages
# This time, the neuron parameter is explicitly mapped to an array of neurons
# More precisely, the parameter is mapped to a group of __devices that are each connected to a single neuron
# The neuron2 parameter will thus be a list of recorders
@nrp.MapSpikeSink("neurons",
nrp.chain_neurons(nrp.brain.actors[slice(2, 4, 1)],
nrp.brain.actors[slice(4, 6, 1)]),
nrp.leaky_integrator_alpha,
updates=[(1.0, [0.4, 0.4])],
v_rest=1.0)
@nrp.Neuron2Robot(Husky.LeftArm.twist)
def left_arm_tw(t, neurons):
if neurons[0].voltage < 0.678:
if neurons[1].voltage > 0.345:
return 0.756
else:
return 1.123
else:
if neurons[1].voltage < 0.789:
return 0.632
else:
return 0.256
nrp.set_nest_adapter(brain)
nrp.set_robot_adapter(robot)
brain.__dict__["actors"] = MockPopulation(range(0, 60))
brain.__dict__["sensors"] = MockPopulation(range(45, 645))
config.brain_root = brain
nrp.initialize("MyTransferFunctions")
husky_right_arm = right_arm.topic
husky_left_arm = left_arm_tw.topic
brain.refresh_buffers(0.5)
robot.refresh_buffers(0.5)
config.active_node.run_neuron_to_robot(0.5)
config.active_node.run_robot_to_neuron(0.5)
brain.refresh_buffers(1.5)
robot.refresh_buffers(1.5)
config.active_node.run_neuron_to_robot(1.5)
config.active_node.run_robot_to_neuron(1.5)
self.assertIsInstance(husky_right_arm, MockPublishedTopic)
self.assertIsInstance(husky_left_arm, MockPublishedTopic)
self.assertEqual(len(husky_right_arm.sent), 2)
self.assertEqual(len(husky_left_arm.sent), 2)
self.assertEqual(husky_right_arm.sent[0], 1.345 * 2.0)
self.assertEqual(husky_right_arm.sent[1], 1.345 * 0.3)
self.assertEqual(husky_left_arm.sent[0], 0.256)
self.assertEqual(husky_left_arm.sent[1], 0.756)
config.active_node.reset()
