File: tutorial_2a_the_concept_of_a_connection.txt

package info (click to toggle)
brian 1.4.3-1
  • links: PTS, VCS
  • area: main
  • in suites: sid, stretch
  • size: 23,436 kB
  • sloc: python: 68,707; cpp: 29,040; ansic: 5,182; sh: 111; makefile: 61
file content (184 lines) | stat: -rw-r--r-- 6,644 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
.. currentmodule:: brian

Tutorial 2a: The concept of a Connection
****************************************

The network
~~~~~~~~~~~

In this first part, we'll build a network consisting of three neurons. The
first two neurons will be under direct control and have no equations
defining them, they'll just produce spikes which will feed into the third
neuron. This third neuron has two different state variables, called Va
and Vb. The first two neurons will be connected to the third neuron, but
a spike arriving at the third neuron will be treated differently
according to whether it came from the first or second neuron (which you
can consider as meaning that the first two neurons have different
types of synapses on to the third neuron).

The program starts as follows.

  ::

    from brian import *
    
    tau_a = 1 * ms
    tau_b = 10 * ms
    Vt = 10 * mV
    Vr = 0 * mV

Differential equations
~~~~~~~~~~~~~~~~~~~~~~

This time, we will have multiple differential equations. We will use the
:class:`Equations` object, although you could equally pass the multi-line string
defining the differential equations directly when initialising the :class:`NeuronGroup`
object (see the next part of the tutorial for an example of this).

  ::

    eqs = Equations('''
          dVa/dt = -Va/tau_a : volt
          dVb/dt = -Vb/tau_b : volt
          ''')

So far, we have defined a model neuron with two state variables, ``Va``
and ``Vb``, which both decay exponentially towards 0, but with different
time constants ``tau_a`` and ``tau_b``. This is just so that you can see
the difference between them more clearly in the plot later on.

SpikeGeneratorGroup
~~~~~~~~~~~~~~~~~~~

Now we introduce the :class:`SpikeGeneratorGroup` class. This is a group of
neurons without a model, which just produces spikes at the times
that you specify. You create a group like this by writing::

    G = SpikeGeneratorGroup(N,spiketimes)

where ``N`` is the number of neurons in the group, and ``spiketimes`` is a
list of pairs ``(i,t)`` indicating that neuron ``i`` should fire at time ``t``.
In fact, ``spiketimes`` can be any 'iterable container' or 'generator',
but we don't cover that here (see the detailed documentation for
:class:`SpikeGeneratorGroup`).

In our case, we want to create a group with two neurons, the first
of which (neuron 0) fires at times 1 ms and 4 ms, and the second
of which (neuron 1) fires at times 2 ms and 3 ms. The list of
``spiketimes`` then is:

  ::

    spiketimes = [(0, 1 * ms), (0, 4 * ms),
                  (1, 2 * ms), (1, 3 * ms)]

and we create the group as follows:

  ::

    G1 = SpikeGeneratorGroup(2, spiketimes)

Now we create a second group, with one neuron, according to the
model we defined earlier.

  ::

    G2 = NeuronGroup(N=1, model=eqs, threshold=Vt, reset=Vr)

Connections
~~~~~~~~~~~

In Brian, a :class:`Connection` from one :class:`NeuronGroup` to another is
defined by writing::

    C = Connection(G,H,state)

Here ``G`` is the source group, ``H`` is the target group, and ``state`` is the
name of the target state variable. When a neuron ``i`` in ``G`` fires, Brian
finds all the neurons ``j`` in ``H`` that ``i`` in ``G`` is connected to, and adds
the amount ``C[i,j]`` to the specified state variable of neuron ``j`` in ``H``.
Here ``C[i,j]`` is the (i,j)th entry of the connection matrix of ``C`` (which
is initially all zero).

To start with, we create two connections from the group of two
directly controlled neurons to the group of one neuron with the
differential equations. The first connection has the target state ``Va``
and the second has the target state ``Vb``.

  ::

    C1 = Connection(G1, G2, 'Va')
    C2 = Connection(G1, G2, 'Vb')

So far, this only declares our intention to connect neurons in group
``G1`` to neurons in group ``G2``, because the connection matrix is initially
all zeros. Now, with connection ``C1`` we connect neuron 0 in group ``G1``
to neuron 0 in group ``G2``, with weight 3 mV. This means that when neuron
0 in group ``G1`` fires, the state variable ``Va`` of the neuron in group ``G2``
will be increased by 6 mV. Then we use connection ``C2`` to connection
neuron 1 in group ``G1`` to neuron 0 in group ``G2``, this time with weight
3 mV.

  ::

    C1[0, 0] = 6 * mV
    C2[1, 0] = 3 * mV

The net effect of this is that when neuron 0 of ``G1`` fires, ``Va`` for
the neuron in ``G2`` will increase 6 mV, and when neuron 1 of ``G1`` fires,
``Vb`` for the neuron in ``G2`` will increase 3 mV.

Now we set up monitors to record the activity of the network,
run it and plot it.

  ::

    Ma = StateMonitor(G2, 'Va', record=True)
    Mb = StateMonitor(G2, 'Vb', record=True)
    
    run(10 * ms)
    
    plot(Ma.times, Ma[0])
    plot(Mb.times, Mb[0])
    show()

.. image:: images/tutorials/2a.jpg

The two plots show the state variables ``Va`` and ``Vb`` for the single
neuron in group ``G2``. ``Va`` is shown in blue, and ``Vb`` in green.
According to the differential equations, ``Va`` decays much faster
than ``Vb`` (time constant 1 ms rather than 10 ms), but we have set
it up (through the connection strengths) that an incoming
spike from neuron 0 of ``G1`` causes a large increase of 6 mV to ``Va``,
whereas a spike from neuron 1 of ``G1`` causes a smaller increase of
3 mV to Vb. The value for ``Va`` then jumps at times 1 ms and 4 ms,
when we defined neuron 0 of ``G1`` to fire, and decays almost back
to rest in between. The value for ``Vb`` jumps at times 2 ms and
3 ms, and because the times are closer together and the time
constant is longer, they add together.

In the next part of this tutorial, we'll see how to use this
system to do something useful.

Exercises
~~~~~~~~~

1. Try playing with the parameters ``tau_a``, ``tau_b`` and the connection
   strengths, ``C1[0,0]`` and ``C2[0,1]``. Try changing the list of
   spike times.
2. In this part of the tutorial, the states ``Va`` and ``Vb`` are
   independent of one another. Try rewriting the differential
   equations so that they're not independent and play around
   with that.
3. Write a network with inhibitory and excitatory neurons. Hint: you
   only need one connection.
4. Write a network with inhibitory and excitatory neurons whose
   actions have different time constants (for example, excitatory
   neurons have a slower effect than inhibitory ones).
   
Solutions
~~~~~~~~~

3. Simple write ``C[i,j]=-3*mV`` to make the connection from neuron
   i to neuron j inhibitory.
4. See the next part of this tutorial.