Edit History

Wiki » History » Version 22

Ramon Martinez, 22 Aug 2014 15:47

1 2 Ramon Martinez
##  Network models of V1
2 1 Padraig Gleeson
3 1 Padraig Gleeson
This project will be used to test implementations in PyNN (and eventually NeuroML) of published models of primary visual cortex (V1) based on spiking point neurons.
4 1 Padraig Gleeson
5 1 Padraig Gleeson
An initial focus will be on pubmed:14614078, but other models investigated will include pubmed:19477158 and pubmed:22681694.
6 1 Padraig Gleeson
7 9 Andrew Davison
This project is part of the [INCF participation in the Google Summer of Code 2014](http://incf.org/gsoc/2014).
8 2 Ramon Martinez
9 2 Ramon Martinez
10 2 Ramon Martinez
### Troyer Model
11 10 Andrew Davison
Here I will describe briefly the implementation of pubmed:9671678. 
12 2 Ramon Martinez
13 2 Ramon Martinez
In order to run this model is necessary to first install [git](http://git-scm.com/) and [PyNN](http://neuralensemble.org/PyNN/) and the appropriate simulator.
14 2 Ramon Martinez
15 3 Ramon Martinez
After that you can clone directly from git using:
16 3 Ramon Martinez
17 3 Ramon Martinez
~~~
18 3 Ramon Martinez
git clone https://github.com/OpenSourceBrain/V1NetworkModels.git
19 3 Ramon Martinez
~~~
20 3 Ramon Martinez
21 17 Ramon Martinez
The model runs in [NEST](http://www.nest-initiative.org/Software:About_NEST) and [Neuron](http://www.neuron.yale.edu/neuron/) with the following versions:
22 1 Padraig Gleeson
23 17 Ramon Martinez
PyNN '0.8beta1'
24 17 Ramon Martinez
Nest version: Version 2.2.2
25 17 Ramon Martinez
Neuron Release 7.3 
26 17 Ramon Martinez
27 13 Ramon Martinez
##### Overview of the model 
28 1 Padraig Gleeson
As the project stands at this moment the workflow can be briefly described in two steps:  first there are two scripts that implement the spatio-temporal filter in the retina and produce the spike-trains for each cell in the Lateral Geniculate Nucelus (LGN) and stores them for further use.  Second, there is a file that loads those spike-trains and runs the simulation of the cortical networks in PyNN using them. The first task is executed by two scripts `produce_lgn_spikes_on_cells.py` and ` produce_lgn_spikes_off_cells.py ` which generates pickled files in the folder './data' with the spike trains and positions for a given contrast that is selected in the parameters of the script. After we have run the file to produce the spikes with a given contrast (which can be adjusted in the scripts mentioned above) we can run the main script `full_model.py` with the same contrast in order to run the complete model. 
29 17 Ramon Martinez
 
30 13 Ramon Martinez
In order to describe the model in more detail we will start by describing `full_model.py`. That is, we will assume that we already have the spikes' data from the LGN that is going to be feed into the other layers. So we will start by describing the general structure of the model which is shown in the following diagram. 
31 13 Ramon Martinez
32 13 Ramon Martinez
![Scheme](http://www.opensourcebrain.org/attachments/download/213/print_model.png)
33 13 Ramon Martinez
34 13 Ramon Martinez
The model consists in three qualitatvely different types of layers. The LGN with center-surround receptive fields and  the inhibitory and excitatory layers which are connected with a Gabor filter profile to the LGN and a correlation based connectivity between them.  At the beginning of the `full_model.py` script we have the following parameters that control the general structure of the model and the connections between the layers. First we have the parameters that control the number of cells in each layer which were set accordingly to the values given in the troyer paper. Furthermore we have included a factor constant to decrease the overall size of the model and we also give the user the ability to chose how many LGN population layers he wants to include in the simulation:
35 13 Ramon Martinez
36 11 Ramon Martinez
~~~
37 11 Ramon Martinez
factor = 1.0  # Reduction factor
38 11 Ramon Martinez
Nside_exc = int(factor * Nside_exc)
39 11 Ramon Martinez
Nside_inh = int(factor * Nside_inh)
40 1 Padraig Gleeson
41 11 Ramon Martinez
Ncell_lgn = Nside_lgn * Nside_lgn
42 11 Ramon Martinez
Ncell_exc = Nside_exc ** 2
43 11 Ramon Martinez
Ncell_inh = Nside_inh ** 2
44 11 Ramon Martinez
45 1 Padraig Gleeson
N_lgn_layers = 1
46 13 Ramon Martinez
~~~
47 1 Padraig Gleeson
48 21 Ramon Martinez
After we also include a series of boolean parameters that give the user the ability to show whether he wants to include certain connections and layers in the simulation. This is very useful to test the effect of a particular connection or layer in the overall behavior of the model.
49 13 Ramon Martinez
50 13 Ramon Martinez
~~~
51 11 Ramon Martinez
## Main connections
52 11 Ramon Martinez
thalamo_cortical_connections = True # If True create connections from the thalamus to the cortex
53 11 Ramon Martinez
feed_forward_inhibition = True # If True add feed-forward inhibition ( i -> e )
54 11 Ramon Martinez
cortical_excitatory_feedback = True # If True add cortical excitatory feedback (e -> e) and ( e -> i )
55 11 Ramon Martinez
background_noise = True  # If True add cortical noise
56 1 Padraig Gleeson
correlated_noise = False  # Makes the noise coorelated
57 13 Ramon Martinez
~~~
58 11 Ramon Martinez
59 14 Ramon Martinez
This is all regarding the general structure of the model. The remaining part of `full_model.py` is composed of two main sections. The first one determines the parameters of the neurons and the connections and were set according the paper. The second part is the building of the model in PyNN, this is detail in the companion blog of this project. In order to allow the user to interact immediately with the model and to provide with a cleared understanding of how different parts of the Troyer model can be reproduce with our code (and its limitations) we provide a series of scripts that reproduce qualitatively a substantial amount of the figures in Troyer original paper.
60 11 Ramon Martinez
61 16 Ramon Martinez
##### Scripts to Reproduce the Figures
62 20 Ramon Martinez
* * First we have the LGN reponse. In order to obtain the results in figure 1a we have to run the file `troyer_plot_1a.py`. We obtain something like the following.
63 1 Padraig Gleeson
![Toyer1a](http://www.opensourcebrain.org/attachments/download/207/troyer_plot1a.png)
64 12 Ramon Martinez
65 20 Ramon Martinez
* Then we have the mechanism that samples connections from a Gabor function shown in figure 2.  In order to obtain the connectivity pattern and to see how the  parameters affect the final outcome the script `troyer_plot2.py` can be used to explore. If run it will produce a figure similar to the following one:
66 1 Padraig Gleeson
![Toyer2](http://www.opensourcebrain.org/attachments/download/212/troyer2.png)
67 1 Padraig Gleeson
 
68 20 Ramon Martinez
* We have also a script that plots the total conductance contribution from the LGN to the excitatory layer for the preferred and null orientation as shown in the paper's figure 3a. In order to play with how the parameters change the profile of this contribution the script `troyer_plot3a.py` can be explored. If run with a particular simulator (run troyer_plot3a.py nest) it will produce an output like this:
69 15 Ramon Martinez
70 1 Padraig Gleeson
![Toyer3a](http://www.opensourcebrain.org/attachments/download/216/troyer3a.png)
71 1 Padraig Gleeson
72 20 Ramon Martinez
* In order to compare the exctiatory effects that come from the LGN with the inhibitory stimulus that come from the inhibitory layer we plot the excitatory and inhibitory conductances as Troyer did for the current in in figure 7a (the condductivity here being a proxy for the current which in the Troyer paper is calculate as if the voltage was clamped at threshold).  In order to explore the dynamic of these effects we can run `troyer_plot7a.py` with nest or neuron as an argument.  This should produce a figure like 
73 1 Padraig Gleeson
74 1 Padraig Gleeson
![Troyer7a](http://www.opensourcebrain.org/attachments/download/214/troyer7a.png)
75 16 Ramon Martinez
76 20 Ramon Martinez
* In order to explore the connection between the cortical layer we create a script that reproduces the general pattern seen in the figure 7b of Troyer's paper. In order to run it we can run `troyer_plot8b.py`
77 16 Ramon Martinez
78 16 Ramon Martinez
![Troyer8b](http://www.opensourcebrain.org/attachments/download/217/troyer8b.png)
79 1 Padraig Gleeson
80 20 Ramon Martinez
* Finally if we want to see how the parameters and options of the model affect the voltage traces of a particular set of neurons we can run the script `troyer_plot9.py`  with nest or neuron. This will produce a figure which is in the spirit of the figure 9 in the paper. 
81 1 Padraig Gleeson
82 17 Ramon Martinez
![Troyer8b](http://www.opensourcebrain.org/attachments/download/215/plot9.png)
83 17 Ramon Martinez
84 17 Ramon Martinez
##### Caveats, Missing Features and Further Work 
85 18 Ramon Martinez
As the code stands the model is able to reproduce qualitatively most of the beahviours of the Troyer paper. There is however the need for tunning to achieve a beahviour that is also quantitatlvely consistent with the one from the paper.  We believe that this boils down to the fact that we have some missing features from the original model that destroy the fine tuning. Among them we find:
86 22 Ramon Martinez
- The Troyer paper uses a conductivity that not only falls exponentially but also rises in such a way. The one we have here limits itself to the falling part.
87 22 Ramon Martinez
- The Troyer paper uses a variable delay after each synaptic event. Our delays are constant.
88 22 Ramon Martinez
- The Troyer paapr uses a correlation connectivity algorithm fro the cortical connections that is based in the correlation between the LGN's receptive field instead of using the Gabor filters directly as we did.
89 17 Ramon Martinez
90 22 Ramon Martinez
Further work could consists in adding PyNN the capabilities to handle such situations in order to implement a Troyer model that is more faithful the the original intentions of the paper. 
91 1 Padraig Gleeson
92 19 Ramon Martinez
#### Details
93 19 Ramon Martinez
The companion blog of this project contains the details of how to construct the different the different layers and connections that belong go this model. In this section we describe the different sections, which libraries of the project it involves and the appropriate reference to the blog post where it is described at more length. 
94 4 Ramon Martinez
##### LGN - spikes
95 4 Ramon Martinez
96 5 Ramon Martinez
In brief, the Retina and the Thalamus part of the model can be represented by a spatio-temporal filter that, when convolved with the stimuli, will produce the firing rate of a given LGN cell. After that, we can use a non-homogeneous Poisson process to produce the corresponding spikes for each cell. We describe this in detail bellow.
97 1 Padraig Gleeson
98 1 Padraig Gleeson
###### Spatio-Temporal Receptive Field (STRF)
99 1 Padraig Gleeson
100 18 Ramon Martinez
The file `kernel_functions.py` contains the code for creating the  STRF.  The spatial part of the kernel possess a **center-surround** architecture which is model as a different of Gaussians. The temporal part of the receptive field has a **biphasic** structure, we use the implementation describe in Cai et al (1998). The details of the implementation are described in detail in the companion blog of this project in the posts  [(Retinal Filter I)](http://neuralensemble.blogspot.fr/2014/06/gsoc-open-source-brain-retinal-filter-i.html). Down here we present a kernel produce with this classes. The time here runs from left to right and from up to down as usual text, so we can see how the spatial components of the filter change in time with this series of two dimensional maps. 
101 1 Padraig Gleeson
102 1 Padraig Gleeson
We also include a small script `center_surround_plot.py` that can be used to visualize the spatial component of the STRF and received immediate feedback on how the overall pattern changes when the parameters and resolutions are changed. 
103 1 Padraig Gleeson
104 5 Ramon Martinez
###### Stimuli 
105 18 Ramon Martinez
The file `stimuli_functions.py` contains the code for creating the stimuli. In particular we used the implementation of a **full field sinusoidal grating** with the parameters described in the paper. We also include a small script `sine_grating_plot.py` to visualize how the sine grating looks at a particular point in time.
106 6 Ramon Martinez
107 6 Ramon Martinez
###### Convolution 
108 6 Ramon Martinez
109 20 Ramon Martinez
After we have the stimuli and the STRF we can use the **convolution** function defined in the file `analysis_functions.py` to calculate the response of LGN' neurons. The details of how the the convolution is implemented is described in the detail in the following entry of the blog [(Retinal Filter II)](http://neuralensemble.blogspot.fr/2014/06/gsoc-open-source-brain-retinal-filter-ii.html).  After we have the sine_grating and the functions to perform the convolution we can calculate the firing rate in the an LGN equipped with cente-surround receptive field's structure. We describe this in more detail in the post [(Firing Rate induced by a Sinus Grating)](http://neuralensemble.blogspot.mx/2014/08/firing-rate-induced-by-sinus-grating.html)
110 6 Ramon Martinez
111 1 Padraig Gleeson
###### Producing Spikes
112 1 Padraig Gleeson
113 6 Ramon Martinez
After we have the firing rate of a neuron we can use the produce_spikes functions in the file `analysis_functions.py`. This functions takes the firing rate and using non-homogeneous Poisson process outputs an array with the spikes times.  We provide in the repository the script `produce_lgn_spikes_one.py` for testing variations of parameters and as an example showcase.
114 6 Ramon Martinez
115 18 Ramon Martinez
###### Storing Spikes
116 1 Padraig Gleeson
Now we have the complete mechanism of spike creation we can use the files `produce_lgn_on_spikes.py` and `produce_lgn_off_spikes.py` to create the spikes for the on and off LGN cells.This file creates a grid of positions (This should correspond to the grid of LGN cells that we are going to use in PyNN) and produces the list of spikes associated with them as well as the positions and stores them using  `cPickled`.
117 7 Ramon Martinez
118 21 Ramon Martinez
##### LGN - Network
119 1 Padraig Gleeson
Now that we have the spikes of the LGN we can start creating the structure of the model within PyNN. The first thing to do is to use the files in `connector_functions.py` in order create the LGN population that will embody the spikes stored in the `cPickled` file described above.  This endeavor is describe in some detail in the following post:
120 1 Padraig Gleeson
[(Arbitrary Spike-trains in PyNN)](http://neuralensemble.blogspot.mx/2014/08/firing-rate-induced-by-sinus-grating.html).
121 21 Ramon Martinez
122 21 Ramon Martinez
##### Thalamo-Cortical Connections
123 21 Ramon Martinez
Also in the functions `connector_functions.py` we find the corresponding functions to create the connection between the LGN and the cortical layers following a Gabor-profile connectivity. The process is described in more detail in the following blog [Thalamo-cortical connections](http://neuralensemble.blogspot.mx/2014/08/gsoc-open-source-brain-thalamo-cortical.html).
124 21 Ramon Martinez
125 21 Ramon Martinez
##### Cortical Connections
126 21 Ramon Martinez
Finally again in the same file `connector_functions.py` there are the necessary files to create a connectivity profile based on correlations between the cortical layers. We implemented this rule with the implementations that follow qualitatively the logic. The explanation on how this was carried out and the comparison between the two approaches can be found in [Cortical Connections](http://neuralensemble.blogspot.mx/2014/08/gsoc-open-source-brain-cortical.html)
127 21 Ramon Martinez
128 21 Ramon Martinez
##### Blog Scripts
129 21 Ramon Martinez
For the sake of complentess we have included all the scripts used in the blog spots in the repository