Oscillations and Filtering Networks

Science, Projects, and Showcases
1

I am working on this paper:

Oscillations and Filtering Networks Support Flexible Routing of Information
Akam et. al. 2010, Neuron

We show that switching one of several convergent pathways from an asynchronous to an oscillatory state allows accurate selective transmission of population-coded information, which can be extracted even when other convergent pathways fire asynchronously at comparable rates. We further show that the band-pass filtering required to perform this information extraction can be implemented in a simple spiking network model with a single feed-forward interneuron layer.

Maybe It’s also interesting for the others and I can get some guide to reproduce the results.
The Brian1 version of the codes available here and I am working to prepare Python3 and brian2 version of the code.

First consider connecting Poissong generator to an inhibitory neuron:

eqs = """
        VT : volt
        IX : amp  # external fixed current
        
        Im = IX + 
            gL * (EL - vm) + 
            gL * DeltaT * exp((vm - VT) / DeltaT) : amp
        
        dvm/dt = (Im + I_syn_x) / C : volt
        # for alpha shape conductance synapse :
        ds_x/dt = -s_x / Tau_x : siemens                
        dg_syn_x/dt = (s_x - g_syn_x) / Tau_x : siemens 
        I_syn_x = g_syn_x * (Erev_x - vm): amp
        """

Poisson_to_I = b2.PoissonGroup(I_cell_params['Ncells'],
                                   rates=param_I_syn["p_rate"])
cIX = b2.Synapses(Poisson_to_I,
                  I_cells,
                  dt=dt0,
                  method=integration_method,
                  on_pre="s_x += {}*nS".format(param_I_syn["w_x"]))
cIX.connect(i=0, j=0)

cell_i_poisson
cell_i_poisson1500×750 49.8 KB

with no fixed input to neuron to see the effect of external poisson generator with rate 400 Hz.

Let’s consider input_network.py script.

There is two population of inhibitory and excitatory exponential LIF neurons which connect to themselves and each other. The is also an external poisson input to each population and also external currents.
The synapse are conductance base with alpha shape.

eqs = Equations(
        """
        VT : volt
        IX : amp
        I_syn_e = g_syn_e * (Erev_e - vm): amp          # input from E cells 
        I_syn_i = g_syn_i * (Erev_i - vm): amp          # input from I cells
        I_syn_x = g_syn_x * (Erev_x - vm): amp          # input from external poisson generator
        Im = IX +
            gL * (EL - vm) +
            gL * DeltaT * exp((vm - VT) / DeltaT) : amp
        
        ######### for inhibitory, excitatory and external inputs
        ds_e/dt = -s_e / Tau_e : siemens
        dg_syn_e/dt = (s_e - g_syn_e) / Tau_e : siemens

        ds_i/dt = -s_i / Tau_i : siemens
        dg_syn_i/dt = (s_i - g_syn_i) / Tau_i : siemens

        ds_x/dt = -s_x / Tau_x : siemens
        dg_syn_x/dt = (s_x - g_syn_x) / Tau_x : siemens

        dvm/dt = (Im + I_syn_e + I_syn_i + I_syn_x) / C : volt
        """
    )

E_cells = b2.NeuronGroup(E_cell_params['Ncells'],
                             model=eqs,
                             dt=dt0,
                             method=integration_method,
                             threshold="vm > 0.*mV",
                             refractory="vm > 0.*mV",
                             reset="vm={}*mV".format(common_params['Vreset']),
                             namespace={**common_params,
                                        **param_E_syn})

with almost the save code for building inhibitory neurons and also changing the parameters.
I think the synapses are the most tricky part of the codes:

Brian1

cEE = Connection(E_cells, E_cells, 'ge')
Connection.connect_random(cEE, sparseness = EEp['sparseness'], weight = EEp['g'], fixed=True)

Brian2

cEE = b2.Synapses(E_cells, E_cells,
                      dt=dt0,
                      delay=common_params['delay'],
                      on_pre='s_e+= {}*nS'.format(param_E_syn['w_e']),
                      namespace={**common_params, **param_E_syn})
cEE.connect(p="{:g}".format(param_E_syn["p_e"]), condition='i!=j')

E
E1500×1200 114 KB

I
I1500×1200 192 KB

which I expect to see a beta pick in the frequency spectrum.
What do you think?

I put the code here in case you want to check.

1 Like