def create_brain():
# neuron parameters that provide smooth and symmetric
# wheel movement
WHEEL_NEURON_PARAMS = {
'v_rest': -60.5,
'cm': 0.025,
'tau_m': 10.,
'tau_refrac': 10.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5,
'e_rev_E': 0.0,
'e_rev_I': -75.0,
'v_thresh': -60.0,
'v_reset': -60.5
}
# stimulus-to-wheels synaptic parameters
WEIGHT_STIMULUS_TO_WHEELS = 1.5e-4
DELAY = 0.1
# PushBot wheel velocity is controlled by neuron membrane potentials
# both left-side wheels are controlled by the same neuron
left_wheels_neuron = sim.Population(1,
sim.IF_cond_exp(**WHEEL_NEURON_PARAMS),
label="left_wheels_neuron")
# both right-side wheels are controlled by the same neuron
right_wheels_neuron = sim.Population(
1, sim.IF_cond_exp(**WHEEL_NEURON_PARAMS), label="right_wheels_neuron")
# setup a source of spikes that will make the PushBot turn
stimulus = sim.Population(
1,
sim.SpikeSourceArray(spike_times=[i * 100 for i in range(100)]),
label="stimulus")
# setup a synaptic connection from the stimulus to the neurons
stim_to_wheels = sim.StaticSynapse(weight=abs(WEIGHT_STIMULUS_TO_WHEELS),
delay=DELAY)
# on left side use inhibitory receptor type to make the PushBot turn CCW
sim.Projection(stimulus,
left_wheels_neuron,
connector=sim.AllToAllConnector(),
synapse_type=stim_to_wheels,
receptor_type='inhibitory')
# on right side use excitatory receptor type to make the PushBot turn CCW
sim.Projection(stimulus,
right_wheels_neuron,
connector=sim.AllToAllConnector(),
synapse_type=stim_to_wheels,
receptor_type='excitatory')
return {
"left_wheels_neuron": left_wheels_neuron,
"right_wheels_neuron": right_wheels_neuron,
"stimulus": stimulus
}
def create_brain():
# Brain simulation set-up
sim.setup(timestep=0.1,
min_delay=0.1,
max_delay=20.0,
threads=1,
rng_seeds=[1234])
## NEURONS ##
# Neuronal parameters
NEURONPARAMS = {
'cm': 0.025,
'v_rest': -60.5,
'tau_m': 10.,
'e_rev_E': 0.0,
'e_rev_I': -75.0,
'v_reset': -60.5,
'v_thresh': -60.0,
'tau_refrac': 10.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5
}
# Build the neuronal model
cell_class = sim.IF_cond_alpha(**NEURONPARAMS)
# Define the neuronal population
population = sim.Population(size=4, cellclass=cell_class)
## SYNAPSES ##
# Build the weights matrix
weights = np.zeros((2, 2))
weights[0, 1] = 1.
weights[1, 0] = 1.
weights *= 5e-5
# Synaptic parameters
SYNAPSE_PARAMS = {
"weight": weights,
"delay": 1.0,
'U': 1.0,
'tau_rec': 1.0,
'tau_facil': 1.0
}
# Build synaptic model
synapse_type = sim.TsodyksMarkramSynapse(**SYNAPSE_PARAMS)
## NETWORK ##
# Connect neurons
connector = sim.AllToAllConnector()
sim.Projection(presynaptic_population=population[0:2],
postsynaptic_population=population[2:4],
connector=connector,
synapse_type=synapse_type,
receptor_type='excitatory')
# Initialize the network
sim.initialize(population, v=population.get('v_rest'))
return population
def create_brain():
"""
Initializes PyNN with the minimal neuronal network
"""
sim.setup(timestep=0.1,
min_delay=0.1,
max_delay=20.0,
threads=1,
rng_seeds=[1234])
# Following parameters were taken from the husky braitenberg brain experiment (braitenberg.py)
SENSORPARAMS = {
'cm': 0.025,
'v_rest': -60.5,
'tau_m': 10.,
'e_rev_E': 0.0,
'e_rev_I': -75.0,
'v_reset': -60.5,
'v_thresh': -60.0,
'tau_refrac': 10.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5
}
SYNAPSE_PARAMS = {
"weight": 0.5e-4,
"delay": 20.0,
'U': 1.0,
'tau_rec': 1.0,
'tau_facil': 1.0
}
cell_class = sim.IF_cond_alpha(**SENSORPARAMS)
# Define the network structure: 2 neurons (1 sensor and 1 actors)
population = sim.Population(size=2, cellclass=cell_class)
synapse_type = sim.TsodyksMarkramSynapse(**SYNAPSE_PARAMS)
connector = sim.AllToAllConnector()
# Connect neurons
sim.Projection(presynaptic_population=population[0:1],
postsynaptic_population=population[1:2],
connector=connector,
synapse_type=synapse_type,
receptor_type='excitatory')
sim.initialize(population, v=population.get('v_rest'))
return population
def add_lateral_connections_topology(layer, distance_to_weight):
proj = sim.Projection(layer.population, layer.population,
sim.AllToAllConnector(), sim.StaticSynapse())
weights = np.zeros((layer.size(), layer.size()))
# for all combinations of neurons
for x1, y1, x2, y2 in itertools.product(np.arange(layer.shape[0]),
np.arange(layer.shape[1]),
repeat=2):
w = distance_to_weight(distance.cityblock([x1, y1], [x2, y2]))
weights[layer.get_idx(x1, y1)][layer.get_idx(x2, y2)] = w
proj.set(weight=weights)
# -*- coding: utf-8 -*-
"""
Tutorial brain for the baseball experiment
"""
# pragma: no cover
__author__ = 'Jacques Kaiser'
from hbp_nrp_cle.brainsim import simulator as sim
import numpy as np
n_sensors = 3
n_motors = 7
np.random.seed(42)
weights = np.random.rand(3, 7) * 5
sensors = sim.Population(n_sensors, cellclass=sim.IF_curr_exp())
motors = sim.Population(n_motors, cellclass=sim.IF_curr_exp())
sim.Projection(sensors, motors, sim.AllToAllConnector(),
sim.StaticSynapse(weight=weights))
circuit = sensors + motors
def create_brain():
"""
Initializes PyNN with the neuronal network that has to be simulated
"""
SENSORPARAMS = {'v_rest': -60.5,
'cm': 0.025,
'tau_m': 10.,
'tau_refrac': 10.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5,
'e_rev_E': 0.0,
'e_rev_I': -75.0,
'v_thresh': -60.0,
'v_reset': -60.5}
GO_ON_PARAMS = {'v_rest': -60.5,
'cm': 0.025,
'tau_m': 10.0,
'e_rev_E': 0.0,
'e_rev_I': -75.0,
'v_reset': -61.6,
'v_thresh': -60.51,
'tau_refrac': 10.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5}
# POPULATION_PARAMS = SENSORPARAMS * 5 + GO_ON_PARAMS + SENSORPARAMS * 2
population = sim.Population(8, sim.IF_cond_alpha())
population[0:5].set(**SENSORPARAMS)
population[5:6].set(**GO_ON_PARAMS)
population[6:8].set(**SENSORPARAMS)
# Shared Synapse Parameters
syn_params = {'U': 1.0, 'tau_rec': 1.0, 'tau_facil': 1.0}
# Synaptic weights
WEIGHT_RED_TO_ACTOR = 1.5e-4
WEIGHT_RED_TO_GO_ON = 1.2e-3 # or -1.2e-3?
WEIGHT_GREEN_BLUE_TO_ACTOR = 1.05e-4
WEIGHT_GO_ON_TO_RIGHT_ACTOR = 1.4e-4
DELAY = 0.1
# Connect neurons
CIRCUIT = population
SYN = sim.TsodyksMarkramSynapse(weight=abs(WEIGHT_RED_TO_ACTOR),
delay=DELAY, **syn_params)
sim.Projection(presynaptic_population=CIRCUIT[2:3],
postsynaptic_population=CIRCUIT[7:8],
connector=sim.AllToAllConnector(),
synapse_type=SYN,
receptor_type='excitatory')
sim.Projection(presynaptic_population=CIRCUIT[3:4],
postsynaptic_population=CIRCUIT[6:7],
connector=sim.AllToAllConnector(),
synapse_type=SYN,
receptor_type='excitatory')
SYN = sim.TsodyksMarkramSynapse(weight=abs(WEIGHT_RED_TO_GO_ON),
delay=DELAY, **syn_params)
sim.Projection(presynaptic_population=CIRCUIT[0:2],
postsynaptic_population=CIRCUIT[5:6],
connector=sim.AllToAllConnector(),
synapse_type=SYN,
receptor_type='inhibitory')
SYN = sim.TsodyksMarkramSynapse(weight=abs(WEIGHT_GREEN_BLUE_TO_ACTOR),
delay=DELAY, **syn_params)
sim.Projection(presynaptic_population=CIRCUIT[4:5],
postsynaptic_population=CIRCUIT[7:8],
connector=sim.AllToAllConnector(),
synapse_type=SYN,
receptor_type='excitatory')
SYN = sim.TsodyksMarkramSynapse(weight=abs(WEIGHT_GO_ON_TO_RIGHT_ACTOR),
delay=DELAY, **syn_params)
sim.Projection(presynaptic_population=CIRCUIT[5:6],
postsynaptic_population=CIRCUIT[7:8],
connector=sim.AllToAllConnector(),
synapse_type=SYN,
receptor_type='excitatory')
sim.initialize(population, v=population.get('v_rest'))
logger.info("Circuit description: " + str(population.describe()))
return population
# -*- coding: utf-8 -*-
"""
This is a minimal brain with 2 neurons connected together.
"""
# pragma: no cover
__author__ = 'Felix Schneider'
from hbp_nrp_cle.brainsim import simulator as sim
import numpy as np
sensors = sim.Population(3, cellclass=sim.IF_curr_exp())
actors = sim.Population(6, cellclass=sim.IF_curr_exp())
# best weights so far:
weights = np.array([
1.2687, 0.9408, 4.0275, 0.4076, 4.9567, 0.6792, 4.9276, 3.8688, 2.1914,
4.1219, 0.9874, 0.3526, 3.5533, 3.8544, 0.0482, 1.7837, 0.5833, 4.221
])
weights = weights.reshape(3, 6)
# weights = np.random.rand(3, 6) * 5
projection = sim.Projection(sensors, actors, sim.AllToAllConnector(),
sim.StaticSynapse(weight=weights))
circuit = sensors + actors
sim.Population(1, cellclass=sim.IF_curr_exp()) for _ in range(n_motors)
]
indices = np.arange(resolution * resolution).reshape((resolution, resolution))
ones = np.ones(shape=((resolution // 2) * resolution, 1))
# upper half = eight rows from the top
upper_half = sim.PopulationView(sensors, indices[:resolution // 2].flatten())
# lower half = eight rows from bottom
lower_half = sim.PopulationView(
sensors, indices[resolution - resolution // 2:].flatten())
# left half = eight columns from left
left_half = sim.PopulationView(sensors, indices[:, :resolution // 2].flatten())
# right half = eight colums from right
right_half = sim.PopulationView(
sensors, indices[:, resolution - resolution // 2:].flatten())
# center nine = nine center squares
center_nine = sim.PopulationView(
sensors, indices[(resolution // 2) - 1:(resolution // 2) + 2,
(resolution // 2) - 1:(resolution // 2) + 2].flatten())
pro_down = sim.Projection(lower_half, down, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_up = sim.Projection(upper_half, up, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_left = sim.Projection(left_half, left, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_right = sim.Projection(right_half, right, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
circuit = sensors + down + up
inhibition_weight = -10
excitatory_weight = 0.5
# slice pixel neurons in 4 corners
top_left_bucket = input_layer.get_neuron_box(low_range, low_range)
top_right_bucket = input_layer.get_neuron_box(high_range, low_range)
bottom_left_bucket = input_layer.get_neuron_box(low_range, high_range)
bottom_right_bucket = input_layer.get_neuron_box(high_range, high_range)
# connect each bucket to respective output neuron
for idx, bucket in enumerate([
top_left_bucket, top_right_bucket, bottom_left_bucket,
bottom_right_bucket
]):
sim.Projection(bucket, sim.PopulationView(motors, [idx]),
sim.AllToAllConnector(),
sim.StaticSynapse(weight=excitatory_weight))
inhibition_weight = -10
# lateral inhibition in the output layer
add_lateral_connections_topology(output_layer, lambda d: inhibition_weight
if d != 0 else 0)
print('There are {}x{}={} neurons in the input layer'.format(
input_shape[0], input_shape[1], np.prod(input_shape)))
print('There are {} motor neurons'.format(len(motors)))
circuit = sensors + motors
n_motors = 4 # down, up, left, right
sensors = sim.Population(resolution * resolution, cellclass=sim.IF_curr_exp())
down_stage_one, up_stage_one, left_stage_one, right_stage_one = [sim.Population(1, cellclass=sim.IF_curr_exp()) for _ in range(n_motors)]
down_stage_two, up_stage_two, left_stage_two, right_stage_two = [sim.Population(1, cellclass=sim.IF_curr_exp()) for _ in range(n_motors)]
indices = np.arange(resolution * resolution).reshape((resolution, resolution))
ones = np.ones(shape=((resolution // 2) * resolution,1))
upper_half = sim.PopulationView(sensors, indices[:resolution // 2].flatten())
lower_half = sim.PopulationView(sensors, indices[resolution - resolution//2:].flatten())
left_half = sim.PopulationView(sensors, indices[:, :resolution // 2].flatten())
right_half = sim.PopulationView(sensors, indices[:, resolution - resolution//2:].flatten())
center_nine = sim.PopulationView(sensors, indices[(resolution//2) - 1 : (resolution//2) + 2, (resolution//2) - 1 : (resolution//2) + 2].flatten())
pro_down_stage_one = sim.Projection(lower_half, down_stage_one, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_up_stage_one = sim.Projection(upper_half, up_stage_one, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_left_stage_one = sim.Projection(left_half, left_stage_one, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_right_stage_one = sim.Projection(right_half, right_stage_one, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_down_stage_two = sim.Projection(lower_half, down_stage_two, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_up_stage_two = sim.Projection(upper_half, up_stage_two, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_left_stage_two = sim.Projection(left_half, left_stage_two, sim.AllToAllConnector(),
sim.StaticSynapse(weight=ones))
pro_right_stage_two = sim.Projection(right_half, right_stage_two, sim.AllToAllConnector(),
]
projs = []
for i in range(n_legs):
# Swing
if i in [0, 3, 4]:
weight = [1.0 for k in range(n_sensors // 3)] # cos
weight.extend([0.0 for k in range(n_sensors // 3)]) # sin
weight.extend([0.0 for k in range(n_sensors // 3)]) # 1
else:
weight = [-1.0 for k in range(n_sensors // 3)] # cos
weight.extend([0.0 for k in range(n_sensors // 3)]) # sin
weight.extend([1.0 for k in range(n_sensors // 3)]) # 1
projs.append(
sim.Projection(
sensors, outputs_swing[i], sim.AllToAllConnector(),
sim.StaticSynapse(weight=np.array(weight).reshape((n_sensors,
1)))))
# Lift
if i in [0, 3, 4]:
weight = [0.0 for k in range(n_sensors // 3)] # cos
weight.extend([0.5 for k in range(n_sensors // 3)]) # sin
weight.extend([0.0 for k in range(n_sensors // 3)]) # 1
else:
weight = [0.0 for k in range(n_sensors // 3)] # cos
weight.extend([-0.5 for k in range(n_sensors // 3)]) # sin
weight.extend([0.5 for k in range(n_sensors // 3)]) # 1
projs.append(
sim.Projection(
sensors, outputs_lift[i], sim.AllToAllConnector(),
# pragma: no cover
__author__ = 'Adrian Hein'
from hbp_nrp_cle.brainsim import simulator as sim
import numpy as np
import nest
# one input neuron that fires if the ball is near enough
n_input = 2
# nine output neurons which are:
# 0: /robot/hollie_real_left_arm_0_joint/cmd_pos
# 1: /robot/hollie_real_left_arm_1_joint/cmd_pos
# 2: /robot/hollie_real_left_arm_2_joint/cmd_pos
# 3: /robot/hollie_real_left_arm_3_joint/cmd_pos
# 4: /robot/hollie_real_left_arm_4_joint/cmd_pos
# 5: /robot/hollie_real_left_arm_5_joint/cmd_pos
# 6: /robot/hollie_real_left_arm_6_joint/cmd_pos
# 7: /robot/hollie_real_left_hand_base_joint/cmd_pos
# 8: /robot/hollie_tennis_racket_joint/cmd_pos
# we have to try out which of them are important if we want to hit the ball in such way that it flies as far as possible
n_output = 7
input_neurons = sim.Population(n_input, cellclass=sim.IF_curr_exp())
output_neurons = sim.Population(n_output, cellclass=sim.IF_curr_exp())
#w = sim.RandomDistribution('gamma', [1, 0.004], rng=NumpyRNG(seed=4242))
connections = sim.Projection(input_neurons, output_neurons, sim.AllToAllConnector(allow_self_connections=False), sim.StaticSynapse(weight=1.))
circuit = input_neurons + output_neurons