FullProjAlignPreDS

FullProjAlignPreDS#

class brainpy.dyn.FullProjAlignPreDS(pre, delay, syn, comm, out, post, out_label=None, name=None, mode=None)[source]#

Full-chain synaptic projection with the align-pre reduction and delay+synapse updating.

The full-chain means that the model needs to provide all information needed for a projection, including pre -> syn -> delay -> comm -> out -> post. Note here, compared to FullProjAlignPreSD, the delay and syn are exchanged.

The align-pre means that the synaptic variables have the same dimension as the pre-synaptic neuron group.

The delay+synapse updating means that the projection first delivers the pre neuron output (usually the spiking) to the delay model, then computes the synapse states, and finally computes the synaptic current.

Neither FullProjAlignPreDS nor FullProjAlignPreSD facilitates the event-driven computation. This is because the comm is computed after the synapse state, which is a floating-point number, rather than the spiking. To facilitate the event-driven computation, please use align post projections.

To simulate an E/I balanced network model:

class EINet(bp.DynSysGroup):
  def __init__(self):
    super().__init__()
    ne, ni = 3200, 800
    self.E = bp.dyn.LifRef(ne, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,
                           V_initializer=bp.init.Normal(-55., 2.))
    self.I = bp.dyn.LifRef(ni, V_rest=-60., V_th=-50., V_reset=-60., tau=20., tau_ref=5.,
                           V_initializer=bp.init.Normal(-55., 2.))
    self.E2E = bp.dyn.FullProjAlignPreDS(pre=self.E,
                                        delay=0.1,
                                        syn=bp.dyn.Expon.desc(size=ne, tau=5.),
                                        comm=bp.dnn.JitFPHomoLinear(ne, ne, prob=0.02, weight=0.6),
                                        out=bp.dyn.COBA(E=0.),
                                        post=self.E)
    self.E2I = bp.dyn.FullProjAlignPreDS(pre=self.E,
                                        delay=0.1,
                                        syn=bp.dyn.Expon.desc(size=ne, tau=5.),
                                        comm=bp.dnn.JitFPHomoLinear(ne, ni, prob=0.02, weight=0.6),
                                        out=bp.dyn.COBA(E=0.),
                                        post=self.I)
    self.I2E = bp.dyn.FullProjAlignPreDS(pre=self.I,
                                        delay=0.1,
                                        syn=bp.dyn.Expon.desc(size=ni, tau=10.),
                                        comm=bp.dnn.JitFPHomoLinear(ni, ne, prob=0.02, weight=6.7),
                                        out=bp.dyn.COBA(E=-80.),
                                        post=self.E)
    self.I2I = bp.dyn.FullProjAlignPreDS(pre=self.I,
                                        delay=0.1,
                                        syn=bp.dyn.Expon.desc(size=ni, tau=10.),
                                        comm=bp.dnn.JitFPHomoLinear(ni, ni, prob=0.02, weight=6.7),
                                        out=bp.dyn.COBA(E=-80.),
                                        post=self.I)

  def update(self, inp):
    self.E2E()
    self.E2I()
    self.I2E()
    self.I2I()
    self.E(inp)
    self.I(inp)
    return self.E.spike

model = EINet()
indices = bm.arange(1000)
spks = bm.for_loop(lambda i: model.step_run(i, 20.), indices)
bp.visualize.raster_plot(indices, spks, show=True)
Parameters:
update()[source]#

The function to specify the updating rule.