Thalamo-cortical connections
Thalamo-cortical connections
In this post I will show how to build arbitrary custom connections in PyNN. We will illustrate the general technique
in the particular case of the Troyer model. In the Troyer model the connections from the LGN to the cortex are determined with
a gabor-profile therefore I am going to describe the required functions to achieve such an aim.
In the PyNN documentation we find
that one of the ways of implementing arbitrary connectivity patterns is to use the FromListConnector utility. In this format
we have to construct a list of tuples with a tuple for each connection. In each tuple we need to include the index of the source
neuron (the neuron from which the synapse originates), the index of the target neuron (the neuron into which the synapse terminates),
the weight and the delay. For example (0, 1, 5, 0.1) would indicate that we have a connection from the neuron 0 to the neuron 1
with a synaptic weight of 5 and a delay of 0.1.
In the light of the explanation above we need to construct a function that is able to construct a list with the
appropriate weights given a target and a source populations. In order to start moving towards this goal we will first write a function
that connects a given neuron in the target population to all the neurons in the source population. We first present the function
here bellow and we will explain it later:
def lgn_to_cortical_connection(cortical_neuron_index, connections, lgn_neurons, n_pick, g, delay, polarity, sigma,
gamma, phi, w, theta, x_cortical, y_cortical):
"""
Creates connections from the LGN to the cortex with a Gabor profile.
This function adds all the connections from the LGN to the cortical cell with index = cortical_neuron_index. It
requires as parameters the cortical_neruon_index, the current list of connections, the lgn population and also
the parameters of the Gabor function.
Parameters
----
cortical_neuron_index : the neuron in the cortex -target- that we are going to connect to
connections: the list with the connections to which we will append the new connnections
lgn_neurons: the source population
n_pick: How many times we will sample per neuron
g: how strong is the connection per neuron
delay: the time it takes for the action potential to arrive to the target neuron from the source neuron
polarity: Whether we are connection from on cells or off cells
sigma: Controls the decay of the exponential term
gamma: x:y proportionality factor, elongates the pattern
phi: Phase of the overall pattern
w: Frequency of the pattern
theta: Rotates the whole pattern by the angle theta
x_cortical, y_cortical : The spatial coordinate of the cortical neuron
"""
for lgn_neuron in lgn_neurons:
# Extract position
x, y = lgn_neuron.position[0:2]
# Calculate the gabbor probability
probability = polarity * gabor_probability(x, y, sigma, gamma, phi, w, theta, x_cortical, y_cortical)
probability = np.sum(np.random.rand(n_pick) < probability) # Samples
synaptic_weight = (g / n_pick) * probability
lgn_neuron_index = lgn_neurons.id_to_index(lgn_neuron)
# The format of the connector list should be pre_neuron, post_neuron, w, tau_delay
if synaptic_weight > 0:
connections.append((lgn_neuron_index, cortical_neuron_index, synaptic_weight, delay))
The first thing to note from the function above are its arguments. It contains the source population and the particular
target neuron that we want to connect to. It also contains all the connectivity and gabor-function related parameters. In
the body of the function we have one loop over the whole source population that decides whether we add a connection from a
particular cell or not. In order to decide if we add a connection we have to determine the probability from the gabor function.
Once we have this we sample n_pick times and add a weighted synaptic weight accordingly to the list for each neuron.
In the function above we have the values of the gabor function passed as arguments. However, the values of each gabor
function depend on the nature of the cell of the target population. In the light of this we will construct another function
that loops over the target population and extracts the appropriate gabor values for each function in this population.
We again present the function and then explain it:
def create_lgn_to_cortical(lgn_population, cortical_population, polarity, n_pick, g, delay, sigma, gamma, phases,
w, orientations):
"""
Creates the connection from the lgn population to the cortical population with a gabor profile. It also extracts
the corresponding gabor parameters that are needed in order to determine the connectivity.
"""
print 'Creating connection from ' + lgn_population.label + ' to ' + cortical_population.label
# Initialize connections
connections = []
for cortical_neuron in cortical_population:
# Set the parameters
x_cortical, y_cortical = cortical_neuron.position[0:2]
cortical_neuron_index = cortical_population.id_to_index(cortical_neuron)
theta = orientations[cortical_neuron_index]
phi = phases[cortical_neuron_index]
# Create the connections from lgn to cortical_neuron
#lgn_to_cortical_connection(cortical_neuron_index, connections, lgn_population, n_pick, g, polarity, sigma,
#gamma, phi, w, theta, x_cortical, y_cortical)
lgn_to_cortical_connection(cortical_neuron_index, connections, lgn_population, n_pick, g, delay, polarity, sigma,
gamma, phi, w, theta, 0, 0)
return connections
This function requires as arguments the source and target populations as well as the necessary parameters that characterize
each cell connectivity: orientation and phase. In the body of the function we have a loop over the cortical population that
extracts the relevant parameters -position, orientation and phase- and then calls the function that we already describe previously
in order to create the connectivity from the source population to the cell in place.
So now we have the necessary functions to construct a list. Now, we can use FromListConnector to transform the list into a
connector. And the use this to define a Projection. We define both the excitatory and inhibitory connections. We abstract this
complete set into the following function:
def create_thalamocortical_connection(source, target, polarity, n_pick, g, delay, sigma, gamma, w, phases, orientations, simulator):
"""
Creates a connection from a layer in the thalamus to a layer in the cortex through the mechanism of Gabor sampling
"""
# Produce a list with the connections
connections_list = create_lgn_to_cortical(source, target, polarity, n_pick, g, delay, sigma, gamma, phases, w, orientations)
# Transform it into a connector
connector = simulator.FromListConnector(connections_list, column_names=["weight", "delay"])
# Create the excitatory and inhibitory projections
simulator.Projection(source, target, connector, receptor_type='excitatory')
simulator.Projection(source, target, connector, receptor_type='inhibitory')
With this we can create in general connections from one target population to the other. We can even change change the gabor
function for whatever we want if we want to experiment with other connectivity patterns. Finally we present down here an example of a
sampling from a Gabor function with the aglorithm we just constructed:
So in the image we show in the left the sampling from the ideal Gabor function in the right.
